sea-chart 0.0.1

package/lib/utils/statistic-utils.js

@@ -0,0 +1,1685 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+var _class;
+import shallowEqual from 'shallowequal';
+import dayjs from 'dayjs';
+import { CellType, COLLABORATOR_COLUMN_TYPES, FORMULA_COLUMN_TYPES_MAP, FORMULA_RESULT_TYPE, MULTIPLE_CELL_VALUE_COLUMN_TYPE_MAP, getDateDisplayString, getFormulaDisplayString, getNumberDisplayString, getOption, getPrecisionNumber, getTableById, getTableColumnByKey, isNumber, isNumericColumn, isDateColumn, sortText, sortNumber, sortDate, sortSingleSelect, sortFormula, getColumnOptions } from 'dtable-utils';
+import { PIE_CHART_COLORS, STATISTIC_SUMMARY_TYPE, STATISTIC_SUPPORT_SORT_COLUMNS, STATISTIC_TYPE, STATISTIC_STYLE_SETTING_KEYS, DEFAULT_LABEL_FONT_SIZE, DEFAULT_NUMBER_FORMAT_OBJECT, SUPPORT_DATA_SORT_STATISTIC_TYPES, X_AXIS_IS_GROUPBY_COLUMN_KEY_STATISTIC_TYPES, STYLE_COLORS, LABEL_COLORS } from '../constants';
+import statisticColumn2SqlColumn, { summaryMethodColumn2SqlColumn } from './statistic-column-2-sql-column-utils';
+import { getClientFormulaDisplayString, getClientLinkDisplayString } from './cell-format-utils';
+import { getKnownCollaboratorByEmail, generateDefaultUser } from './collaborator-utils';
+import { getDateColumnFormat, getColumnByKey } from './column-utils';
+import ObjectUtils from './object-utils';
+import intl from '../intl';
+var StatisticsUtils = /*#__PURE__*/function () {
+  function StatisticsUtils() {
+    _classCallCheck(this, StatisticsUtils);
+  }
+  _createClass(StatisticsUtils, null, [{
+    key: "formatGroupsLabel",
+    value: function formatGroupsLabel(results, statistic, tables) {
+      var _this = this;
+      if (!results) return;
+      var groupby_column_key, column_groupby_column_key;
+      var type = statistic.type,
+        config = statistic.config;
+      if (X_AXIS_IS_GROUPBY_COLUMN_KEY_STATISTIC_TYPES.includes(type)) {
+        groupby_column_key = config.groupby_column_key;
+      } else {
+        groupby_column_key = config.x_axis_column_key;
+        column_groupby_column_key = config.column_groupby_column_key;
+      }
+      var table_id = config.table_id;
+      var table = getTableById(tables, table_id);
+      var groupbyColumn = getTableColumnByKey(table, groupby_column_key);
+      var columnGroupbyColumn = getTableColumnByKey(table, column_groupby_column_key);
+      results.forEach(function (item) {
+        var name = item.name,
+          group_name = item.group_name;
+        if (groupbyColumn) {
+          _this.convertResultName(item, groupbyColumn, name, 'name', 'color');
+        }
+        if (columnGroupbyColumn) {
+          _this.convertResultName(item, columnGroupbyColumn, group_name, 'group_name', 'group_color');
+        }
+      });
+    }
+  }, {
+    key: "convertResultName",
+    value: function convertResultName(result, column, name, nameKey, colorKey) {
+      var columnType = column.type,
+        columnData = column.data;
+      if (columnType === CellType.SINGLE_SELECT || columnType === CellType.MULTIPLE_SELECT) {
+        var options = getColumnOptions(column);
+        var selectedOption = getOption(options, name);
+        if (selectedOption) {
+          result[nameKey] = selectedOption.name;
+          result[colorKey] = selectedOption.color;
+        } else {
+          result[colorKey] = '#dbdbdb';
+        }
+      } else if (columnType === CellType.COLLABORATOR) {
+        var collaborator = getKnownCollaboratorByEmail(name);
+        if (collaborator) {
+          result[nameKey] = collaborator.name;
+        }
+      } else if (columnType === CellType.CREATOR || columnType === CellType.LAST_MODIFIER) {
+        if (name === 'anonymous') {
+          result[nameKey] = name;
+        } else {
+          var _collaborator = getKnownCollaboratorByEmail(name);
+          var collaboratorTemplate = {
+            loaded: false,
+            email: name,
+            name: name
+          };
+          window.seaStatistic.context.updateCollaboratorsCache(name, collaboratorTemplate);
+          if (!_collaborator) {
+            window.seaStatistic.queryUsers([name], function (emailUserMap) {
+              var collaborator = emailUserMap && emailUserMap[name] || generateDefaultUser(name);
+              var loadedCollaborator = _objectSpread(_objectSpread({}, collaborator), {}, {
+                loaded: true
+              });
+              window.seaStatistic.context.updateCollaboratorsCache(name, loadedCollaborator);
+              result[nameKey] = name;
+            });
+          } else {
+            result[nameKey] = _collaborator.name;
+          }
+        }
+      } else if (columnType === CellType.NUMBER) {
+        var valueNumber = parseFloat(name);
+        result[nameKey] = isNumber(valueNumber) ? getNumberDisplayString(valueNumber, columnData) : name;
+      } else if (columnType === CellType.DATE) {
+        if (name && name.split('-').length === 3) {
+          var format = getDateColumnFormat(column);
+          var spaceIndex = format.indexOf(' ');
+          if (spaceIndex > -1) {
+            format = format.slice(0, spaceIndex);
+          }
+          result[nameKey] = dayjs(name).format(format);
+        }
+      } else if (FORMULA_COLUMN_TYPES_MAP[columnType]) {
+        var _ref = columnData || {},
+          result_type = _ref.result_type,
+          array_type = _ref.array_type;
+        if (result_type === FORMULA_RESULT_TYPE.NUMBER) {
+          var _valueNumber = parseFloat(name);
+          result[nameKey] = isNumber(_valueNumber) ? getNumberDisplayString(_valueNumber, columnData) : name;
+        } else if (result_type === FORMULA_RESULT_TYPE.ARRAY) {
+          if (COLLABORATOR_COLUMN_TYPES.includes(array_type) && Array.isArray(name)) {
+            result[nameKey] = name.map(function (email) {
+              var user = array_type === CellType.COLLABORATOR ? getKnownCollaboratorByEmail(email) : getKnownCollaboratorByEmail(email);
+              return (user || {}).name;
+            });
+          }
+        }
+      } else if (columnType === CellType.LINK) {
+        result[nameKey] = getClientFormulaDisplayString([name], columnData) || null;
+      }
+    }
+  }, {
+    key: "shouldChartComponentUpdate",
+    value: function shouldChartComponentUpdate(prevProps, currentProps) {
+      return !this.isStatisticEqual(prevProps.statistic, currentProps.statistic) ||
+      // statistic attributes changed
+      !shallowEqual(prevProps.canvasStyle, currentProps.canvasStyle) ||
+      // canvasStyle
+      !shallowEqual(prevProps.groupbyColumn, currentProps.groupbyColumn) ||
+      // groupbyColumn's data、type changed or not exist
+      !shallowEqual(prevProps.columnGroupbyColumn, currentProps.columnGroupbyColumn) ||
+      // columnGroupbyColumn's data、type changed or not exist
+      !shallowEqual(prevProps.summaryColumn, currentProps.summaryColumn) ||
+      // summaryColumn's data、type changed or not exist
+      this._isChartDataChange(prevProps, currentProps) || this.isChartStyleChanged(prevProps.statistic, currentProps.statistic);
+    }
+  }, {
+    key: "_isCombinationDataChange",
+    value: function _isCombinationDataChange(prevResult, currentResult) {
+      if (prevResult.value_left !== currentResult.value_left) return true;
+      if (prevResult.value_right !== currentResult.value_right) return true;
+      return false;
+    }
+  }]);
+  return StatisticsUtils;
+}();
+_class = StatisticsUtils;
+StatisticsUtils.sortStatistics = function (statistics, column, sortKey) {
+  var columnType = column.type,
+    data = column.data;
+  var sortType = 'up';
+  var optionIdIndexMap = {};
+  if (columnType === CellType.SINGLE_SELECT) {
+    var _ref2 = data || {},
+      options = _ref2.options;
+    Array.isArray(options) && options.forEach(function (option, index) {
+      optionIdIndexMap[option.id] = index;
+    });
+  }
+  statistics.sort(function (currResult, nextResult) {
+    var current = currResult[sortKey];
+    var next = nextResult[sortKey];
+    if (!current && current !== 0) {
+      return -1;
+    }
+    if (!next && next !== 0) {
+      return 1;
+    }
+    if (STATISTIC_SUPPORT_SORT_COLUMNS.includes(columnType)) {
+      switch (columnType) {
+        case CellType.NUMBER:
+        case CellType.RATE:
+          {
+            if (current) {
+              current = current - 0;
+            }
+            if (next) {
+              next = next - 0;
+            }
+            return sortNumber(current, next, sortType);
+          }
+        case CellType.DATE:
+        case CellType.CTIME:
+        case CellType.MTIME:
+          {
+            return sortDate(current, next, sortType);
+          }
+        case CellType.SINGLE_SELECT:
+        case CellType.MULTIPLE_SELECT:
+          {
+            return sortSingleSelect(current, next, {
+              sort_type: sortType,
+              option_id_index_map: optionIdIndexMap
+            });
+          }
+        case CellType.FORMULA:
+        case CellType.LINK_FORMULA:
+          {
+            return sortFormula(current, next, sortType, {
+              columnData: data,
+              value: {}
+            });
+          }
+        default:
+          {
+            return sortText(current, next, sortType);
+          }
+      }
+    }
+    return 0;
+  });
+};
+StatisticsUtils.sortStatisticData = function (statistics, sort_key) {
+  statistics.sort(function (currResult, nextResult) {
+    var current = currResult.value;
+    var next = nextResult.value;
+    if (!current && current !== 0) return -1;
+    if (!next && next !== 0) return 1;
+    if (sort_key === 'ascending') {
+      return current > next ? 1 : -1;
+    }
+    return current > next ? -1 : 1;
+  });
+};
+StatisticsUtils.sortByDate = function (currentDate, nextDate) {
+  if (currentDate.name === 'undefined') return -1;
+  if (nextDate.name === 'undefined') return 1;
+  if (currentDate.name > nextDate.name) return 1;
+  if (currentDate.name < nextDate.name) return -1;
+  return 0;
+};
+StatisticsUtils.moveNullDataToEnd = function (arr) {
+  var nullData;
+  var nullDataIndex = arr.findIndex(function (item) {
+    return item.name === 'undefined';
+  });
+  if (nullDataIndex > -1) {
+    nullData = arr.splice(nullDataIndex, 1);
+    arr.push.apply(arr, _toConsumableArray(nullData));
+  }
+  return arr;
+};
+StatisticsUtils.getGroupColumn = function (table, statistic) {
+  var config = statistic.config;
+  var type = config.type;
+  if (X_AXIS_IS_GROUPBY_COLUMN_KEY_STATISTIC_TYPES.includes(type)) {
+    return getTableColumnByKey(table, config.groupby_column_key);
+  }
+  if (type === STATISTIC_TYPE.BASIC_NUMBER_CARD) {
+    return getTableColumnByKey(table, config.numeric_column_key);
+  }
+  return getTableColumnByKey(table, config.x_axis_column_key);
+};
+StatisticsUtils.getColumnGroupColumn = function (table, statistic) {
+  var config = statistic.config;
+  var type = config.type;
+  if (X_AXIS_IS_GROUPBY_COLUMN_KEY_STATISTIC_TYPES.includes(type)) {
+    return getTableColumnByKey(table, config.column_groupby_column_key);
+  }
+  if ([STATISTIC_TYPE.BAR_GROUP, STATISTIC_TYPE.LINE_GROUP, STATISTIC_TYPE.HORIZONTAL_GROUP_BAR].includes(type)) {
+    return getTableColumnByKey(table, config.column_groupby_column_key);
+  }
+  return getTableColumnByKey(table, config.y_axis_summary_column_key);
+};
+StatisticsUtils.getSummaryColumn = function (table, statistic) {
+  var config = statistic.config;
+  var summary_column_key = config.summary_column_key,
+    y_axis_summary_column_key = config.y_axis_summary_column_key,
+    type = config.type,
+    numeric_column_key = config.numeric_column_key;
+  switch (type) {
+    case STATISTIC_TYPE.BAR:
+    case STATISTIC_TYPE.BAR_GROUP:
+    case STATISTIC_TYPE.LINE:
+    case STATISTIC_TYPE.LINE_GROUP:
+    case STATISTIC_TYPE.AREA:
+    case STATISTIC_TYPE.HORIZONTAL_BAR:
+    case STATISTIC_TYPE.HORIZONTAL_GROUP_BAR:
+      {
+        return getTableColumnByKey(table, y_axis_summary_column_key);
+      }
+    case STATISTIC_TYPE.BASIC_NUMBER_CARD:
+      {
+        return getTableColumnByKey(table, numeric_column_key);
+      }
+    default:
+      {
+        return getTableColumnByKey(table, summary_column_key);
+      }
+  }
+};
+StatisticsUtils.getGroupName = function (tables, statistic) {
+  var config = statistic.config;
+  var table = getTableById(tables, config.table_id);
+  var column = _class.getGroupColumn(table, statistic);
+  return column.name;
+};
+StatisticsUtils.getChartGroups = function (statistics) {
+  var chartGroups = [];
+  Array.isArray(statistics) && statistics.forEach(function (item) {
+    if (!chartGroups.find(function (g) {
+      return g.name === item.name;
+    })) {
+      chartGroups.push(item);
+    }
+  });
+  return chartGroups;
+};
+StatisticsUtils.isValidExistStatistic = function (tables, statistic) {
+  if (!statistic) return false;
+  var config = statistic.config;
+  var table_id = config.table_id,
+    type = config.type;
+  var table = getTableById(tables, table_id);
+  if (!table) return false;
+  if (config.type === STATISTIC_TYPE.BASIC_NUMBER_CARD) {
+    var numericColumnKey = config.numeric_column_key;
+    if (!numericColumnKey) return false;
+    return getTableColumnByKey(table, numericColumnKey);
+  }
+  if (config.type === STATISTIC_TYPE.DASHBOARD) {
+    var targetColumnKey = config.target_value_column_key;
+    if (!targetColumnKey) return false;
+    var totalColumnKey = config.total_value_column_key;
+    if (!totalColumnKey) return false;
+    if (!getTableColumnByKey(table, targetColumnKey)) return false;
+    return getTableColumnByKey(table, totalColumnKey);
+  }
+  var groupByColumnKey = config.groupby_column_key || config.x_axis_column_key || config.vertical_axis_column_key;
+  if (!groupByColumnKey) return false;
+  if (!getTableColumnByKey(table, groupByColumnKey)) return false;
+  if (type === STATISTIC_TYPE.COMBINATION) {
+    var isExist = _class.isValidCombinationStatistic(config, table);
+    if (!isExist) return false;
+  } else {
+    var summaryColumnKey = config.summary_column_key || config.y_axis_summary_column_key || config.horizontal_axis_column_key;
+    var summaryType = config.summary_type || config.y_axis_summary_type || config.horizontal_axis_summary_type;
+    if (summaryType === STATISTIC_SUMMARY_TYPE.ADVANCED && !summaryColumnKey) return false;
+    if (summaryColumnKey) {
+      return getTableColumnByKey(table, summaryColumnKey);
+    }
+  }
+  return true;
+};
+StatisticsUtils.isValidCombinationStatistic = function (config, table) {
+  var summaryLeftColumnKey = config.y_axis_left_summary_column;
+  var summaryLeftType = config.y_axis_left_summary_type;
+  if (summaryLeftType === STATISTIC_SUMMARY_TYPE.ADVANCED && !summaryLeftColumnKey) return false;
+  if (summaryLeftColumnKey) {
+    if (!getTableColumnByKey(table, summaryLeftColumnKey)) return false;
+  }
+  var summaryRightColumnKey = config.y_axis_right_summary_column;
+  var summaryRightType = config.y_axis_right_summary_type;
+  if (summaryRightType === STATISTIC_SUMMARY_TYPE.ADVANCED && !summaryRightColumnKey) return false;
+  if (summaryRightColumnKey) {
+    return getTableColumnByKey(table, summaryRightColumnKey);
+  }
+  return true;
+};
+StatisticsUtils.getGroupLabelFromDB = function (cellValue, column, tables) {
+  var collaborators = window.seaStatistic.context.getCollaboratorsFromCache();
+  var type = column.type,
+    data = column.data;
+  switch (type) {
+    case CellType.TEXT:
+    case CellType.DATE:
+    case CellType.CTIME:
+    case CellType.MTIME:
+      {
+        return cellValue || null;
+      }
+    case CellType.NUMBER:
+      {
+        if (!cellValue && cellValue !== 0) return null;
+        return getPrecisionNumber(cellValue, data);
+      }
+    case CellType.SINGLE_SELECT:
+      {
+        var isInvalidValue = data && data.options && data.options.findIndex(function (opt) {
+          return opt.id === cellValue;
+        }) < 0;
+        return isInvalidValue ? null : cellValue;
+      }
+    case CellType.MULTIPLE_SELECT:
+      {
+        var options = data && data.options;
+        if (!Array.isArray(options) || options.length === 0) return [];
+        if (!Array.isArray(cellValue) || cellValue.length === 0) return [];
+        return cellValue.filter(function (optionId) {
+          return options.find(function (option) {
+            return option.id === optionId;
+          });
+        });
+      }
+    case CellType.COLLABORATOR:
+      {
+        if (!Array.isArray(collaborators) || collaborators.length === 0) return [];
+        if (!Array.isArray(cellValue) || cellValue.length === 0) return [];
+        return cellValue.filter(function (email) {
+          return collaborators.find(function (option) {
+            return option.email === email;
+          });
+        });
+      }
+    case CellType.CREATOR:
+    case CellType.LAST_MODIFIER:
+      {
+        return cellValue ? cellValue : null;
+      }
+    case CellType.GEOLOCATION:
+      {
+        return cellValue || null;
+      }
+    case CellType.FORMULA:
+    case CellType.LINK_FORMULA:
+      {
+        var validValue = getFormulaDisplayString(cellValue, data, {
+          tables: tables
+        });
+        if (!validValue && validValue !== 0) return null;
+        return validValue;
+      }
+    case CellType.LINK:
+      {
+        return Array.isArray(cellValue) ? cellValue.map(function (linked) {
+          return getClientLinkDisplayString([linked], data, {});
+        }) : [];
+      }
+    case CellType.CHECKBOX:
+      {
+        return String(cellValue) === 'true' ? 'Checked' : 'Unchecked';
+      }
+    case CellType.RATE:
+      {
+        return cellValue ? String(cellValue) : null;
+      }
+    default:
+      {
+        return null;
+      }
+  }
+};
+StatisticsUtils.oneDimensionStatisticTableSQLResult2JavaScript = function (statistic, sqlRows, statisticSQLMap, columnMap, tables) {
+  var groupbyColumn = columnMap.groupbyColumn;
+  var summary_type = statistic.config.summary_type;
+  var pivot_columns = [];
+  var pivot_rows = [];
+  var isCount = summary_type === STATISTIC_SUMMARY_TYPE.COUNT;
+  if (isCount) {
+    var _sqlGroupbyColumnKey = statisticSQLMap.sqlGroupbyColumnKey,
+      sqlSummaryColumnKey = statisticSQLMap.sqlSummaryColumnKey;
+    var _allTotal = 0;
+    sqlRows.forEach(function (row) {
+      var total = row[sqlSummaryColumnKey] || 0;
+      _allTotal += total;
+      pivot_rows.push({
+        name: _class.getGroupLabelFromDB(row[_sqlGroupbyColumnKey], groupbyColumn, tables),
+        rows: [],
+        total: {
+          total: total
+        }
+      });
+    });
+    return {
+      pivot_columns: pivot_columns,
+      pivot_rows: pivot_rows,
+      pivot_columns_total: {
+        total: _allTotal
+      }
+    };
+  }
+  var sqlGroupbyColumnKey = statisticSQLMap.sqlGroupbyColumnKey,
+    summarySQLColumnName2ColumnKey = statisticSQLMap.summarySQLColumnName2ColumnKey,
+    summaryTableColumnKey2Column = statisticSQLMap.summaryTableColumnKey2Column,
+    summaryTableColumnKey2Method = statisticSQLMap.summaryTableColumnKey2Method;
+  var summaryColumnKeys = Object.values(summarySQLColumnName2ColumnKey);
+  var sqlSummaryColumnKeys = Object.keys(summarySQLColumnName2ColumnKey);
+  var totalTemplate = {};
+  Object.values(summaryColumnKeys).forEach(function (key) {
+    var summaryMethod = summaryTableColumnKey2Method[key];
+    totalTemplate[key] = _class.initTotal(summaryMethod);
+    pivot_columns.push({
+      key: key
+    });
+  });
+  var allTotal = _objectSpread({}, totalTemplate);
+  sqlRows.forEach(function (row) {
+    var rowTotal = _objectSpread({}, totalTemplate);
+    sqlSummaryColumnKeys.forEach(function (key) {
+      var columnKey = summarySQLColumnName2ColumnKey[key];
+      var summaryColumn = summaryTableColumnKey2Column[columnKey];
+      var summaryMethod = summaryTableColumnKey2Method[columnKey];
+      var value = row[key] || _class.initTotal(summaryMethod);
+      allTotal[columnKey] = _class.getSummaryValue({
+        summaryColumn: summaryColumn,
+        summaryMethod: summaryMethod
+      }, allTotal[columnKey], value);
+      if (_class.isDateSummaryColumn(summaryColumn)) {
+        rowTotal[columnKey] = value;
+      } else if (_class.isNumericSummaryColumn(summaryColumn)) {
+        rowTotal[columnKey] = rowTotal[columnKey] + value;
+      }
+    });
+    pivot_rows.push({
+      name: _class.getGroupLabelFromDB(row[sqlGroupbyColumnKey], groupbyColumn, tables),
+      rows: [row],
+      total: rowTotal
+    });
+  });
+  if (pivot_columns.length < 2) {
+    var pivot_column = pivot_columns[0];
+    var key = pivot_column.key;
+    pivot_rows.forEach(function (row) {
+      row.total = _objectSpread(_objectSpread({}, row.total), {}, {
+        total: row.total[key]
+      });
+    });
+    allTotal = _objectSpread(_objectSpread({}, allTotal), {}, {
+      total: allTotal[key]
+    });
+  }
+  _class.sortStatistics(pivot_rows, groupbyColumn, 'name');
+  return {
+    pivot_columns: pivot_columns,
+    pivot_rows: pivot_rows,
+    pivot_columns_total: allTotal
+  };
+};
+StatisticsUtils.updateTwoDimensionColumns = function (pivot_columns, key, _ref3) {
+  var isIncludeEmpty = _ref3.isIncludeEmpty,
+    isCellValueAsAnArray = _ref3.isCellValueAsAnArray;
+  if (isCellValueAsAnArray) {
+    if ((!Array.isArray(key) || key.length === 0) && isIncludeEmpty) {
+      var _pivotColumnIndex = pivot_columns.findIndex(function (r) {
+        return !r.key;
+      });
+      if (_pivotColumnIndex < 0) {
+        pivot_columns.unshift({
+          key: null
+        });
+      }
+      return;
+    }
+    key.forEach(function (k) {
+      var pivotColumnIndex = pivot_columns.findIndex(function (r) {
+        return r.key === k;
+      });
+      if (pivotColumnIndex < 0) {
+        pivot_columns.push({
+          key: k
+        });
+      }
+    });
+    return;
+  }
+  var pivotColumnIndex = pivot_columns.findIndex(function (r) {
+    var resKey = r.key;
+    return resKey === null && key === null || resKey === undefined && key === undefined || resKey === 0 && key === 0 || resKey === key;
+  });
+  if (pivotColumnIndex < 0) {
+    pivot_columns.push({
+      key: key
+    });
+  }
+};
+StatisticsUtils.isSameGroup = function (isColumnDataAsAnArray, source, target) {
+  if (isColumnDataAsAnArray) {
+    return (!Array.isArray(source) || source.length === 0) && !target || source.includes(target);
+  }
+  return source === null && target === null || source === undefined && target === undefined || source === target;
+};
+StatisticsUtils.updateTwoDimensionRows = function (pivot_rows, pivot_columns, index, name, count, row, isColumnDataAsAnArray, cellValue, _ref4) {
+  var summaryMethod = _ref4.summaryMethod,
+    summaryColumn = _ref4.summaryColumn;
+  if (index > -1) {
+    var updatedPivotRow = pivot_rows[index];
+    var _cells = updatedPivotRow.cells,
+      _total = updatedPivotRow.total;
+    pivot_columns.forEach(function (c) {
+      var key = c.key;
+      if (_class.isSameGroup(isColumnDataAsAnArray, cellValue, key)) {
+        if (_cells[key]) {
+          _cells[key].rows.push(row);
+          _cells[key].total = _class.getSummaryValue({
+            summaryMethod: summaryMethod,
+            summaryColumn: summaryColumn
+          }, _cells[key].total, count);
+        } else {
+          _cells[key] = {
+            rows: [row],
+            total: count
+          };
+        }
+      }
+    });
+    updatedPivotRow.cells = _cells;
+    updatedPivotRow.total = _class.getSummaryValue({
+      summaryMethod: summaryMethod,
+      summaryColumn: summaryColumn
+    }, _total, count);
+    pivot_rows[index] = updatedPivotRow;
+    return;
+  }
+  var cells = {};
+  var total = _class.initTotal(summaryMethod);
+  pivot_columns.forEach(function (c) {
+    var key = c.key;
+    if (_class.isSameGroup(isColumnDataAsAnArray, cellValue, key)) {
+      cells[key] = {
+        rows: [row],
+        total: count
+      };
+      total = _class.getSummaryValue({
+        summaryMethod: summaryMethod,
+        summaryColumn: summaryColumn
+      }, total, count);
+    }
+  });
+  pivot_rows.push({
+    name: name,
+    cells: cells,
+    total: total
+  });
+};
+StatisticsUtils.getSummaryValue = function (_ref5, currentValue, nextValue) {
+  var summaryMethod = _ref5.summaryMethod,
+    summaryColumn = _ref5.summaryColumn;
+  if (_class.isDateSummaryColumn(summaryColumn)) {
+    if (summaryMethod === 'MAX') {
+      if (currentValue && nextValue) {
+        return dayjs(currentValue).isBefore(nextValue) ? nextValue : currentValue;
+      }
+      if (!currentValue && nextValue) return nextValue;
+      return currentValue;
+    }
+    if (summaryMethod === 'MIN') {
+      if (currentValue && nextValue) {
+        return dayjs(currentValue).isBefore(nextValue) ? currentValue : nextValue;
+      }
+      if (!currentValue && nextValue) return nextValue;
+      return currentValue;
+    }
+    return currentValue;
+  }
+  if (summaryMethod === 'MAX' || summaryMethod === 'MIN') {
+    if (currentValue === null && nextValue === null) return null;
+    if (currentValue === null) return nextValue;
+    if (nextValue === null) return currentValue;
+  }
+  return (currentValue - 0 || 0) + (nextValue - 0 || 0);
+};
+StatisticsUtils.getAndUpdateTwoDimensionTotal = function (pivot_columns_total, pivot_columns, pivot_rows, _ref6) {
+  var summaryMethod = _ref6.summaryMethod,
+    summaryColumn = _ref6.summaryColumn;
+  var pivot_table_total = _class.initTotal(summaryMethod);
+  pivot_rows.forEach(function (row) {
+    var cells = row.cells,
+      total = row.total;
+    pivot_table_total = _class.getSummaryValue({
+      summaryMethod: summaryMethod,
+      summaryColumn: summaryColumn
+    }, pivot_table_total, total);
+    pivot_columns.forEach(function (column) {
+      var key = column.key;
+      var cell = cells[key];
+      if (cell) {
+        var pivot_column_total = pivot_columns_total && pivot_columns_total[key] ? pivot_columns_total[key] : _class.initTotal(summaryMethod);
+        pivot_columns_total[key] = _class.getSummaryValue({
+          summaryMethod: summaryMethod,
+          summaryColumn: summaryColumn
+        }, pivot_column_total, cell.total);
+      }
+    });
+  });
+  return pivot_table_total;
+};
+StatisticsUtils.isValidCellValue = function (cellValue) {
+  var includeEmpty = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  if (includeEmpty) return true;
+  if (typeof cellValue === 'boolean') return true;
+  return cellValue || cellValue === 0;
+};
+StatisticsUtils.twoDimensionStatisticTableSQLResult2JavaScript = function (statistic, sqlRows, statisticSQLMap, columnMap, tables) {
+  var _ref7 = columnMap || {},
+    groupbyColumn = _ref7.groupbyColumn,
+    columnGroupbyColumn = _ref7.columnGroupbyColumn,
+    summaryColumn = _ref7.summaryColumn;
+  var _statistic$config = statistic.config,
+    groupby_include_empty_cells = _statistic$config.groupby_include_empty_cells,
+    summary_method = _statistic$config.summary_method;
+  var sqlGroupbyColumnKey = statisticSQLMap.sqlGroupbyColumnKey,
+    sqlColumnGroupbyColumnKey = statisticSQLMap.sqlColumnGroupbyColumnKey,
+    sqlSummaryColumnKey = statisticSQLMap.sqlSummaryColumnKey;
+  if (!sqlColumnGroupbyColumnKey) return _class.oneDimensionStatisticTableSQLResult2JavaScript(statistic, sqlRows, statisticSQLMap, columnMap, tables);
+  var summaryMethod = (summary_method || 'sum').toUpperCase();
+  var pivot_columns = [];
+  var pivot_rows = [];
+  var pivot_columns_total = {};
+  var isRowGroupbyColumnDataAsAnArray = !!MULTIPLE_CELL_VALUE_COLUMN_TYPE_MAP[columnGroupbyColumn.type];
+  sqlRows.forEach(function (row) {
+    var groupbyColumnCellValue = row[sqlGroupbyColumnKey];
+    var groupbyColumnCellValueKey = _class.getGroupLabelFromDB(groupbyColumnCellValue, groupbyColumn, tables);
+    var columnGroupbyColumnCellValue = row[sqlColumnGroupbyColumnKey];
+    var columnGroupbyColumnCellValueKey = _class.getGroupLabelFromDB(columnGroupbyColumnCellValue, columnGroupbyColumn, tables);
+    var count = !row[sqlSummaryColumnKey] && row[sqlSummaryColumnKey] !== 0 ? null : row[sqlSummaryColumnKey];
+    if (_class.isValidCellValue(columnGroupbyColumnCellValue, groupby_include_empty_cells)) {
+      _class.updateTwoDimensionColumns(pivot_columns, columnGroupbyColumnCellValueKey, {
+        isIncludeEmpty: groupby_include_empty_cells,
+        isCellValueAsAnArray: isRowGroupbyColumnDataAsAnArray
+      });
+    }
+    if (_class.isValidCellValue(groupbyColumnCellValue, groupby_include_empty_cells)) {
+      if (MULTIPLE_CELL_VALUE_COLUMN_TYPE_MAP[groupbyColumn]) {
+        if ((!Array.isArray(groupbyColumnCellValueKey) || groupbyColumnCellValueKey.length === 0) && groupby_include_empty_cells) {
+          var pivotRowIndex = pivot_rows.findIndex(function (r) {
+            return !r.name;
+          });
+          _class.updateTwoDimensionRows(pivot_rows, pivot_columns, pivotRowIndex, null, count, row, isRowGroupbyColumnDataAsAnArray, columnGroupbyColumnCellValueKey, {
+            summaryMethod: summaryMethod,
+            summaryColumn: summaryColumn
+          });
+        } else {
+          groupbyColumnCellValueKey.forEach(function (n) {
+            var pivotRowIndex = pivot_rows.findIndex(function (r) {
+              return n === r.name;
+            });
+            _class.updateTwoDimensionRows(pivot_rows, pivot_columns, pivotRowIndex, n, count, row, isRowGroupbyColumnDataAsAnArray, columnGroupbyColumnCellValueKey, {
+              summaryMethod: summaryMethod,
+              summaryColumn: summaryColumn
+            });
+          });
+        }
+      } else {
+        var _pivotRowIndex = pivot_rows.findIndex(function (r) {
+          var resName = r.name;
+          return resName === null && groupbyColumnCellValueKey === null || resName === undefined && groupbyColumnCellValueKey === undefined || resName === 0 && groupbyColumnCellValueKey === 0 || resName === groupbyColumnCellValueKey;
+        });
+        _class.updateTwoDimensionRows(pivot_rows, pivot_columns, _pivotRowIndex, groupbyColumnCellValueKey, count, row, isRowGroupbyColumnDataAsAnArray, columnGroupbyColumnCellValueKey, {
+          summaryMethod: summaryMethod,
+          summaryColumn: summaryColumn
+        });
+      }
+    }
+  });
+  var pivot_table_total = _class.getAndUpdateTwoDimensionTotal(pivot_columns_total, pivot_columns, pivot_rows, {
+    summaryMethod: summaryMethod,
+    summaryColumn: summaryColumn
+  });
+  _class.sortStatistics(pivot_rows, groupbyColumn, 'name');
+  _class.sortStatistics(pivot_columns, columnGroupbyColumn, 'key');
+  return {
+    pivot_columns: pivot_columns,
+    pivot_rows: pivot_rows,
+    pivot_columns_total: pivot_columns_total,
+    pivot_table_total: pivot_table_total
+  };
+};
+StatisticsUtils.basicChartStatisticSQLResult2JavaScript = function (statistic, sqlRows, statisticSQLMap, columnMap, tables) {
+  var config = statistic.config;
+  var type = config.type,
+    sort_type = config.sort_type;
+  var groupbyColumn = columnMap.groupbyColumn;
+  var isGroupbyColumnDataAsAnArray = MULTIPLE_CELL_VALUE_COLUMN_TYPE_MAP[groupbyColumn.type];
+  var sqlGroupbyColumnKey = statisticSQLMap.sqlGroupbyColumnKey,
+    sqlSummaryColumnKey = statisticSQLMap.sqlSummaryColumnKey;
+  var result = [];
+  sqlRows.forEach(function (row) {
+    var cellValue = row[sqlGroupbyColumnKey];
+    var summaryValue = row[sqlSummaryColumnKey];
+    if (_class.isValidCellValue(cellValue)) {
+      var key = _class.getGroupLabelFromDB(cellValue, groupbyColumn, tables);
+      if (isGroupbyColumnDataAsAnArray) {
+        if (!Array.isArray(key) || key.length === 0) {
+          var itemIdx = result.findIndex(function (v) {
+            return v.name === null;
+          });
+          if (itemIdx < 0) {
+            result.push({
+              color: '',
+              name: null,
+              rows: [row],
+              value: summaryValue
+            });
+          } else {
+            var itemRow = result[itemIdx];
+            itemRow.rows.push(row);
+            itemRow.value = itemRow.value + summaryValue;
+          }
+        } else {
+          key.forEach(function (item) {
+            var itemIdx = result.findIndex(function (v) {
+              return v.name === item;
+            });
+            if (itemIdx < 0) {
+              result.push({
+                color: '',
+                name: item,
+                rows: [row],
+                value: summaryValue
+              });
+            } else {
+              var _itemRow = result[itemIdx];
+              _itemRow.rows.push(row);
+              _itemRow.value = _itemRow.value + summaryValue;
+            }
+          });
+        }
+      } else {
+        var _itemIdx = result.findIndex(function (v) {
+          return v.name === key;
+        });
+        if (_itemIdx < 0) {
+          result.push({
+            color: '',
+            name: key,
+            rows: [row],
+            value: summaryValue
+          });
+        } else {
+          var _itemRow2 = result[_itemIdx];
+          _itemRow2.rows.push(row);
+          _itemRow2.value = _itemRow2.value + summaryValue;
+        }
+      }
+    }
+  });
+  _class.updateTableViewList(result, groupbyColumn, 'name', 'color');
+  if (SUPPORT_DATA_SORT_STATISTIC_TYPES.includes(type) && sort_type) {
+    _class.sortStatisticData(result, sort_type);
+    return result;
+  }
+  _class.sortStatistics(result, groupbyColumn, 'name');
+  return result;
+};
+StatisticsUtils.basicNumberCardStatisticSQLResult2JavaScript = function (statistic, sqlRows, statisticSQLMap, columnMap, tables) {
+  if (sqlRows.length > 0) {
+    var summaryResult = sqlRows[0];
+    var key = Object.keys(summaryResult)[0];
+    return summaryResult[key];
+  }
+  return 0;
+};
+StatisticsUtils.combinationStatisticSQLResult2Javascript = function (statistic, sqlRows, statisticSQLMap, columnMap, tables) {
+  var config = statistic.config;
+  var y_axis_left_group_by_multiple_numeric_column = config.y_axis_left_group_by_multiple_numeric_column,
+    y_axis_left_summary_type = config.y_axis_left_summary_type,
+    y_axis_left_summary_column = config.y_axis_left_summary_column,
+    y_axis_left_summary_method = config.y_axis_left_summary_method,
+    y_axis_right_summary_type = config.y_axis_right_summary_type,
+    y_axis_right_summary_column = config.y_axis_right_summary_column,
+    table_id = config.table_id,
+    y_axis_left_group_by_numeric_columns = config.y_axis_left_group_by_numeric_columns;
+  var table = getTableById(tables, table_id);
+  var groupbyColumn = columnMap.groupbyColumn;
+  var sqlGroupbyColumnKey = statisticSQLMap.sqlGroupbyColumnKey,
+    sqlSummaryColumnKey = statisticSQLMap.sqlSummaryColumnKey,
+    sqlRightSummaryColumnKey = statisticSQLMap.sqlRightSummaryColumnKey,
+    sqlLeftSummaryColumnKey = statisticSQLMap.sqlLeftSummaryColumnKey;
+  var isGroupbyColumnDataAsAnArray = MULTIPLE_CELL_VALUE_COLUMN_TYPE_MAP[groupbyColumn.type];
+  var result = [];
+  if (!y_axis_left_group_by_multiple_numeric_column) {
+    var leftSummaryColumn, rightSummaryColumn;
+    if (y_axis_left_summary_type === STATISTIC_SUMMARY_TYPE.ADVANCED) {
+      leftSummaryColumn = getTableColumnByKey(table, y_axis_left_summary_column);
+    }
+    if (y_axis_right_summary_type === STATISTIC_SUMMARY_TYPE.ADVANCED) {
+      rightSummaryColumn = getTableColumnByKey(table, y_axis_right_summary_column);
+    }
+    sqlRows.forEach(function (row) {
+      var cellValue = row[sqlGroupbyColumnKey];
+      var summaryValue = row[sqlSummaryColumnKey];
+      var key = _class.getGroupLabelFromDB(cellValue, groupbyColumn, tables);
+      var valueLeft = row[sqlLeftSummaryColumnKey] || 0;
+      var valueRight = row[sqlRightSummaryColumnKey] || 0;
+      if (y_axis_left_summary_type === STATISTIC_SUMMARY_TYPE.ADVANCED) {
+        valueLeft = _class.getPrecisionNumber(valueLeft, leftSummaryColumn.data);
+      }
+      if (y_axis_right_summary_type === STATISTIC_SUMMARY_TYPE.ADVANCED) {
+        valueRight = _class.getPrecisionNumber(valueRight, rightSummaryColumn.data);
+      }
+      if (isGroupbyColumnDataAsAnArray) {
+        if (!Array.isArray(key) || key.length === 0) {
+          var itemIdx = result.findIndex(function (v) {
+            return v.name === null;
+          });
+          if (itemIdx < 0) {
+            result.push({
+              color: '',
+              name: null,
+              rows: [row],
+              value_left: valueLeft,
+              value_right: valueRight
+            });
+          } else {
+            var itemRow = result[itemIdx];
+            itemRow.rows.push(row);
+            itemRow.value_left = itemRow.value_left + summaryValue;
+            itemRow.value_right = itemRow.value_right + summaryValue;
+          }
+        } else {
+          key.forEach(function (item) {
+            var itemIdx = result.findIndex(function (v) {
+              return v.name === item;
+            });
+            if (itemIdx < 0) {
+              result.push({
+                color: '',
+                name: item,
+                rows: [row],
+                value_left: valueLeft,
+                value_right: valueRight
+              });
+            } else {
+              var _itemRow3 = result[itemIdx];
+              _itemRow3.rows.push(row);
+              _itemRow3.value_left = _itemRow3.value_left + summaryValue;
+              _itemRow3.value_right = _itemRow3.value_right + summaryValue;
+            }
+          });
+        }
+      } else {
+        var _itemIdx2 = result.findIndex(function (v) {
+          return v.name === key;
+        });
+        if (_itemIdx2 < 0) {
+          result.push({
+            color: '',
+            name: key,
+            rows: [row],
+            value_left: valueLeft,
+            value_right: valueRight
+          });
+        } else {
+          var _itemRow4 = result[_itemIdx2];
+          _itemRow4.rows.push(row);
+          _itemRow4.value_left = _itemRow4.value_left + summaryValue;
+          _itemRow4.value_right = _itemRow4.value_right + summaryValue;
+        }
+      }
+    });
+  } else {
+    var _rightSummaryColumn;
+    if (y_axis_right_summary_type === STATISTIC_SUMMARY_TYPE.ADVANCED) {
+      _rightSummaryColumn = getTableColumnByKey(table, y_axis_right_summary_column);
+    }
+    var groupItems = [];
+    var _leftSummaryColumn = getTableColumnByKey(table, y_axis_left_summary_column);
+    var summaryMethod = y_axis_left_summary_method.toUpperCase();
+    var _summaryMethodColumn = summaryMethodColumn2SqlColumn(summaryMethod, _leftSummaryColumn || {}),
+      groupItem = _summaryMethodColumn.key;
+    _leftSummaryColumn && !groupItems.includes(groupItem) && groupItems.push(groupItem);
+    y_axis_left_group_by_numeric_columns.forEach(function (item, index) {
+      var column = getTableColumnByKey(table, item.column_key);
+      if (column) {
+        var itemSummaryMethod = item.summary_method.toUpperCase();
+        var _summaryMethodColumn2 = summaryMethodColumn2SqlColumn(itemSummaryMethod, column || {}),
+          _groupItem = _summaryMethodColumn2.key;
+        !groupItems.includes(_groupItem) && groupItems.push(_groupItem);
+      }
+    });
+    sqlRows.forEach(function (item, index) {
+      var cellValue = item[sqlGroupbyColumnKey];
+      var key = _class.getGroupLabelFromDB(cellValue, groupbyColumn, tables);
+      var valueRight = item[sqlRightSummaryColumnKey] || 0;
+      if (y_axis_right_summary_type === STATISTIC_SUMMARY_TYPE.ADVANCED) {
+        valueRight = _class.getPrecisionNumber(valueRight, _rightSummaryColumn.data);
+      }
+      groupItems.forEach(function (groupItem, index) {
+        var value = item[groupItem] || 0;
+        if (y_axis_right_summary_type === STATISTIC_SUMMARY_TYPE.ADVANCED) {
+          value = _class.getPrecisionNumber(value, _leftSummaryColumn.data);
+        }
+        result.push({
+          name: key,
+          value_left: value,
+          value_right: valueRight,
+          color: LABEL_COLORS[index % 12]
+        });
+      });
+    });
+  }
+  return result;
+};
+StatisticsUtils.getPrecisionNumber = function (value, data) {
+  var valueString = getPrecisionNumber(value, data);
+  var valueNumber = parseFloat(valueString);
+  return isNumber(valueNumber) ? valueNumber : 0;
+};
+StatisticsUtils.dashboardStatisticSQLResult2JavaScript = function (statistic, sqlRows, statisticSQLMap, columnMap, tables) {
+  if (sqlRows.length > 0) {
+    var summaryResult = sqlRows[0];
+    var config = statistic.config;
+    var target_value_column_summary_method = config.target_value_column_summary_method,
+      total_value_column_summary_method = config.total_value_column_summary_method,
+      target_value_column_key = config.target_value_column_key,
+      total_value_column_key = config.total_value_column_key,
+      table_id = config.table_id;
+    var table = getTableById(tables, table_id);
+    var targetColumn = getTableColumnByKey(table, target_value_column_key);
+    var totalColumn = getTableColumnByKey(table, total_value_column_key);
+    var targetSummaryMethod = target_value_column_summary_method.toUpperCase();
+    var totalSummaryMethod = total_value_column_summary_method.toUpperCase();
+    var _summaryMethodColumn3 = summaryMethodColumn2SqlColumn(targetSummaryMethod, targetColumn),
+      targetResultKey = _summaryMethodColumn3.key;
+    var _summaryMethodColumn4 = summaryMethodColumn2SqlColumn(totalSummaryMethod, totalColumn),
+      totalResultKey = _summaryMethodColumn4.key;
+    var targetResult = summaryResult[targetResultKey];
+    var totalResult = summaryResult[totalResultKey];
+    if (totalResult === 0) {
+      return 0;
+    }
+    return targetResult / totalResult;
+  }
+  return 0;
+};
+StatisticsUtils.updateTableViewListItemNameAndColor = function (result, column, nameKey, colorKey) {
+  var columnType = column.type,
+    columnData = column.data;
+  var name = result[nameKey];
+  if (columnType === CellType.SINGLE_SELECT || columnType === CellType.MULTIPLE_SELECT) {
+    var options = getColumnOptions(column);
+    var selectedOption = getOption(options, name);
+    var _ref8 = selectedOption || {},
+      optionName = _ref8.name,
+      optionColor = _ref8.color;
+    if (selectedOption) {
+      result[nameKey] = optionName;
+      result[colorKey] = optionColor;
+    } else {
+      result[colorKey] = '#dbdbdb';
+    }
+  } else if (columnType === CellType.COLLABORATOR) {
+    var collaborator = getKnownCollaboratorByEmail(name);
+    if (collaborator) {
+      result[nameKey] = collaborator.name;
+    }
+  } else if (columnType === CellType.CREATOR || columnType === CellType.LAST_MODIFIER) {
+    if (name === 'anonymous') {
+      result[nameKey] = name;
+    } else {
+      var _collaborator2 = getKnownCollaboratorByEmail(name);
+      var collaboratorTemplate = {
+        loaded: false,
+        email: name,
+        name: name
+      };
+      window.seaStatistic.context.updateCollaboratorsCache(name, collaboratorTemplate);
+      if (!_collaborator2) {
+        window.seaStatistic.queryUsers([name], function (emailUserMap) {
+          var collaborator = emailUserMap && emailUserMap[name] || generateDefaultUser(name);
+          var loadedCollaborator = _objectSpread(_objectSpread({}, collaborator), {}, {
+            loaded: true
+          });
+          window.seaStatistic.context.updateCollaboratorsCache(name, loadedCollaborator);
+          result[nameKey] = name;
+        });
+      } else {
+        result[nameKey] = _collaborator2.name;
+      }
+    }
+  } else if (columnType === CellType.NUMBER) {
+    var valueNumber = parseFloat(name);
+    result[nameKey] = isNumber(valueNumber) ? getNumberDisplayString(valueNumber, columnData) : name;
+  } else if (columnType === CellType.DATE) {
+    name = name + '';
+    if (name && name.split('-').length === 3) {
+      var format = getDateColumnFormat(column);
+      var spaceIndex = format.indexOf(' ');
+      if (spaceIndex > -1) {
+        format = format.slice(0, spaceIndex);
+      }
+      result[nameKey] = dayjs(name).format(format);
+    }
+  }
+};
+StatisticsUtils.updateTableViewList = function (result, column, nameKey, colorKey) {
+  result.forEach(function (result) {
+    _class.updateTableViewListItemNameAndColor(result, column, nameKey, colorKey);
+  });
+};
+StatisticsUtils.updateGroupingChartRow = function (results, name, groupName, row, count) {
+  var updatedIndex = results.findIndex(function (result) {
+    return result.name === name && result.group_name === groupName;
+  });
+  if (updatedIndex > -1) {
+    var updatedResult = results[updatedIndex];
+    updatedResult.rows.push(row);
+    updatedResult.value = updatedResult.value + count;
+    results[updatedIndex] = updatedResult;
+  } else {
+    results.push({
+      name: name,
+      rows: [row],
+      group_name: groupName,
+      value: count
+    });
+  }
+};
+StatisticsUtils.updateGroupingChartRows = function (results, name, row, count, isColumnGroupbyColumnDataAsAnArray, groupName) {
+  if (isColumnGroupbyColumnDataAsAnArray) {
+    if (!Array.isArray(groupName) || groupName.length === 0) {
+      _class.updateGroupingChartRow(results, name, null, row, count);
+      return;
+    }
+    groupName.forEach(function (v) {
+      _class.updateGroupingChartRow(results, name, v, row, count);
+    });
+    return;
+  }
+  _class.updateGroupingChartRow(results, name, groupName, row, count);
+};
+StatisticsUtils.groupingTwoDimensionChartStatisticSQLResult2JavaScript = function (statistic, sqlRows, statisticSQLMap, columnMap, tables) {
+  var groupbyColumn = columnMap.groupbyColumn,
+    columnGroupbyColumn = columnMap.columnGroupbyColumn;
+  var includeEmpty = statistic.config.x_axis_include_empty_cells;
+  var sqlGroupbyColumnKey = statisticSQLMap.sqlGroupbyColumnKey,
+    sqlColumnGroupbyColumnKey = statisticSQLMap.sqlColumnGroupbyColumnKey,
+    sqlSummaryColumnKey = statisticSQLMap.sqlSummaryColumnKey;
+  var result = [];
+  var isGroupbyColumnDataAsAnArray = !!MULTIPLE_CELL_VALUE_COLUMN_TYPE_MAP[groupbyColumn.type];
+  var isColumnGroupbyColumnDataAsAnArray = !!MULTIPLE_CELL_VALUE_COLUMN_TYPE_MAP[columnGroupbyColumn.type];
+  sqlRows.forEach(function (row) {
+    var groupbyColumnCellValue = row[sqlGroupbyColumnKey];
+    var groupbyColumnCellValueKey = _class.getGroupLabelFromDB(groupbyColumnCellValue, groupbyColumn, tables);
+    if (_class.isValidCellValue(groupbyColumnCellValueKey, includeEmpty)) {
+      var columnGroupbyColumnCellValue = row[sqlColumnGroupbyColumnKey];
+      var columnGroupbyColumnCellValueKey = _class.getGroupLabelFromDB(columnGroupbyColumnCellValue, columnGroupbyColumn, tables);
+      var count = row[sqlSummaryColumnKey];
+      if (isGroupbyColumnDataAsAnArray) {
+        if (!Array.isArray(groupbyColumnCellValueKey) || groupbyColumnCellValueKey.length === 0) {
+          _class.updateGroupingChartRows(result, null, row, count, isColumnGroupbyColumnDataAsAnArray, columnGroupbyColumnCellValueKey);
+        } else {
+          groupbyColumnCellValueKey.forEach(function (n) {
+            _class.updateGroupingChartRows(result, n, row, count, isColumnGroupbyColumnDataAsAnArray, columnGroupbyColumnCellValueKey);
+          });
+        }
+      } else {
+        _class.updateGroupingChartRows(result, groupbyColumnCellValueKey, row, count, isColumnGroupbyColumnDataAsAnArray, columnGroupbyColumnCellValueKey);
+      }
+    }
+  });
+  _class.updateTableViewList(result, groupbyColumn, 'name', 'color');
+  _class.updateTableViewList(result, columnGroupbyColumn, 'group_name', 'group_color');
+  _class.sortStatistics(result, groupbyColumn, 'name');
+  return result;
+};
+StatisticsUtils.groupingChartStatisticSQLResult2JavaScript = function (statistic, sqlRows, statisticSQLMap, columnMap, tables) {
+  var _statistic$config2 = statistic.config,
+    column_groupby_column_key = _statistic$config2.column_groupby_column_key,
+    column_groupby_multiple_numeric_column = _statistic$config2.column_groupby_multiple_numeric_column,
+    y_axis_summary_type = _statistic$config2.y_axis_summary_type,
+    includeEmpty = _statistic$config2.x_axis_include_empty_cells;
+  if (!column_groupby_column_key && !column_groupby_multiple_numeric_column) {
+    return _class.basicChartStatisticSQLResult2JavaScript(statistic, sqlRows, statisticSQLMap, columnMap, tables);
+  }
+  var groupbyColumn = columnMap.groupbyColumn,
+    columnGroupbyColumn = columnMap.columnGroupbyColumn;
+  if (y_axis_summary_type === STATISTIC_SUMMARY_TYPE.COUNT) {
+    if (!columnGroupbyColumn) return _class.basicChartStatisticSQLResult2JavaScript(statistic, sqlRows, statisticSQLMap, columnMap, tables);
+    return _class.groupingTwoDimensionChartStatisticSQLResult2JavaScript(statistic, sqlRows, statisticSQLMap, columnMap, tables);
+  }
+  var sqlGroupbyColumnKey = statisticSQLMap.sqlGroupbyColumnKey;
+  if (column_groupby_multiple_numeric_column) {
+    var summaryColumns = statisticSQLMap.summaryColumns;
+    var result = [];
+    var isGroupbyColumnDataAsAnArray = !!MULTIPLE_CELL_VALUE_COLUMN_TYPE_MAP[groupbyColumn.type];
+    sqlRows.forEach(function (row) {
+      var groupbyColumnCellValue = row[sqlGroupbyColumnKey];
+      var groupbyColumnCellValueKey = _class.getGroupLabelFromDB(groupbyColumnCellValue, groupbyColumn, tables);
+      if (_class.isValidCellValue(groupbyColumnCellValueKey, includeEmpty)) {
+        Object.keys(summaryColumns).forEach(function (sqlSummaryColumnName) {
+          var _summaryColumns$sqlSu = summaryColumns[sqlSummaryColumnName],
+            sqlSummaryColumnKey = _summaryColumns$sqlSu.sqlSummaryColumnKey,
+            columnName = _summaryColumns$sqlSu.columnName;
+          var numberColumnCellValue = row[sqlSummaryColumnKey];
+          if (isGroupbyColumnDataAsAnArray) {
+            if (!Array.isArray(groupbyColumnCellValueKey) || groupbyColumnCellValueKey.length === 0) {
+              _class.updateGroupingChartRows(result, null, row, numberColumnCellValue, false, columnName);
+            } else {
+              groupbyColumnCellValueKey.forEach(function (n) {
+                _class.updateGroupingChartRows(result, n, row, numberColumnCellValue, false, columnName);
+              });
+            }
+          } else {
+            _class.updateGroupingChartRows(result, groupbyColumnCellValueKey, row, numberColumnCellValue, false, columnName);
+          }
+        });
+      }
+    });
+    _class.updateTableViewList(result, groupbyColumn, 'name', 'color');
+    _class.sortStatistics(result, groupbyColumn, 'name');
+    return result;
+  }
+  if (!columnGroupbyColumn) {
+    return _class.basicChartStatisticSQLResult2JavaScript(statistic, sqlRows, statisticSQLMap, columnMap, tables);
+  }
+  return _class.groupingTwoDimensionChartStatisticSQLResult2JavaScript(statistic, sqlRows, statisticSQLMap, columnMap, tables);
+};
+StatisticsUtils.sqlResult2JavaScript = function (statistic, sqlRows, statisticSQLMap, columnMap, tables) {
+  var type = statistic.config.type;
+  switch (type) {
+    case STATISTIC_TYPE.TABLE:
+      {
+        var column_groupby_column_key = statistic.config.column_groupby_column_key;
+        if (!column_groupby_column_key) {
+          return {
+            result: _class.oneDimensionStatisticTableSQLResult2JavaScript(statistic, sqlRows, statisticSQLMap, columnMap, tables)
+          };
+        }
+        return {
+          result: _class.twoDimensionStatisticTableSQLResult2JavaScript(statistic, sqlRows, statisticSQLMap, columnMap, tables)
+        };
+      }
+    case STATISTIC_TYPE.PIE:
+    case STATISTIC_TYPE.RING:
+    case STATISTIC_TYPE.TREE_MAP:
+      {
+        return {
+          result: _class.basicChartStatisticSQLResult2JavaScript(statistic, sqlRows, statisticSQLMap, columnMap, tables)
+        };
+      }
+    case STATISTIC_TYPE.BASIC_NUMBER_CARD:
+      {
+        return {
+          result: _class.basicNumberCardStatisticSQLResult2JavaScript(statistic, sqlRows, statisticSQLMap, columnMap, tables)
+        };
+      }
+    case STATISTIC_TYPE.DASHBOARD:
+      {
+        return {
+          result: _class.dashboardStatisticSQLResult2JavaScript(statistic, sqlRows, statisticSQLMap, columnMap, tables)
+        };
+      }
+    case STATISTIC_TYPE.BAR:
+    case STATISTIC_TYPE.LINE:
+    case STATISTIC_TYPE.HORIZONTAL_BAR:
+    case STATISTIC_TYPE.AREA:
+      {
+        return {
+          result: _class.basicChartStatisticSQLResult2JavaScript(statistic, sqlRows, statisticSQLMap, columnMap, tables)
+        };
+      }
+    case STATISTIC_TYPE.COMBINATION:
+      {
+        return {
+          result: _class.combinationStatisticSQLResult2Javascript(statistic, sqlRows, statisticSQLMap, columnMap, tables)
+        };
+      }
+    case STATISTIC_TYPE.BAR_GROUP:
+    case STATISTIC_TYPE.LINE_GROUP:
+    case STATISTIC_TYPE.HORIZONTAL_GROUP_BAR:
+      {
+        return {
+          result: _class.groupingChartStatisticSQLResult2JavaScript(statistic, sqlRows, statisticSQLMap, columnMap, tables)
+        };
+      }
+    default:
+      {
+        return;
+      }
+  }
+};
+StatisticsUtils.convertStatisticConfig = function (config) {
+  var type = config.type;
+  if (type === STATISTIC_TYPE.HORIZONTAL_BAR || type === STATISTIC_TYPE.HORIZONTAL_GROUP_BAR) {
+    var vertical_axis_column_key = config.vertical_axis_column_key,
+      vertical_axis_date_granularity = config.vertical_axis_date_granularity,
+      vertical_axis_geolocation_granularity = config.vertical_axis_geolocation_granularity,
+      vertical_axis_include_empty = config.vertical_axis_include_empty,
+      horizontal_axis_summary_type = config.horizontal_axis_summary_type,
+      horizontal_axis_summary_method = config.horizontal_axis_summary_method,
+      horizontal_axis_column_key = config.horizontal_axis_column_key,
+      show_vertical_axis_label = config.show_vertical_axis_label,
+      vertical_axis_label_position = config.vertical_axis_label_position,
+      show_horizontal_axis_label = config.show_horizontal_axis_label,
+      horizontal_axis_label_position = config.horizontal_axis_label_position,
+      horizontal_axis_label_color = config.horizontal_axis_label_color;
+    var newConfig = {
+      x_axis_column_key: vertical_axis_column_key,
+      x_axis_date_granularity: vertical_axis_date_granularity,
+      x_axis_geolocation_granularity: vertical_axis_geolocation_granularity,
+      x_axis_include_empty_cells: vertical_axis_include_empty,
+      y_axis_summary_type: horizontal_axis_summary_type,
+      y_axis_summary_method: horizontal_axis_summary_method,
+      y_axis_summary_column_key: horizontal_axis_column_key,
+      x_axis_show_label: show_vertical_axis_label,
+      x_axis_label_position: vertical_axis_label_position,
+      y_axis_show_label: show_horizontal_axis_label,
+      y_axis_label_position: horizontal_axis_label_position,
+      y_axis_label_color: horizontal_axis_label_color,
+      y_axis_auto_range: config.horizontal_axis_auto_range,
+      y_axis_max: config.horizontal_axis_max,
+      y_axis_mix: config.horizontal_axis_min
+    };
+    return Object.assign({}, config, newConfig);
+  }
+  return config;
+};
+StatisticsUtils.imEmptyStatistic = function (statisticResult) {
+  return !statisticResult || !statisticResult.result && statisticResult.result !== 0 || Array.isArray(statisticResult.result) && statisticResult.result.length === 0;
+};
+StatisticsUtils.calculateStatistic = function (statistic, queryDataAPI, tables, callback, isStatisticalData) {
+  if (!_class.isValidExistStatistic(tables, statistic)) {
+    var tip_message = 'Please_complete_the_chart_configuration_first';
+    return callback && callback('', tip_message, null);
+  }
+  var id = statistic.id,
+    config = statistic.config,
+    type = statistic.type;
+  var newConfig = _class.convertStatisticConfig(config);
+  var newStatistic = {
+    id: id,
+    config: newConfig,
+    type: type
+  };
+  var table_id = config.table_id;
+  var table = getTableById(tables, table_id);
+  var groupbyColumn = _class.getGroupColumn(table, newStatistic);
+  var columnGroupbyColumn = _class.getColumnGroupColumn(table, newStatistic);
+  var summaryColumn = _class.getSummaryColumn(table, newStatistic);
+  var columnMap = {
+    groupbyColumn: groupbyColumn,
+    columnGroupbyColumn: columnGroupbyColumn,
+    summaryColumn: summaryColumn
+  };
+  var statisticTableColumns = table.columns;
+  var statisticSQLMap = null;
+  try {
+    statisticSQLMap = statisticColumn2SqlColumn(newStatistic, table);
+  } catch (error) {
+    var error_message = 'There_are_some_problems_with_the_filters';
+    return callback && callback(error_message, '', null);
+  }
+  queryDataAPI({
+    onSuccess: function onSuccess(res) {
+      var _res$data = res.data,
+        success = _res$data.success,
+        sqlRows = _res$data.results,
+        error_message = _res$data.error_message;
+      if (success) {
+        if (isStatisticalData) {
+          var tipMessage = 'There_are_no_statistic_results_yet';
+          if (!Array.isArray(sqlRows) || sqlRows.length === 0) {
+            callback && callback('', tipMessage, null);
+            return;
+          }
+          var statisticResult = _class.sqlResult2JavaScript(newStatistic, sqlRows, statisticSQLMap, columnMap, tables);
+          if (_class.imEmptyStatistic(statisticResult)) {
+            callback && callback('', tipMessage, null);
+            return;
+          }
+          callback && callback('', '', _objectSpread(_objectSpread({}, statisticResult), {}, {
+            groupbyColumn: groupbyColumn,
+            columnGroupbyColumn: columnGroupbyColumn,
+            summaryColumn: summaryColumn,
+            statisticTableColumns: statisticTableColumns
+          }));
+          return;
+        }
+      }
+      callback && callback(error_message, '', null);
+    },
+    onFail: function onFail(err) {
+      var errorMessage = 'Network_error';
+      if (err.response) {
+        var status = err.response.status;
+        if (status === 500) {
+          errorMessage = 'Internal_server_error';
+        }
+      }
+      callback && callback(errorMessage, '', null);
+    }
+  });
+};
+StatisticsUtils.calculateStaticStatistic = function (tables, statistic, statisticalResult, callback) {
+  if (!_class.isValidExistStatistic(tables, statistic)) {
+    var tip_message = 'Please_complete_the_chart_configuration_first';
+    return callback && callback('', tip_message, null);
+  }
+  if (!statisticalResult) {
+    var _tip_message = 'There_are_no_statistic_results_yet';
+    return callback && callback('', _tip_message, null);
+  }
+  var id = statistic.id,
+    config = statistic.config;
+  var newConfig = _class.convertStatisticConfig(config);
+  var newStatistic = {
+    id: id,
+    config: newConfig
+  };
+  var type = config.type;
+  if (type === STATISTIC_TYPE.TABLE) return callback && callback('', '', statisticalResult);
+  var table_id = config.table_id,
+    sort_type = config.sort_type;
+  var table = getTableById(tables, table_id);
+  var groupbyColumn = _class.getGroupColumn(table, newStatistic);
+  var result = statisticalResult.result;
+  if (!result) {
+    var _tip_message2 = 'There_are_no_statistic_results_yet';
+    return callback && callback('', _tip_message2, null);
+  }
+  if (SUPPORT_DATA_SORT_STATISTIC_TYPES.includes(type) && sort_type) {
+    _class.sortStatisticData(result, sort_type);
+    var _newStatisticalResult = _objectSpread(_objectSpread({}, statisticalResult), {}, {
+      result: result
+    });
+    return callback && callback('', '', _newStatisticalResult);
+  }
+  _class.sortStatistics(result, groupbyColumn, 'name');
+  var newStatisticalResult = _objectSpread(_objectSpread({}, statisticalResult), {}, {
+    result: result
+  });
+  return callback && callback('', '', newStatisticalResult);
+};
+StatisticsUtils.getPieColorSet = function (tables, statistic, result) {
+  if (!Array.isArray(result)) return [];
+  var _statistic$config3 = statistic.config,
+    table_id = _statistic$config3.table_id,
+    column_id = _statistic$config3.groupby_column_key;
+  var column = _class.getColumn(tables, table_id, column_id);
+  var _ref9 = column || {},
+    columnType = _ref9.type;
+  var pieChartColorsLength = PIE_CHART_COLORS.length - 1;
+  var backgroundColor = [];
+  result.forEach(function (item, index) {
+    if (columnType === CellType.SINGLE_SELECT || columnType === CellType.MULTIPLE_SELECT) {
+      var color = item.color;
+      backgroundColor.push(color);
+    } else {
+      if (index > pieChartColorsLength) {
+        index = index % pieChartColorsLength;
+      }
+      backgroundColor.push(PIE_CHART_COLORS[index]);
+    }
+  });
+  return backgroundColor;
+};
+StatisticsUtils.getColumn = function (tables, tableId, columnKey) {
+  var table = getTableById(tables, tableId);
+  return getTableColumnByKey(table, columnKey);
+};
+StatisticsUtils.formatEmptyName = function (dataList, column_groupby_column_key, emptyName) {
+  if (!Array.isArray(dataList)) return [];
+  var updatedStatistics = [];
+  dataList.forEach(function (item) {
+    var updated = {};
+    if (!item.name) {
+      updated.name = emptyName;
+    }
+    if (column_groupby_column_key && !item.group_name) {
+      updated.group_name = emptyName;
+    }
+    updatedStatistics.push(Object.assign({}, item, updated));
+  });
+  return updatedStatistics;
+};
+StatisticsUtils.getStatisticColumns = function (table) {
+  var columns = table.columns;
+  var unStatisticalColumns = [CellType.LONG_TEXT, CellType.IMAGE, CellType.FILE, CellType.CHECKBOX];
+  return columns.filter(function (column) {
+    return unStatisticalColumns.indexOf(column.type) === -1;
+  });
+};
+StatisticsUtils.isStatisticEqual = function (preStatisticElement, curStatisticElement) {
+  var elementType = preStatisticElement.config.type;
+  if (elementType !== curStatisticElement.config.type) return false;
+  return shallowEqual(preStatisticElement.config, curStatisticElement.config);
+};
+StatisticsUtils.isStatisticStyleChange = function (preStatisticElement, curStatisticElement) {
+  var elementType = preStatisticElement.config.type;
+  if (elementType !== curStatisticElement.config.type) return false;
+  if (preStatisticElement.height.value !== curStatisticElement.height.value) return true;
+  if (preStatisticElement.left_in_unit !== curStatisticElement.left_in_unit) return true;
+  if (preStatisticElement.width_in_unit !== curStatisticElement.width_in_unit) return true;
+  if (!ObjectUtils.isSameObject(preStatisticElement.style_config, curStatisticElement.style_config)) return true;
+  return !STATISTIC_STYLE_SETTING_KEYS.every(function (key) {
+    return preStatisticElement.config[key] === curStatisticElement.config[key];
+  });
+};
+StatisticsUtils.isStatisticTypeChange = function (preStatisticElement, curStatisticElement) {
+  var elementType = preStatisticElement.config.type;
+  if (elementType !== curStatisticElement.config.type) return true;
+  return false;
+};
+StatisticsUtils.isStatisticSortChange = function (preStatisticElement, curStatisticElement) {
+  return preStatisticElement.config.sort_type !== curStatisticElement.config.sort_type;
+};
+StatisticsUtils.isChartStyleChanged = function (prevElement, currElement) {
+  var prevStyleConfig = prevElement && prevElement.style_config;
+  var currStyleConfig = currElement && currElement.style_config;
+  if (!prevStyleConfig && !currStyleConfig) {
+    return false;
+  }
+  if (!prevStyleConfig || !currStyleConfig) {
+    return true;
+  }
+  var prevBorder = prevStyleConfig.border,
+    prevTitle = prevStyleConfig.title;
+  var currBorder = currStyleConfig.border,
+    currTitle = currStyleConfig.title;
+  return !shallowEqual(prevBorder, currBorder) || !shallowEqual(prevTitle, currTitle);
+};
+StatisticsUtils._isChartDataChange = function (prevProps, currentProps) {
+  var newData = prevProps.result,
+    statistic = prevProps.statistic;
+  var oldData = currentProps.result;
+  if (statistic.config.type === STATISTIC_TYPE.COMBINATION) {
+    return _class._isCombinationDataChange(newData, oldData);
+  }
+  if (!newData && !oldData) return false;
+  if (!newData && oldData || newData && !oldData) return true;
+  var dataLength = newData === null || newData === void 0 ? void 0 : newData.length;
+  if (dataLength !== (oldData === null || oldData === void 0 ? void 0 : oldData.length)) return true;
+  for (var i = 0; i < dataLength; i++) {
+    var newDataItem = newData[i];
+    var oldDataItem = oldData[i];
+    if (newDataItem.value !== oldDataItem.value) return true; // row's length
+    if (newDataItem.name !== oldDataItem.name) return true;
+  }
+  for (var _i = 0; _i < dataLength; _i++) {
+    var newDataItemRows = newData[_i].rows;
+    var oldDataItemRows = oldData[_i].rows;
+    for (var j = 0; j < (newDataItemRows === null || newDataItemRows === void 0 ? void 0 : newDataItemRows.length) || 0; j++) {
+      var newDataItemRow = newDataItemRows[j];
+      var oldDataItemRow = oldDataItemRows[j];
+      if (!shallowEqual(newDataItemRow, oldDataItemRow)) return true;
+    }
+  }
+  return false;
+};
+StatisticsUtils.isValidValue = function (value) {
+  if (value === 0) return true;
+  return Boolean(value);
+};
+StatisticsUtils.getSummaryValueDisplayString = function (summaryColumn, summaryValue) {
+  var summaryMethod = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'count';
+  if (!summaryColumn) return summaryValue;
+  if (!summaryValue && summaryValue !== 0) return summaryValue;
+  if (summaryMethod.toUpperCase() === 'DISTINCT_VALUES') return summaryValue;
+  var data = summaryColumn.data;
+  if (_class.isDateSummaryColumn(summaryColumn)) {
+    if (typeof summaryValue !== 'string') return summaryValue;
+
+    // Compatible with previous data
+    var _ref10 = data || {
+        format: 'YYYY-HH-MM'
+      },
+      format = _ref10.format;
+
+    // The date returned by db carries T and Z, so that there is a time difference in data formatting
+    return getDateDisplayString(summaryValue.replace(/[T|Z]/g, ' '), format);
+  }
+  if (typeof summaryValue !== 'number') return summaryValue;
+  return getNumberDisplayString(summaryValue, data || DEFAULT_NUMBER_FORMAT_OBJECT);
+};
+StatisticsUtils.isNumericSummaryColumn = function (summaryColumn) {
+  if (!summaryColumn) return false;
+  var type = summaryColumn.type;
+  return type !== CellType.LINK && isNumericColumn(summaryColumn);
+};
+StatisticsUtils.isDateSummaryColumn = function (summaryColumn) {
+  if (!summaryColumn) return false;
+  var type = summaryColumn.type;
+  return type !== CellType.LINK && isDateColumn(summaryColumn);
+};
+StatisticsUtils.getSummaryExplanation = function (statistic) {
+  var config = statistic.config;
+  var type = config.type;
+  switch (type) {
+    case STATISTIC_TYPE.PIE:
+    case STATISTIC_TYPE.LINE:
+    case STATISTIC_TYPE.LINE_GROUP:
+    case STATISTIC_TYPE.RING:
+      {
+        return {
+          count: intl.get('Count_the_number_of_records_in_each_group'),
+          advanced: intl.get('Compute_the_sum_maximum_or_minimum_value_of_records_in_each_group_by_a_field')
+        };
+      }
+    case STATISTIC_TYPE.BAR:
+    case STATISTIC_TYPE.BAR_GROUP:
+      {
+        return {
+          count: intl.get('Group_the_records_according_to_the_vertical_axis_and_count_the_records_in_each_group'),
+          advanced: intl.get('Group_the_records_according_to_the_vertical_axis_and_compute_the_sum_maximum_or_minimum_of_records_in_each_group_by_a_field')
+        };
+      }
+    default:
+      {
+        return {
+          count: intl.get('Count_the_records'),
+          advanced: intl.get('Compute_sum_max_min')
+        };
+      }
+  }
+};
+StatisticsUtils.getLabelFontSize = function (labelFontSize) {
+  return isNumber(labelFontSize) ? labelFontSize : DEFAULT_LABEL_FONT_SIZE;
+};
+StatisticsUtils.getPieColor = function (column, index, data) {
+  var columnType = column.type,
+    columnData = column.data;
+  if (columnType === 'single-select' || columnType === 'multiple-select') {
+    if (columnData && columnData.options) {
+      var selectedItem = columnData.options.find(function (item) {
+        return item.name === data.name;
+      }) || {};
+      return selectedItem.color || '#dbdbdb';
+    }
+  } else {
+    var pieChartColorsLength = PIE_CHART_COLORS.length - 1;
+    var newIndex = index > pieChartColorsLength ? index % pieChartColorsLength : index;
+    return PIE_CHART_COLORS[newIndex];
+  }
+};
+StatisticsUtils.formatPieChartData = function (data, statistic, tables) {
+  if (!Array.isArray(data) || data.length === 0 || !statistic) {
+    return {
+      data: [],
+      total: 0,
+      colorSet: []
+    };
+  }
+  var _statistic$config4 = statistic.config,
+    table_id = _statistic$config4.table_id,
+    groupby_column_key = _statistic$config4.groupby_column_key,
+    minimum_slice_percent = _statistic$config4.minimum_slice_percent;
+  var table = getTableById(tables, table_id);
+  var column = getColumnByKey(groupby_column_key, table ? table.columns : []);
+  var sum = data.reduce(function (total, currentValue) {
+    return total += currentValue.value;
+  }, 0);
+  var minimumSlicePercentage = typeof minimum_slice_percent === 'number' ? minimum_slice_percent : 1.5;
+  var threshold = sum * (minimumSlicePercentage / 100 || 0);
+  var filteredItems = [];
+  var colorSet = [];
+  var filteredData = [];
+  var rows = [];
+  data.forEach(function (item, index) {
+    var value = item.value;
+    if (value >= threshold) {
+      item.percent = String(Number.parseFloat(value / sum * 100).toFixed(1)) + '%';
+      var color = _class.getPieColor(column, index, item);
+      item.color = color;
+      colorSet.push(color);
+      filteredData.push(item);
+    } else {
+      rows.push.apply(rows, _toConsumableArray(item.rows));
+      filteredItems.push(item);
+    }
+  });
+  if (filteredItems.length > 0) {
+    var filteredSum = filteredItems.reduce(function (total, currentValue) {
+      return total += currentValue.value;
+    }, 0);
+    filteredData.push({
+      name: '_Others',
+      value: filteredSum,
+      color: '#dbdbdb',
+      percent: String(Number.parseFloat(filteredSum / sum * 100).toFixed(1)) + '%',
+      rows: rows
+    });
+    colorSet.push('#dbdbdb');
+  }
+  return {
+    data: filteredData,
+    total: sum,
+    colorSet: colorSet
+  };
+};
+StatisticsUtils.initTotal = function (summaryMethod) {
+  if (summaryMethod === 'SUM' || summaryMethod === 'DISTINCT_VALUES') return 0;
+  return null;
+};
+StatisticsUtils.getCurrentTheme = function (themeName) {
+  if (themeName) {
+    var currentColorTheme = STYLE_COLORS.find(function (item) {
+      return item.name === themeName;
+    });
+    return currentColorTheme;
+  }
+  return STYLE_COLORS[0];
+};
+export default StatisticsUtils;