@gingkoo/pandora-metabase 1.0.125 → 1.0.127

package/lib/es/utils.js

@@ -5,7 +5,7 @@ import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 var _excluded = ["list"];
-import { __ } from './locale';
+import { __, isEn } from './locale';
 import { TypeEnum, SQL_COLUMN_TYPE } from './store/enum';
 import { AtomsTypeEnum } from './store/types';
 import { summarizeByToSql, summarizeToSql } from './store/helper';
@@ -240,44 +240,348 @@ var AliasType;
   AliasType["table"] = "table";
   AliasType["field"] = "field";
 })(AliasType || (AliasType = {}));
+var normalizeAtomQuotes = function normalizeAtomQuotes(quotes) {
+  return quotes.replace(/\s+/g, ' ').trim();
+};
+var getExpressionConditionText = function getExpressionConditionText(condition) {
+  var localeKey = {
+    等于: 'filter.equal',
+    不等于: 'filter.notEqual',
+    大于: 'filter.greaterThan',
+    小于: 'filter.lessThan',
+    介于之间: 'filter.inBetween',
+    大于或等于: 'filter.greaterThanOrEqualTo',
+    小于或等于: 'filter.lessThanOrEqualTo',
+    为空: 'filter.empty',
+    不为空: 'filter.notEmpty',
+    包含: 'filter.contain',
+    不包含: 'filter.notInclude',
+    '以...开始': 'filter.startWith',
+    '以...结束': 'filter.endWith',
+    '不以...开始': 'filter.notStartWith',
+    '不以...结束': 'filter.notEndWith',
+    早于: 'filter.earlierThan',
+    晚于: 'filter.laterThan',
+    是空的: 'filter.isEmpty',
+    In: 'filter.within',
+    'Not In': 'filter.withnotin',
+    无需结果: 'filter.notresults',
+    正则匹配: 'filter.regularMatch'
+  }[condition];
+  return localeKey ? __(localeKey) : condition;
+};
+var getSelectAtomText = function getSelectAtomText(item) {
+  var displayField = item.displayField || 'value';
+  var getOptionText = function getOptionText(value) {
+    var _ref, _option$displayField;
+    var option = (item.options || []).find(function (currentOption) {
+      return currentOption.value === value;
+    });
+    if (!option) return value || '';
+    return String((_ref = (_option$displayField = option[displayField]) !== null && _option$displayField !== void 0 ? _option$displayField : option.value) !== null && _ref !== void 0 ? _ref : '');
+  };
+  if (Array.isArray(item.val)) {
+    return item.val.map(function (currentValue) {
+      return getOptionText(String(currentValue));
+    }).join(', ');
+  }
+  return getOptionText(String(item.val || ''));
+};
+var _getAtomDisplayText = function getAtomDisplayText(item) {
+  if (!item) return '';
+  if (item.type === AtomsTypeEnum.FIELD) {
+    return item.fieldAlias || item.fieldName || '';
+  }
+  if (item.type === AtomsTypeEnum.CASE_WHEN) {
+    return buildCaseWhenQuotes(item);
+  }
+  if (item.type === AtomsTypeEnum.AND_OR) {
+    return buildAndOrQuotes(item);
+  }
+  if (item.type === AtomsTypeEnum.EXPRESSION) {
+    return buildExpressionQuotes(item);
+  }
+  if (item.type === AtomsTypeEnum.FORMULA) {
+    return buildFormulaQuotes(item);
+  }
+  if (item.type === AtomsTypeEnum.COLLECTION) {
+    return (item.list || []).map(_getAtomDisplayText).join(' ');
+  }
+  if (item.type === AtomsTypeEnum.SELECT) {
+    return getSelectAtomText(item);
+  }
+  if (item.type === AtomsTypeEnum.EXISTS || item.type === AtomsTypeEnum.NOT_EXISTS || item.type === AtomsTypeEnum.SUB_QUERY) {
+    return item.quotes || '';
+  }
+  var val = item.val;
+  if (Array.isArray(val)) return val.join(', ');
+  return val || val === 0 ? String(val) : '';
+};
+var buildFormulaQuotes = function buildFormulaQuotes(item) {
+  var argsText = (item.args || []).map(_getAtomDisplayText).join(' , ');
+  return normalizeAtomQuotes("".concat(item.name || '', " ( ").concat(argsText, " )"));
+};
+var buildAndOrQuotes = function buildAndOrQuotes(item) {
+  var hasBinarySides = Array.isArray(item.leftAtoms) || Array.isArray(item.rightAtoms);
+  if (hasBinarySides) {
+    var leftText = (item.leftAtoms || []).map(_getAtomDisplayText).join(' ');
+    var rightText = (item.rightAtoms || []).map(_getAtomDisplayText).join(' ');
+    return normalizeAtomQuotes("( ".concat(leftText, " ").concat(item.operator || 'and', " ").concat(rightText, " )"));
+  }
+  var atomsText = (item.atoms || []).map(_getAtomDisplayText).join(' ');
+  return normalizeAtomQuotes("".concat(item.operator || 'and', " ( ").concat(atomsText, " )"));
+};
+var buildCaseWhenQuotes = function buildCaseWhenQuotes(item) {
+  var caseAtomsText = (item.caseAtoms || []).map(_getAtomDisplayText).join(' ');
+  var whenClausesText = (item.whenClauses || []).map(function (clause) {
+    var whenText = (clause.whenAtoms || []).map(_getAtomDisplayText).join(' ');
+    var thenText = (clause.thenAtoms || []).map(_getAtomDisplayText).join(' ');
+    return "when ".concat(whenText, " then ").concat(thenText).trim();
+  }).join(' ');
+  var elseAtomsText = (item.elseAtoms || []).length ? " else ".concat((item.elseAtoms || []).map(_getAtomDisplayText).join(' ')) : '';
+  return normalizeAtomQuotes("case ".concat(caseAtomsText, " ").concat(whenClausesText).concat(elseAtomsText, " end"));
+};
+var getExpressionAtomsText = function getExpressionAtomsText() {
+  var items = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var formula = arguments.length > 1 ? arguments[1] : undefined;
+  var names = items.map(_getAtomDisplayText).join(' || ');
+  if ((formula === null || formula === void 0 ? void 0 : formula.type) === 'SUBSTR') {
+    var _formula$params, _formula$params2;
+    return "SUBSTR(".concat(names, ",").concat(formula === null || formula === void 0 || (_formula$params = formula.params) === null || _formula$params === void 0 ? void 0 : _formula$params[1], ",").concat(formula === null || formula === void 0 || (_formula$params2 = formula.params) === null || _formula$params2 === void 0 ? void 0 : _formula$params2[2], ")");
+  }
+  return names;
+};
+var getExpressionFirstValue = function getExpressionFirstValue() {
+  var items = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var firstItem = items[0];
+  if (!firstItem) {
+    return {
+      firstVal: '',
+      secondVal: ''
+    };
+  }
+  if (Array.isArray(firstItem.val)) {
+    return {
+      firstVal: firstItem.val[0] || '',
+      secondVal: firstItem.val[1] || ''
+    };
+  }
+  return {
+    firstVal: firstItem.val || firstItem.val === 0 ? String(firstItem.val) : _getAtomDisplayText(firstItem),
+    secondVal: ''
+  };
+};
+var buildExpressionQuotes = function buildExpressionQuotes(item) {
+  var condition = item.condition || '';
+  var lhsText = getExpressionAtomsText(item.lhs || [], item.formula);
+  var rhsText = getExpressionAtomsText(item.rhs || [], item.formula);
+  var _getExpressionFirstVa = getExpressionFirstValue(item.rhs || []),
+    firstVal = _getExpressionFirstVa.firstVal,
+    secondVal = _getExpressionFirstVa.secondVal;
+  if (condition === '以...开始') {
+    return normalizeAtomQuotes("".concat(lhsText, " ").concat(isEn ? "startWith ".concat(firstVal) : "\u4EE5 ".concat(firstVal, " \u5F00\u59CB")));
+  }
+  if (condition === '不以...开始') {
+    return normalizeAtomQuotes("".concat(lhsText, " ").concat(isEn ? "not startWith ".concat(firstVal) : "\u4E0D\u4EE5 ".concat(firstVal, " \u5F00\u59CB")));
+  }
+  if (condition === '以...结束') {
+    return normalizeAtomQuotes("".concat(lhsText, " ").concat(isEn ? "endWith ".concat(firstVal) : "\u4EE5 ".concat(firstVal, " \u7ED3\u675F")));
+  }
+  if (condition === '不以...结束') {
+    return normalizeAtomQuotes("".concat(lhsText, " ").concat(isEn ? "not endWith ".concat(firstVal) : "\u4E0D\u4EE5 ".concat(firstVal, " \u7ED3\u675F")));
+  }
+  if (condition === '介于之间') {
+    return normalizeAtomQuotes("".concat(lhsText, " ").concat(isEn ? "Between ".concat(firstVal, " and ").concat(secondVal) : "\u4ECB\u4E8E".concat(firstVal, "\u548C").concat(secondVal, "\u4E4B\u95F4")));
+  }
+  if (condition === '前') {
+    return normalizeAtomQuotes("".concat(lhsText, " ").concat(isEn ? "previous ".concat(firstVal).concat(secondVal) : "\u4E0A\u4E00\u4E2A".concat(firstVal).concat(secondVal)));
+  }
+  if (condition === '下一个') {
+    return normalizeAtomQuotes("".concat(lhsText, " ").concat(isEn ? "next ".concat(firstVal).concat(secondVal) : "\u4E0B\u4E00\u4E2A".concat(firstVal).concat(secondVal)));
+  }
+  if (condition === '在') {
+    return normalizeAtomQuotes("".concat(lhsText, " ").concat(isEn ? 'is' : '是', " ").concat(firstVal));
+  }
+  if (condition === '是空的') {
+    return normalizeAtomQuotes("".concat(lhsText, " ").concat(isEn ? 'is empty' : '为空'));
+  }
+  if (condition === '不是空的') {
+    return normalizeAtomQuotes("".concat(lhsText, " ").concat(isEn ? 'not empty' : '不为空'));
+  }
+  if (condition === '当前') {
+    if (firstVal === '天') {
+      return normalizeAtomQuotes("".concat(lhsText, " ").concat(isEn ? 'today' : '今天'));
+    }
+    return normalizeAtomQuotes("".concat(lhsText, " ").concat(isEn ? "this is ".concat(firstVal) : "\u8FD9\u4E2A".concat(firstVal)));
+  }
+  if (condition === 'In' || condition === 'Not In') {
+    return normalizeAtomQuotes("".concat(lhsText, " ").concat(getExpressionConditionText(condition), " (").concat(firstVal, ")"));
+  }
+  return normalizeAtomQuotes("".concat(lhsText, " ").concat(getExpressionConditionText(condition), " ").concat(rhsText || firstVal));
+};
+var syncAtomQuotes = function syncAtomQuotes(item) {
+  if (item.type === AtomsTypeEnum.JOIN_DEFAULT) {
+    return _objectSpread(_objectSpread({}, item), {}, {
+      lhs: syncAtomQuotesList(item.lhs || []),
+      rhs: syncAtomQuotesList(item.rhs || [])
+    });
+  }
+  if (item.type === AtomsTypeEnum.EXPRESSION) {
+    var nextItem = _objectSpread(_objectSpread({}, item), {}, {
+      lhs: syncAtomQuotesList(item.lhs || []),
+      rhs: syncAtomQuotesList(item.rhs || [])
+    });
+    return _objectSpread(_objectSpread({}, nextItem), {}, {
+      quotes: buildExpressionQuotes(nextItem)
+    });
+  }
+  if (item.type === AtomsTypeEnum.FORMULA) {
+    var _nextItem = _objectSpread(_objectSpread({}, item), {}, {
+      args: syncAtomQuotesList(item.args || [])
+    });
+    return _objectSpread(_objectSpread({}, _nextItem), {}, {
+      quotes: buildFormulaQuotes(_nextItem)
+    });
+  }
+  if (item.type === AtomsTypeEnum.COLLECTION) {
+    var _nextItem2 = _objectSpread(_objectSpread({}, item), {}, {
+      list: syncAtomQuotesList(item.list || [])
+    });
+    return _objectSpread(_objectSpread({}, _nextItem2), {}, {
+      quotes: (_nextItem2.list || []).map(_getAtomDisplayText).join(' ')
+    });
+  }
+  if (item.type === AtomsTypeEnum.CASE_WHEN) {
+    var _nextItem3 = _objectSpread(_objectSpread({}, item), {}, {
+      caseAtoms: syncAtomQuotesList(item.caseAtoms || []),
+      whenClauses: (item.whenClauses || []).map(function (clause) {
+        return _objectSpread(_objectSpread({}, clause), {}, {
+          whenAtoms: syncAtomQuotesList(clause.whenAtoms || []),
+          thenAtoms: syncAtomQuotesList(clause.thenAtoms || [])
+        });
+      }),
+      elseAtoms: syncAtomQuotesList(item.elseAtoms || [])
+    });
+    return _objectSpread(_objectSpread({}, _nextItem3), {}, {
+      quotes: buildCaseWhenQuotes(_nextItem3)
+    });
+  }
+  if (item.type === AtomsTypeEnum.AND_OR) {
+    var hasBinarySides = Array.isArray(item.leftAtoms) || Array.isArray(item.rightAtoms);
+    var _nextItem4 = _objectSpread(_objectSpread({}, item), hasBinarySides ? {
+      atoms: undefined,
+      leftAtoms: syncAtomQuotesList(item.leftAtoms || []),
+      rightAtoms: syncAtomQuotesList(item.rightAtoms || [])
+    } : {
+      atoms: syncAtomQuotesList(item.atoms || [])
+    });
+    return _objectSpread(_objectSpread({}, _nextItem4), {}, {
+      quotes: buildAndOrQuotes(_nextItem4)
+    });
+  }
+  return item;
+};
+var syncAtomQuotesList = function syncAtomQuotesList(items) {
+  return items.map(syncAtomQuotes);
+};
+var isSameAliasTargetTable = function isSameAliasTargetTable(item, target) {
+  if (target.tableUuid && item.tableUuid && item.tableUuid === target.tableUuid) {
+    return true;
+  }
+  if (target.datasourceId && item.datasourceId && item.datasourceId !== target.datasourceId) {
+    return false;
+  }
+  if (target.tableId && item.tableId && item.tableId === target.tableId) {
+    return true;
+  }
+  return Boolean(target.tableName && item.tableName && item.tableName === target.tableName);
+};
+var isAliasTargetField = function isAliasTargetField(item, target) {
+  if (target.uuid && item.fieldUuid && item.fieldUuid === target.uuid) {
+    return true;
+  }
+  var sameTable = isSameAliasTargetTable(item, target);
+  if (target.fieldId && item.fieldId && item.fieldId === target.fieldId) {
+    return sameTable || !target.tableId;
+  }
+  return Boolean(target.fieldName && item.fieldName && item.fieldName === target.fieldName && sameTable);
+};
 var _changeAlias = function changeAlias(items, val, type) {
   return items.map(function (v) {
+    var nextItem;
     if (v.type === AtomsTypeEnum.JOIN_DEFAULT || v.type === AtomsTypeEnum.EXPRESSION) {
-      return _objectSpread(_objectSpread({}, v), {}, {
+      nextItem = _objectSpread(_objectSpread({}, v), {}, {
         lhs: _changeAlias(v.lhs, val, type),
         rhs: _changeAlias(v.rhs, val, type)
       });
     } else if (v.type === AtomsTypeEnum.FIELD) {
+      nextItem = _objectSpread({}, v);
       if (type === AliasType.table && v.tableUuid === val.uuid) {
-        v.tableAlias = val.alias;
+        nextItem.tableAlias = val.alias;
       }
-      if (type === AliasType.field && v.fieldUuid === val.uuid) {
-        v.fieldAlias = val.alias;
+      if (type === AliasType.field && isAliasTargetField(v, val)) {
+        nextItem.fieldAlias = val.alias;
       }
-      return v;
     } else if (v.type === AtomsTypeEnum.EXISTS || v.type === AtomsTypeEnum.NOT_EXISTS) {
+      nextItem = _objectSpread({}, v);
       if (type === AliasType.table) {
-        v.notExists = changeTableAlias(v.notExists || [], {
-          tableUuid: val.uuid,
+        nextItem.notExists = changeTableAlias(v.notExists || [], {
+          tableUuid: val.uuid || '',
           alias: val.alias
         });
       }
       if (type === AliasType.field) {
-        v.notExists = changeFieldAlias(v.notExists || [], {
-          fieldUuid: val.uuid,
+        nextItem.notExists = changeFieldAlias(v.notExists || [], {
+          fieldUuid: val.uuid || '',
+          fieldAlias: val.alias
+        });
+      }
+    } else if (v.type === AtomsTypeEnum.SUB_QUERY) {
+      nextItem = _objectSpread({}, v);
+      if (type === AliasType.table) {
+        nextItem.subQuery = changeTableAlias(v.subQuery || [], {
+          tableUuid: val.uuid || '',
+          alias: val.alias
+        });
+      }
+      if (type === AliasType.field) {
+        nextItem.subQuery = changeFieldAlias(v.subQuery || [], {
+          fieldUuid: val.uuid || '',
           fieldAlias: val.alias
         });
       }
-      return v;
     } else if (v.type === AtomsTypeEnum.FORMULA) {
-      v.args = _changeAlias(v.args, val, type);
-      return v;
+      nextItem = _objectSpread(_objectSpread({}, v), {}, {
+        args: _changeAlias(v.args || [], val, type)
+      });
     } else if (v.type === AtomsTypeEnum.COLLECTION) {
-      v.list = _changeAlias(v.list, val, type);
-      return v;
+      nextItem = _objectSpread(_objectSpread({}, v), {}, {
+        list: _changeAlias(v.list || [], val, type)
+      });
+    } else if (v.type === AtomsTypeEnum.CASE_WHEN) {
+      nextItem = _objectSpread(_objectSpread({}, v), {}, {
+        caseAtoms: _changeAlias(v.caseAtoms || [], val, type),
+        whenClauses: (v.whenClauses || []).map(function (clause) {
+          return _objectSpread(_objectSpread({}, clause), {}, {
+            whenAtoms: _changeAlias(clause.whenAtoms || [], val, type),
+            thenAtoms: _changeAlias(clause.thenAtoms || [], val, type)
+          });
+        }),
+        elseAtoms: _changeAlias(v.elseAtoms || [], val, type)
+      });
+    } else if (v.type === AtomsTypeEnum.AND_OR) {
+      var hasBinarySides = Array.isArray(v.leftAtoms) || Array.isArray(v.rightAtoms);
+      nextItem = _objectSpread(_objectSpread({}, v), hasBinarySides ? {
+        atoms: undefined,
+        leftAtoms: _changeAlias(v.leftAtoms || [], val, type),
+        rightAtoms: _changeAlias(v.rightAtoms || [], val, type)
+      } : {
+        atoms: _changeAlias(v.atoms || [], val, type)
+      });
     } else {
-      return v;
+      nextItem = v;
     }
+    return syncAtomQuotes(nextItem);
   });
 };
 export function isValidSQLAlias(str) {
@@ -340,27 +644,27 @@ export var changeTableAlias = function changeTableAlias(list, curObj) {
     }
     if (v.type === TypeEnum.summarize) {
       v.group.map(function (group) {
-        if (group.tableUuid === tableUuid) {
+        var groupAtoms = group.atoms;
+        if (groupAtoms && groupAtoms.length > 0) {
+          group.atoms = _changeAlias(groupAtoms, {
+            uuid: tableUuid,
+            alias: alias
+          }, AliasType.table);
+          group.sql = summarizeToSql(v.group, group).sql;
+        } else if (group.tableUuid === tableUuid) {
           group.alias = alias;
-          var groupAtoms = group.atoms;
-          if (groupAtoms && groupAtoms.length > 0) {
-            group.atoms = _changeAlias(groupAtoms, {
-              uuid: tableUuid,
-              alias: alias
-            }, AliasType.table);
-          }
           group.sql = summarizeToSql(v.group, group).sql;
         }
       });
       v.by.map(function (by) {
-        if (by.tableUuid === tableUuid) {
+        if (by.atoms && by.atoms.length > 0) {
+          by.atoms = _changeAlias(by.atoms, {
+            uuid: tableUuid,
+            alias: alias
+          }, AliasType.table);
+          by.sql = summarizeByToSql(by);
+        } else if (by.tableUuid === tableUuid) {
           by.alias = alias;
-          if (by.atoms && by.atoms.length > 0) {
-            by.atoms = _changeAlias(by.atoms, {
-              uuid: tableUuid,
-              alias: alias
-            }, AliasType.table);
-          }
           by.sql = summarizeByToSql(by);
         }
       });
@@ -377,74 +681,76 @@ export var changeTableAlias = function changeTableAlias(list, curObj) {
   })) || [];
 };
 export var changeFieldAlias = function changeFieldAlias(list, curObj) {
+  var _firstData$table, _firstData$table2, _firstData$table3, _firstData$table4;
   var _cloneDeep2 = cloneDeep(curObj),
     uuid = _cloneDeep2.fieldUuid,
-    alias = _cloneDeep2.fieldAlias;
+    alias = _cloneDeep2.fieldAlias,
+    fieldId = _cloneDeep2.id,
+    fieldName = _cloneDeep2.name,
+    datasourceId = _cloneDeep2.datasourceId,
+    table = _cloneDeep2.table,
+    tableId = _cloneDeep2.tableId,
+    tableUuid = _cloneDeep2.tableUuid;
+  var firstData = list.find(function (item) {
+    return item.type === TypeEnum.data;
+  });
+  var aliasTarget = {
+    uuid: uuid,
+    alias: alias,
+    fieldId: curObj.fieldId || fieldId,
+    fieldName: fieldName,
+    tableId: tableId || (firstData === null || firstData === void 0 || (_firstData$table = firstData.table) === null || _firstData$table === void 0 ? void 0 : _firstData$table.id),
+    tableName: table || (firstData === null || firstData === void 0 || (_firstData$table2 = firstData.table) === null || _firstData$table2 === void 0 ? void 0 : _firstData$table2.name),
+    tableUuid: tableUuid || (firstData === null || firstData === void 0 || (_firstData$table3 = firstData.table) === null || _firstData$table3 === void 0 ? void 0 : _firstData$table3.tableUuid),
+    datasourceId: datasourceId || (firstData === null || firstData === void 0 || (_firstData$table4 = firstData.table) === null || _firstData$table4 === void 0 ? void 0 : _firstData$table4.datasourceId)
+  };
   var newList = cloneDeep(list);
   return (newList === null || newList === void 0 ? void 0 : newList.map(function (v) {
     if (v.type === TypeEnum.data) {}
     if (v.type === TypeEnum.joinData) {
       if (v.expressions && v.expressions.length > 0) {
-        v.expressions = _changeAlias(v.expressions, {
-          uuid: uuid,
-          alias: alias
-        }, AliasType.field);
+        v.expressions = _changeAlias(v.expressions, aliasTarget, AliasType.field);
       }
     }
     if (v.type === TypeEnum.customColumn) {
       v.customColumn.map(function (item) {
         if (item.formulaList && item.formulaList.length > 0) {
-          item.formulaList = _changeAlias(item.formulaList, {
-            uuid: uuid,
-            alias: alias
-          }, AliasType.field);
+          item.formulaList = _changeAlias(item.formulaList, aliasTarget, AliasType.field);
         }
       });
     }
     if (v.type === TypeEnum.rowLimit) {}
     if (v.type === TypeEnum.summarize) {
       v.group.map(function (group) {
-        if (group.fieldUuid === uuid) {
+        var groupAtoms = group.atoms;
+        if (groupAtoms && groupAtoms.length > 0) {
+          group.atoms = _changeAlias(groupAtoms, aliasTarget, AliasType.field);
+          group.sql = summarizeToSql(v.group, group).sql;
+        } else if (group.fieldUuid === uuid) {
           group.fieldAlias = alias;
-          var groupAtoms = group.atoms;
-          if (groupAtoms && groupAtoms.length > 0) {
-            group.atoms = _changeAlias(groupAtoms, {
-              uuid: uuid,
-              alias: alias
-            }, AliasType.field);
-          }
           group.sql = summarizeToSql(v.group, group).sql;
         }
       });
       v.by.map(function (by) {
-        if (by.fieldUuid === uuid) {
+        if (by.atoms && by.atoms.length > 0) {
+          by.atoms = _changeAlias(by.atoms, aliasTarget, AliasType.field);
+          by.sql = summarizeByToSql(by);
+        } else if (by.fieldUuid === uuid) {
           by.fieldAlias = alias;
-          if (by.atoms && by.atoms.length > 0) {
-            by.atoms = _changeAlias(by.atoms, {
-              uuid: uuid,
-              alias: alias
-            }, AliasType.field);
-          }
           by.sql = summarizeByToSql(by);
         }
       });
     }
     if (v.type === TypeEnum.filter) {
       if (v.filter && v.filter.length > 0) {
-        v.filter = _changeAlias(v.filter, {
-          uuid: uuid,
-          alias: alias
-        }, AliasType.field);
+        v.filter = _changeAlias(v.filter, aliasTarget, AliasType.field);
       }
     }
     if (v.type === TypeEnum.sort) {
       if (v.sort && v.sort.length > 0) {
         v.sort = v.sort.map(function (sort) {
           return _objectSpread(_objectSpread({}, sort), {}, {
-            expression: _changeAlias(sort.expression, {
-              uuid: uuid,
-              alias: alias
-            }, AliasType.field)
+            expression: _changeAlias(sort.expression, aliasTarget, AliasType.field)
           });
         });
       }
@@ -502,7 +808,8 @@ var stripSummarizeTableFields = function stripSummarizeTableFields(record) {
     tableUuid: '',
     alias: '',
     datasourceId: '',
-    datasourceName: ''
+    datasourceName: '',
+    datasourceType: ''
   });
 };
 var createSummarizeFieldAtom = function createSummarizeFieldAtom(record) {
@@ -520,6 +827,7 @@ var createSummarizeFieldAtom = function createSummarizeFieldAtom(record) {
     tableUuid: record.tableUuid || '',
     datasourceName: record.datasourceName || '',
     datasourceId: record.datasourceId || '',
+    datasourceType: record.datasourceType || '',
     type: AtomsTypeEnum.FIELD
   };
 };
@@ -782,6 +1090,7 @@ function setNewField(field, data) {
       }
       field.datasourceId = table.datasourceId || '';
       field.datasourceName = table.datasourceName || '';
+      field.datasourceType = table.datasourceType || '';
       field.tableId = table.id || '';
       field.tableName = table.name || '';
       field.tableAlias = table.alias || '';
@@ -821,6 +1130,15 @@ var _changeCopyField = function changeCopyField(items, data) {
     } else if (v.type === AtomsTypeEnum.FORMULA) {
       v.args = _changeCopyField(v.args, data);
       return v;
+    } else if (v.type === AtomsTypeEnum.AND_OR) {
+      var hasBinarySides = Array.isArray(v.leftAtoms) || Array.isArray(v.rightAtoms);
+      return _objectSpread(_objectSpread({}, v), hasBinarySides ? {
+        atoms: undefined,
+        leftAtoms: _changeCopyField(v.leftAtoms || [], data),
+        rightAtoms: _changeCopyField(v.rightAtoms || [], data)
+      } : {
+        atoms: _changeCopyField(v.atoms || [], data)
+      });
     } else if (v.type === AtomsTypeEnum.COLLECTION) {
       v.list = _changeCopyField(v.list, data);
       return v;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gingkoo/pandora-metabase",
-  "version": "1.0.125",
+  "version": "1.0.127",
   "description": "",
   "main": "lib/es/index.js",
   "module": "lib/es/index.js",