dtable-statistic 4.0.2-test-2

package/es/calculator/heat-map-calculator.js

@@ -0,0 +1,225 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+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 { formatNumericValue, getSummaryColumnMethod } from '../utils/common-utils';
+import { DTABLE_DB_SUMMARY_METHOD } from '../constants';
+var HeatMapCalculator = /*#__PURE__*/function (_BaseCalculator) {
+  _inherits(HeatMapCalculator, _BaseCalculator);
+  var _super = _createSuper(HeatMapCalculator);
+  function HeatMapCalculator(_ref) {
+    var value = _ref.value,
+      statisticThreadManager = _ref.statisticThreadManager,
+      username = _ref.username,
+      userId = _ref.userId;
+    _classCallCheck(this, HeatMapCalculator);
+    return _super.call(this, {
+      value: value,
+      statisticThreadManager: statisticThreadManager,
+      username: username,
+      userId: userId
+    });
+  }
+  _createClass(HeatMapCalculator, [{
+    key: "isValidChart",
+    value: function isValidChart(chart) {
+      if (!this.validateBaseConfigs(chart)) {
+        return false;
+      }
+      var table_id = chart.table_id,
+        time_column = chart.time_column,
+        summary_column = chart.summary_column;
+      var table = this.getTableById(table_id);
+      if (!TableUtils.getTableColumnByKey(table, time_column)) {
+        return false;
+      }
+      if (summary_column && !TableUtils.getTableColumnByKey(table, summary_column)) {
+        return false;
+      }
+      return true;
+    }
+  }, {
+    key: "calculate",
+    value: function () {
+      var _calculate = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(chart) {
+        var result, data, years;
+        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", {
+                  data: [],
+                  years: []
+                });
+              case 2:
+                if (!this.isCalcByQueryDB(chart)) {
+                  _context.next = 8;
+                  break;
+                }
+                _context.next = 5;
+                return this.queryDb(chart);
+              case 5:
+                _context.t0 = _context.sent;
+                _context.next = 11;
+                break;
+              case 8:
+                _context.next = 10;
+                return this.calculateWithWorker(this.convertChart(chart));
+              case 10:
+                _context.t0 = _context.sent;
+              case 11:
+                result = _context.t0;
+                data = [];
+                years = [];
+                result.forEach(function (item) {
+                  if (!item.name) {
+                    data.push(item);
+                    return;
+                  }
+                  var year = dayjs(item.name).year();
+                  data.push(_objectSpread(_objectSpread({}, item), {}, {
+                    year: year
+                  }));
+                  if (years.indexOf(year) < 0) {
+                    years.push(year);
+                  }
+                });
+                this.sortDataByYear(data);
+                return _context.abrupt("return", {
+                  data: data,
+                  years: years
+                });
+              case 17:
+              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, time_column, summary_type, summary_method, summary_column, selectedTable, selectedView, selectedColumn, columnName, isAdvanced, method, sqlCondition, summaryColumnName, summaryColumn, sqlString, 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, time_column = chart.time_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);
+                selectedColumn = TableUtils.getTableColumnByKey(selectedTable, time_column);
+                columnName = selectedColumn.name;
+                isAdvanced = summary_type === 'advanced';
+                method = isAdvanced ? DTABLE_DB_SUMMARY_METHOD[summary_method] : 'COUNT';
+                sqlCondition = filter2SqlCondition(selectedTable, selectedView);
+                summaryColumnName = '';
+                sqlString = '';
+                if (isAdvanced) {
+                  summaryColumn = TableUtils.getTableColumnByKey(selectedTable, summary_column);
+                  summaryColumnName = summaryColumn.name;
+                  summaryColumnMethod = getSummaryColumnMethod(method, summaryColumnName);
+                  sqlString = "select `".concat(columnName, "`, ").concat(summaryColumnMethod, " from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by `").concat(columnName, "` limit 5000");
+                } else {
+                  sqlString = "select `".concat(columnName, "`, ").concat(method, "(").concat(columnName, ") from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by `").concat(columnName, "` limit 5000");
+                }
+                _context2.next = 13;
+                return this.sqlQuery(sqlString);
+              case 13:
+                result = _context2.sent;
+                if (!(result.status === 200 && result.data.success)) {
+                  _context2.next = 23;
+                  break;
+                }
+                data = result.data;
+                if (data.results) {
+                  _context2.next = 18;
+                  break;
+                }
+                return _context2.abrupt("return", []);
+              case 18:
+                newResult = [];
+                _summaryColumnMethod = getSummaryColumnMethod(method, summaryColumnName);
+                valueKey = isAdvanced ? "".concat(_summaryColumnMethod) : "".concat(method, "(").concat(columnName, ")");
+                data.results.forEach(function (item) {
+                  var currentValue = item[time_column];
+                  if (currentValue) {
+                    var value = item[valueKey];
+                    if (isAdvanced) {
+                      value = formatNumericValue(value, summaryColumn);
+                    }
+                    var name = typeof currentValue === 'string' ? currentValue : currentValue.country_region;
+                    newResult.push({
+                      name: dayjs(name).format('YYYY-MM-DD'),
+                      value: value
+                    });
+                  }
+                });
+                return _context2.abrupt("return", newResult);
+              case 23:
+                return _context2.abrupt("return", []);
+              case 24:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+      function queryDb(_x2) {
+        return _queryDb.apply(this, arguments);
+      }
+      return queryDb;
+    }()
+  }, {
+    key: "convertChart",
+    value: function convertChart(chart) {
+      var _id = chart._id,
+        table_id = chart.table_id,
+        view_id = chart.view_id,
+        time_column = chart.time_column,
+        summary_type = chart.summary_type,
+        summary_column = chart.summary_column,
+        summary_method = chart.summary_method;
+      return {
+        _id: _id,
+        table_id: table_id,
+        view_id: view_id,
+        x_axis_column_key: time_column,
+        y_axis_summary_type: summary_type,
+        y_axis_summary_method: summary_method,
+        y_axis_column_key: summary_column,
+        x_axis_date_granularity: 'day'
+      };
+    }
+  }, {
+    key: "sortDataByYear",
+    value: function sortDataByYear(data) {
+      data.sort(function (current, next) {
+        if (current.year > next.year) {
+          return -1;
+        } else if (current.year < next.year) {
+          return 1;
+        } else {
+          return 0;
+        }
+      });
+    }
+  }]);
+  return HeatMapCalculator;
+}(BaseCalculator);
+export default HeatMapCalculator;

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

@@ -0,0 +1,100 @@
+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);
+    this.basicChartCalculator = new BasicChartCalculator({
+      value: value,
+      username: username,
+      userId: userId,
+      statisticThreadManager: 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
+      };
+    }
+  }]);
+  return HorizontalBarCalculator;
+}();
+export default HorizontalBarCalculator;

package/es/calculator/index.js

@@ -0,0 +1,88 @@
+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';
+import HorizontalBarCalculator from './horizontal-bar-calculator';
+import CompletenessCalculator from './completeness-calculator';
+import ScatterCalculator from './scatter-calculator';
+import CombinationCalculator from './combination-calculator';
+import MapCalculator from './map-calculator';
+import WorldMapCalculator from './world-map-calculator';
+import HeatMapCalculator from './heat-map-calculator';
+import MirrorCalculator from './mirror-calculator';
+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
+    };
+    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;
+    }
+  }, {
+    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;
+}();
+export default ChartCalculator;

package/es/calculator/map-calculator.js

@@ -0,0 +1,169 @@
+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';
+import { getSqlGroup } from '../utils/sql-utils';
+import { DTABLE_DB_SUMMARY_METHOD } from '../constants';
+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
+    });
+  }
+  _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;
+    }
+  }, {
+    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, geolocation_granularity, selectedTable, selectedView, column, columnName, isAdvanced, 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, geolocation_granularity = chart.geolocation_granularity;
+                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';
+                method = isAdvanced ? DTABLE_DB_SUMMARY_METHOD[summary_method] : 'COUNT';
+                sqlCondition = filter2SqlCondition(selectedTable, selectedView);
+                groupName = getSqlGroup(geolocation_granularity, column);
+                sqlString = '';
+                summaryColumnName = '';
+                if (isAdvanced) {
+                  summaryColumn = TableUtils.getTableColumnByKey(selectedTable, summary_column);
+                  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");
+                } else {
+                  sqlString = "select ".concat(groupName, ", ").concat(method, "(`").concat(columnName, "`) from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by ").concat(groupName, " limit 5000");
+                }
+                _context2.next = 16;
+                return this.sqlQuery(sqlString);
+              case 16:
+                result = _context2.sent;
+                if (!(result.status === 200 && result.data.success)) {
+                  _context2.next = 26;
+                  break;
+                }
+                data = result.data;
+                if (data.results) {
+                  _context2.next = 21;
+                  break;
+                }
+                return _context2.abrupt("return", []);
+              case 21:
+                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];
+                  if (isAdvanced) {
+                    value = formatNumericValue(value, summaryColumn);
+                  }
+                  if (currentValue) {
+                    newResult.push({
+                      name: currentValue,
+                      value: value
+                    });
+                  }
+                });
+                return _context2.abrupt("return", newResult);
+              case 26:
+                return _context2.abrupt("return", []);
+              case 27:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+      function queryDb(_x2) {
+        return _queryDb.apply(this, arguments);
+      }
+      return queryDb;
+    }()
+  }]);
+  return MapCalculator;
+}(BaseCalculator);
+export default MapCalculator;