dtable-statistic 4.0.2-test-2

package/es/calculator/scatter-calculator.js

@@ -0,0 +1,150 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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 _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import { filter2SqlCondition, TableUtils } from 'dtable-store';
+import BaseCalculator from './base-calculator';
+import { getFormattedLabel } from '../utils/row-utils';
+import StatUtils from '../utils/stat-utils';
+import { DATE_GRANULARITY } from '../constants';
+var ScatterCalculator = /*#__PURE__*/function (_BaseCalculator) {
+  _inherits(ScatterCalculator, _BaseCalculator);
+  var _super = _createSuper(ScatterCalculator);
+  function ScatterCalculator(_ref) {
+    var value = _ref.value,
+      statisticThreadManager = _ref.statisticThreadManager,
+      username = _ref.username,
+      userId = _ref.userId;
+    _classCallCheck(this, ScatterCalculator);
+    return _super.call(this, {
+      value: value,
+      statisticThreadManager: statisticThreadManager,
+      username: username,
+      userId: userId
+    });
+  }
+  _createClass(ScatterCalculator, [{
+    key: "isValidChart",
+    value: function isValidChart(chart) {
+      if (!this.validateBaseConfigs(chart)) {
+        return false;
+      }
+      var table_id = chart.table_id,
+        x_axis_column = chart.x_axis_column,
+        y_axis_column = chart.y_axis_column,
+        group_column = chart.group_column;
+      var table = this.getTableById(table_id);
+      if (!TableUtils.getTableColumnByKey(table, x_axis_column) || !TableUtils.getTableColumnByKey(table, y_axis_column) || !TableUtils.getTableColumnByKey(table, group_column)) {
+        return false;
+      }
+      return true;
+    }
+  }, {
+    key: "calculate",
+    value: function () {
+      var _calculate = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(chart) {
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (this.isValidChart(chart)) {
+                  _context.next = 2;
+                  break;
+                }
+                return _context.abrupt("return", []);
+              case 2:
+                if (!this.isCalcByQueryDB(chart)) {
+                  _context.next = 6;
+                  break;
+                }
+                _context.next = 5;
+                return this.queryDb(chart);
+              case 5:
+                return _context.abrupt("return", _context.sent);
+              case 6:
+                _context.next = 8;
+                return this.calculateWithWorker(chart);
+              case 8:
+                return _context.abrupt("return", _context.sent);
+              case 9:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+      function calculate(_x) {
+        return _calculate.apply(this, arguments);
+      }
+      return calculate;
+    }()
+  }, {
+    key: "queryDb",
+    value: function () {
+      var _queryDb = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(chart) {
+        var _this = this;
+        var table_id, view_id, x_axis_column, y_axis_column, group_column, selectedTable, selectedView, selectedXAxisColumn, selectedYAxisColumn, selectedGroupColumn, sqlCondition, sqlString, result, data;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                table_id = chart.table_id, view_id = chart.view_id, x_axis_column = chart.x_axis_column, y_axis_column = chart.y_axis_column, group_column = chart.group_column;
+                selectedTable = this.getTableById(table_id);
+                selectedView = this.getViewById(view_id, selectedTable);
+                selectedXAxisColumn = TableUtils.getTableColumnByKey(selectedTable, x_axis_column);
+                selectedYAxisColumn = TableUtils.getTableColumnByKey(selectedTable, y_axis_column);
+                selectedGroupColumn = TableUtils.getTableColumnByKey(selectedTable, group_column);
+                sqlCondition = filter2SqlCondition(selectedTable, selectedView);
+                sqlString = "select `".concat(selectedXAxisColumn.name, "`, `").concat(selectedYAxisColumn.name, "`, `").concat(selectedGroupColumn.name, "` from `").concat(selectedTable.name, "` ").concat(sqlCondition, " limit 5000");
+                _context2.next = 10;
+                return this.sqlQuery(sqlString);
+              case 10:
+                result = _context2.sent;
+                if (!(result.status === 200 && result.data.success)) {
+                  _context2.next = 16;
+                  break;
+                }
+                data = result.data.results;
+                if (data) {
+                  _context2.next = 15;
+                  break;
+                }
+                return _context2.abrupt("return", []);
+              case 15:
+                return _context2.abrupt("return", data.map(function (item) {
+                  var name = _this.getColumnValue(item, selectedGroupColumn);
+                  return {
+                    x_axis: item[x_axis_column],
+                    y_axis: item[y_axis_column],
+                    group_by: name,
+                    name: name,
+                    original_name: item[selectedGroupColumn.key]
+                  };
+                }));
+              case 16:
+                return _context2.abrupt("return", []);
+              case 17:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+      function queryDb(_x2) {
+        return _queryDb.apply(this, arguments);
+      }
+      return queryDb;
+    }()
+  }, {
+    key: "getColumnValue",
+    value: function getColumnValue(data, column) {
+      var tempValue = data[column.key];
+      var value = StatUtils.getGroupLabel(tempValue, {}, column, DATE_GRANULARITY.DAY, '', this.value);
+      return getFormattedLabel(column, value, this.value.collaborators);
+    }
+  }]);
+  return ScatterCalculator;
+}(BaseCalculator);
+export default ScatterCalculator;

package/es/calculator/thread-manager.js

@@ -0,0 +1,70 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+var ThreadManager = function ThreadManager(threadCount) {
+  var _this = this;
+  _classCallCheck(this, ThreadManager);
+  this.applyThread = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(id, workerConstructor) {
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              return _context.abrupt("return", new Promise(function (resolve, reject) {
+                if (_this.threadList.length < _this.threadCount) {
+                  var worker = new workerConstructor();
+                  worker.id = id;
+                  _this.threadList.push(worker);
+                  resolve(worker);
+                } else {
+                  _this.queue.push({
+                    id: id,
+                    emitter: resolve,
+                    workerConstructor: workerConstructor
+                  });
+                }
+              }));
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+    return function (_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  this.removeThread = function (id) {
+    var index = _this.threadList.findIndex(function (worker) {
+      return worker.id === id;
+    });
+    if (index > -1) {
+      _this.threadList[index] && _this.threadList[index].terminate();
+      _this.threadList.splice(index, 1);
+    }
+    if (_this.queue.length > 0) {
+      var _this$queue$shift = _this.queue.shift(),
+        _id = _this$queue$shift.id,
+        emitter = _this$queue$shift.emitter,
+        workerConstructor = _this$queue$shift.workerConstructor;
+      var worker = new workerConstructor();
+      worker.id = _id;
+      _this.threadList.push(worker);
+      emitter(worker);
+    }
+  };
+  this.clearQueue = function () {
+    _this.queue = [];
+  };
+  this.terminateWorkers = function () {
+    _this.threadList.forEach(function (item) {
+      item && item.terminate();
+    });
+    _this.threadList = [];
+  };
+  this.threadCount = threadCount;
+  this.threadList = [];
+  this.queue = [];
+};
+export default ThreadManager;

package/es/calculator/trend-calculator.js

@@ -0,0 +1,204 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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 _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import { filter2SqlCondition, TableUtils } from 'dtable-store';
+import BaseCalculator from './base-calculator';
+import { getSummaryColumnMethod } from '../utils/common-utils';
+import { getSqlGroup } from '../utils/sql-utils';
+import { getCompareDate, summaryDurationResult } from '../utils/trend-utils';
+import { DTABLE_DB_SUMMARY_METHOD, SUMMARY_TYPE } from '../constants';
+var TrendCalculator = /*#__PURE__*/function (_BaseCalculator) {
+  _inherits(TrendCalculator, _BaseCalculator);
+  var _super = _createSuper(TrendCalculator);
+  function TrendCalculator(_ref) {
+    var value = _ref.value,
+      statisticThreadManager = _ref.statisticThreadManager,
+      username = _ref.username,
+      userId = _ref.userId;
+    _classCallCheck(this, TrendCalculator);
+    return _super.call(this, {
+      value: value,
+      statisticThreadManager: statisticThreadManager,
+      username: username,
+      userId: userId
+    });
+  }
+  _createClass(TrendCalculator, [{
+    key: "isValidChart",
+    value: function isValidChart(chart) {
+      if (!this.validateBaseConfigs(chart)) {
+        return false;
+      }
+      var table_id = chart.table_id,
+        date_column = chart.date_column,
+        summary_column = chart.summary_column,
+        summary_type = chart.summary_type;
+      var table = this.getTableById(table_id);
+      if (!TableUtils.getTableColumnByKey(table, date_column)) return false;
+      if (summary_type === SUMMARY_TYPE.ADVANCED && !TableUtils.getTableColumnByKey(table, summary_column)) {
+        return false;
+      }
+      return true;
+    }
+  }, {
+    key: "calculate",
+    value: function () {
+      var _calculate = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(chart) {
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (this.isValidChart(chart)) {
+                  _context.next = 2;
+                  break;
+                }
+                return _context.abrupt("return", {});
+              case 2:
+                if (!this.isCalcByQueryDB(chart)) {
+                  _context.next = 6;
+                  break;
+                }
+                _context.next = 5;
+                return this.queryDb(chart);
+              case 5:
+                return _context.abrupt("return", _context.sent);
+              case 6:
+                _context.next = 8;
+                return this.calculateWithWorker(chart);
+              case 8:
+                return _context.abrupt("return", _context.sent);
+              case 9:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+      function calculate(_x) {
+        return _calculate.apply(this, arguments);
+      }
+      return calculate;
+    }()
+  }, {
+    key: "queryDb",
+    value: function () {
+      var _queryDb = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(chart) {
+        var table_id, view_id, date_column, date_granularity, summary_column, summary_type, summary_method, selectedTable, selectedView, selectedColumn, sqlCondition, numericColumn, columnName, dateGroupBy, sqlString, summaryColumnMethod, result, data, results, summaryKey, _summaryColumnMethod, compareValue, comparedValue, _summaryDurationResul, value1, value2, _getCompareDate, compareDate, comparedDate, index, item, currentDate;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                table_id = chart.table_id, view_id = chart.view_id, date_column = chart.date_column, date_granularity = chart.date_granularity, summary_column = chart.summary_column, summary_type = chart.summary_type, summary_method = chart.summary_method;
+                selectedTable = this.getTableById(table_id);
+                selectedView = this.getViewById(view_id, selectedTable);
+                selectedColumn = TableUtils.getTableColumnByKey(selectedTable, date_column);
+                if (selectedColumn) {
+                  _context2.next = 6;
+                  break;
+                }
+                return _context2.abrupt("return", {});
+              case 6:
+                sqlCondition = filter2SqlCondition(selectedTable, selectedView);
+                numericColumn = TableUtils.getTableColumnByKey(selectedTable, summary_column);
+                columnName = selectedColumn.name;
+                dateGroupBy = getSqlGroup(date_granularity, selectedColumn);
+                sqlString = '';
+                if (summary_type === SUMMARY_TYPE.COUNT) {
+                  sqlString = "select ".concat(dateGroupBy, ", ").concat(DTABLE_DB_SUMMARY_METHOD.Row_count, "(").concat(columnName, ") from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by ").concat(dateGroupBy, " order by ").concat(dateGroupBy, " limit 5000");
+                } else {
+                  summaryColumnMethod = getSummaryColumnMethod(DTABLE_DB_SUMMARY_METHOD[summary_method], numericColumn.name);
+                  sqlString = "select ".concat(dateGroupBy, ", ").concat(summaryColumnMethod, " from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by ").concat(dateGroupBy, " order by ").concat(dateGroupBy, " limit 5000");
+                }
+                _context2.next = 14;
+                return this.sqlQuery(sqlString);
+              case 14:
+                result = _context2.sent;
+                if (!(result.status === 200 && result.data.success)) {
+                  _context2.next = 45;
+                  break;
+                }
+                data = result.data;
+                if (data.results) {
+                  _context2.next = 19;
+                  break;
+                }
+                return _context2.abrupt("return", {});
+              case 19:
+                results = data.results;
+                summaryKey = "".concat(DTABLE_DB_SUMMARY_METHOD.Row_count, "(").concat(columnName, ")");
+                if (summary_type === SUMMARY_TYPE.ADVANCED) {
+                  _summaryColumnMethod = getSummaryColumnMethod(DTABLE_DB_SUMMARY_METHOD[summary_method], numericColumn.name);
+                  summaryKey = _summaryColumnMethod;
+                }
+                if (!(date_granularity === 'days_30' || date_granularity === 'days_7')) {
+                  _context2.next = 28;
+                  break;
+                }
+                _summaryDurationResul = summaryDurationResult(results, date_granularity, summary_type, summary_method, true, dateGroupBy, summaryKey), value1 = _summaryDurationResul.compareValue, value2 = _summaryDurationResul.comparedValue;
+                compareValue = value1;
+                comparedValue = value2;
+                _context2.next = 44;
+                break;
+              case 28:
+                _getCompareDate = getCompareDate(date_granularity), compareDate = _getCompareDate.compareDate, comparedDate = _getCompareDate.comparedDate;
+                index = results.length - 1;
+              case 30:
+                if (!(index >= 0)) {
+                  _context2.next = 44;
+                  break;
+                }
+                item = results[index];
+                if (item[dateGroupBy]) {
+                  _context2.next = 34;
+                  break;
+                }
+                return _context2.abrupt("continue", 41);
+              case 34:
+                currentDate = item[dateGroupBy] + '';
+                if (!(currentDate && currentDate < comparedDate)) {
+                  _context2.next = 37;
+                  break;
+                }
+                return _context2.abrupt("break", 44);
+              case 37:
+                if (currentDate === compareDate) {
+                  compareValue = item[summaryKey];
+                }
+                if (!(currentDate === comparedDate)) {
+                  _context2.next = 41;
+                  break;
+                }
+                comparedValue = item[summaryKey];
+                return _context2.abrupt("break", 44);
+              case 41:
+                index--;
+                _context2.next = 30;
+                break;
+              case 44:
+                return _context2.abrupt("return", {
+                  latest: compareValue,
+                  previous: comparedValue,
+                  result: Math.abs(compareValue - comparedValue) / comparedValue,
+                  type: compareValue > comparedValue ? 'up' : 'down'
+                });
+              case 45:
+                return _context2.abrupt("return", {});
+              case 46:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+      function queryDb(_x2) {
+        return _queryDb.apply(this, arguments);
+      }
+      return queryDb;
+    }()
+  }]);
+  return TrendCalculator;
+}(BaseCalculator);
+export default TrendCalculator;