dtable-statistic 4.0.2-test-2

package/es/calculator/combination-calculator.js

@@ -0,0 +1,296 @@
+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 { CellType, filter2SqlCondition, TableUtils } from 'dtable-store';
+import BaseCalculator from './base-calculator';
+import StatUtils from '../utils/stat-utils';
+import { getSummaryColumnMethod, formatNumericValue } from '../utils/common-utils';
+import { getFormattedLabel } from '../utils/row-utils';
+import { getSqlGroup } from '../utils/sql-utils';
+import { DTABLE_DB_SUMMARY_METHOD, LABEL_COLORS, SUMMARY_TYPE, TIME_COLUMN_LIST } from '../constants';
+var CombinationCalculator = /*#__PURE__*/function (_BaseCalculator) {
+  _inherits(CombinationCalculator, _BaseCalculator);
+  var _super = _createSuper(CombinationCalculator);
+  function CombinationCalculator(_ref) {
+    var _this;
+    var value = _ref.value,
+      statisticThreadManager = _ref.statisticThreadManager,
+      username = _ref.username,
+      userId = _ref.userId;
+    _classCallCheck(this, CombinationCalculator);
+    _this = _super.call(this, {
+      value: value,
+      statisticThreadManager: statisticThreadManager,
+      username: username,
+      userId: userId
+    });
+    _this.isEmptyLabel = function (label) {
+      return !label;
+    };
+    return _this;
+  }
+  _createClass(CombinationCalculator, [{
+    key: "isValidChart",
+    value: function isValidChart(chart) {
+      if (!this.validateBaseConfigs(chart)) {
+        return false;
+      }
+      var table_id = chart.table_id,
+        x_axis_column_key = chart.x_axis_column_key,
+        y_axis_left_summary_column = chart.y_axis_left_summary_column,
+        y_axis_right_summary_column = chart.y_axis_right_summary_column,
+        y_axis_left_summary_method = chart.y_axis_left_summary_method,
+        y_axis_right_summary_method = chart.y_axis_right_summary_method,
+        y_axis_right_summary_type = chart.y_axis_right_summary_type,
+        y_axis_left_summary_type = chart.y_axis_left_summary_type;
+      var table = this.getTableById(table_id);
+      if (x_axis_column_key && !TableUtils.getTableColumnByKey(table, x_axis_column_key)) {
+        return false;
+      }
+      if (!y_axis_left_summary_type || !y_axis_right_summary_type) return false;
+      if (y_axis_left_summary_type === SUMMARY_TYPE.ADVANCED && y_axis_left_summary_method && !TableUtils.getTableColumnByKey(table, y_axis_left_summary_column)) {
+        return false;
+      }
+      if (y_axis_right_summary_type === SUMMARY_TYPE.ADVANCED && y_axis_right_summary_method && !TableUtils.getTableColumnByKey(table, y_axis_right_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 _this2 = this;
+        var table_id, x_axis_column_key, x_axis_include_empty, groupby_date_granularity, groupby_geolocation_granularity, y_axis_left_summary_type, y_axis_right_summary_type, y_axis_right_summary_method, y_axis_left_summary_method, y_axis_left_summary_column, y_axis_right_summary_column, y_axis_left_group_by_multiple_numeric_column, y_axis_left_group_by_numeric_columns, selectedTable, selectedColumn, groupName, sqlString, result, newResult, results, data, value1Key, leftSummaryColumn, rightSummaryColumn, value2Key, _rightSummaryColumn, _value2Key, groupItems, _leftSummaryColumn, groupItem;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                table_id = chart.table_id, x_axis_column_key = chart.x_axis_column_key, x_axis_include_empty = chart.x_axis_include_empty, groupby_date_granularity = chart.x_axis_date_granularity, groupby_geolocation_granularity = chart.x_axis_geolocation_granularity, y_axis_left_summary_type = chart.y_axis_left_summary_type, y_axis_right_summary_type = chart.y_axis_right_summary_type, y_axis_right_summary_method = chart.y_axis_right_summary_method, y_axis_left_summary_method = chart.y_axis_left_summary_method, y_axis_left_summary_column = chart.y_axis_left_summary_column, y_axis_right_summary_column = chart.y_axis_right_summary_column, y_axis_left_group_by_multiple_numeric_column = chart.y_axis_left_group_by_multiple_numeric_column, y_axis_left_group_by_numeric_columns = chart.y_axis_left_group_by_numeric_columns;
+                selectedTable = this.getTableById(table_id);
+                selectedColumn = TableUtils.getTableColumnByKey(selectedTable, x_axis_column_key);
+                if (selectedColumn) {
+                  _context2.next = 5;
+                  break;
+                }
+                return _context2.abrupt("return", []);
+              case 5:
+                groupName = "`".concat(selectedColumn.name, "`");
+                if (TIME_COLUMN_LIST.includes(selectedColumn.type)) {
+                  groupName = getSqlGroup(groupby_date_granularity, selectedColumn);
+                } else if (selectedColumn.type === CellType.GEOLOCATION) {
+                  groupName = getSqlGroup(groupby_geolocation_granularity, selectedColumn);
+                }
+                sqlString = this.getSqlString(chart, groupName);
+                _context2.next = 10;
+                return this.sqlQuery(sqlString);
+              case 10:
+                result = _context2.sent;
+                if (!(result.status !== 200 || !result.data.success)) {
+                  _context2.next = 13;
+                  break;
+                }
+                return _context2.abrupt("return", []);
+              case 13:
+                newResult = [];
+                if (!(result.status === 200 && result.data.success)) {
+                  _context2.next = 20;
+                  break;
+                }
+                results = result.data || {};
+                data = results.results;
+                if (data) {
+                  _context2.next = 19;
+                  break;
+                }
+                return _context2.abrupt("return", []);
+              case 19:
+                if (!y_axis_left_group_by_multiple_numeric_column) {
+                  value1Key = "COUNT(".concat(selectedColumn.name, ")");
+                  if (y_axis_left_summary_type === SUMMARY_TYPE.ADVANCED) {
+                    leftSummaryColumn = TableUtils.getTableColumnByKey(selectedTable, y_axis_left_summary_column);
+                    value1Key = getSummaryColumnMethod(DTABLE_DB_SUMMARY_METHOD[y_axis_left_summary_method], leftSummaryColumn.name);
+                  }
+                  value2Key = "COUNT(".concat(selectedColumn.name, ")");
+                  if (y_axis_right_summary_type === SUMMARY_TYPE.ADVANCED) {
+                    rightSummaryColumn = TableUtils.getTableColumnByKey(selectedTable, y_axis_right_summary_column);
+                    value2Key = getSummaryColumnMethod(DTABLE_DB_SUMMARY_METHOD[y_axis_right_summary_method], rightSummaryColumn.name);
+                  }
+                  data.forEach(function (item) {
+                    var label = _this2.getLabel(selectedColumn, groupName, item, groupby_date_granularity, groupby_geolocation_granularity);
+                    var value1 = item[value1Key] || 0;
+                    if (y_axis_left_summary_type === SUMMARY_TYPE.ADVANCED) {
+                      value1 = formatNumericValue(value1, leftSummaryColumn);
+                    }
+                    var value2 = item[value2Key] || 0;
+                    if (y_axis_right_summary_type === SUMMARY_TYPE.ADVANCED) {
+                      value2 = formatNumericValue(value2, rightSummaryColumn);
+                    }
+                    if (!_this2.isEmptyLabel(label) || x_axis_include_empty) {
+                      newResult.push({
+                        name: label,
+                        value_left: value1,
+                        value_right: value2,
+                        original_name: item[selectedColumn.key]
+                      });
+                    }
+                  });
+                } else {
+                  _value2Key = "COUNT(".concat(selectedColumn.name, ")");
+                  if (y_axis_right_summary_type === SUMMARY_TYPE.ADVANCED) {
+                    _rightSummaryColumn = TableUtils.getTableColumnByKey(selectedTable, y_axis_right_summary_column);
+                    _value2Key = getSummaryColumnMethod(DTABLE_DB_SUMMARY_METHOD[y_axis_right_summary_method], _rightSummaryColumn.name);
+                  }
+                  groupItems = [];
+                  _leftSummaryColumn = TableUtils.getTableColumnByKey(selectedTable, y_axis_left_summary_column);
+                  groupItem = getSummaryColumnMethod(DTABLE_DB_SUMMARY_METHOD[y_axis_left_summary_method], _leftSummaryColumn.name);
+                  _leftSummaryColumn && !groupItems.includes(groupItem) && groupItems.push(groupItem);
+                  y_axis_left_group_by_numeric_columns.forEach(function (item, index) {
+                    var column = TableUtils.getTableColumnByKey(selectedTable, item.column_key);
+                    if (column) {
+                      var _groupItem = getSummaryColumnMethod(DTABLE_DB_SUMMARY_METHOD[item.summary_method], column.name);
+                      !groupItems.includes(_groupItem) && groupItems.push(_groupItem);
+                    }
+                  });
+                  data.forEach(function (item, index) {
+                    var label = _this2.getLabel(selectedColumn, groupName, item, groupby_date_granularity, groupby_geolocation_granularity);
+                    var value2 = item[_value2Key] || 0;
+                    if (y_axis_right_summary_type === SUMMARY_TYPE.ADVANCED) {
+                      value2 = formatNumericValue(value2, _rightSummaryColumn);
+                    }
+                    groupItems.forEach(function (groupItem, index) {
+                      if (!_this2.isEmptyLabel(label) || x_axis_include_empty) {
+                        var value = item[groupItems[index]] || 0;
+                        if (y_axis_right_summary_type === SUMMARY_TYPE.ADVANCED) {
+                          value = formatNumericValue(value, _leftSummaryColumn);
+                        }
+                        newResult.push({
+                          name: label,
+                          value_left: value,
+                          value_right: value2,
+                          color: LABEL_COLORS[index % 12],
+                          original_name: item[selectedColumn.key]
+                        });
+                      }
+                    });
+                  });
+                }
+              case 20:
+                return _context2.abrupt("return", newResult);
+              case 21:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+      function queryDb(_x2) {
+        return _queryDb.apply(this, arguments);
+      }
+      return queryDb;
+    }()
+  }, {
+    key: "getSqlString",
+    value: function getSqlString(chart, groupName) {
+      var table_id = chart.table_id,
+        view_id = chart.view_id,
+        x_axis_column_key = chart.x_axis_column_key,
+        y_axis_left_summary_type = chart.y_axis_left_summary_type,
+        y_axis_right_summary_type = chart.y_axis_right_summary_type,
+        y_axis_right_summary_method = chart.y_axis_right_summary_method,
+        y_axis_left_summary_method = chart.y_axis_left_summary_method,
+        y_axis_left_summary_column = chart.y_axis_left_summary_column,
+        y_axis_right_summary_column = chart.y_axis_right_summary_column,
+        y_axis_left_group_by_multiple_numeric_column = chart.y_axis_left_group_by_multiple_numeric_column,
+        y_axis_left_group_by_numeric_columns = chart.y_axis_left_group_by_numeric_columns;
+      var selectedTable = this.getTableById(table_id);
+      var selectedView = this.getViewById(view_id, selectedTable);
+      var selectedColumn = TableUtils.getTableColumnByKey(selectedTable, x_axis_column_key);
+      var column1 = TableUtils.getTableColumnByKey(selectedTable, y_axis_left_summary_column);
+      var column2 = TableUtils.getTableColumnByKey(selectedTable, y_axis_right_summary_column);
+      if (!selectedColumn) return [];
+      var sqlCondition = filter2SqlCondition(selectedTable, selectedView);
+      var sqlItems = [];
+      if (y_axis_left_summary_type === SUMMARY_TYPE.COUNT || y_axis_right_summary_type === SUMMARY_TYPE.COUNT) {
+        sqlItems.push("COUNT(`".concat(selectedColumn.name, "`)"));
+      }
+      if (y_axis_right_summary_type === SUMMARY_TYPE.ADVANCED && column2) {
+        var rightSummaryColumnMethod = getSummaryColumnMethod(DTABLE_DB_SUMMARY_METHOD[y_axis_right_summary_method], column2.name);
+        sqlItems.push("".concat(rightSummaryColumnMethod));
+      }
+      if (y_axis_left_summary_type === SUMMARY_TYPE.ADVANCED && column1) {
+        var groupItem = getSummaryColumnMethod(DTABLE_DB_SUMMARY_METHOD[y_axis_left_summary_method], column1.name);
+        !sqlItems.includes(groupItem) && sqlItems.push(groupItem);
+        if (y_axis_left_group_by_multiple_numeric_column) {
+          y_axis_left_group_by_numeric_columns.forEach(function (item, index) {
+            var column = TableUtils.getTableColumnByKey(selectedTable, item.column_key);
+            if (column) {
+              groupItem = getSummaryColumnMethod(DTABLE_DB_SUMMARY_METHOD[item.summary_method], column.name);
+              !sqlItems.includes(groupItem) && sqlItems.push(groupItem);
+            }
+          });
+        }
+      }
+      var sqlColumn = sqlItems.join(',');
+      return "select ".concat(groupName, ", ").concat(sqlColumn, " from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by ").concat(groupName, " order by ").concat(groupName, " limit 5000");
+    }
+  }, {
+    key: "getLabel",
+    value: function getLabel(groupColumn, groupName, item, groupby_date_granularity, groupby_geolocation_granularity) {
+      var isTimeColumn = TIME_COLUMN_LIST.includes(groupColumn.type);
+      var label;
+      if (isTimeColumn || groupColumn.type === CellType.GEOLOCATION) {
+        label = item[groupName];
+      } else {
+        var currentGroupLabel = item[groupColumn.key];
+        label = StatUtils.getGroupLabel(currentGroupLabel, {}, groupColumn, groupby_date_granularity, groupby_geolocation_granularity, this.value);
+        label = getFormattedLabel(groupColumn, label);
+      }
+      return label;
+    }
+  }]);
+  return CombinationCalculator;
+}(BaseCalculator);
+export default CombinationCalculator;

package/es/calculator/compare-bar-calculator.js

@@ -0,0 +1,291 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+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 dayjs from 'dayjs';
+import { filter2SqlCondition, TableUtils } from 'dtable-store';
+import BaseCalculator from './base-calculator';
+import { getSqlGroup, getSqlOrder } from '../utils/sql-utils';
+import StatUtils from '../utils/stat-utils';
+import { getSummaryResult } from '../utils/common-utils';
+import { DTABLE_DB_SUMMARY_METHOD, SUMMARY_TYPE } from '../constants';
+var CompareBarCalculator = /*#__PURE__*/function (_BaseCalculator) {
+  _inherits(CompareBarCalculator, _BaseCalculator);
+  var _super = _createSuper(CompareBarCalculator);
+  function CompareBarCalculator(_ref) {
+    var value = _ref.value,
+      statisticThreadManager = _ref.statisticThreadManager,
+      username = _ref.username,
+      userId = _ref.userId;
+    _classCallCheck(this, CompareBarCalculator);
+    return _super.call(this, {
+      value: value,
+      statisticThreadManager: statisticThreadManager,
+      username: username,
+      userId: userId
+    });
+  }
+  _createClass(CompareBarCalculator, [{
+    key: "isValidChart",
+    value: function isValidChart(chart) {
+      if (!this.validateBaseConfigs(chart)) {
+        return false;
+      }
+      var table_id = chart.table_id,
+        x_axis_column_key = chart.x_axis_column_key,
+        summary_column_key = chart.summary_column_key,
+        y_axis_column_key = chart.y_axis_column_key,
+        x_axis_date_range_start = chart.x_axis_date_range_start,
+        x_axis_date_range_end = chart.x_axis_date_range_end,
+        x_axis_compared_date_range_start = chart.x_axis_compared_date_range_start,
+        x_axis_compared_date_range_end = chart.x_axis_compared_date_range_end;
+      var table = this.getTableById(table_id);
+      if (!TableUtils.getTableColumnByKey(table, x_axis_column_key)) return false;
+      var summaryColumnKey = summary_column_key || y_axis_column_key;
+      if (summaryColumnKey && !TableUtils.getTableColumnByKey(table, summaryColumnKey)) return false;
+      if (!x_axis_date_range_start || !x_axis_date_range_end || !x_axis_compared_date_range_start || !x_axis_compared_date_range_end) {
+        return false;
+      }
+      if (x_axis_date_range_start > x_axis_date_range_end || x_axis_compared_date_range_start > x_axis_compared_date_range_end) {
+        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_key, x_axis_date_granularity, y_axis_summary_type, y_axis_summary_method, y_axis_column_key, x_axis_date_range_start, x_axis_date_range_end, x_axis_compared_date_range_start, x_axis_compared_date_range_end, display_increase, selectedTable, selectedView, selectedColumn, isAdvanced, method, sqlString, groupName, sqlOrder, summaryColumnName, selectedSummaryColumn, sqlCondition, result, groupName1, groupName2, dateRangeResult, dateComparedResult, valueKey, comparedResult, rangeResult, data, _iterator, _step, item, value, index, _iterator2, _step2, _item, dateRangeItem, _value, newItem, value1, increaseValue;
+        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_key = chart.x_axis_column_key, x_axis_date_granularity = chart.x_axis_date_granularity, y_axis_summary_type = chart.y_axis_summary_type, y_axis_summary_method = chart.y_axis_summary_method, y_axis_column_key = chart.y_axis_column_key, x_axis_date_range_start = chart.x_axis_date_range_start, x_axis_date_range_end = chart.x_axis_date_range_end, x_axis_compared_date_range_start = chart.x_axis_compared_date_range_start, x_axis_compared_date_range_end = chart.x_axis_compared_date_range_end, display_increase = chart.display_increase;
+                selectedTable = this.getTableById(table_id);
+                selectedView = this.getViewById(view_id, selectedTable);
+                selectedColumn = TableUtils.getTableColumnByKey(selectedTable, x_axis_column_key);
+                isAdvanced = y_axis_summary_type === SUMMARY_TYPE.ADVANCED;
+                method = isAdvanced ? DTABLE_DB_SUMMARY_METHOD[y_axis_summary_method] : 'COUNT';
+                sqlString = '';
+                groupName = getSqlGroup('day', selectedColumn);
+                sqlOrder = getSqlOrder(null, groupName);
+                summaryColumnName = "".concat(selectedColumn.name);
+                selectedSummaryColumn = {};
+                if (!isAdvanced) {
+                  _context2.next = 16;
+                  break;
+                }
+                selectedSummaryColumn = TableUtils.getTableColumnByKey(selectedTable, y_axis_column_key);
+                if (selectedSummaryColumn) {
+                  _context2.next = 15;
+                  break;
+                }
+                return _context2.abrupt("return", []);
+              case 15:
+                summaryColumnName = "".concat(selectedSummaryColumn.name);
+              case 16:
+                sqlCondition = filter2SqlCondition(selectedTable, selectedView);
+                sqlCondition = this.getStatItemSqlCondition(chart, sqlCondition, "`".concat(selectedColumn.name, "`"));
+                sqlString = "select ".concat(groupName, ", ").concat(method, "(").concat(summaryColumnName, ") from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by ").concat(groupName, " ").concat(sqlOrder, " limit 5000");
+                _context2.next = 21;
+                return this.sqlQuery(sqlString);
+              case 21:
+                result = _context2.sent;
+                groupName1 = "".concat(x_axis_date_range_start, " - ").concat(x_axis_date_range_end);
+                groupName2 = "".concat(x_axis_compared_date_range_start, " - ").concat(x_axis_compared_date_range_end);
+                if (!(result.status === 200 && result.data.success)) {
+                  _context2.next = 61;
+                  break;
+                }
+                dateRangeResult = new Map();
+                dateComparedResult = new Map();
+                valueKey = isAdvanced ? "".concat(method, "(").concat(summaryColumnName, ")") : "".concat(method, "(").concat(selectedColumn.name, ")");
+                result.data.results.forEach(function (item) {
+                  var name = item[groupName];
+                  var label = StatUtils.getGroupLabel(name, {}, selectedColumn, x_axis_date_granularity, '', _this.value);
+                  var value = item[valueKey];
+                  if (name >= x_axis_date_range_start && name <= x_axis_date_range_end) {
+                    var currentValue = dateRangeResult.get(label);
+                    if (!currentValue) {
+                      if (isAdvanced) {
+                        dateRangeResult.set(label, [value]);
+                      } else {
+                        dateRangeResult.set(label, value);
+                      }
+                    } else {
+                      if (isAdvanced) {
+                        currentValue.push(value);
+                      } else {
+                        dateRangeResult.set(label, value + currentValue);
+                      }
+                    }
+                  } else if (name >= x_axis_compared_date_range_start && name <= x_axis_compared_date_range_end) {
+                    var _currentValue = dateComparedResult.get(label);
+                    if (!_currentValue) {
+                      if (isAdvanced) {
+                        dateComparedResult.set(label, [value]);
+                      } else {
+                        dateComparedResult.set(label, value);
+                      }
+                    } else {
+                      if (isAdvanced) {
+                        dateComparedResult.push(value);
+                      } else {
+                        dateComparedResult.set(label, value + _currentValue);
+                      }
+                    }
+                  }
+                });
+                comparedResult = [];
+                rangeResult = [];
+                data = selectedSummaryColumn.data || {};
+                _iterator = _createForOfIteratorHelper(dateRangeResult);
+                try {
+                  for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                    item = _step.value;
+                    value = item[1];
+                    if (isAdvanced) {
+                      value = getSummaryResult(item[1], y_axis_summary_method, data.precision);
+                    }
+                    rangeResult.push({
+                      name: item[0],
+                      value: value,
+                      group_name: groupName1,
+                      raw_name: item[0]
+                    });
+                  }
+                } catch (err) {
+                  _iterator.e(err);
+                } finally {
+                  _iterator.f();
+                }
+                index = 0;
+                _iterator2 = _createForOfIteratorHelper(dateComparedResult);
+                _context2.prev = 36;
+                _iterator2.s();
+              case 38:
+                if ((_step2 = _iterator2.n()).done) {
+                  _context2.next = 51;
+                  break;
+                }
+                _item = _step2.value;
+                dateRangeItem = rangeResult[index];
+                if (dateRangeItem) {
+                  _context2.next = 43;
+                  break;
+                }
+                return _context2.abrupt("break", 51);
+              case 43:
+                _value = _item[1];
+                if (isAdvanced) {
+                  _value = getSummaryResult(_item[1], y_axis_summary_method, data.precision);
+                }
+                newItem = {
+                  name: dateRangeItem.name,
+                  value: _value,
+                  group_name: groupName2,
+                  raw_name: _item[0]
+                };
+                if (display_increase) {
+                  value1 = dateRangeItem.value;
+                  increaseValue = Number(((value1 - _value) / _value).toFixed(2));
+                  if (!_value) {
+                    increaseValue = 1;
+                  }
+                  newItem.increase_value = increaseValue;
+                }
+                comparedResult.push(newItem);
+                index++;
+              case 49:
+                _context2.next = 38;
+                break;
+              case 51:
+                _context2.next = 56;
+                break;
+              case 53:
+                _context2.prev = 53;
+                _context2.t0 = _context2["catch"](36);
+                _iterator2.e(_context2.t0);
+              case 56:
+                _context2.prev = 56;
+                _iterator2.f();
+                return _context2.finish(56);
+              case 59:
+                if (comparedResult.length > rangeResult.length) {
+                  comparedResult = comparedResult.slice(0, rangeResult.length);
+                }
+                return _context2.abrupt("return", [].concat(_toConsumableArray(comparedResult), rangeResult));
+              case 61:
+                return _context2.abrupt("return", []);
+              case 62:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this, [[36, 53, 56, 59]]);
+      }));
+      function queryDb(_x2) {
+        return _queryDb.apply(this, arguments);
+      }
+      return queryDb;
+    }()
+  }, {
+    key: "getStatItemSqlCondition",
+    value: function getStatItemSqlCondition(chart, sqlCondition, name) {
+      var x_axis_date_range_start = chart.x_axis_date_range_start,
+        x_axis_date_range_end = chart.x_axis_date_range_end,
+        x_axis_compared_date_range_start = chart.x_axis_compared_date_range_start,
+        x_axis_compared_date_range_end = chart.x_axis_compared_date_range_end;
+      var newSqlCondition = sqlCondition.length === 0 ? 'where ' : sqlCondition + ' AND';
+      var formattedXAxisDateRangeEnd = dayjs(x_axis_date_range_end).add(1, 'days').format('YYYY-MM-DD');
+      var formattedXAxisComparedDateRangeEnd = dayjs(x_axis_compared_date_range_end).add(1, 'days').format('YYYY-MM-DD');
+      return newSqlCondition + " ((".concat(name, " >= '").concat(x_axis_date_range_start, "' AND ").concat(name, " < '").concat(formattedXAxisDateRangeEnd, "') Or (").concat(name, " >= '").concat(x_axis_compared_date_range_start, "' AND ").concat(name, " < '").concat(formattedXAxisComparedDateRangeEnd, "'))");
+    }
+  }]);
+  return CompareBarCalculator;
+}(BaseCalculator);
+export default CompareBarCalculator;