dtable-statistic 4.0.2-test-2

package/es/calculator/basic-chart-calculator.js

@@ -0,0 +1,571 @@
+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 { DTABLE_DB_SUMMARY_METHOD, STAT_TYPE, SUMMARY_TYPE, TIME_COLUMN_LIST, Y_AXIS_TYPE_PREFIX } from '../constants';
+import { getSqlGroup, getSqlOrder } from '../utils/sql-utils';
+import { formatNumericValue, getSummaryColumnMethod } from '../utils/common-utils';
+import StatUtils from '../utils/stat-utils';
+import { getColorFromSingleSelectColumn } from '../utils/column-utils';
+import { getFormattedLabel } from '../utils/row-utils';
+var BasicChartCalculator = /*#__PURE__*/function (_BaseCalculator) {
+  _inherits(BasicChartCalculator, _BaseCalculator);
+  var _super = _createSuper(BasicChartCalculator);
+  function BasicChartCalculator(_ref) {
+    var value = _ref.value,
+      statisticThreadManager = _ref.statisticThreadManager,
+      username = _ref.username,
+      userId = _ref.userId;
+    _classCallCheck(this, BasicChartCalculator);
+    return _super.call(this, {
+      value: value,
+      statisticThreadManager: statisticThreadManager,
+      username: username,
+      userId: userId
+    });
+  }
+  _createClass(BasicChartCalculator, [{
+    key: "isValidChart",
+    value: function isValidChart(chart) {
+      if (!this.validateBaseConfigs(chart)) {
+        return false;
+      }
+      if (chart.type === STAT_TYPE.CUSTOM_BAR) {
+        return this.isValidCustomBar(chart);
+      }
+      var table_id = chart.table_id,
+        groupby_column_key = chart.groupby_column_key,
+        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;
+      var table = this.getTableById(table_id);
+      var groupbyColumnKey = groupby_column_key || x_axis_column_key;
+      if (!groupbyColumnKey || !TableUtils.getTableColumnByKey(table, groupbyColumnKey)) {
+        return false;
+      }
+      var summaryColumnKey = summary_column_key || y_axis_column_key;
+      if (summaryColumnKey && !TableUtils.getTableColumnByKey(table, summaryColumnKey)) {
+        return false;
+      }
+      return true;
+    }
+  }, {
+    key: "isValidCustomBar",
+    value: function isValidCustomBar(chart) {
+      var table_id = chart.table_id,
+        x_axis_column_key = chart.x_axis_column_key,
+        y_axises = chart.y_axises;
+      var table = this.getTableById(table_id);
+      if (!table.columns.find(function (column) {
+        return column.key === x_axis_column_key;
+      }) || !Array.isArray(y_axises) || y_axises.length === 0 || y_axises.every(function (yAxis) {
+        return !Array.isArray(yAxis.column_groupby_numeric_columns) || yAxis.column_groupby_numeric_columns.length === 0;
+      })) {
+        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, groupby_column_key, summary_type, summary_method, summary_column_key, groupby_date_granularity, include_empty, groupby_geolocation_granularity, column_groupby_multiple_numeric_column, column_groupby_column_key, sortType, yAxisType, selectedTable, selectedView, groupbyColumn, sqlCondition, groupbyName, isTimeColumn, results, column_groupby_numeric_columns, summaryColumn, column_groupby_date_granularity, column_groupby_geolocation_granularity;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                if (!(chart.type === STAT_TYPE.CUSTOM_BAR)) {
+                  _context2.next = 2;
+                  break;
+                }
+                return _context2.abrupt("return", this.queryDbFromCustomBar(chart));
+              case 2:
+                table_id = chart.table_id, view_id = chart.view_id;
+                column_groupby_column_key = chart.column_groupby_column_key;
+                sortType = chart.sort_type;
+                if (chart.type === STAT_TYPE.PIE || chart.type === STAT_TYPE.RING || chart.type === STAT_TYPE.TREEMAP) {
+                  groupby_column_key = chart.groupby_column_key;
+                  summary_type = chart.summary_type;
+                  summary_method = chart.summary_method;
+                  summary_column_key = chart.summary_column_key;
+                  groupby_date_granularity = chart.groupby_date_granularity;
+                  include_empty = chart.groupby_include_empty_cells;
+                  groupby_geolocation_granularity = chart.groupby_geolocation_granularity;
+                } else {
+                  groupby_column_key = chart.x_axis_column_key;
+                  summary_type = chart.y_axis_summary_type;
+                  summary_method = chart.y_axis_summary_method;
+                  summary_column_key = chart.y_axis_column_key;
+                  groupby_date_granularity = chart.x_axis_date_granularity;
+                  groupby_geolocation_granularity = chart.x_axis_geolocation_granularity;
+                  include_empty = chart.x_axis_include_empty;
+                }
+                yAxisType = null;
+                selectedTable = this.getTableById(table_id);
+                selectedView = this.getViewById(view_id, selectedTable);
+                if (selectedView) {
+                  _context2.next = 11;
+                  break;
+                }
+                return _context2.abrupt("return", []);
+              case 11:
+                groupbyColumn = TableUtils.getTableColumnByKey(selectedTable, groupby_column_key);
+                sqlCondition = filter2SqlCondition(selectedTable, selectedView);
+                groupbyName = "`".concat(groupbyColumn.name, "`");
+                isTimeColumn = TIME_COLUMN_LIST.includes(groupbyColumn.type);
+                if (isTimeColumn) {
+                  groupbyName = getSqlGroup(groupby_date_granularity, groupbyColumn);
+                } else if (groupbyColumn.type === CellType.GEOLOCATION) {
+                  groupbyName = getSqlGroup(groupby_geolocation_granularity, groupbyColumn);
+                }
+                if (!(!column_groupby_column_key && !column_groupby_multiple_numeric_column)) {
+                  _context2.next = 22;
+                  break;
+                }
+                _context2.next = 19;
+                return this.getNoneGroupbyResults(groupbyName, groupbyColumn, groupby_date_granularity, groupby_geolocation_granularity, include_empty, summary_type, summary_column_key, summary_method, sortType, sqlCondition, selectedTable, yAxisType);
+              case 19:
+                results = _context2.sent;
+                _context2.next = 36;
+                break;
+              case 22:
+                if (!column_groupby_multiple_numeric_column) {
+                  _context2.next = 32;
+                  break;
+                }
+                column_groupby_numeric_columns = chart.column_groupby_numeric_columns;
+                summaryColumn = TableUtils.getTableColumnByKey(selectedTable, summary_column_key);
+                if (summaryColumn) {
+                  _context2.next = 27;
+                  break;
+                }
+                return _context2.abrupt("return", []);
+              case 27:
+                _context2.next = 29;
+                return this.getGroupbyMultipleNumericColumnsResults(groupbyName, groupbyColumn, groupby_date_granularity, groupby_geolocation_granularity, include_empty, summary_type, summaryColumn, summary_method, column_groupby_numeric_columns, sqlCondition, selectedTable, yAxisType);
+              case 29:
+                results = _context2.sent;
+                _context2.next = 36;
+                break;
+              case 32:
+                column_groupby_date_granularity = chart.column_groupby_date_granularity, column_groupby_geolocation_granularity = chart.column_groupby_geolocation_granularity;
+                _context2.next = 35;
+                return this.getGroupbyOneColumnResults(groupbyName, groupbyColumn, groupby_date_granularity, groupby_geolocation_granularity, include_empty, summary_type, summary_column_key, summary_method, column_groupby_column_key, column_groupby_date_granularity, column_groupby_geolocation_granularity, sqlCondition, selectedTable, yAxisType);
+              case 35:
+                results = _context2.sent;
+              case 36:
+                sortType && StatUtils.sortStatisticData(results, sortType);
+                return _context2.abrupt("return", results);
+              case 38:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+      function queryDb(_x2) {
+        return _queryDb.apply(this, arguments);
+      }
+      return queryDb;
+    }()
+  }, {
+    key: "queryDbFromCustomBar",
+    value: function () {
+      var _queryDbFromCustomBar = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(chart) {
+        var table_id, view_id, x_axis_column_key, x_axis_date_granularity, x_axis_geolocation_granularity, x_axis_include_empty, y_axises, sort_type, selectedTable, selectedView, groupbyColumn, sqlCondition, isTimeColumn, groupbyName, summaryType, yAxisSummaryColumn, yAxisSummaryMethod, results, i, len, stack, yAxisType, column_groupby_numeric_columns, _yAxisType, currentResults;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.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, x_axis_geolocation_granularity = chart.x_axis_geolocation_granularity, x_axis_include_empty = chart.x_axis_include_empty, y_axises = chart.y_axises, sort_type = chart.sort_type;
+                selectedTable = this.getTableById(table_id);
+                selectedView = this.getViewById(view_id, selectedTable);
+                if (!(!selectedView || !x_axis_column_key || !Array.isArray(y_axises) || y_axises.length === 0)) {
+                  _context3.next = 5;
+                  break;
+                }
+                return _context3.abrupt("return", []);
+              case 5:
+                groupbyColumn = TableUtils.getTableColumnByKey(selectedTable, x_axis_column_key);
+                if (groupbyColumn) {
+                  _context3.next = 8;
+                  break;
+                }
+                return _context3.abrupt("return", []);
+              case 8:
+                sqlCondition = filter2SqlCondition(selectedTable, selectedView);
+                isTimeColumn = TIME_COLUMN_LIST.includes(groupbyColumn.type);
+                groupbyName = "`".concat(groupbyColumn.name, "`");
+                if (isTimeColumn) {
+                  groupbyName = getSqlGroup(x_axis_date_granularity, groupbyColumn);
+                } else if (groupbyColumn.type === CellType.GEOLOCATION) {
+                  groupbyName = getSqlGroup(x_axis_geolocation_granularity, groupbyColumn);
+                }
+                summaryType = SUMMARY_TYPE.ADVANCED;
+                yAxisSummaryColumn = null;
+                yAxisSummaryMethod = null;
+                results = [];
+                i = 0, len = y_axises.length;
+              case 17:
+                if (!(i < len)) {
+                  _context3.next = 31;
+                  break;
+                }
+                stack = y_axises[i];
+                yAxisType = stack.type, column_groupby_numeric_columns = stack.column_groupby_numeric_columns;
+                if (!(yAxisType === STAT_TYPE.BAR_STACK)) {
+                  _context3.next = 28;
+                  break;
+                }
+                if (!(!Array.isArray(column_groupby_numeric_columns) || column_groupby_numeric_columns.length === 0)) {
+                  _context3.next = 23;
+                  break;
+                }
+                return _context3.abrupt("continue", 28);
+              case 23:
+                _yAxisType = "".concat(Y_AXIS_TYPE_PREFIX).concat(i);
+                _context3.next = 26;
+                return this.getGroupbyMultipleNumericColumnsResults(groupbyName, groupbyColumn, x_axis_date_granularity, x_axis_geolocation_granularity, x_axis_include_empty, summaryType, yAxisSummaryColumn, yAxisSummaryMethod, column_groupby_numeric_columns, sqlCondition, selectedTable, _yAxisType);
+              case 26:
+                currentResults = _context3.sent;
+                results = results.concat(currentResults);
+              case 28:
+                i++;
+                _context3.next = 17;
+                break;
+              case 31:
+                sort_type && StatUtils.sortStatisticData(results, sort_type);
+                return _context3.abrupt("return", results);
+              case 33:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+      function queryDbFromCustomBar(_x3) {
+        return _queryDbFromCustomBar.apply(this, arguments);
+      }
+      return queryDbFromCustomBar;
+    }()
+  }, {
+    key: "getNoneGroupbyResults",
+    value: function () {
+      var _getNoneGroupbyResults = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(groupbyName, groupbyColumn, groupbyDateGranularity, groupbyGeolocationGranularity, includeEmpty, summaryType, summaryColumnKey, summaryMethod, sortType, sqlCondition, table, yAxisType) {
+        var _this = this;
+        var isAdvanced, selectedSummaryColumn, summaryColumnName, method, summaryColumnMethod, sqlOrder, sqlString, queryResult, data, newResult, valueKey;
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                isAdvanced = summaryType === SUMMARY_TYPE.ADVANCED;
+                summaryColumnName = "`".concat(groupbyColumn.name, "`");
+                if (!isAdvanced) {
+                  _context4.next = 7;
+                  break;
+                }
+                selectedSummaryColumn = TableUtils.getTableColumnByKey(table, summaryColumnKey);
+                if (selectedSummaryColumn) {
+                  _context4.next = 6;
+                  break;
+                }
+                return _context4.abrupt("return", []);
+              case 6:
+                summaryColumnName = selectedSummaryColumn.name;
+              case 7:
+                method = isAdvanced ? DTABLE_DB_SUMMARY_METHOD[summaryMethod] : 'COUNT';
+                summaryColumnMethod = getSummaryColumnMethod(method, summaryColumnName);
+                sqlOrder = getSqlOrder(sortType, groupbyName);
+                sqlString = "select ".concat(groupbyName, ", ").concat(summaryColumnMethod, " from `").concat(table.name, "` ").concat(sqlCondition, " group by ").concat(groupbyName, " ").concat(sqlOrder, " limit 5000");
+                _context4.next = 13;
+                return this.sqlQuery(sqlString);
+              case 13:
+                queryResult = _context4.sent;
+                if (!(queryResult.status !== 200 || !queryResult.data.success)) {
+                  _context4.next = 16;
+                  break;
+                }
+                return _context4.abrupt("return", []);
+              case 16:
+                data = queryResult.data;
+                if (data.results) {
+                  _context4.next = 19;
+                  break;
+                }
+                return _context4.abrupt("return", []);
+              case 19:
+                newResult = [];
+                valueKey = isAdvanced ? "".concat(summaryColumnMethod) : "".concat(method, "(").concat(groupbyColumn.name, ")");
+                data.results.forEach(function (item) {
+                  var label = _this.getLabel(groupbyColumn, groupbyName, item, groupbyDateGranularity, groupbyGeolocationGranularity);
+                  var value = item[valueKey] || 0;
+                  if (isAdvanced) {
+                    value = formatNumericValue(value, selectedSummaryColumn);
+                  }
+                  if (!includeEmpty && _this.isEmptyLabel(label)) {
+                    return;
+                  }
+                  newResult.push({
+                    name: label,
+                    value: value,
+                    original_name: item[groupbyColumn.key],
+                    y_axis_type: yAxisType
+                  });
+                });
+                return _context4.abrupt("return", newResult);
+              case 23:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+      function getNoneGroupbyResults(_x4, _x5, _x6, _x7, _x8, _x9, _x10, _x11, _x12, _x13, _x14, _x15) {
+        return _getNoneGroupbyResults.apply(this, arguments);
+      }
+      return getNoneGroupbyResults;
+    }()
+  }, {
+    key: "getGroupbyOneColumnResults",
+    value: function () {
+      var _getGroupbyOneColumnResults = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(groupbyName, groupbyColumn, groupbyDateGranularity, groupbyGeolocationGranularity, includeEmpty, summaryType, summaryColumnKey, summaryMethod, columnGroupbyColumnKey, columnGroupbyDateGranularity, columnGroupbyGeolocationGranularity, sqlCondition, table, yAxisType) {
+        var _this2 = this;
+        var isAdvanced, selectedSummaryColumn, summaryColumnName, columnGroupbyColumn, columnGroupbyColumnName, method, summaryColumnMethod, sqlString, queryResult, data, newResult, valueKey;
+        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                isAdvanced = summaryType === SUMMARY_TYPE.ADVANCED;
+                summaryColumnName = "`".concat(groupbyColumn.name, "`");
+                if (!isAdvanced) {
+                  _context5.next = 7;
+                  break;
+                }
+                selectedSummaryColumn = TableUtils.getTableColumnByKey(table, summaryColumnKey);
+                if (selectedSummaryColumn) {
+                  _context5.next = 6;
+                  break;
+                }
+                return _context5.abrupt("return", []);
+              case 6:
+                summaryColumnName = selectedSummaryColumn.name;
+              case 7:
+                columnGroupbyColumn = TableUtils.getTableColumnByKey(table, columnGroupbyColumnKey);
+                columnGroupbyColumnName = "`".concat(columnGroupbyColumn.name, "`");
+                if (TIME_COLUMN_LIST.includes(columnGroupbyColumn.type)) {
+                  columnGroupbyColumnName = getSqlGroup(columnGroupbyDateGranularity, columnGroupbyColumn);
+                } else if (columnGroupbyColumn.type === CellType.GEOLOCATION) {
+                  columnGroupbyColumnName = getSqlGroup(columnGroupbyGeolocationGranularity, columnGroupbyColumn);
+                }
+                method = isAdvanced ? DTABLE_DB_SUMMARY_METHOD[summaryMethod] : 'COUNT';
+                summaryColumnMethod = getSummaryColumnMethod(method, summaryColumnName);
+                sqlString = "select ".concat(groupbyName, ", ").concat(columnGroupbyColumnName, ", ").concat(summaryColumnMethod, " from `").concat(table.name, "` ").concat(sqlCondition, " group by ").concat(groupbyName, ", ").concat(columnGroupbyColumnName, " order by ").concat(groupbyName, " limit 5000");
+                _context5.next = 15;
+                return this.sqlQuery(sqlString);
+              case 15:
+                queryResult = _context5.sent;
+                if (!(queryResult.status !== 200 || !queryResult.data.success)) {
+                  _context5.next = 18;
+                  break;
+                }
+                return _context5.abrupt("return", []);
+              case 18:
+                data = queryResult.data;
+                if (data.results) {
+                  _context5.next = 21;
+                  break;
+                }
+                return _context5.abrupt("return", []);
+              case 21:
+                newResult = [];
+                valueKey = isAdvanced ? "".concat(summaryColumnMethod) : "".concat(method, "(").concat(groupbyColumn.name, ")");
+                data.results.forEach(function (item) {
+                  var value = item[valueKey] || 0;
+                  if (isAdvanced) {
+                    value = formatNumericValue(value, selectedSummaryColumn);
+                  }
+                  var label = _this2.getLabel(groupbyColumn, groupbyName, item, groupbyDateGranularity, groupbyGeolocationGranularity);
+                  if (!includeEmpty && _this2.isEmptyLabel(label)) {
+                    return;
+                  }
+                  var color;
+                  if (columnGroupbyColumn.type === CellType.SINGLE_SELECT) {
+                    var tempValue = StatUtils.getGroupLabel(item[columnGroupbyColumn.key], {}, columnGroupbyColumn, columnGroupbyDateGranularity, columnGroupbyGeolocationGranularity, _this2.value);
+                    color = getColorFromSingleSelectColumn(columnGroupbyColumn, tempValue);
+                  }
+                  var groupLabel = _this2.getLabel(columnGroupbyColumn, columnGroupbyColumnName, item, columnGroupbyDateGranularity, columnGroupbyGeolocationGranularity);
+                  newResult.push({
+                    value: value,
+                    color: color,
+                    name: label,
+                    group_name: groupLabel,
+                    group_original_name: item[columnGroupbyColumn.key],
+                    original_name: item[groupbyColumn.key],
+                    y_axis_type: yAxisType
+                  });
+                });
+                return _context5.abrupt("return", newResult);
+              case 25:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+      function getGroupbyOneColumnResults(_x16, _x17, _x18, _x19, _x20, _x21, _x22, _x23, _x24, _x25, _x26, _x27, _x28, _x29) {
+        return _getGroupbyOneColumnResults.apply(this, arguments);
+      }
+      return getGroupbyOneColumnResults;
+    }()
+  }, {
+    key: "getGroupbyMultipleNumericColumnsResults",
+    value: function () {
+      var _getGroupbyMultipleNumericColumnsResults = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(groupbyName, groupbyColumn, groupbyDateGranularity, groupbyGeolocationGranularity, includeEmpty, summaryType, summaryColumn, summaryMethod, columnGroupbyNumericColumns, sqlCondition, table, yAxisType) {
+        var _this3 = this;
+        var isAdvanced, numericColumns, groupColumnNames, groupMethods, summaryColumnName, method, summaryColumnMethod, sqlString, result, data, newResult;
+        return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                isAdvanced = summaryType === SUMMARY_TYPE.ADVANCED;
+                numericColumns = [];
+                groupColumnNames = [];
+                groupMethods = [];
+                if (summaryColumn) {
+                  summaryColumnName = isAdvanced ? summaryColumn.name : "`".concat(groupbyColumn.name, "`");
+                  method = isAdvanced ? DTABLE_DB_SUMMARY_METHOD[summaryMethod] : 'COUNT';
+                  summaryColumnMethod = getSummaryColumnMethod(method, summaryColumnName);
+                  numericColumns.push(summaryColumn);
+                  groupColumnNames.push(summaryColumnName);
+                  groupMethods.push(summaryColumnMethod);
+                }
+                columnGroupbyNumericColumns.forEach(function (item) {
+                  var numericColumn = TableUtils.getTableColumnByKey(table, item.column_key);
+                  var groupColumnName = numericColumn.name;
+                  numericColumns.push(numericColumn);
+                  groupColumnNames.push(groupColumnName);
+                  groupMethods.push(getSummaryColumnMethod(DTABLE_DB_SUMMARY_METHOD[item.summary_method], groupColumnName));
+                });
+                sqlString = "select ".concat(groupbyName, ", ").concat(groupMethods.join(','), " from `").concat(table.name, "` ").concat(sqlCondition, " group by ").concat(groupbyName, " order by ").concat(groupbyName, " limit 5000");
+                _context6.next = 9;
+                return this.sqlQuery(sqlString);
+              case 9:
+                result = _context6.sent;
+                if (!(result.status !== 200 || !result.data.success)) {
+                  _context6.next = 12;
+                  break;
+                }
+                return _context6.abrupt("return", []);
+              case 12:
+                data = result.data;
+                if (data.results) {
+                  _context6.next = 15;
+                  break;
+                }
+                return _context6.abrupt("return", []);
+              case 15:
+                newResult = [];
+                data.results.forEach(function (item) {
+                  var label = _this3.getLabel(groupbyColumn, groupbyName, item, groupbyDateGranularity, groupbyGeolocationGranularity);
+                  var isEmpty = _this3.isEmptyLabel(label);
+                  var groupItems = [];
+                  groupMethods.forEach(function (_, index) {
+                    if (!includeEmpty && isEmpty) {
+                      return;
+                    }
+                    var value = item[groupMethods[index]] || 0;
+                    var formatted_value = value;
+                    if (isAdvanced) {
+                      value = formatNumericValue(value, numericColumns[index]);
+                      formatted_value = StatUtils.getFormattedValue(value, numericColumns[index]);
+                    }
+                    groupItems.push({
+                      name: label,
+                      value: value,
+                      formatted_value: formatted_value,
+                      group_name: groupColumnNames[index],
+                      original_name: item[groupbyColumn.key],
+                      y_axis_type: yAxisType
+                    });
+                  });
+                  newResult = newResult.concat(groupItems);
+                });
+                return _context6.abrupt("return", newResult);
+              case 18:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6, this);
+      }));
+      function getGroupbyMultipleNumericColumnsResults(_x30, _x31, _x32, _x33, _x34, _x35, _x36, _x37, _x38, _x39, _x40, _x41) {
+        return _getGroupbyMultipleNumericColumnsResults.apply(this, arguments);
+      }
+      return getGroupbyMultipleNumericColumnsResults;
+    }()
+  }, {
+    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, this.value.collaborators);
+      }
+      return label;
+    }
+  }, {
+    key: "isEmptyLabel",
+    value: function isEmptyLabel(label) {
+      return !label;
+    }
+  }]);
+  return BasicChartCalculator;
+}(BaseCalculator);
+export default BasicChartCalculator;