dtable-statistic 4.2.1 → 4.3.0

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

@@ -1,100 +1,71 @@
-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 BasicChartCalculator from './basic-chart-calculator';
 import { DATA_SORT_TYPE } from '../constants';
-var HorizontalBarCalculator = /*#__PURE__*/function () {
-  function HorizontalBarCalculator(_ref) {
-    var value = _ref.value,
-      statisticThreadManager = _ref.statisticThreadManager,
-      username = _ref.username,
-      userId = _ref.userId;
-    _classCallCheck(this, HorizontalBarCalculator);
+class HorizontalBarCalculator {
+  constructor(_ref) {
+    let {
+      value,
+      statisticThreadManager,
+      username,
+      userId
+    } = _ref;
     this.basicChartCalculator = new BasicChartCalculator({
-      value: value,
-      username: username,
-      userId: userId,
-      statisticThreadManager: statisticThreadManager
+      value,
+      username,
+      userId,
+      statisticThreadManager
     });
   }
-  _createClass(HorizontalBarCalculator, [{
-    key: "isValidChart",
-    value: function isValidChart(chart) {
-      var convertedChart = this.convertChart(chart);
-      return this.basicChartCalculator.isValidChart(convertedChart);
-    }
-  }, {
-    key: "calculate",
-    value: function () {
-      var _calculate = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(chart) {
-        var convertedChart;
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                convertedChart = this.convertChart(chart);
-                _context.next = 3;
-                return this.basicChartCalculator.calculate(convertedChart);
-              case 3:
-                return _context.abrupt("return", _context.sent);
-              case 4:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this);
-      }));
-      function calculate(_x) {
-        return _calculate.apply(this, arguments);
-      }
-      return calculate;
-    }()
-  }, {
-    key: "convertChart",
-    value: function convertChart(chart) {
-      var _id = chart._id,
-        table_id = chart.table_id,
-        view_id = chart.view_id,
-        vertical_axis_column_key = chart.vertical_axis_column_key,
-        vertical_axis_date_granularity = chart.vertical_axis_date_granularity,
-        vertical_axis_geolocation_granularity = chart.vertical_axis_geolocation_granularity,
-        vertical_axis_include_empty = chart.vertical_axis_include_empty,
-        horizontal_axis_summary_type = chart.horizontal_axis_summary_type,
-        horizontal_axis_column_key = chart.horizontal_axis_column_key,
-        horizontal_axis_summary_method = chart.horizontal_axis_summary_method,
-        column_groupby_column_key = chart.column_groupby_column_key,
-        column_groupby_date_granularity = chart.column_groupby_date_granularity,
-        column_groupby_geolocation_granularity = chart.column_groupby_geolocation_granularity,
-        column_groupby_multiple_numeric_column = chart.column_groupby_multiple_numeric_column,
-        column_groupby_numeric_columns = chart.column_groupby_numeric_columns;
-      var sortType = chart.sort_type;
-      if (sortType === DATA_SORT_TYPE.ASCENDING) {
-        sortType = DATA_SORT_TYPE.DESCENDING;
-      } else if (sortType === DATA_SORT_TYPE.DESCENDING) {
-        sortType = DATA_SORT_TYPE.ASCENDING;
-      }
-      return {
-        type: 'bar',
-        _id: _id,
-        table_id: table_id,
-        view_id: view_id,
-        y_axis_column_key: horizontal_axis_column_key,
-        x_axis_date_granularity: vertical_axis_date_granularity,
-        x_axis_geolocation_granularity: vertical_axis_geolocation_granularity,
-        x_axis_include_empty: vertical_axis_include_empty,
-        y_axis_summary_type: horizontal_axis_summary_type,
-        x_axis_column_key: vertical_axis_column_key,
-        y_axis_summary_method: horizontal_axis_summary_method,
-        column_groupby_column_key: column_groupby_column_key,
-        column_groupby_date_granularity: column_groupby_date_granularity,
-        column_groupby_geolocation_granularity: column_groupby_geolocation_granularity,
-        column_groupby_multiple_numeric_column: column_groupby_multiple_numeric_column,
-        column_groupby_numeric_columns: column_groupby_numeric_columns,
-        sort_type: sortType
-      };
+  isValidChart(chart) {
+    const convertedChart = this.convertChart(chart);
+    return this.basicChartCalculator.isValidChart(convertedChart);
+  }
+  async calculate(chart) {
+    const convertedChart = this.convertChart(chart);
+    return await this.basicChartCalculator.calculate(convertedChart);
+  }
+  convertChart(chart) {
+    const {
+      _id,
+      table_id,
+      view_id,
+      vertical_axis_column_key,
+      vertical_axis_date_granularity,
+      vertical_axis_geolocation_granularity,
+      vertical_axis_include_empty,
+      horizontal_axis_summary_type,
+      horizontal_axis_column_key,
+      horizontal_axis_summary_method,
+      column_groupby_column_key,
+      column_groupby_date_granularity,
+      column_groupby_geolocation_granularity,
+      column_groupby_multiple_numeric_column,
+      column_groupby_numeric_columns
+    } = chart;
+    let sortType = chart.sort_type;
+    if (sortType === DATA_SORT_TYPE.ASCENDING) {
+      sortType = DATA_SORT_TYPE.DESCENDING;
+    } else if (sortType === DATA_SORT_TYPE.DESCENDING) {
+      sortType = DATA_SORT_TYPE.ASCENDING;
     }
-  }]);
-  return HorizontalBarCalculator;
-}();
+    return {
+      type: 'bar',
+      _id,
+      table_id,
+      view_id,
+      y_axis_column_key: horizontal_axis_column_key,
+      x_axis_date_granularity: vertical_axis_date_granularity,
+      x_axis_geolocation_granularity: vertical_axis_geolocation_granularity,
+      x_axis_include_empty: vertical_axis_include_empty,
+      y_axis_summary_type: horizontal_axis_summary_type,
+      x_axis_column_key: vertical_axis_column_key,
+      y_axis_summary_method: horizontal_axis_summary_method,
+      column_groupby_column_key,
+      column_groupby_date_granularity,
+      column_groupby_geolocation_granularity,
+      column_groupby_multiple_numeric_column,
+      column_groupby_numeric_columns,
+      sort_type: sortType
+    };
+  }
+}
 export default HorizontalBarCalculator;

package/es/calculator/index.js

@@ -1,8 +1,3 @@
-import _regeneratorRuntime from "@babel/runtime/regenerator";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
 import PivotTableCalculator from './pivot-table-calculator';
 import BasicChartCalculator from './basic-chart-calculator';
 import CompareBarCalculator from './compare-bar-calculator';
@@ -18,71 +13,60 @@ import NumberCardCalculator from './number-card-calculator';
 import TrendCalculator from './trend-calculator';
 import DashboardCalculator from './dashboard-calculator';
 import { STAT_TYPE } from '../constants';
-var BASIC_CHART = 'basic_chart';
-var ChartCalculator = /*#__PURE__*/function () {
-  function ChartCalculator(_ref) {
-    var _this$chartCalculatio;
-    var username = _ref.username,
-      userId = _ref.userId,
-      value = _ref.value,
-      statisticThreadManager = _ref.statisticThreadManager;
-    _classCallCheck(this, ChartCalculator);
-    var configs = {
-      username: username,
-      userId: userId,
-      value: value,
-      statisticThreadManager: statisticThreadManager
+const BASIC_CHART = 'basic_chart';
+class ChartCalculator {
+  constructor(_ref) {
+    let {
+      username,
+      userId,
+      value,
+      statisticThreadManager
+    } = _ref;
+    const configs = {
+      username,
+      userId,
+      value,
+      statisticThreadManager
+    };
+    this.chartCalculationMap = {
+      [STAT_TYPE.PIVOT_TABLE]: new PivotTableCalculator(configs),
+      [BASIC_CHART]: new BasicChartCalculator(configs),
+      [STAT_TYPE.COMPARE_BAR]: new CompareBarCalculator(configs),
+      [STAT_TYPE.HORIZONTAL_BAR]: new HorizontalBarCalculator(configs),
+      [STAT_TYPE.HORIZONTAL_GROUP_BAR]: new HorizontalBarCalculator(configs),
+      [STAT_TYPE.STACKED_HORIZONTAL_BAR]: new HorizontalBarCalculator(configs),
+      [STAT_TYPE.COMPLETENESS_CHART]: new CompletenessCalculator(configs),
+      [STAT_TYPE.GROUP_COMPLETENESS_CHART]: new CompletenessCalculator(configs),
+      [STAT_TYPE.SCATTER]: new ScatterCalculator(configs),
+      [STAT_TYPE.COMBINATION_CHART]: new CombinationCalculator(configs),
+      [STAT_TYPE.MAP]: new MapCalculator(configs),
+      [STAT_TYPE.MAP_BUBBLE]: new MapCalculator(configs),
+      [STAT_TYPE.WORLD_MAP]: new WorldMapCalculator(configs),
+      [STAT_TYPE.WORLD_MAP_BUBBLE]: new WorldMapCalculator(configs),
+      [STAT_TYPE.HEAT_MAP]: new HeatMapCalculator(configs),
+      [STAT_TYPE.MIRROR]: new MirrorCalculator(configs),
+      [STAT_TYPE.BASIC_NUMBER_CARD]: new NumberCardCalculator(configs),
+      [STAT_TYPE.TREND_CHART]: new TrendCalculator(configs),
+      [STAT_TYPE.DASHBOARD]: new DashboardCalculator(configs)
     };
-    this.chartCalculationMap = (_this$chartCalculatio = {}, _defineProperty(_this$chartCalculatio, STAT_TYPE.PIVOT_TABLE, new PivotTableCalculator(configs)), _defineProperty(_this$chartCalculatio, BASIC_CHART, new BasicChartCalculator(configs)), _defineProperty(_this$chartCalculatio, STAT_TYPE.COMPARE_BAR, new CompareBarCalculator(configs)), _defineProperty(_this$chartCalculatio, STAT_TYPE.HORIZONTAL_BAR, new HorizontalBarCalculator(configs)), _defineProperty(_this$chartCalculatio, STAT_TYPE.HORIZONTAL_GROUP_BAR, new HorizontalBarCalculator(configs)), _defineProperty(_this$chartCalculatio, STAT_TYPE.STACKED_HORIZONTAL_BAR, new HorizontalBarCalculator(configs)), _defineProperty(_this$chartCalculatio, STAT_TYPE.COMPLETENESS_CHART, new CompletenessCalculator(configs)), _defineProperty(_this$chartCalculatio, STAT_TYPE.GROUP_COMPLETENESS_CHART, new CompletenessCalculator(configs)), _defineProperty(_this$chartCalculatio, STAT_TYPE.SCATTER, new ScatterCalculator(configs)), _defineProperty(_this$chartCalculatio, STAT_TYPE.COMBINATION_CHART, new CombinationCalculator(configs)), _defineProperty(_this$chartCalculatio, STAT_TYPE.MAP, new MapCalculator(configs)), _defineProperty(_this$chartCalculatio, STAT_TYPE.MAP_BUBBLE, new MapCalculator(configs)), _defineProperty(_this$chartCalculatio, STAT_TYPE.WORLD_MAP, new WorldMapCalculator(configs)), _defineProperty(_this$chartCalculatio, STAT_TYPE.WORLD_MAP_BUBBLE, new WorldMapCalculator(configs)), _defineProperty(_this$chartCalculatio, STAT_TYPE.HEAT_MAP, new HeatMapCalculator(configs)), _defineProperty(_this$chartCalculatio, STAT_TYPE.MIRROR, new MirrorCalculator(configs)), _defineProperty(_this$chartCalculatio, STAT_TYPE.BASIC_NUMBER_CARD, new NumberCardCalculator(configs)), _defineProperty(_this$chartCalculatio, STAT_TYPE.TREND_CHART, new TrendCalculator(configs)), _defineProperty(_this$chartCalculatio, STAT_TYPE.DASHBOARD, new DashboardCalculator(configs)), _this$chartCalculatio);
   }
-  _createClass(ChartCalculator, [{
-    key: "isValidChart",
-    value: function isValidChart(chart) {
-      if (!chart) {
-        return false;
-      }
-      var chartCalculation = this.chartCalculationMap[chart.type];
-      if (!chartCalculation) {
-        return this.chartCalculationMap[BASIC_CHART].isValidChart(chart);
-      }
-      return chartCalculation ? chartCalculation.isValidChart(chart) : false;
+  isValidChart(chart) {
+    if (!chart) {
+      return false;
+    }
+    const chartCalculation = this.chartCalculationMap[chart.type];
+    if (!chartCalculation) {
+      return this.chartCalculationMap[BASIC_CHART].isValidChart(chart);
     }
-  }, {
-    key: "calculate",
-    value: function () {
-      var _calculate = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(chart) {
-        var chartCalculation;
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                if (chart) {
-                  _context.next = 2;
-                  break;
-                }
-                return _context.abrupt("return", null);
-              case 2:
-                chartCalculation = this.chartCalculationMap[chart.type];
-                if (chartCalculation) {
-                  _context.next = 5;
-                  break;
-                }
-                return _context.abrupt("return", this.chartCalculationMap[BASIC_CHART].calculate(chart));
-              case 5:
-                return _context.abrupt("return", chartCalculation.calculate(chart));
-              case 6:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this);
-      }));
-      function calculate(_x) {
-        return _calculate.apply(this, arguments);
-      }
-      return calculate;
-    }()
-  }]);
-  return ChartCalculator;
-}();
+    return chartCalculation ? chartCalculation.isValidChart(chart) : false;
+  }
+  async calculate(chart) {
+    if (!chart) return null;
+    const chartCalculation = this.chartCalculationMap[chart.type];
+    if (!chartCalculation) {
+      return this.chartCalculationMap[BASIC_CHART].calculate(chart);
+    }
+    return chartCalculation.calculate(chart);
+  }
+}
 export default ChartCalculator;

package/es/calculator/map-calculator.js

@@ -1,9 +1,3 @@
-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 { formatNumericValue, getSummaryColumnMethod } from '../utils/common-utils';
@@ -11,176 +5,106 @@ import { getSqlGroup } from '../utils/sql-utils';
 import { DTABLE_DB_SUMMARY_METHOD } from '../constants';
 import { fixMapGeoGranularity } from '../utils/map';
 import StatUtils from '../utils/stat-utils';
-var MapCalculator = /*#__PURE__*/function (_BaseCalculator) {
-  _inherits(MapCalculator, _BaseCalculator);
-  var _super = _createSuper(MapCalculator);
-  function MapCalculator(_ref) {
-    var value = _ref.value,
-      statisticThreadManager = _ref.statisticThreadManager,
-      username = _ref.username,
-      userId = _ref.userId;
-    _classCallCheck(this, MapCalculator);
-    return _super.call(this, {
-      value: value,
-      statisticThreadManager: statisticThreadManager,
-      username: username,
-      userId: userId
+class MapCalculator extends BaseCalculator {
+  constructor(_ref) {
+    let {
+      value,
+      statisticThreadManager,
+      username,
+      userId
+    } = _ref;
+    super({
+      value,
+      statisticThreadManager,
+      username,
+      userId
     });
   }
-  _createClass(MapCalculator, [{
-    key: "isValidChart",
-    value: function isValidChart(chart) {
-      if (!this.validateBaseConfigs(chart)) {
-        return false;
-      }
-      var table_id = chart.table_id,
-        geo_column = chart.geo_column,
-        summary_column = chart.summary_column;
-      var table = this.getTableById(table_id);
-      var selectedColumn = geo_column && TableUtils.getTableColumnByKey(table, geo_column);
-      if (geo_column && (!selectedColumn || selectedColumn.type !== CellType.GEOLOCATION)) {
-        return false;
-      }
-      if (summary_column && !TableUtils.getTableColumnByKey(table, summary_column)) {
-        return false;
-      }
-      return true;
+  isValidChart(chart) {
+    if (!this.validateBaseConfigs(chart)) {
+      return false;
     }
-  }, {
-    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, geo_column, summary_type, summary_method, summary_column, selectedTable, selectedView, column, columnName, isAdvanced, geoGranularity, method, sqlCondition, groupName, sqlString, summaryColumn, summaryColumnName, summaryColumnMethod, result, data, newResult, _summaryColumnMethod, valueKey;
-        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, geo_column = chart.geo_column, summary_type = chart.summary_type, summary_method = chart.summary_method, summary_column = chart.summary_column;
-                selectedTable = this.getTableById(table_id);
-                selectedView = this.getViewById(view_id, selectedTable);
-                column = TableUtils.getTableColumnByKey(selectedTable, geo_column);
-                if (column) {
-                  _context2.next = 6;
-                  break;
-                }
-                return _context2.abrupt("return", []);
-              case 6:
-                columnName = column.name;
-                isAdvanced = summary_type === 'advanced';
-                geoGranularity = fixMapGeoGranularity(chart);
-                method = isAdvanced ? DTABLE_DB_SUMMARY_METHOD[summary_method] : 'COUNT';
-                sqlCondition = filter2SqlCondition(selectedTable, selectedView);
-                groupName = getSqlGroup(geoGranularity, column);
-                sqlString = '';
-                summaryColumnName = '';
-                if (!isAdvanced) {
-                  _context2.next = 23;
-                  break;
-                }
-                summaryColumn = TableUtils.getTableColumnByKey(selectedTable, summary_column);
-                if (summaryColumn) {
-                  _context2.next = 18;
-                  break;
-                }
-                return _context2.abrupt("return", []);
-              case 18:
-                summaryColumnName = summaryColumn.name;
-                summaryColumnMethod = getSummaryColumnMethod(method, summaryColumnName);
-                sqlString = "select ".concat(groupName, ", ").concat(summaryColumnMethod, " from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by ").concat(groupName, " limit 5000");
-                _context2.next = 24;
-                break;
-              case 23:
-                sqlString = "select ".concat(groupName, ", ").concat(method, "(`").concat(columnName, "`) from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by ").concat(groupName, " limit 5000");
-              case 24:
-                _context2.next = 26;
-                return this.sqlQuery(sqlString);
-              case 26:
-                result = _context2.sent;
-                if (!(result.status === 200 && result.data.success)) {
-                  _context2.next = 36;
-                  break;
-                }
-                data = result.data;
-                if (data.results) {
-                  _context2.next = 31;
-                  break;
-                }
-                return _context2.abrupt("return", []);
-              case 31:
-                newResult = [];
-                _summaryColumnMethod = getSummaryColumnMethod(method, summaryColumnName);
-                valueKey = isAdvanced ? "".concat(_summaryColumnMethod) : "".concat(method, "(").concat(columnName, ")");
-                data.results.forEach(function (item) {
-                  var currentValue = item[groupName];
-                  var value = item[valueKey];
-                  var formatted_value = value;
-                  if (isAdvanced) {
-                    value = formatNumericValue(value, summaryColumn);
-                    formatted_value = StatUtils.getFormattedValue(value, summaryColumn, method);
-                  }
-                  if (currentValue) {
-                    newResult.push({
-                      name: currentValue,
-                      value: value,
-                      formatted_value: formatted_value
-                    });
-                  }
-                });
-                return _context2.abrupt("return", newResult);
-              case 36:
-                return _context2.abrupt("return", []);
-              case 37:
-              case "end":
-                return _context2.stop();
-            }
-          }
-        }, _callee2, this);
-      }));
-      function queryDb(_x2) {
-        return _queryDb.apply(this, arguments);
+    const {
+      table_id,
+      geo_column,
+      summary_column
+    } = chart;
+    const table = this.getTableById(table_id);
+    const selectedColumn = geo_column && TableUtils.getTableColumnByKey(table, geo_column);
+    if (geo_column && (!selectedColumn || selectedColumn.type !== CellType.GEOLOCATION)) {
+      return false;
+    }
+    if (summary_column && !TableUtils.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,
+      geo_column,
+      summary_type,
+      summary_method,
+      summary_column
+    } = chart;
+    const selectedTable = this.getTableById(table_id);
+    const selectedView = this.getViewById(view_id, selectedTable);
+    const column = TableUtils.getTableColumnByKey(selectedTable, geo_column);
+    if (!column) return [];
+    const columnName = column.name;
+    const isAdvanced = summary_type === 'advanced';
+    const geoGranularity = fixMapGeoGranularity(chart);
+    const method = isAdvanced ? DTABLE_DB_SUMMARY_METHOD[summary_method] : 'COUNT';
+    const sqlCondition = filter2SqlCondition(selectedTable, selectedView);
+    const groupName = getSqlGroup(geoGranularity, column);
+    let sqlString = '';
+    let summaryColumn;
+    let summaryColumnName = '';
+    if (isAdvanced) {
+      summaryColumn = TableUtils.getTableColumnByKey(selectedTable, summary_column);
+      if (!summaryColumn) {
+        return [];
       }
-      return queryDb;
-    }()
-  }]);
-  return MapCalculator;
-}(BaseCalculator);
+      summaryColumnName = summaryColumn.name;
+      const summaryColumnMethod = getSummaryColumnMethod(method, summaryColumnName);
+      sqlString = "select ".concat(groupName, ", ").concat(summaryColumnMethod, " from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by ").concat(groupName, " limit 5000");
+    } else {
+      sqlString = "select ".concat(groupName, ", ").concat(method, "(`").concat(columnName, "`) from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by ").concat(groupName, " limit 5000");
+    }
+    const result = await this.sqlQuery(sqlString);
+    if (result.status === 200 && result.data.success) {
+      const data = result.data;
+      if (!data.results) return [];
+      const newResult = [];
+      const summaryColumnMethod = getSummaryColumnMethod(method, summaryColumnName);
+      const valueKey = isAdvanced ? "".concat(summaryColumnMethod) : "".concat(method, "(").concat(columnName, ")");
+      data.results.forEach(item => {
+        const currentValue = item[groupName];
+        let value = item[valueKey];
+        let formatted_value = value;
+        if (isAdvanced) {
+          value = formatNumericValue(value, summaryColumn);
+          formatted_value = StatUtils.getFormattedValue(value, summaryColumn, method);
+        }
+        if (currentValue) {
+          newResult.push({
+            name: currentValue,
+            value,
+            formatted_value
+          });
+        }
+      });
+      return newResult;
+    }
+    return [];
+  }
+}
 export default MapCalculator;