dtable-statistic 4.4.24-alpha.9 → 5.0.0

package/es/calculator/scatter-calculator.js

@@ -0,0 +1,75 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dtableUtils = require("dtable-utils");
+var _baseCalculator = _interopRequireDefault(require("./base-calculator"));
+var _rowUtils = require("../utils/row-utils");
+var _statUtils = _interopRequireDefault(require("../utils/stat-utils"));
+var _constants = require("../constants");
+class ScatterCalculator extends _baseCalculator.default {
+  isValidChart(chart) {
+    if (!this.validateBaseConfigs(chart)) {
+      return false;
+    }
+    const {
+      table_id,
+      x_axis_column,
+      y_axis_column,
+      group_column
+    } = chart;
+    const table = this.getTableById(table_id);
+    if (!(0, _dtableUtils.getTableColumnByKey)(table, x_axis_column) || !(0, _dtableUtils.getTableColumnByKey)(table, y_axis_column) || !(0, _dtableUtils.getTableColumnByKey)(table, group_column)) {
+      return false;
+    }
+    return true;
+  }
+  async calculate(chart) {
+    if (!this.isValidChart(chart)) return [];
+    if (this.isCalcByQueryDB(chart)) {
+      return await this.queryDb(chart);
+    }
+    return await this.calculateWithWorker(chart);
+  }
+  async queryDb(chart) {
+    const {
+      table_id,
+      view_id,
+      x_axis_column,
+      y_axis_column,
+      group_column
+    } = chart;
+    const selectedTable = this.getTableById(table_id);
+    const selectedView = this.getViewById(view_id, selectedTable);
+    const selectedXAxisColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, x_axis_column);
+    const selectedYAxisColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, y_axis_column);
+    const selectedGroupColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, group_column);
+    const sqlCondition = this.filter2SqlCondition(selectedTable, selectedView);
+    const sqlString = "select `".concat(selectedXAxisColumn.name, "`, `").concat(selectedYAxisColumn.name, "`, `").concat(selectedGroupColumn.name, "` from `").concat(selectedTable.name, "` ").concat(sqlCondition, " limit 5000");
+    const result = await this.sqlQuery(sqlString);
+    if (result.status === 200 && result.data.success) {
+      const data = result.data.results;
+      if (!data) return [];
+      return data.map(item => {
+        const name = this.getColumnValue(item, selectedGroupColumn);
+        return {
+          x_axis: item[x_axis_column],
+          y_axis: item[y_axis_column],
+          group_by: name,
+          name,
+          original_name: item[selectedGroupColumn.key]
+        };
+      });
+    }
+    return [];
+  }
+  getColumnValue(data, column) {
+    const tempValue = data[column.key];
+    const value = _statUtils.default.getGroupLabel(tempValue, data, column, _constants.DATE_GRANULARITY.DAY, '', this.value);
+    return (0, _rowUtils.getFormattedLabel)(column, value, this.value.collaborators);
+  }
+}
+var _default = exports.default = ScatterCalculator;

package/es/calculator/thread-manager.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class ThreadManager {
+  constructor(threadCount) {
+    this.threadCount = threadCount;
+    this.threadList = [];
+    this.queue = [];
+  }
+  async applyThread(id, workerConstructor) {
+    return new Promise((resolve, reject) => {
+      if (this.threadList.length < this.threadCount) {
+        const worker = new workerConstructor();
+        worker.id = id;
+        this.threadList.push(worker);
+        resolve(worker);
+      } else {
+        this.queue.push({
+          id,
+          emitter: resolve,
+          workerConstructor
+        });
+      }
+    });
+  }
+  removeThread(id) {
+    const index = this.threadList.findIndex(worker => worker.id === id);
+    if (index > -1) {
+      this.threadList[index] && this.threadList[index].terminate();
+      this.threadList.splice(index, 1);
+    }
+    if (this.queue.length > 0) {
+      const {
+        id,
+        emitter,
+        workerConstructor
+      } = this.queue.shift();
+      const worker = new workerConstructor();
+      worker.id = id;
+      this.threadList.push(worker);
+      emitter(worker);
+    }
+  }
+  clearQueue() {
+    this.queue = [];
+  }
+  terminateWorkers() {
+    this.threadList.forEach(item => {
+      item && item.terminate();
+    });
+    this.threadList = [];
+  }
+}
+var _default = exports.default = ThreadManager;

package/es/calculator/trend-calculator.js

@@ -0,0 +1,113 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dtableUtils = require("dtable-utils");
+var _baseCalculator = _interopRequireDefault(require("./base-calculator"));
+var _commonUtils = require("../utils/common-utils");
+var _sqlUtils = require("../utils/sql-utils");
+var _trendUtils = require("../utils/trend-utils");
+var _constants = require("../constants");
+class TrendCalculator extends _baseCalculator.default {
+  isValidChart(chart) {
+    if (!this.validateBaseConfigs(chart)) {
+      return false;
+    }
+    const {
+      table_id,
+      date_column,
+      summary_column,
+      summary_type
+    } = chart;
+    const table = this.getTableById(table_id);
+    if (!(0, _dtableUtils.getTableColumnByKey)(table, date_column)) return false;
+    if (summary_type === _constants.SUMMARY_TYPE.ADVANCED && !(0, _dtableUtils.getTableColumnByKey)(table, summary_column)) {
+      return false;
+    }
+    return true;
+  }
+  async calculate(chart) {
+    if (!this.isValidChart(chart)) return {};
+    if (this.isCalcByQueryDB(chart)) {
+      return await this.queryDb(chart);
+    }
+    return await this.calculateWithWorker(chart);
+  }
+  async queryDb(chart) {
+    const {
+      table_id,
+      view_id,
+      date_column,
+      date_granularity,
+      summary_column,
+      summary_type,
+      summary_method
+    } = chart;
+    const selectedTable = this.getTableById(table_id);
+    const selectedView = this.getViewById(view_id, selectedTable);
+    const selectedColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, date_column);
+    if (!selectedColumn) return {};
+    const sqlCondition = this.filter2SqlCondition(selectedTable, selectedView);
+    const numericColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, summary_column);
+    const columnName = selectedColumn.name;
+    const dateGroupBy = (0, _sqlUtils.getSqlGroup)(date_granularity, selectedColumn);
+    let sqlString = '';
+    if (summary_type === _constants.SUMMARY_TYPE.COUNT) {
+      sqlString = "select ".concat(dateGroupBy, ", ").concat(_constants.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 {
+      const summaryColumnMethod = (0, _commonUtils.getSummaryColumnMethod)(_constants.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");
+    }
+    const result = await this.sqlQuery(sqlString);
+    if (result.status === 200 && result.data.success) {
+      const data = result.data;
+      if (!data.results) return {};
+      const results = data.results;
+      let summaryKey = "".concat(_constants.DTABLE_DB_SUMMARY_METHOD.Row_count, "(").concat(columnName, ")");
+      if (summary_type === _constants.SUMMARY_TYPE.ADVANCED) {
+        const summaryColumnMethod = (0, _commonUtils.getSummaryColumnMethod)(_constants.DTABLE_DB_SUMMARY_METHOD[summary_method], numericColumn.name);
+        summaryKey = summaryColumnMethod;
+      }
+      let compareValue, comparedValue;
+      if (date_granularity === 'days_30' || date_granularity === 'days_7') {
+        const {
+          compareValue: value1,
+          comparedValue: value2
+        } = (0, _trendUtils.summaryDurationResult)(results, date_granularity, summary_type, summary_method, true, dateGroupBy, summaryKey);
+        compareValue = value1;
+        comparedValue = value2;
+      } else {
+        const {
+          compareDate,
+          comparedDate
+        } = (0, _trendUtils.getCompareDate)(date_granularity);
+        for (let index = results.length - 1; index >= 0; index--) {
+          const item = results[index];
+          if (!item[dateGroupBy]) continue;
+          const currentDate = item[dateGroupBy] + '';
+          if (currentDate && currentDate < comparedDate) {
+            break;
+          }
+          if (currentDate === compareDate) {
+            compareValue = item[summaryKey];
+          }
+          if (currentDate === comparedDate) {
+            comparedValue = item[summaryKey];
+            break;
+          }
+        }
+      }
+      return {
+        latest: compareValue,
+        previous: comparedValue,
+        result: Math.abs(compareValue - comparedValue) / comparedValue,
+        type: compareValue > comparedValue ? 'up' : 'down'
+      };
+    }
+    return {};
+  }
+}
+var _default = exports.default = TrendCalculator;