@kepler.gl/duckdb 3.3.0-alpha.2 → 3.3.0-alpha.20

package/dist/esm/table/duckdb-table.js

@@ -0,0 +1,548 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _get from "@babel/runtime/helpers/esm/get";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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) { _defineProperty(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 = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(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, o, e, r) { var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import * as arrow from 'apache-arrow';
+import Console from 'global/console';
+import { ALL_FIELD_TYPES, DatasetType, DATASET_FORMATS, GEOARROW_EXTENSIONS, GEOARROW_METADATA_KEY } from '@kepler.gl/constants';
+import { arrowSchemaToFields, isArrowData, getGeoJsonFromLoaderResult, isKeplerGlMap, isRowObject, processArrowBatches } from '@kepler.gl/processors';
+import { KeplerTable } from '@kepler.gl/table';
+import { getApplicationConfig, compactArrowTable, isArrowTable, isArrowVector, timeToUnixMilli } from '@kepler.gl/utils';
+import { fieldTypeToColumnType, processCsvRowObject, processGeojson, processKeplerglJSONforDuckDb } from '../processors/data-processor';
+import { isGeoArrowPoint, isGeoArrowLineString, isGeoArrowPolygon, isGeoArrowMultiPoint, isGeoArrowMultiLineString, isGeoArrowMultiPolygon } from './duckdb-table-utils';
+import { castDuckDBTypesForKepler, dropTableIfExists, getDuckDBColumnTypes, getDuckDBColumnTypesMap, quoteColumnName, quoteTableName, removeUnsupportedExtensions, restoreArrowTable, setGeoArrowWKBExtension, restoreUnsupportedExtensions } from '../table/duckdb-table-utils';
+
+// TODO use files from disk or url directly, without parsing by loaders and then ingection into DeckDb
+
+/**
+ * Default DuckDb geometry columns created by ST_READ
+ */
+var DUCKDB_GEOM_COLUMN = 'geom';
+var DUCKDB_WKB_COLUMN = 'wkb_geometry';
+
+/**
+ Default column name for processed geojson in Kepler.
+ Use this name to rename default 'geom' column from DuckDb
+ in order to support Kepler maps saved before introduction of DuckDb plugin.
+ */
+var KEPLER_GEOM_FROM_GEOJSON_COLUMN = '_geojson';
+var DUCKDB_ROW_EDIT_NOT_IMPLEMENTED = 'In-place row edits (append, upsert, delete) are not implemented for DuckDB tables. DuckDB INSERT is not supported yet. Use addDataToMap with keepExistingConfig to replace the table.';
+function warnDuckDbRowEdits(method) {
+  Console.warn("KeplerGlDuckDbTable.".concat(method, ": ").concat(DUCKDB_ROW_EDIT_NOT_IMPLEMENTED));
+}
+
+/**
+ * Names of columns that most likely contain binary wkb geometry
+ */
+var SUGGESTED_GEOM_COLUMNS = _defineProperty(_defineProperty(_defineProperty({}, KEPLER_GEOM_FROM_GEOJSON_COLUMN, GEOARROW_EXTENSIONS.WKB), DUCKDB_GEOM_COLUMN, GEOARROW_EXTENSIONS.WKB), "geometry", GEOARROW_EXTENSIONS.WKB);
+export var KeplerGlDuckDbTable = /*#__PURE__*/function (_KeplerTable) {
+  function KeplerGlDuckDbTable(props) {
+    _classCallCheck(this, KeplerGlDuckDbTable);
+    return _callSuper(this, KeplerGlDuckDbTable, [props]);
+  }
+  _inherits(KeplerGlDuckDbTable, _KeplerTable);
+  return _createClass(KeplerGlDuckDbTable, [{
+    key: "importRowData",
+    value: function () {
+      var _importRowData = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref) {
+        var data, db, c, fields, rows, columnTypes, rowsForDb, columns, createTableSql;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              data = _ref.data, db = _ref.db, c = _ref.c;
+              _context.prev = 1;
+              fields = data.fields, rows = data.rows;
+              columnTypes = fields.map(function (field) {
+                var explicitDuckDBColumnType = field.duckDBColumnType;
+                var duckDBColumnType = explicitDuckDBColumnType !== null && explicitDuckDBColumnType !== void 0 ? explicitDuckDBColumnType : fieldTypeToColumnType(field.type);
+                if (!duckDBColumnType) {
+                  throw new Error("Unsupported field type \"".concat(field.type, "\" for DuckDB column \"").concat(field.name, "\""));
+                }
+                return {
+                  duckDBColumnType: duckDBColumnType,
+                  normalizeTimestamp: explicitDuckDBColumnType === undefined
+                };
+              }); // DATASET_FORMATS.keplergl loads data as any[][] instead of [{}]
+              // TODO potential memory usage explosion: original data, new object and then DuckDb table
+              rowsForDb = rows.map(function (row) {
+                var isArrayRow = Array.isArray(row);
+                var newRow = isArrayRow ? {} : _objectSpread({}, row);
+                fields.forEach(function (field, index) {
+                  var value = isArrayRow ? row[index] : row[field.name];
+                  var timestamp = columnTypes[index].normalizeTimestamp && field.type === ALL_FIELD_TYPES.timestamp && value !== null && value !== undefined ? timeToUnixMilli(value, field.format || '') : null;
+                  newRow[field.name] = timestamp !== null && Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : value;
+                });
+                return newRow;
+              });
+              _context.next = 7;
+              return db.registerFileText(this.id, JSON.stringify(rowsForDb));
+            case 7:
+              columns = fields.reduce(function (acc, field, index) {
+                var duckDBColumnType = columnTypes[index].duckDBColumnType;
+                return "".concat(acc).concat(index > 0 ? ',' : '', " '").concat(field.name, "': '").concat(duckDBColumnType, "'");
+              }, '');
+              createTableSql = "\n        CREATE TABLE ".concat(quoteTableName(this.label), " AS\n        SELECT *\n        FROM read_json('").concat(this.id, "',\n                       columns = {").concat(columns, "});\n      ");
+              _context.next = 11;
+              return c.query(createTableSql);
+            case 11:
+              _context.next = 17;
+              break;
+            case 13:
+              _context.prev = 13;
+              _context.t0 = _context["catch"](1);
+              console.log('importRowData', _context.t0);
+              throw _context.t0;
+            case 17:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[1, 13]]);
+      }));
+      function importRowData(_x) {
+        return _importRowData.apply(this, arguments);
+      }
+      return importRowData;
+    }()
+  }, {
+    key: "importGeoJsonData",
+    value: function () {
+      var _importGeoJsonData = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_ref2) {
+        var data, db, c, rows, tableName, createTableSql;
+        return _regeneratorRuntime.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;
+              rows = data.rows;
+              _context2.next = 5;
+              return db.registerFileText(this.id, JSON.stringify(rows));
+            case 5:
+              // Identifiers need double quotes; file paths stay single-quoted string literals.
+              tableName = quoteTableName(this.label);
+              createTableSql = "\n        install spatial;\n        load spatial;\n        CREATE TABLE ".concat(tableName, " AS\n        SELECT *\n        FROM ST_READ('").concat(this.id, "', keep_wkb = TRUE);\n        ALTER TABLE ").concat(tableName, "\n        RENAME ").concat(quoteColumnName(DUCKDB_WKB_COLUMN), "\n        TO ").concat(quoteColumnName(KEPLER_GEOM_FROM_GEOJSON_COLUMN), ";\n      ");
+              _context2.next = 9;
+              return c.query(createTableSql);
+            case 9:
+              _context2.next = 15;
+              break;
+            case 11:
+              _context2.prev = 11;
+              _context2.t0 = _context2["catch"](1);
+              console.error('importGeoJsonData', _context2.t0);
+              throw _context2.t0;
+            case 15:
+              return _context2.abrupt("return", {
+                // _geojson column is created from geometry with keep_wkb flag and contains valid WKB data.
+                geoarrowMetadata: _defineProperty({}, KEPLER_GEOM_FROM_GEOJSON_COLUMN, GEOARROW_EXTENSIONS.WKB)
+              });
+            case 16:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[1, 11]]);
+      }));
+      function importGeoJsonData(_x2) {
+        return _importGeoJsonData.apply(this, arguments);
+      }
+      return importGeoJsonData;
+    }()
+  }, {
+    key: "importArrowData",
+    value: function () {
+      var _importArrowData = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3(_ref3) {
+        var data, c, adjustedMetadata, arrowTable, setupSql;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              data = _ref3.data, c = _ref3.c;
+              adjustedMetadata = {};
+              _context3.prev = 2;
+              // 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 = isArrowTable(data.rows) ? data.rows : restoreArrowTable(data.cols || [], data.fields, data.arrowSchema); // remove unsupported extensions from an arrow table that throw exceptions in DuckDB.
+              adjustedMetadata = removeUnsupportedExtensions(arrowTable);
+              setupSql = "\n        install spatial;\n        load spatial;\n      ";
+              _context3.next = 8;
+              return c.query(setupSql);
+            case 8:
+              _context3.next = 10;
+              return c.insertArrowTable(arrowTable, {
+                name: this.label
+              });
+            case 10:
+              // restore unsupported extensions that throw exceptions in DuckDb
+              restoreUnsupportedExtensions(arrowTable, adjustedMetadata);
+              _context3.next = 17;
+              break;
+            case 13:
+              _context3.prev = 13;
+              _context3.t0 = _context3["catch"](2);
+              // Known issues:
+              // 1) Arrow Type with extension name: geoarrow.point and format: +w:2 is not currently supported in DuckDB.
+              console.error('importArrowData', _context3.t0);
+              throw _context3.t0;
+            case 17:
+              return _context3.abrupt("return", {
+                geoarrowMetadata: _objectSpread(_objectSpread({}, SUGGESTED_GEOM_COLUMNS), adjustedMetadata),
+                // use fields generated from the created arrow table
+                useNewFields: true
+              });
+            case 18:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[2, 13]]);
+      }));
+      function importArrowData(_x3) {
+        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 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4(data) {
+        var db, c, _data$duckdbTableName, tableName, format, _data$rows, _data$rows2, _data$rows3, _data$cols, importDetails, fields, cols, _data$fields, _ref4, _ref4$geoarrowMetadat, geoarrowMetadata, _ref4$useNewFields, useNewFields, duckDbColumns, tableDuckDBTypes, adjustedQuery, arrowResult, compactedResult;
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 2;
+              return getApplicationConfig().database;
+            case 2:
+              db = _context4.sent;
+              if (db) {
+                _context4.next = 6;
+                break;
+              }
+              console.error('The database is not configured properly.');
+              return _context4.abrupt("return", {
+                fields: [],
+                cols: []
+              });
+            case 6:
+              _context4.next = 8;
+              return db.connect();
+            case 8:
+              c = _context4.sent;
+              _context4.prev = 9;
+              tableName = (_data$duckdbTableName = data.duckdbTableName) !== null && _data$duckdbTableName !== void 0 ? _data$duckdbTableName : this.label; // An explicit duckdbTableName reuses an existing table (for example, a SQL query result).
+              // Preserve it; only replace tables that Kepler will populate from imported data below.
+              if (data.duckdbTableName) {
+                _context4.next = 14;
+                break;
+              }
+              _context4.next = 14;
+              return dropTableIfExists(c, tableName);
+            case 14:
+              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]) || _typeof((_data$rows2 = data.rows) === null || _data$rows2 === void 0 ? void 0 : _data$rows2[0]) === 'object') {
+                  format = DATASET_FORMATS.row;
+                } else if (((_data$rows3 = data.rows) === null || _data$rows3 === void 0 ? void 0 : _data$rows3.type) === 'FeatureCollection') {
+                  format = DATASET_FORMATS.geojson;
+                } else if (isArrowVector((_data$cols = data.cols) === null || _data$cols === void 0 ? void 0 : _data$cols[0])) {
+                  format = DATASET_FORMATS.arrow;
+                }
+              }
+              if (!data.duckdbTableName) {
+                _context4.next = 20;
+                break;
+              }
+              importDetails = {
+                useNewFields: true
+              };
+              _context4.next = 38;
+              break;
+            case 20:
+              if (!(format === DATASET_FORMATS.row)) {
+                _context4.next = 25;
+                break;
+              }
+              _context4.next = 23;
+              return this.importRowData({
+                data: data,
+                db: db,
+                c: c
+              });
+            case 23:
+              _context4.next = 38;
+              break;
+            case 25:
+              if (!(format === DATASET_FORMATS.geojson)) {
+                _context4.next = 31;
+                break;
+              }
+              _context4.next = 28;
+              return this.importGeoJsonData({
+                data: data,
+                db: db,
+                c: c
+              });
+            case 28:
+              importDetails = _context4.sent;
+              _context4.next = 38;
+              break;
+            case 31:
+              if (!(format === DATASET_FORMATS.arrow)) {
+                _context4.next = 37;
+                break;
+              }
+              _context4.next = 34;
+              return this.importArrowData({
+                data: data,
+                db: db,
+                c: c
+              });
+            case 34:
+              importDetails = _context4.sent;
+              _context4.next = 38;
+              break;
+            case 37:
+              console.error('Unrecognized format', format);
+            case 38:
+              fields = [];
+              cols = [];
+              _context4.prev = 40;
+              _ref4 = importDetails || {}, _ref4$geoarrowMetadat = _ref4.geoarrowMetadata, geoarrowMetadata = _ref4$geoarrowMetadat === void 0 ? {} : _ref4$geoarrowMetadat, _ref4$useNewFields = _ref4.useNewFields, useNewFields = _ref4$useNewFields === void 0 ? false : _ref4$useNewFields;
+              _context4.next = 44;
+              return getDuckDBColumnTypes(c, tableName);
+            case 44:
+              duckDbColumns = _context4.sent;
+              tableDuckDBTypes = getDuckDBColumnTypesMap(duckDbColumns);
+              adjustedQuery = castDuckDBTypesForKepler(tableName, duckDbColumns);
+              _context4.next = 49;
+              return c.query(adjustedQuery);
+            case 49:
+              arrowResult = _context4.sent;
+              setGeoArrowWKBExtension(arrowResult, duckDbColumns);
+
+              // TODO if format is an arrow table then just use the original one, instead of the new table from the query?
+
+              restoreGeoarrowMetadata(arrowResult, geoarrowMetadata);
+              compactedResult = compactArrowTable(arrowResult);
+              fields = useNewFields ? arrowSchemaToFields(compactedResult, tableDuckDBTypes) : (_data$fields = data.fields) !== null && _data$fields !== void 0 ? _data$fields : arrowSchemaToFields(compactedResult, tableDuckDBTypes);
+              cols = _toConsumableArray(Array(compactedResult.numCols).keys()).map(function (i) {
+                return compactedResult.getChildAt(i);
+              }).filter(function (col) {
+                return col;
+              });
+              _context4.next = 61;
+              break;
+            case 57:
+              _context4.prev = 57;
+              _context4.t0 = _context4["catch"](40);
+              console.error('DuckDB table: createTableAndGetArrow', _context4.t0);
+              throw _context4.t0;
+            case 61:
+              return _context4.abrupt("return", {
+                fields: fields,
+                cols: cols
+              });
+            case 62:
+              _context4.prev = 62;
+              _context4.next = 65;
+              return c.close();
+            case 65:
+              return _context4.finish(62);
+            case 66:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this, [[9,, 62, 66], [40, 57]]);
+      }));
+      function createTableAndGetArrow(_x4) {
+        return _createTableAndGetArrow.apply(this, arguments);
+      }
+      return createTableAndGetArrow;
+    }())
+  }, {
+    key: "importData",
+    value: function () {
+      var _importData = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5(_ref5) {
+        var data, _yield$this$createTab, fields, cols;
+        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              data = _ref5.data;
+              if (!(this.type === DatasetType.VECTOR_TILE)) {
+                _context5.next = 4;
+                break;
+              }
+              _superPropGet(KeplerGlDuckDbTable, "importData", this, 3)([{
+                data: _objectSpread(_objectSpread({}, data), {}, {
+                  rows: []
+                })
+              }]);
+              return _context5.abrupt("return");
+            case 4:
+              _context5.next = 6;
+              return this.createTableAndGetArrow(data);
+            case 6:
+              _yield$this$createTab = _context5.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 _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function importData(_x5) {
+        return _importData.apply(this, arguments);
+      }
+      return importData;
+    }()
+  }, {
+    key: "update",
+    value: function () {
+      var _update = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6(data) {
+        var _yield$this$createTab2, cols;
+        return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              if (!(this.type === DatasetType.VECTOR_TILE)) {
+                _context6.next = 3;
+                break;
+              }
+              _superPropGet(KeplerGlDuckDbTable, "importData", this, 3)([{
+                data: data
+              }]);
+              return _context6.abrupt("return", this);
+            case 3:
+              _context6.next = 5;
+              return this.createTableAndGetArrow(data);
+            case 5:
+              _yield$this$createTab2 = _context6.sent;
+              cols = _yield$this$createTab2.cols;
+              return _context6.abrupt("return", _superPropGet(KeplerGlDuckDbTable, "update", this, 3)([{
+                cols: cols,
+                rows: [],
+                fields: []
+              }]));
+            case 8:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function update(_x6) {
+        return _update.apply(this, arguments);
+      }
+      return update;
+    }()
+    /**
+     * DuckDB's Arrow view is a query snapshot. Mutating it without SQL INSERT
+     * would desync the WASM table, so row edits stay a warned no-op.
+     */
+  }, {
+    key: "appendRows",
+    value: function appendRows(_rows) {
+      warnDuckDbRowEdits('appendRows');
+      return false;
+    }
+  }, {
+    key: "upsertRows",
+    value: function upsertRows(_rows, _keyField) {
+      warnDuckDbRowEdits('upsertRows');
+      return false;
+    }
+  }, {
+    key: "removeRows",
+    value: function removeRows(_indexes) {
+      warnDuckDbRowEdits('removeRows');
+      return false;
+    }
+  }]);
+}(KeplerTable);
+
+/**
+ * Try to restore geoarrow metadata lost during DuckDb ingestion.
+ * Note that this function can generate wrong geometry types.
+ * @param arrowTable Arrow table to update.
+ * @param geoarrowMetadata A map with field names that usually used to store geoarrow geometry.
+ */
+_defineProperty(KeplerGlDuckDbTable, "getFileProcessor", function (data, inputFormat) {
+  var processor;
+  var format;
+  var geojsonData = getGeoJsonFromLoaderResult(data);
+  if (inputFormat === DATASET_FORMATS.arrow || isArrowData(data)) {
+    format = DATASET_FORMATS.arrow;
+    processor = processArrowBatches;
+  } else if (inputFormat === DATASET_FORMATS.keplergl || isKeplerGlMap(data)) {
+    format = DATASET_FORMATS.keplergl;
+    processor = processKeplerglJSONforDuckDb;
+  } else if (inputFormat === DATASET_FORMATS.geojson || geojsonData) {
+    format = DATASET_FORMATS.geojson;
+    processor = function processor(raw) {
+      var _getGeoJsonFromLoader;
+      return processGeojson((_getGeoJsonFromLoader = getGeoJsonFromLoaderResult(raw)) !== null && _getGeoJsonFromLoader !== void 0 ? _getGeoJsonFromLoader : raw);
+    };
+  } else if (inputFormat === DATASET_FORMATS.row || isRowObject(data)) {
+    // csv file goes here
+    format = DATASET_FORMATS.row;
+    processor = processCsvRowObject; // directly import json object into duckdb-wasm
+  } else if (data && _typeof(data) === 'object' && (data.shape === 'object-row-table' || data.shape === 'row-table') && Array.isArray(data.data)) {
+    format = DATASET_FORMATS.row;
+    processor = function processor() {
+      return processCsvRowObject(data.data);
+    };
+  }
+  return {
+    processor: processor,
+    format: format
+  };
+});
+_defineProperty(KeplerGlDuckDbTable, "getInputDataValidator", function () {
+  // In DuckDB mode data is validated later during import.
+  return function (d) {
+    return d;
+  };
+});
+export var restoreGeoarrowMetadata = function restoreGeoarrowMetadata(arrowTable, geoarrowMetadata) {
+  arrowTable.schema.fields.forEach(function (f) {
+    if (arrow.DataType.isBinary(f.type) && geoarrowMetadata[f.name]) {
+      f.metadata.set(GEOARROW_METADATA_KEY, geoarrowMetadata[f.name]);
+    } else if (isGeoArrowPoint(f.type)) {
+      f.metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.POINT);
+    } else if (isGeoArrowLineString(f.type)) {
+      f.metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.LINESTRING);
+    } else if (isGeoArrowPolygon(f.type)) {
+      f.metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.POLYGON);
+    } else if (isGeoArrowMultiPoint(f.type)) {
+      f.metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.MULTIPOINT);
+    } else if (isGeoArrowMultiLineString(f.type)) {
+      f.metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.MULTILINESTRING);
+    } else if (isGeoArrowMultiPolygon(f.type)) {
+      f.metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.MULTIPOLYGON);
+    }
+  });
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["arrow","Console","ALL_FIELD_TYPES","DatasetType","DATASET_FORMATS","GEOARROW_EXTENSIONS","GEOARROW_METADATA_KEY","arrowSchemaToFields","isArrowData","getGeoJsonFromLoaderResult","isKeplerGlMap","isRowObject","processArrowBatches","KeplerTable","getApplicationConfig","compactArrowTable","isArrowTable","isArrowVector","timeToUnixMilli","fieldTypeToColumnType","processCsvRowObject","processGeojson","processKeplerglJSONforDuckDb","isGeoArrowPoint","isGeoArrowLineString","isGeoArrowPolygon","isGeoArrowMultiPoint","isGeoArrowMultiLineString","isGeoArrowMultiPolygon","castDuckDBTypesForKepler","dropTableIfExists","getDuckDBColumnTypes","getDuckDBColumnTypesMap","quoteColumnName","quoteTableName","removeUnsupportedExtensions","restoreArrowTable","setGeoArrowWKBExtension","restoreUnsupportedExtensions","DUCKDB_GEOM_COLUMN","DUCKDB_WKB_COLUMN","KEPLER_GEOM_FROM_GEOJSON_COLUMN","DUCKDB_ROW_EDIT_NOT_IMPLEMENTED","warnDuckDbRowEdits","method","warn","concat","SUGGESTED_GEOM_COLUMNS","_defineProperty","WKB","KeplerGlDuckDbTable","_KeplerTable","props","_classCallCheck","_callSuper","_inherits","_createClass","key","value","_importRowData","_asyncToGenerator","_regeneratorRuntime","mark","_callee","_ref","data","db","c","fields","rows","columnTypes","rowsForDb","columns","createTableSql","wrap","_callee$","_context","prev","next","map","field","explicitDuckDBColumnType","duckDBColumnType","type","Error","name","normalizeTimestamp","undefined","row","isArrayRow","Array","isArray","newRow","_objectSpread","forEach","index","timestamp","format","Number","isFinite","Date","toISOString","registerFileText","id","JSON","stringify","reduce","acc","label","query","t0","console","log","stop","importRowData","_x","apply","arguments","_importGeoJsonData","_callee2","_ref2","tableName","_callee2$","_context2","error","abrupt","geoarrowMetadata","importGeoJsonData","_x2","_importArrowData","_callee3","_ref3","adjustedMetadata","arrowTable","setupSql","_callee3$","_context3","cols","arrowSchema","insertArrowTable","useNewFields","importArrowData","_x3","_createTableAndGetArrow","_callee4","_data$duckdbTableName","_data$rows","_data$rows2","_data$rows3","_data$cols","importDetails","_data$fields","_ref4","_ref4$geoarrowMetadat","_ref4$useNewFields","duckDbColumns","tableDuckDBTypes","adjustedQuery","arrowResult","compactedResult","_callee4$","_context4","database","sent","connect","duckdbTableName","metadata","_typeof","geojson","restoreGeoarrowMetadata","_toConsumableArray","numCols","keys","i","getChildAt","filter","col","close","finish","createTableAndGetArrow","_x4","_importData","_callee5","_ref5","_yield$this$createTab","_callee5$","_context5","VECTOR_TILE","_superPropGet","importData","_x5","_update","_callee6","_yield$this$createTab2","_callee6$","_context6","update","_x6","appendRows","_rows","upsertRows","_keyField","removeRows","_indexes","inputFormat","processor","geojsonData","keplergl","raw","_getGeoJsonFromLoader","shape","d","schema","f","DataType","isBinary","set","POINT","LINESTRING","POLYGON","MULTIPOINT","MULTILINESTRING","MULTIPOLYGON"],"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 Console from 'global/console';\n\nimport {\n  ALL_FIELD_TYPES,\n  DatasetType,\n  DATASET_FORMATS,\n  GEOARROW_EXTENSIONS,\n  GEOARROW_METADATA_KEY\n} from '@kepler.gl/constants';\nimport {\n  arrowSchemaToFields,\n  isArrowData,\n  getGeoJsonFromLoaderResult,\n  isKeplerGlMap,\n  isRowObject,\n  processArrowBatches\n} from '@kepler.gl/processors';\nimport {KeplerTable} from '@kepler.gl/table';\nimport {Field} from '@kepler.gl/types';\nimport {\n  getApplicationConfig,\n  DatabaseAdapter,\n  DatabaseConnection,\n  compactArrowTable,\n  isArrowTable,\n  isArrowVector,\n  timeToUnixMilli\n} from '@kepler.gl/utils';\n\nimport {\n  fieldTypeToColumnType,\n  processCsvRowObject,\n  processGeojson,\n  processKeplerglJSONforDuckDb,\n  ProcessorResult\n} from '../processors/data-processor';\n\nimport {\n  isGeoArrowPoint,\n  isGeoArrowLineString,\n  isGeoArrowPolygon,\n  isGeoArrowMultiPoint,\n  isGeoArrowMultiLineString,\n  isGeoArrowMultiPolygon\n} from './duckdb-table-utils';\n\nimport {\n  castDuckDBTypesForKepler,\n  dropTableIfExists,\n  getDuckDBColumnTypes,\n  getDuckDBColumnTypesMap,\n  quoteColumnName,\n  quoteTableName,\n  removeUnsupportedExtensions,\n  restoreArrowTable,\n  setGeoArrowWKBExtension,\n  restoreUnsupportedExtensions\n} from '../table/duckdb-table-utils';\n\n// TODO use files from disk or url directly, without parsing by loaders and then ingection into DeckDb\n\n/**\n * Default DuckDb geometry columns created by ST_READ\n */\nconst DUCKDB_GEOM_COLUMN = 'geom';\nconst DUCKDB_WKB_COLUMN = 'wkb_geometry';\n\n/**\n Default column name for processed geojson in Kepler.\n Use this name to rename default 'geom' column from DuckDb\n in order to support Kepler maps saved before introduction of DuckDb plugin.\n */\nconst KEPLER_GEOM_FROM_GEOJSON_COLUMN = '_geojson';\n\nconst DUCKDB_ROW_EDIT_NOT_IMPLEMENTED =\n  'In-place row edits (append, upsert, delete) are not implemented for DuckDB tables. DuckDB INSERT is not supported yet. Use addDataToMap with keepExistingConfig to replace the table.';\n\nfunction warnDuckDbRowEdits(method: string): void {\n  Console.warn(`KeplerGlDuckDbTable.${method}: ${DUCKDB_ROW_EDIT_NOT_IMPLEMENTED}`);\n}\n\n/**\n * Names of columns that most likely contain binary wkb geometry\n */\nconst SUGGESTED_GEOM_COLUMNS = {\n  [KEPLER_GEOM_FROM_GEOJSON_COLUMN]: GEOARROW_EXTENSIONS.WKB,\n  [DUCKDB_GEOM_COLUMN]: GEOARROW_EXTENSIONS.WKB,\n  geometry: GEOARROW_EXTENSIONS.WKB\n};\n\ntype ImportDataToDuckProps = {\n  data: ProcessorResult & {arrowSchema: arrow.Schema};\n  db: DatabaseAdapter;\n  c: DatabaseConnection;\n};\n\ntype ImportDataToDuckResult = {\n  // DuckDb drops geoarrow metadata, so try to preserve and then restore the extension name\n  geoarrowMetadata?: Record<string, string>;\n  // Use fields from arrow table even if fields are provided\n  useNewFields?: boolean;\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      const columnTypes = fields.map(field => {\n        const explicitDuckDBColumnType = (field as typeof field & {duckDBColumnType?: string})\n          .duckDBColumnType;\n        const duckDBColumnType = explicitDuckDBColumnType ?? fieldTypeToColumnType(field.type);\n\n        if (!duckDBColumnType) {\n          throw new Error(\n            `Unsupported field type \"${field.type}\" for DuckDB column \"${field.name}\"`\n          );\n        }\n\n        return {\n          duckDBColumnType,\n          normalizeTimestamp: explicitDuckDBColumnType === undefined\n        };\n      });\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 = rows.map(row => {\n        const isArrayRow = Array.isArray(row);\n        const newRow: Record<string, unknown> = isArrayRow ? {} : {...row};\n\n        fields.forEach((field, index) => {\n          const value = isArrayRow ? row[index] : row[field.name];\n          const timestamp =\n            columnTypes[index].normalizeTimestamp &&\n            field.type === ALL_FIELD_TYPES.timestamp &&\n            value !== null &&\n            value !== undefined\n              ? timeToUnixMilli(value as string | number | Date, field.format || '')\n              : null;\n\n          newRow[field.name] =\n            timestamp !== null && Number.isFinite(timestamp)\n              ? new Date(timestamp).toISOString()\n              : value;\n        });\n\n        return newRow;\n      });\n\n      await db.registerFileText(this.id, JSON.stringify(rowsForDb));\n\n      const columns = fields.reduce((acc, field, index) => {\n        const {duckDBColumnType} = columnTypes[index];\n        return `${acc}${index > 0 ? ',' : ''} '${field.name}': '${duckDBColumnType}'`;\n      }, '');\n\n      const createTableSql = `\n        CREATE TABLE ${quoteTableName(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      throw error;\n    }\n  }\n\n  async importGeoJsonData({data, db, c}: ImportDataToDuckProps): Promise<ImportDataToDuckResult> {\n    try {\n      const {rows} = data;\n      await db.registerFileText(this.id, JSON.stringify(rows));\n\n      // Identifiers need double quotes; file paths stay single-quoted string literals.\n      const tableName = quoteTableName(this.label);\n      const createTableSql = `\n        install spatial;\n        load spatial;\n        CREATE TABLE ${tableName} AS\n        SELECT *\n        FROM ST_READ('${this.id}', keep_wkb = TRUE);\n        ALTER TABLE ${tableName}\n        RENAME ${quoteColumnName(DUCKDB_WKB_COLUMN)}\n        TO ${quoteColumnName(KEPLER_GEOM_FROM_GEOJSON_COLUMN)};\n      `;\n\n      await c.query(createTableSql);\n    } catch (error) {\n      console.error('importGeoJsonData', error);\n      throw error;\n    }\n\n    return {\n      // _geojson column is created from geometry with keep_wkb flag and contains valid WKB data.\n      geoarrowMetadata: {[KEPLER_GEOM_FROM_GEOJSON_COLUMN]: GEOARROW_EXTENSIONS.WKB}\n    };\n  }\n\n  async importArrowData({data, c}: ImportDataToDuckProps): Promise<ImportDataToDuckResult> {\n    let adjustedMetadata = {};\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 = isArrowTable(data.rows)\n        ? data.rows\n        : restoreArrowTable(data.cols || [], data.fields, data.arrowSchema);\n\n      // remove unsupported extensions from an arrow table that throw exceptions in DuckDB.\n      adjustedMetadata = removeUnsupportedExtensions(arrowTable);\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\n      // restore unsupported extensions that throw exceptions in DuckDb\n      restoreUnsupportedExtensions(arrowTable, adjustedMetadata);\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      throw error;\n    }\n\n    return {\n      geoarrowMetadata: {...SUGGESTED_GEOM_COLUMNS, ...adjustedMetadata},\n      // use fields generated from the created arrow table\n      useNewFields: true\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 getApplicationConfig().database;\n    if (!db) {\n      console.error('The database is not configured properly.');\n      return {fields: [], cols: []};\n    }\n    const c = await db.connect();\n\n    try {\n      const tableName = data.duckdbTableName ?? this.label;\n      // An explicit duckdbTableName reuses an existing table (for example, a SQL query result).\n      // Preserve it; only replace tables that Kepler will populate from imported data below.\n      if (!data.duckdbTableName) await dropTableIfExists(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 (isArrowVector(data.cols?.[0])) {\n          format = DATASET_FORMATS.arrow;\n        }\n      }\n\n      let importDetails: ImportDataToDuckResult | undefined;\n      if (data.duckdbTableName) {\n        importDetails = {useNewFields: true};\n      } else if (format === DATASET_FORMATS.row) {\n        await this.importRowData({data, db, c});\n      } else if (format === DATASET_FORMATS.geojson) {\n        importDetails = await this.importGeoJsonData({data, db, c});\n      } else if (format === DATASET_FORMATS.arrow) {\n        importDetails = 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        const {geoarrowMetadata = {}, useNewFields = false} = importDetails || {};\n\n        const duckDbColumns = await getDuckDBColumnTypes(c, tableName);\n        const tableDuckDBTypes = getDuckDBColumnTypesMap(duckDbColumns);\n        const adjustedQuery = castDuckDBTypesForKepler(tableName, duckDbColumns);\n        const arrowResult = await c.query(adjustedQuery);\n        setGeoArrowWKBExtension(arrowResult, duckDbColumns);\n\n        // TODO if format is an arrow table then just use the original one, instead of the new table from the query?\n\n        restoreGeoarrowMetadata(arrowResult, geoarrowMetadata);\n\n        const compactedResult = compactArrowTable(arrowResult);\n\n        fields = useNewFields\n          ? arrowSchemaToFields(compactedResult, tableDuckDBTypes)\n          : data.fields ?? arrowSchemaToFields(compactedResult, tableDuckDBTypes);\n        cols = [...Array(compactedResult.numCols).keys()]\n          .map(i => compactedResult.getChildAt(i))\n          .filter(col => col) as arrow.Vector[];\n      } catch (error) {\n        console.error('DuckDB table: createTableAndGetArrow', error);\n        throw error;\n      }\n\n      return {fields, cols};\n    } finally {\n      await c.close();\n    }\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  /**\n   * DuckDB's Arrow view is a query snapshot. Mutating it without SQL INSERT\n   * would desync the WASM table, so row edits stay a warned no-op.\n   */\n  appendRows(_rows: any[][]): boolean {\n    warnDuckDbRowEdits('appendRows');\n    return false;\n  }\n\n  upsertRows(_rows: any[][], _keyField: string): boolean {\n    warnDuckDbRowEdits('upsertRows');\n    return false;\n  }\n\n  removeRows(_indexes: number[]): boolean {\n    warnDuckDbRowEdits('removeRows');\n    return false;\n  }\n\n  static getFileProcessor = function (data: any, inputFormat?: string) {\n    let processor;\n    let format;\n    const geojsonData = getGeoJsonFromLoaderResult(data);\n    if (inputFormat === DATASET_FORMATS.arrow || isArrowData(data)) {\n      format = DATASET_FORMATS.arrow;\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.geojson || geojsonData) {\n      format = DATASET_FORMATS.geojson;\n      processor = (raw: unknown) => processGeojson(getGeoJsonFromLoaderResult(raw) ?? raw);\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 (\n      data &&\n      typeof data === 'object' &&\n      (data.shape === 'object-row-table' || data.shape === 'row-table') &&\n      Array.isArray(data.data)\n    ) {\n      format = DATASET_FORMATS.row;\n      processor = () => processCsvRowObject(data.data);\n    }\n    return {processor, format};\n  };\n\n  static getInputDataValidator = function () {\n    // In DuckDB mode data is validated later during import.\n    return d => d;\n  };\n}\n\n/**\n * Try to restore geoarrow metadata lost during DuckDb ingestion.\n * Note that this function can generate wrong geometry types.\n * @param arrowTable Arrow table to update.\n * @param geoarrowMetadata A map with field names that usually used to store geoarrow geometry.\n */\nexport const restoreGeoarrowMetadata = (\n  arrowTable: arrow.Table,\n  geoarrowMetadata: Record<string, string>\n) => {\n  arrowTable.schema.fields.forEach(f => {\n    if (arrow.DataType.isBinary(f.type) && geoarrowMetadata[f.name]) {\n      f.metadata.set(GEOARROW_METADATA_KEY, geoarrowMetadata[f.name]);\n    } else if (isGeoArrowPoint(f.type)) {\n      f.metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.POINT);\n    } else if (isGeoArrowLineString(f.type)) {\n      f.metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.LINESTRING);\n    } else if (isGeoArrowPolygon(f.type)) {\n      f.metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.POLYGON);\n    } else if (isGeoArrowMultiPoint(f.type)) {\n      f.metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.MULTIPOINT);\n    } else if (isGeoArrowMultiLineString(f.type)) {\n      f.metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.MULTILINESTRING);\n    } else if (isGeoArrowMultiPolygon(f.type)) {\n      f.metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.MULTIPOLYGON);\n    }\n  });\n};\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/table/index.js

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+export * from './duckdb-table-utils';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3RhYmxlL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVRcbi8vIENvcHlyaWdodCBjb250cmlidXRvcnMgdG8gdGhlIGtlcGxlci5nbCBwcm9qZWN0XG5cbmV4cG9ydCAqIGZyb20gJy4vZHVja2RiLXRhYmxlLXV0aWxzJztcbiJdLCJtYXBwaW5ncyI6IkFBQUE7QUFDQTs7QUFFQSxjQUFjLHNCQUFzQiIsImlnbm9yZUxpc3QiOltdfQ==