dtable-statistic 4.4.24-alpha.9 → 5.0.0

package/es/calculator/pivot-table-calculator.js

@@ -0,0 +1,821 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dayjs = _interopRequireDefault(require("dayjs"));
+var _dtableUtils = require("dtable-utils");
+var _baseCalculator = _interopRequireDefault(require("./base-calculator"));
+var _constants = require("../constants");
+var _commonUtils = require("../utils/common-utils");
+var _statUtils = _interopRequireDefault(require("../utils/stat-utils"));
+var _rowUtils = require("../utils/row-utils");
+class PivotTableCalculator extends _baseCalculator.default {
+  isValidChart(chart) {
+    if (!this.validateBaseConfigs(chart)) {
+      return false;
+    }
+    const {
+      table_id,
+      groupby_column_key,
+      summary_type,
+      summary_column_key,
+      column_groupby_column_key,
+      summary_columns_option
+    } = chart;
+    const table = this.getTableById(table_id);
+    if (!groupby_column_key || !(0, _dtableUtils.getTableColumnByKey)(table, groupby_column_key)) {
+      return false;
+    }
+    if (column_groupby_column_key && !(0, _dtableUtils.getTableColumnByKey)(table, column_groupby_column_key)) {
+      return false;
+    }
+    if (summary_type === _constants.SUMMARY_TYPE.ADVANCED) {
+      const summaryColumnsKeys = summary_columns_option ? summary_columns_option.map(item => item.key) : [];
+      if (!table.columns.find(column => column.key === summary_column_key || summaryColumnsKeys.includes(column.key))) {
+        return false;
+      }
+    }
+    return true;
+  }
+  async calculate(chart) {
+    if (!this.isValidChart(chart)) return {};
+    if (this.isCalcByQueryDB(chart)) {
+      return await this.queryDb(chart);
+    }
+    return await this.calculateWithWorker(chart);
+  }
+  async queryDb(chart) {
+    const {
+      table_id,
+      view_id,
+      column_groupby_column_key,
+      groupby_column_key,
+      summary_column_key
+    } = chart;
+    const table = this.getTableById(table_id);
+    const view = this.getViewById(view_id, table);
+    const groupbyColumn = (0, _dtableUtils.getTableColumnByKey)(table, groupby_column_key);
+    const columnGroupbyColumn = (0, _dtableUtils.getTableColumnByKey)(table, column_groupby_column_key);
+    const summaryColumn = (0, _dtableUtils.getTableColumnByKey)(table, summary_column_key);
+    const sqlMap = this.generateSqlFromChart(chart, table, view);
+    const columnMap = {
+      groupbyColumn,
+      columnGroupbyColumn,
+      summaryColumn
+    };
+    const result = await this.sqlQuery(sqlMap.sql);
+    const {
+      status,
+      data
+    } = result;
+    if (!status === 200 || !data || !data.success) return {};
+    const {
+      results: sqlRows
+    } = data;
+    if (!column_groupby_column_key) {
+      return this.oneDimensionTableSQLResult2JavaScript(chart, sqlRows, sqlMap, columnMap);
+    }
+    return this.twoDimensionTableSQLResult2JavaScript(chart, sqlRows, sqlMap, columnMap);
+  }
+  generateSqlFromChart(chart, table, view) {
+    if (!chart || !table || !view) return '';
+    const {
+      column_groupby_column_key,
+      groupby_column_key
+    } = chart;
+    if (!groupby_column_key) return '';
+    const condition = this.filter2SqlCondition(table, view);
+    if (!column_groupby_column_key) {
+      return this.oneDimensionStatisticTable2sql(chart, condition);
+    }
+    return this.twoDimensionStatisticTable2sql(chart, condition);
+  }
+  oneDimensionStatisticTable2sql(chart, condition) {
+    const {
+      table_id,
+      groupby_column_key,
+      summary_type,
+      summary_column_key,
+      numeric_column_keys,
+      groupby_date_granularity,
+      groupby_geolocation_granularity,
+      summary_method,
+      summary_columns_option
+    } = chart;
+    const table = this.getTableById(table_id);
+    const groupbyColumn = (0, _dtableUtils.getTableColumnByKey)(table, groupby_column_key);
+    if (!groupbyColumn) return '';
+    const {
+      name: sqlGroupbyColumnName,
+      key: sqlGroupbyColumnKey
+    } = this.column2SqlColumn(groupbyColumn, {
+      dateGranularity: groupby_date_granularity,
+      geolocationGranularity: groupby_geolocation_granularity
+    });
+    let tableName = "`".concat(table.name, "`");
+    if (summary_type === _constants.SUMMARY_TYPE.COUNT) {
+      const {
+        name: sqlSummaryColumnName,
+        key: sqlSummaryColumnKey
+      } = this.summaryMethodColumn2SqlColumn('Count', groupbyColumn);
+      const sql = "SELECT ".concat(sqlGroupbyColumnName, ", ").concat(sqlSummaryColumnName, " FROM ").concat(tableName, " ").concat(condition, " GROUP BY ").concat(sqlGroupbyColumnName, " ORDER BY `").concat(groupbyColumn.name, "` LIMIT 0, 5000");
+      return {
+        sql,
+        sqlGroupbyColumnKey,
+        sqlSummaryColumnKey
+      };
+    }
+    if (summary_columns_option) {
+      let summaries = [];
+      let summaryColumnOptions = [];
+      const summaryMethod = summary_method;
+      const summaryColumn = (0, _dtableUtils.getTableColumnByKey)(table, summary_column_key);
+      if (summaryColumn && ((0, _dtableUtils.isNumericColumn)(summaryColumn) || (0, _dtableUtils.isDateColumn)(summaryColumn))) {
+        const {
+          name: sqlSummaryMethodColumnName,
+          key: sqlSummaryMethodColumnKey
+        } = this.summaryMethodColumn2SqlColumn(summaryMethod, summaryColumn);
+        summaries.push({
+          sqlSummaryMethodColumnKey,
+          summaryColumn,
+          summaryMethod
+        });
+        summaryColumnOptions.push(sqlSummaryMethodColumnName);
+      }
+      summary_columns_option.forEach(option => {
+        const {
+          key,
+          method
+        } = option;
+        const summaryColumn = (0, _dtableUtils.getTableColumnByKey)(table, key);
+        const summaryMethod = method;
+        if (summaryColumn && ((0, _dtableUtils.isNumericColumn)(summaryColumn) || (0, _dtableUtils.isDateColumn)(summaryColumn))) {
+          const {
+            name: sqlSummaryMethodColumnName,
+            key: sqlSummaryMethodColumnKey
+          } = this.summaryMethodColumn2SqlColumn(summaryMethod, summaryColumn);
+          summaries.push({
+            sqlSummaryMethodColumnKey,
+            summaryColumn,
+            summaryMethod
+          });
+          summaryColumnOptions.push(sqlSummaryMethodColumnName);
+        }
+      });
+      const statisticSummaryColumnsString = summaryColumnOptions.join(', ');
+      const sql = "SELECT ".concat(sqlGroupbyColumnName).concat(statisticSummaryColumnsString ? ', ' + statisticSummaryColumnsString : '', " FROM ").concat(tableName, " ").concat(condition, " GROUP BY ").concat(sqlGroupbyColumnName, " LIMIT 0, 5000");
+      return {
+        sql,
+        sqlGroupbyColumnKey,
+        summaries
+      };
+    }
+    const summaryMethod = summary_method;
+    const statisticNumericColumnKeys = [summary_column_key, ...(numeric_column_keys || [])];
+    const validStatisticNumericColumnKeys = [...new Set(statisticNumericColumnKeys)];
+    let sqlNumericColumns = [];
+    let summaries = [];
+    validStatisticNumericColumnKeys.map(key => (0, _dtableUtils.getTableColumnByKey)(table, key)).filter(column => column && ((0, _dtableUtils.isDateColumn)(column) || (0, _dtableUtils.isNumericColumn)(column))).forEach(column => {
+      const {
+        name: sqlNumericColumn,
+        key: sqlNumericColumnKey
+      } = this.summaryMethodColumn2SqlColumn(summaryMethod, column);
+      summaries.push({
+        sqlSummaryMethodColumnKey: sqlNumericColumnKey,
+        summaryColumn: column,
+        summaryMethod
+      });
+      sqlNumericColumns.push(sqlNumericColumn);
+    });
+    const statisticSummaryColumnsString = sqlNumericColumns.join(', ');
+    const sql = "SELECT ".concat(sqlGroupbyColumnName).concat(statisticSummaryColumnsString ? ', ' + statisticSummaryColumnsString : '', " FROM ").concat(tableName, " ").concat(condition, " GROUP BY ").concat(sqlGroupbyColumnName, " LIMIT 0, 5000");
+    return {
+      sql,
+      sqlGroupbyColumnKey,
+      summaries
+    };
+  }
+  twoDimensionStatisticTable2sql(chart, condition) {
+    const {
+      table_id,
+      groupby_column_key,
+      column_groupby_column_key,
+      summary_type,
+      summary_column_key,
+      groupby_date_granularity,
+      groupby_geolocation_granularity,
+      column_groupby_date_granularity,
+      column_groupby_geolocation_granularity,
+      summary_method,
+      column_groupby_multiple_numeric_column,
+      summary_columns_option
+    } = chart;
+    const table = this.getTableById(table_id);
+    let tableName = "`".concat(table.name, "`");
+    const columnGroupbyColumn = (0, _dtableUtils.getTableColumnByKey)(table, column_groupby_column_key);
+    if (!columnGroupbyColumn) return this.oneDimensionStatisticTable2sql(chart, table, tableName, condition);
+    const groupbyColumn = (0, _dtableUtils.getTableColumnByKey)(table, groupby_column_key);
+    if (!groupbyColumn) return '';
+    const {
+      name: sqlGroupbyColumnName,
+      key: sqlGroupbyColumnKey
+    } = this.column2SqlColumn(groupbyColumn, {
+      dateGranularity: groupby_date_granularity,
+      geolocationGranularity: groupby_geolocation_granularity
+    });
+    const {
+      name: sqlColumnGroupbyColumn,
+      key: sqlColumnGroupbyColumnKey
+    } = this.column2SqlColumn(columnGroupbyColumn, {
+      dateGranularity: column_groupby_date_granularity,
+      geolocationGranularity: column_groupby_geolocation_granularity
+    });
+    let sqlSummaryColumnName;
+    let sqlSummaryColumnKey;
+    if (summary_type === _constants.SUMMARY_TYPE.COUNT) {
+      const {
+        name,
+        key
+      } = this.summaryMethodColumn2SqlColumn('Count', groupbyColumn);
+      sqlSummaryColumnName = name;
+      sqlSummaryColumnKey = key;
+    } else {
+      const summaryMethod = summary_method;
+      const summaryColumn = (0, _dtableUtils.getTableColumnByKey)(table, summary_column_key) || {};
+      const {
+        name,
+        key
+      } = this.summaryMethodColumn2SqlColumn(summaryMethod, summaryColumn);
+      sqlSummaryColumnName = name;
+      sqlSummaryColumnKey = key;
+      if (column_groupby_multiple_numeric_column && column_groupby_column_key) {
+        const sqlSummaryMultipleNumericColumnName = Array.isArray(summary_columns_option) ? summary_columns_option.forEach(item => {
+          const summaryColumn = (0, _dtableUtils.getTableColumnByKey)(table, item.key) || {};
+          const {
+            name
+          } = this.summaryMethodColumn2SqlColumn(item.method, summaryColumn);
+          return name;
+        }) : [];
+        sqlSummaryColumnName = sqlSummaryMultipleNumericColumnName;
+      }
+      if (summary_columns_option) {
+        let summaryColumnOptions = [];
+        summary_columns_option.forEach(option => {
+          const {
+            key,
+            method
+          } = option;
+          const summaryColumn = (0, _dtableUtils.getTableColumnByKey)(table, key);
+          const summaryMethod = method;
+          if (summaryColumn && ((0, _dtableUtils.isNumericColumn)(summaryColumn) || (0, _dtableUtils.isDateColumn)(summaryColumn))) {
+            const {
+              name: sqlSummaryMethodColumnName
+            } = this.summaryMethodColumn2SqlColumn(summaryMethod, summaryColumn);
+            summaryColumnOptions.push(sqlSummaryMethodColumnName);
+          }
+        });
+        const statisticSummaryColumnsString = summaryColumnOptions.join(', ');
+        if (statisticSummaryColumnsString) {
+          if (sqlSummaryColumnName) {
+            sqlSummaryColumnName += ", ".concat(statisticSummaryColumnsString);
+          } else {
+            sqlSummaryColumnName = statisticSummaryColumnsString;
+          }
+        }
+      }
+    }
+    let sql;
+    if (sqlSummaryColumnName) {
+      sql = "SELECT ".concat(sqlGroupbyColumnName, ", ").concat(sqlColumnGroupbyColumn, ", ").concat(sqlSummaryColumnName, " FROM ").concat(tableName, " ").concat(condition, " GROUP BY ").concat(sqlGroupbyColumnName, ", ").concat(sqlColumnGroupbyColumn, " ORDER BY `").concat(groupbyColumn.name, "` LIMIT 0, 5000");
+    } else {
+      sql = "SELECT ".concat(sqlGroupbyColumnName, ", ").concat(sqlColumnGroupbyColumn, " FROM ").concat(tableName, " ").concat(condition, " GROUP BY ").concat(sqlGroupbyColumnName, ", ").concat(sqlColumnGroupbyColumn, " ORDER BY `").concat(groupbyColumn.name, "` LIMIT 0, 5000");
+    }
+    return {
+      sql,
+      sqlGroupbyColumnKey,
+      sqlColumnGroupbyColumnKey,
+      sqlSummaryColumnKey
+    };
+  }
+  oneDimensionTableSQLResult2JavaScript(chart, sqlRows, statisticSQLMap, columnMap) {
+    const {
+      groupbyColumn
+    } = columnMap;
+    const {
+      summary_type,
+      groupby_geolocation_granularity,
+      groupby_date_granularity,
+      groupby_include_empty_cells
+    } = chart;
+    let pivot_columns = [];
+    let pivot_rows = [];
+    const isCount = summary_type === _constants.SUMMARY_TYPE.COUNT;
+    if (isCount) {
+      const {
+        sqlGroupbyColumnKey,
+        sqlSummaryColumnKey
+      } = statisticSQLMap;
+      let allTotal = 0;
+      sqlRows.forEach(row => {
+        const originalLabel = this.getOriginalLabel(groupbyColumn, sqlGroupbyColumnKey, row, groupby_geolocation_granularity, groupby_date_granularity);
+        const name = this.getLabel(groupbyColumn, originalLabel);
+        const original_name = this.getOriginalName(groupbyColumn, originalLabel);
+        if (!groupby_include_empty_cells && !name) {
+          return;
+        }
+        const total = row[sqlSummaryColumnKey] || 0;
+        allTotal += total;
+        pivot_rows.push({
+          name,
+          original_name,
+          rows: [],
+          total: {
+            total
+          }
+        });
+      });
+      return {
+        pivot_columns,
+        pivot_rows,
+        pivot_columns_total: {
+          total: allTotal
+        }
+      };
+    }
+    const {
+      sqlGroupbyColumnKey,
+      summaries
+    } = statisticSQLMap;
+    let totalTemplate = {};
+    summaries.forEach(summary => {
+      const {
+        summaryColumn,
+        summaryMethod
+      } = summary;
+      const summaryColumnKey = summaryColumn.key;
+      totalTemplate[summaryColumnKey + summaryMethod] = this.initTotal(summaryMethod);
+      pivot_columns.push({
+        key: summaryColumnKey,
+        method: summaryMethod
+      });
+    });
+    let allTotal = {
+      ...totalTemplate
+    };
+    sqlRows.forEach(row => {
+      let rowTotal = {
+        ...totalTemplate
+      };
+      summaries.forEach(summary => {
+        const {
+          sqlSummaryMethodColumnKey,
+          summaryColumn,
+          summaryMethod
+        } = summary;
+        const summaryColumnKey = summaryColumn.key;
+        const totalKey = summaryColumnKey + summaryMethod;
+        const value = row[sqlSummaryMethodColumnKey] || this.initTotal(summaryMethod);
+        allTotal[totalKey] = this.getSummaryValue({
+          summaryColumn,
+          summaryMethod
+        }, allTotal[totalKey], value);
+        if (summaryColumn && (0, _dtableUtils.isDateColumn)(summaryColumn)) {
+          rowTotal[totalKey] = value;
+        } else if (summaryColumn && (0, _dtableUtils.isNumericColumn)(summaryColumn)) {
+          rowTotal[totalKey] = rowTotal[totalKey] + value;
+        }
+      });
+      const originalLabel = this.getOriginalLabel(groupbyColumn, sqlGroupbyColumnKey, row, groupby_geolocation_granularity, groupby_date_granularity);
+      const name = this.getLabel(groupbyColumn, originalLabel);
+      const original_name = this.getOriginalName(groupbyColumn, originalLabel);
+      pivot_rows.push({
+        name,
+        original_name,
+        rows: [row],
+        total: rowTotal
+      });
+    });
+    if (pivot_columns.length < 2) {
+      const pivot_column = pivot_columns[0];
+      const {
+        key,
+        method
+      } = pivot_column;
+      pivot_rows.forEach(row => {
+        row.total = {
+          ...row.total,
+          total: row.total[key + method]
+        };
+      });
+      allTotal = {
+        ...allTotal,
+        total: allTotal[key + method]
+      };
+    }
+    return {
+      pivot_columns,
+      pivot_rows,
+      pivot_columns_total: allTotal
+    };
+  }
+  twoDimensionTableSQLResult2JavaScript(chart, sqlRows, statisticSQLMap, columnMap) {
+    const {
+      groupbyColumn,
+      columnGroupbyColumn,
+      summaryColumn
+    } = columnMap || {};
+    const {
+      table_id,
+      groupby_include_empty_cells,
+      summary_method,
+      groupby_date_granularity,
+      groupby_geolocation_granularity,
+      column_groupby_geolocation_granularity,
+      column_groupby_date_granularity,
+      summary_columns_option
+    } = chart;
+    const {
+      sqlGroupbyColumnKey,
+      sqlColumnGroupbyColumnKey,
+      sqlSummaryColumnKey
+    } = statisticSQLMap;
+    if (!sqlColumnGroupbyColumnKey) return this.oneDimensionTableSQLResult2JavaScript(chart, sqlRows, statisticSQLMap, columnMap);
+    const summaryMethod = summary_method ? summary_method.toUpperCase() : '';
+    let pivot_columns = [];
+    let pivot_rows = [];
+    let pivot_columns_total = {};
+    const isRowGroupbyColumnDataAsAnArray = !!_constants.MULTIPLE_CELL_VALUE_COLUMN_TYPE_MAP[columnGroupbyColumn.type];
+    sqlRows.forEach(row => {
+      const groupbyColumnCellValue = row[sqlGroupbyColumnKey];
+      const groupbyColumnOriginalLabel = this.getOriginalLabel(groupbyColumn, sqlGroupbyColumnKey, row, groupby_geolocation_granularity, groupby_date_granularity);
+      const groupbyColumnCellValueKey = this.getLabel(groupbyColumn, groupbyColumnOriginalLabel);
+      const groupbyColumnOriginalCellValueKey = this.getOriginalName(groupbyColumn, groupbyColumnOriginalLabel);
+      const columnGroupbyColumnCellValue = row[sqlColumnGroupbyColumnKey];
+      const columnGroupbyColumnOriginalLabel = this.getOriginalLabel(columnGroupbyColumn, sqlColumnGroupbyColumnKey, row, column_groupby_geolocation_granularity, column_groupby_date_granularity);
+      const columnGroupbyColumnCellValueKey = this.getLabel(columnGroupbyColumn, columnGroupbyColumnOriginalLabel);
+      const columnGroupbyColumnOriginalCellValueKey = this.getOriginalName(columnGroupbyColumn, columnGroupbyColumnOriginalLabel);
+      const count = row[sqlSummaryColumnKey];
+      if (this.isValidCellValue(columnGroupbyColumnCellValue, groupby_include_empty_cells)) {
+        this.updateTwoDimensionColumns(pivot_columns, columnGroupbyColumnCellValueKey, columnGroupbyColumnOriginalCellValueKey, {
+          isIncludeEmpty: groupby_include_empty_cells,
+          isCellValueAsAnArray: isRowGroupbyColumnDataAsAnArray
+        });
+      }
+      if (this.isValidCellValue(groupbyColumnCellValue, groupby_include_empty_cells)) {
+        let pivotRowIndex = pivot_rows.findIndex(r => {
+          let resName = r.name;
+          return resName === null && groupbyColumnCellValueKey === null || resName === undefined && groupbyColumnCellValueKey === undefined || resName === 0 && groupbyColumnCellValueKey === 0 || resName === groupbyColumnCellValueKey;
+        });
+        this.updateTwoDimensionRows(pivot_rows, pivot_columns, pivotRowIndex, groupbyColumnCellValueKey, groupbyColumnOriginalCellValueKey, count, row, isRowGroupbyColumnDataAsAnArray, columnGroupbyColumnCellValueKey, {
+          summaryMethod,
+          summaryColumn
+        });
+      }
+    });
+    let pivot_table_total = this.getAndUpdateTwoDimensionTotal(pivot_columns_total, pivot_columns, pivot_rows, {
+      summaryMethod,
+      summaryColumn
+    });
+    const selectedTable = this.getTableById(table_id);
+    let pivot_summary_multiple_columns = [];
+    Array.isArray(summary_columns_option) && summary_columns_option.forEach(columnOption => {
+      const {
+        key,
+        method
+      } = columnOption;
+      const column = (0, _dtableUtils.getTableColumnByKey)(selectedTable, columnOption.key);
+      const {
+        name
+      } = this.summaryMethodColumn2SqlColumn(columnOption.method, column, true);
+      if (column && (0, _dtableUtils.isNumericColumn)(column)) {
+        pivot_summary_multiple_columns.push({
+          key,
+          method,
+          type: column.type,
+          column_name: column.name,
+          sqlKey: name
+        });
+      }
+    });
+    return {
+      pivot_columns,
+      pivot_rows,
+      pivot_columns_total,
+      pivot_table_total,
+      pivot_summary_multiple_columns,
+      isSqlQuery: true
+    };
+  }
+  column2SqlColumn(column) {
+    let {
+      dateGranularity,
+      geolocationGranularity
+    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const {
+      name,
+      type,
+      key
+    } = column;
+    const validColumnName = "`".concat(name, "`");
+    switch (type) {
+      case _dtableUtils.CellType.DATE:
+      case _dtableUtils.CellType.MTIME:
+      case _dtableUtils.CellType.CTIME:
+        {
+          const validDateGranularity = dateGranularity && dateGranularity.toUpperCase();
+          if (validDateGranularity === 'DAY') {
+            const sqlColumnName = "ISODATE(".concat(validColumnName, ")");
+            return {
+              name: sqlColumnName,
+              key: sqlColumnName
+            };
+          }
+          if (validDateGranularity === 'WEEK') {
+            const sqlColumnName = "ISODATE(STARTOFWEEK(".concat(validColumnName, ", monday\"))");
+            return {
+              name: sqlColumnName,
+              key: sqlColumnName
+            };
+          }
+          if (validDateGranularity === 'MONTH') {
+            const sqlColumnName = "ISOMONTH(".concat(validColumnName, ")");
+            return {
+              name: sqlColumnName,
+              key: sqlColumnName
+            };
+          }
+          if (validDateGranularity === 'QUARTER') {
+            const sqlColumnName = "CONCATENATE(year(".concat(validColumnName, "), \"-Q\", quarter(").concat(validColumnName, "))");
+            return {
+              name: sqlColumnName,
+              key: sqlColumnName
+            };
+          }
+          if (validDateGranularity === 'YEAR') {
+            const sqlColumnName = "YEAR(".concat(validColumnName, ")");
+            return {
+              name: sqlColumnName,
+              key: sqlColumnName
+            };
+          }
+          if (validDateGranularity === 'MAX' || validDateGranularity === 'MIN') {
+            const sqlColumnName = "".concat(validDateGranularity, "(").concat(validColumnName, ")");
+            return {
+              name: sqlColumnName,
+              key: sqlColumnName
+            };
+          }
+          const sqlColumnName = "ISOMONTH(".concat(validColumnName, ")");
+          return {
+            name: sqlColumnName,
+            key: sqlColumnName
+          };
+        }
+      case _dtableUtils.CellType.GEOLOCATION:
+        {
+          let sqlColumnName;
+          if (geolocationGranularity === 'province') {
+            sqlColumnName = "PROVINCE(".concat(validColumnName, ")");
+          }
+          if (geolocationGranularity === 'city') {
+            sqlColumnName = "CITY(".concat(validColumnName, ")");
+          }
+          if (geolocationGranularity === 'district') {
+            sqlColumnName = "DISTRICT(".concat(validColumnName, ")");
+          }
+          return {
+            name: sqlColumnName,
+            key: sqlColumnName
+          };
+        }
+      default:
+        {
+          return {
+            name: validColumnName,
+            key
+          };
+        }
+    }
+  }
+  summaryMethodColumn2SqlColumn(summaryMethod, column, useSingleQuote) {
+    const columnName = column.name;
+    const isUseSingleQuote = useSingleQuote ? false : true;
+    return {
+      name: (0, _commonUtils.getSummaryColumnMethod)(_constants.DTABLE_DB_SUMMARY_METHOD[summaryMethod], columnName, isUseSingleQuote),
+      key: (0, _commonUtils.getSummaryColumnMethod)(_constants.DTABLE_DB_SUMMARY_METHOD[summaryMethod], columnName)
+    };
+  }
+  getOriginalLabel(groupColumn, groupName, statRow, groupby_date_granularity, groupby_geolocation_granularity) {
+    const isTimeColumn = _constants.TIME_COLUMN_LIST.includes(groupColumn.type);
+    if (isTimeColumn || groupColumn.type === _dtableUtils.CellType.GEOLOCATION) {
+      return statRow[groupName];
+    }
+    const currentGroupLabel = statRow[groupColumn.key];
+    return _statUtils.default.getGroupLabel(currentGroupLabel, statRow, groupColumn, groupby_date_granularity, groupby_geolocation_granularity, this.value);
+  }
+  getOriginalName(groupColumn, originalLabel) {
+    const isTimeColumn = _constants.TIME_COLUMN_LIST.includes(groupColumn.type);
+    if (isTimeColumn || groupColumn.type === _dtableUtils.CellType.GEOLOCATION) {
+      return originalLabel;
+    }
+    let {
+      type: columnType
+    } = groupColumn;
+    if (columnType === _dtableUtils.CellType.MULTIPLE_SELECT || columnType === _dtableUtils.CellType.COLLABORATOR) {
+      return Array.isArray(originalLabel) ? originalLabel[0] : null;
+    }
+    return originalLabel;
+  }
+  getLabel(groupColumn, originalLabel) {
+    const isTimeColumn = _constants.TIME_COLUMN_LIST.includes(groupColumn.type);
+    if (isTimeColumn || groupColumn.type === _dtableUtils.CellType.GEOLOCATION) {
+      return originalLabel;
+    }
+    return (0, _rowUtils.getFormattedLabel)(groupColumn, originalLabel, this.value.collaborators);
+  }
+  initTotal(summaryMethod) {
+    if (summaryMethod === 'SUM' || summaryMethod === 'DISTINCT_VALUES') return 0;
+    return null;
+  }
+  getSummaryValue(_ref, currentValue, nextValue) {
+    let {
+      summaryMethod,
+      summaryColumn
+    } = _ref;
+    if (summaryColumn && (0, _dtableUtils.isDateColumn)(summaryColumn)) {
+      if (summaryMethod === _constants.SUMMARY_METHOD_MAP.Max) {
+        if (currentValue && nextValue) {
+          return (0, _dayjs.default)(currentValue).isBefore(nextValue) ? nextValue : currentValue;
+        }
+        if (!currentValue && nextValue) {
+          return nextValue;
+        }
+        return currentValue;
+      }
+      if (summaryMethod === _constants.SUMMARY_METHOD_MAP.Min) {
+        if (currentValue && nextValue) {
+          return (0, _dayjs.default)(currentValue).isBefore(nextValue) ? currentValue : nextValue;
+        }
+        if (!currentValue && nextValue) {
+          return nextValue;
+        }
+        return currentValue;
+      }
+      if (summaryMethod === _constants.SUMMARY_METHOD_MAP.Distinct_values) {
+        return (currentValue - 0 || 0) + (nextValue - 0 || 0);
+      }
+      return currentValue;
+    }
+    if (summaryMethod === _constants.SUMMARY_METHOD_MAP.Max || _constants.SUMMARY_METHOD_MAP.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);
+  }
+  isValidCellValue(cellValue, includeEmpty) {
+    if (includeEmpty) return true;
+    return cellValue || cellValue === 0;
+  }
+  updateTwoDimensionColumns(pivot_columns, key, original_key, _ref2) {
+    let {
+      isIncludeEmpty,
+      isCellValueAsAnArray
+    } = _ref2;
+    if (isCellValueAsAnArray && Array.isArray(key)) {
+      if (key.length === 0 && isIncludeEmpty) {
+        const pivotColumnIndex = pivot_columns.findIndex(r => !r.key);
+        if (pivotColumnIndex < 0) {
+          pivot_columns.unshift({
+            key: null,
+            original_key: null
+          });
+        }
+        return;
+      }
+      key.forEach(k => {
+        const pivotColumnIndex = pivot_columns.findIndex(r => r.key === k);
+        if (pivotColumnIndex < 0) {
+          pivot_columns.push({
+            key: k,
+            original_key: k
+          });
+        }
+      });
+      return;
+    }
+    const pivotColumnIndex = pivot_columns.findIndex(r => {
+      let 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,
+        original_key
+      });
+    }
+  }
+  updateTwoDimensionRows(pivot_rows, pivot_columns, index, name, original_name, count, row, isColumnDataAsAnArray, cellValue, _ref3) {
+    let {
+      summaryMethod,
+      summaryColumn
+    } = _ref3;
+    if (index > -1) {
+      let updatedPivotRow = pivot_rows[index];
+      let {
+        cells,
+        total
+      } = updatedPivotRow;
+      pivot_columns.forEach(c => {
+        let {
+          key
+        } = c;
+        if (this.isSameGroup(isColumnDataAsAnArray, cellValue, key)) {
+          if (cells[key]) {
+            cells[key].rows.push(row);
+            cells[key].total = this.getSummaryValue({
+              summaryMethod,
+              summaryColumn
+            }, cells[key].total, count);
+          } else {
+            cells[key] = {
+              rows: [row],
+              total: count
+            };
+          }
+        }
+      });
+      updatedPivotRow.cells = cells;
+      updatedPivotRow.total = this.getSummaryValue({
+        summaryMethod,
+        summaryColumn
+      }, total, count);
+      pivot_rows[index] = updatedPivotRow;
+    } else {
+      let cells = {};
+      let total = 0;
+      pivot_columns.forEach(c => {
+        let {
+          key
+        } = c;
+        if (this.isSameGroup(isColumnDataAsAnArray, cellValue, key)) {
+          cells[key] = {
+            rows: [row],
+            total: count
+          };
+          total = this.getSummaryValue({
+            summaryMethod,
+            summaryColumn
+          }, total, count);
+        }
+      });
+      pivot_rows.push({
+        name,
+        cells,
+        total,
+        original_name
+      });
+    }
+  }
+  isSameGroup(isColumnDataAsAnArray, source, target) {
+    if (isColumnDataAsAnArray) {
+      return source.length === 0 && !target || source.includes(target);
+    }
+    return source === null && target === null || source === undefined && target === undefined || source === target;
+  }
+  getAndUpdateTwoDimensionTotal(pivot_columns_total, pivot_columns, pivot_rows, _ref4) {
+    let {
+      summaryMethod,
+      summaryColumn
+    } = _ref4;
+    let pivot_table_total = this.initTotal(summaryMethod);
+    pivot_rows.forEach(row => {
+      const {
+        cells,
+        total
+      } = row;
+      pivot_table_total = this.getSummaryValue({
+        summaryMethod,
+        summaryColumn
+      }, pivot_table_total, total);
+      pivot_columns.forEach(column => {
+        const {
+          key
+        } = column;
+        const cell = cells[key];
+        if (cell) {
+          let pivot_column_total = pivot_columns_total && pivot_columns_total[key] ? pivot_columns_total[key] : 0;
+          pivot_columns_total[key] = this.getSummaryValue({
+            summaryMethod,
+            summaryColumn
+          }, pivot_column_total, cell.total);
+        }
+      });
+    });
+    return pivot_table_total;
+  }
+}
+var _default = exports.default = PivotTableCalculator;