@gingkoo/pandora-metabase 1.0.95 → 1.0.96

package/lib/cjs/hooks/patch2.js

@@ -0,0 +1,600 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sortPatch = exports.patchMetas = exports.joinDataPatch = exports.filterPatch = exports.dataPatch = exports.customColumnPatch = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _helper = require("../utils/helper");
+var _utils = require("../utils");
+var _types = require("../store/types");
+var _enum = require("../store/enum");
+var dataPatch = exports.dataPatch = function dataPatch(newMeta) {
+  // let item = newMeta.expressions?.[0] || {};
+  // if (item?.type && Object.values(AtomsTypeEnum).includes(item.type)) {
+  //   if (item.type === AtomsTypeEnum.EXPRESSION && item.lhs) {
+  //     return newMeta;
+  //   }
+  // }
+  newMeta.subquery = _patchMetas(newMeta.subquery);
+  return newMeta;
+};
+var joinDataPatch = exports.joinDataPatch = function joinDataPatch(newMeta) {
+  var _fields, _fields2, _fields3, _fields4, _newMeta$expressions;
+  // let item = newMeta.expressions?.[0] || {};
+  // if (item?.type && Object.values(AtomsTypeEnum).includes(item.type)) {
+  //   if (
+  //     (item.type === AtomsTypeEnum.EXPRESSION || item.type === AtomsTypeEnum.JOIN_DEFAULT) &&
+  //     item.lhs
+  //   ) {
+  //     return newMeta;
+  //   }
+  //   if (item.type === AtomsTypeEnum.EXISTS && !item.tableUuid) {
+  //     return newMeta;
+  //   }
+  //   if (item.type === AtomsTypeEnum.NOT_EXISTS && !item.tableUuid) {
+  //     return newMeta;
+  //   }
+  //   if (item.type === AtomsTypeEnum.FIELD && item.fieldName) {
+  //     return newMeta;
+  //   }
+  // }
+  // if (
+  //   newMeta.expressions?.[0]?.type &&
+  //   Object.values(AtomsTypeEnum).includes(newMeta.expressions[0].type)
+  // ) {
+  //   return newMeta;
+  // }
+  var fields1 = newMeta.table1.fields || [];
+  var fields2 = newMeta.table2.fields || [];
+  // 处理老字段
+  var field1 = {
+    fieldAlias: newMeta.table1.fieldAlias || newMeta.table1.column || newMeta.table1.name,
+    fieldUuid: newMeta.table1.fieldUuid || (0, _helper.uuidv4)('field'),
+    fieldId: newMeta.table1.fieldId,
+    fieldNameZh: newMeta.table1.name_zh,
+    fieldName: newMeta.table1.fieldName || newMeta.table1.name
+    // quotes: newMeta.table1.quotes || newMeta.table1.column,
+    // tableUuid: newMeta.table1.tableUuid,
+    // tableId: newMeta.table1.datasourceId,
+    // tableAlias: newMeta.table1.alias,
+  };
+  var field2 = {
+    fieldAlias: newMeta.table2.fieldAlias || newMeta.table2.column || newMeta.table2.name,
+    fieldUuid: newMeta.table2.fieldUuid || (0, _helper.uuidv4)('field'),
+    fieldId: newMeta.table2.fieldId,
+    fieldNameZh: newMeta.table2.name_zh,
+    fieldName: newMeta.table2.fieldName || newMeta.table2.name
+  };
+  // 处理多选
+  if (field1.fieldAlias && ((_fields = fields1) === null || _fields === void 0 ? void 0 : _fields.length) < 1) {
+    fields1 = [(0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, field1), {}, {
+      // quotes: field1.quotes,
+      fieldUuid: field1.fieldUuid,
+      fieldAlias: field1.fieldAlias,
+      fieldId: field1.fieldId
+      // fieldNameZh: newMeta.table1.name_zh,
+      // fieldName: newMeta.table1.fieldName || newMeta.table1.name,
+      // tableAlias: newMeta.table1.alias,
+      // tableId: newMeta.table1.id,
+      // tableName: newMeta.table1.name,
+      // tableNameZh: newMeta.table1.name_zh,
+      // tableUuid: newMeta.table1.tableUuid,
+      // datasourceName: newMeta.table1.datasourceName, // 数据源名
+      // datasourceId: newMeta.table1.datasourceId, // 数据源id
+    })];
+  }
+  if (field2.fieldAlias && ((_fields2 = fields2) === null || _fields2 === void 0 ? void 0 : _fields2.length) < 1) {
+    fields2 = [(0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, field2), {}, {
+      // quotes: field2.quotes,
+      fieldUuid: field2.fieldUuid,
+      fieldAlias: field2.fieldAlias,
+      fieldId: field2.fieldId
+      // fieldNameZh: newMeta.table2.name_zh,
+      // fieldName: newMeta.table2.fieldName || newMeta.table2.name,
+      // tableAlias: newMeta.table2.alias,
+      // tableId: newMeta.table2.id,
+      // tableName: newMeta.table2.name,
+      // tableNameZh: newMeta.table2.name_zh,
+      // tableUuid: newMeta.table2.tableUuid,
+      // datasourceName: newMeta.table2.datasourceName, // 数据源名
+      // datasourceId: newMeta.table2.datasourceId, // 数据源id
+    })];
+  }
+  // newMeta.table1 = {
+  //   ...newMeta.table1,
+  //   ...field1,
+  //   tableUuid: newMeta.table1.tableUuid || uuidv4('table'),
+  //   fields: fields1,
+  // };
+  // newMeta.table2 = {
+  //   ...newMeta.table2,
+  //   ...field2,
+  //   tableUuid: newMeta.table2.tableUuid || uuidv4('table'),
+  //   fields: fields2,
+  // };
+  var beforeExpressions = [];
+  if (((_fields3 = fields1) === null || _fields3 === void 0 ? void 0 : _fields3.length) > 0 || ((_fields4 = fields2) === null || _fields4 === void 0 ? void 0 : _fields4.length) > 0) {
+    beforeExpressions = [{
+      left_constant: '',
+      left_string: '',
+      operator: '等于',
+      left_fields: fields1 || [],
+      left_type: 'field',
+      right_constant: '',
+      right_string: '',
+      right_fields: fields2 || [],
+      right_type: 'field',
+      type: 'default' // 默认是字段模式
+    }];
+  }
+  var expressions = ((_newMeta$expressions = newMeta.expressions) === null || _newMeta$expressions === void 0 ? void 0 : _newMeta$expressions.map(function (v) {
+    var _left_fields, _right_fields;
+    var left_fields = v.left_fields || [];
+    var right_fields = v.right_fields || [];
+    // if (v.type !== 'default') {
+    //   return v;
+    // }
+    // 先处理老数据的字段
+    var left_field = {
+      left_fieldAlias: v.left_fieldAlias || v.left_column,
+      left_fieldUuid: v.left_fieldUuid || (0, _helper.uuidv4)('field'),
+      left_quotes: v.left_quotes || v.left_column
+    };
+    var right_field = {
+      right_fieldAlias: v.right_fieldAlias || v.right_column,
+      right_fieldUuid: v.right_fieldUuid || (0, _helper.uuidv4)('field'),
+      right_quotes: v.right_quotes || v.right_column
+    };
+    // 再处理多选
+    if (left_field.left_fieldAlias && ((_left_fields = left_fields) === null || _left_fields === void 0 ? void 0 : _left_fields.length) < 1) {
+      left_fields = [{
+        fieldAlias: left_field.left_fieldAlias,
+        fieldUuid: left_field.left_fieldUuid,
+        quotes: left_field.left_quotes
+        // tableUuid: newMeta.table1.tableUuid,
+        // tableId: newMeta.table1.datasourceId,
+        // tableAlias: newMeta.table1.alias,
+      }];
+    }
+    if (right_field.right_fieldAlias && ((_right_fields = right_fields) === null || _right_fields === void 0 ? void 0 : _right_fields.length) < 1) {
+      right_fields = [{
+        fieldAlias: right_field.right_fieldAlias,
+        fieldUuid: right_field.right_fieldUuid,
+        quotes: right_field.right_quotes
+        // tableUuid: newMeta.table2.tableUuid,
+        // tableId: newMeta.table2.datasourceId,
+        // tableAlias: newMeta.table2.alias,
+      }];
+    }
+    return {
+      left_constant: v.left_constant || '',
+      left_string: v.left_string || '',
+      left_fields: left_fields,
+      left_type: v.left_type || '',
+      operator: v.operator || '',
+      right_constant: v.right_constant || '',
+      right_string: v.right_string || '',
+      right_fields: right_fields,
+      right_type: v.right_type || '',
+      type: v.type || 'default' // 默认是字段模式
+    };
+  })) || [];
+  var _expressions = beforeExpressions.concat(expressions);
+  var newExpressions = [];
+  _expressions === null || _expressions === void 0 || _expressions.map(function (v, i) {
+    var lhs = [];
+    var rhs = [];
+    if (v.left_type === 'string') {
+      lhs = [{
+        val: v.left_string,
+        type: _types.AtomsTypeEnum.INPUT_STRING
+      }];
+    } else if (v.left_type === 'constant') {
+      lhs = [{
+        val: v.left_constant,
+        type: _types.AtomsTypeEnum.CONSTANT
+      }];
+    } else {
+      var _v$left_fields;
+      lhs = (_v$left_fields = v.left_fields) === null || _v$left_fields === void 0 ? void 0 : _v$left_fields.map(function (vv) {
+        return (0, _objectSpread2["default"])({
+          fieldNameZh: newMeta.table1.name_zh,
+          fieldName: vv.fieldName || vv.quotes || vv.fieldAlias || newMeta.table1.fieldName || newMeta.table1.name,
+          tableAlias: newMeta.table1.alias,
+          tableId: newMeta.table1.id,
+          tableName: newMeta.table1.name,
+          tableNameZh: newMeta.table1.name_zh,
+          tableUuid: newMeta.table1.tableUuid,
+          datasourceName: newMeta.table1.datasourceName,
+          // 数据源名
+          datasourceId: newMeta.table1.datasourceId,
+          // 数据源id
+          type: _types.AtomsTypeEnum.FIELD
+        }, vv);
+      });
+    }
+    if (v.right_type === 'string') {
+      rhs = [{
+        val: v.right_string,
+        type: _types.AtomsTypeEnum.INPUT_STRING
+      }];
+    } else if (v.right_type === 'constant') {
+      rhs = [{
+        val: v.right_constant,
+        type: _types.AtomsTypeEnum.CONSTANT
+      }];
+    } else {
+      var _v$right_fields;
+      rhs = (_v$right_fields = v.right_fields) === null || _v$right_fields === void 0 ? void 0 : _v$right_fields.map(function (vv) {
+        return (0, _objectSpread2["default"])({
+          fieldNameZh: newMeta.table2.name_zh,
+          fieldName: vv.fieldName || vv.quotes || vv.fieldAlias || newMeta.table2.fieldName || newMeta.table2.name,
+          tableAlias: newMeta.table2.alias,
+          tableId: newMeta.table2.id,
+          tableName: newMeta.table2.name,
+          tableNameZh: newMeta.table2.name_zh,
+          tableUuid: newMeta.table2.tableUuid,
+          datasourceName: newMeta.table2.datasourceName,
+          // 数据源名
+          datasourceId: newMeta.table2.datasourceId,
+          // 数据源id
+          type: _types.AtomsTypeEnum.FIELD
+        }, vv);
+      });
+    }
+    var item = {
+      lhs: lhs,
+      rhs: rhs,
+      // database_type: '',
+      condition: '',
+      // quotes: '',
+      type: _types.AtomsTypeEnum.JOIN_DEFAULT
+    };
+    newExpressions.push(item);
+    if (_expressions.length - 1 > i) {
+      newExpressions.push({
+        val: 'AND',
+        type: _types.AtomsTypeEnum.OPERATOR
+      });
+    }
+    return item;
+  });
+  // 清除table1中不用字段
+  delete newMeta.table1.fields;
+  // 清除table2中不用字段
+  delete newMeta.table2.fields;
+  newMeta.subquery = _patchMetas(newMeta.subquery);
+  newMeta.expressions = newExpressions;
+  return newMeta;
+};
+var filterPatch = exports.filterPatch = function filterPatch(newMeta) {
+  var _newMeta$filter;
+  // let item = newMeta.filter?.[0] || {};
+  // if (item?.type && Object.values(AtomsTypeEnum).includes(item.type)) {
+  //   if (item.type === AtomsTypeEnum.EXPRESSION && item.lhs) {
+  //     return newMeta;
+  //   }
+  //   if (item.type === AtomsTypeEnum.EXISTS && !item.tableUuid) {
+  //     return newMeta;
+  //   }
+  //   if (item.type === AtomsTypeEnum.NOT_EXISTS && !item.tableUuid) {
+  //     return newMeta;
+  //   }
+  //   if (item.type === AtomsTypeEnum.FIELD && item.fieldName) {
+  //     return newMeta;
+  //   }
+  // }
+  var _filter = (_newMeta$filter = newMeta.filter) === null || _newMeta$filter === void 0 ? void 0 : _newMeta$filter.map(function (v) {
+    // 表达式
+    var tem;
+    if (typeof v === 'string') {
+      return {
+        val: v,
+        type: _types.AtomsTypeEnum.OPERATOR
+      };
+    } else if (v.type === 'expression') {
+      var rhs;
+      if (v.valType === 'field') {
+        rhs = [{
+          fieldName: v.table2.name,
+          fieldNameZh: v.table2.name_zh,
+          fieldAlias: v.table2.fieldAlias,
+          fieldUuid: v.table2.fieldUuid,
+          fieldId: v.table2.id,
+          tableName: v.table2.table,
+          tableNameZh: '',
+          tableId: v.table2.tableId,
+          tableAlias: v.table2.alias,
+          tableUuid: v.table2.tableUuid,
+          datasourceName: v.table2.datasourceName,
+          datasourceId: v.table2.datasourceId,
+          type: _types.AtomsTypeEnum.FIELD
+        }];
+      } else if (v.valType === 'constant') {
+        var _v$val;
+        rhs = [{
+          val: ((_v$val = v.val) === null || _v$val === void 0 ? void 0 : _v$val[0]) || '',
+          type: _types.AtomsTypeEnum.CONSTANT
+        }];
+      } else {
+        var _v$val2;
+        if (((_v$val2 = v.val) === null || _v$val2 === void 0 ? void 0 : _v$val2.length) > 1) {
+          rhs = [{
+            val: v.val,
+            type: _types.AtomsTypeEnum.INPUT_STRING_LIST
+          }];
+        } else {
+          var _v$val3;
+          rhs = [{
+            val: ((_v$val3 = v.val) === null || _v$val3 === void 0 ? void 0 : _v$val3[0]) || '',
+            type: _types.AtomsTypeEnum.INPUT_STRING
+          }];
+        }
+      }
+      tem = {
+        lhs: [{
+          fieldName: v.name,
+          fieldNameZh: v.name_zh,
+          fieldAlias: v.fieldAlias || v.name,
+          fieldUuid: v.fieldUuid,
+          fieldId: v.id,
+          tableName: v.table,
+          tableNameZh: '',
+          tableId: v.tableId,
+          tableAlias: v.alias,
+          tableUuid: v.tableUuid,
+          datasourceName: v.datasourceName,
+          datasourceId: v.datasourceId,
+          type: _types.AtomsTypeEnum.FIELD
+        }],
+        rhs: rhs,
+        database_type: v.database_type,
+        condition: v.condition,
+        quotes: v.quotes,
+        formula: v.formula,
+        type: _types.AtomsTypeEnum.EXPRESSION
+      };
+      return tem;
+    } else if (v.type === 'notExists') {
+      var notExists = _patchMetas(v.notExists);
+      return {
+        notExists: notExists,
+        quotes: (0, _utils.buildSqlQuery)(notExists, v.type),
+        type: _types.AtomsTypeEnum.NOT_EXISTS
+      };
+    } else if (v.type === 'exists') {
+      var _notExists = _patchMetas(v.notExists);
+      return {
+        notExists: _notExists,
+        quotes: (0, _utils.buildSqlQuery)(_notExists, v.type),
+        type: _types.AtomsTypeEnum.EXISTS
+      };
+    }
+    return v;
+  });
+  newMeta.filter = _filter;
+  return newMeta;
+};
+var customColumnPatch = exports.customColumnPatch = function customColumnPatch(newMeta) {
+  var _newMeta$customColumn;
+  // let item = newMeta.customColumn?.[0]?.formulaList?.[0] || {};
+  // if (item?.type && Object.values(AtomsTypeEnum).includes(item.type)) {
+  //   if (item.type === AtomsTypeEnum.EXPRESSION && item.lhs) {
+  //     return newMeta;
+  //   }
+  //   if (item.type === AtomsTypeEnum.EXISTS && !item.tableUuid) {
+  //     return newMeta;
+  //   }
+  //   if (item.type === AtomsTypeEnum.NOT_EXISTS && !item.tableUuid) {
+  //     return newMeta;
+  //   }
+  //   if (item.type === AtomsTypeEnum.FIELD && item.fieldName) {
+  //     return newMeta;
+  //   }
+  // }
+  newMeta.customColumn = (newMeta === null || newMeta === void 0 || (_newMeta$customColumn = newMeta.customColumn) === null || _newMeta$customColumn === void 0 ? void 0 : _newMeta$customColumn.map(function (v) {
+    var _formulaList = v.formulaList.map(function (formula) {
+      var tem = formula;
+      if (formula.type === 'expression') {
+        var rhs;
+        if (formula.expression.valType === 'field') {
+          rhs = [{
+            fieldName: formula.expression.table2.name,
+            fieldNameZh: formula.expression.table2.name_zh,
+            fieldAlias: formula.expression.table2.fieldAlias,
+            fieldUuid: formula.expression.table2.fieldUuid,
+            fieldId: formula.expression.table2.id,
+            tableName: formula.expression.table2.table,
+            tableNameZh: '',
+            tableId: formula.expression.table2.tableId,
+            tableAlias: formula.expression.table2.alias,
+            tableUuid: formula.expression.table2.tableUuid,
+            datasourceName: formula.expression.table2.datasourceName,
+            datasourceId: formula.expression.table2.datasourceId,
+            // quotes: formula.expression.table2.quotes,
+            type: _types.AtomsTypeEnum.FIELD
+          }];
+        } else if (formula.expression.valType === 'constant') {
+          var _formula$expression$v;
+          rhs = [{
+            val: ((_formula$expression$v = formula.expression.val) === null || _formula$expression$v === void 0 ? void 0 : _formula$expression$v[0]) || '',
+            type: _types.AtomsTypeEnum.CONSTANT
+          }];
+        } else {
+          var _formula$expression$v2;
+          if (((_formula$expression$v2 = formula.expression.val) === null || _formula$expression$v2 === void 0 ? void 0 : _formula$expression$v2.length) > 1) {
+            rhs = [{
+              val: formula.expression.val,
+              type: _types.AtomsTypeEnum.INPUT_STRING_LIST
+            }];
+          } else {
+            var _formula$expression$v3;
+            rhs = [{
+              val: ((_formula$expression$v3 = formula.expression.val) === null || _formula$expression$v3 === void 0 ? void 0 : _formula$expression$v3[0]) || '',
+              type: _types.AtomsTypeEnum.INPUT_STRING
+            }];
+          }
+        }
+        tem = {
+          lhs: [{
+            fieldName: formula.expression.name,
+            fieldNameZh: formula.expression.name_zh,
+            fieldAlias: formula.expression.fieldAlias || formula.expression.name,
+            fieldUuid: formula.expression.fieldUuid,
+            fieldId: formula.expression.id,
+            tableName: formula.expression.table,
+            tableNameZh: '',
+            tableId: formula.expression.tableId,
+            tableAlias: formula.expression.alias,
+            tableUuid: formula.expression.tableUuid,
+            datasourceName: formula.expression.datasourceName,
+            datasourceId: formula.expression.datasourceId,
+            // quotes: formula.expression.name,
+            type: _types.AtomsTypeEnum.FIELD
+          }],
+          rhs: rhs,
+          database_type: formula.expression.database_type,
+          condition: formula.expression.condition,
+          quotes: formula.expression.quotes,
+          formula: formula.expression.formula,
+          type: _types.AtomsTypeEnum.EXPRESSION
+        };
+      } else if (formula.type === 'field') {
+        tem = {
+          fieldName: formula.expression.name,
+          fieldNameZh: formula.expression.name_zh,
+          fieldAlias: formula.expression.fieldAlias,
+          fieldUuid: formula.expression.fieldUuid,
+          fieldId: formula.expression.id,
+          tableName: formula.expression.table,
+          tableNameZh: '',
+          tableId: formula.expression.tableId,
+          tableAlias: formula.expression.alias,
+          tableUuid: formula.expression.tableUuid,
+          datasourceName: formula.expression.datasourceName,
+          datasourceId: formula.expression.datasourceId,
+          // quotes: formula.expression.quotes,
+          type: _types.AtomsTypeEnum.FIELD
+        };
+      } else if (formula.type === 'operator') {
+        tem = {
+          val: formula.operator,
+          type: _types.AtomsTypeEnum.OPERATOR
+        };
+      } else if (formula.type === 'other') {
+        tem = {
+          val: formula.operator,
+          type: _types.AtomsTypeEnum.OPERATOR
+        };
+      } else if (formula.type === 'input') {
+        tem = {
+          val: formula.operator,
+          type: _types.AtomsTypeEnum.INPUT_STRING
+        };
+      } else if (formula.type === 'notExists') {
+        //应该是多余
+        return {
+          notExists: v.expression.notExists,
+          quotes: v.expression.quotes,
+          type: _types.AtomsTypeEnum.NOT_EXISTS
+        };
+      }
+      return tem;
+    });
+    {}
+    return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, v), {}, {
+      formulaList: _formulaList
+    });
+  })) || newMeta.customColumn;
+  return newMeta;
+};
+var sortPatch = exports.sortPatch = function sortPatch(newMeta) {
+  var _newMeta$sort;
+  // let item = newMeta.sort?.[0].expression?.[0] || {};
+  // if (item?.type && Object.values(AtomsTypeEnum).includes(item.type)) {
+  //   if (item.type === AtomsTypeEnum.EXPRESSION && item.lhs) {
+  //     return newMeta;
+  //   }
+  //   if (item.type === AtomsTypeEnum.EXISTS && !item.tableUuid) {
+  //     return newMeta;
+  //   }
+  //   if (item.type === AtomsTypeEnum.NOT_EXISTS && !item.tableUuid) {
+  //     return newMeta;
+  //   }
+  //   if (item.type === AtomsTypeEnum.FIELD && item.fieldName) {
+  //     return newMeta;
+  //   }
+  // }
+  var _sort = (_newMeta$sort = newMeta.sort) === null || _newMeta$sort === void 0 ? void 0 : _newMeta$sort.map(function (v) {
+    return {
+      expression: [{
+        fieldName: v.name,
+        fieldNameZh: v.name_zh,
+        fieldAlias: v.fieldAlias || v.name,
+        fieldUuid: v.fieldUuid,
+        fieldId: v.id,
+        tableName: v.table,
+        tableNameZh: '',
+        tableId: v.tableId,
+        tableAlias: v.alias,
+        tableUuid: v.tableUuid,
+        datasourceName: v.datasourceName,
+        datasourceId: v.datasourceId,
+        type: _types.AtomsTypeEnum.FIELD
+      }],
+      sort: v.sort
+    };
+  });
+  newMeta.sort = _sort;
+  return newMeta;
+};
+var _patchMetas = exports.patchMetas = function patchMetas(items) {
+  return (items === null || items === void 0 ? void 0 : items.map(function (v) {
+    if (v.type === _enum.TypeEnum.data) {
+      v = dataPatch(v);
+    }
+    if (v.type === _enum.TypeEnum.joinData) {
+      v = joinDataPatch(v);
+    }
+    if (v.type === _enum.TypeEnum.filter) {
+      v = filterPatch(v);
+    }
+    if (v.type === _enum.TypeEnum.sort) {
+      v = sortPatch(v);
+    }
+    if (v.type === _enum.TypeEnum.customColumn) {
+      v = customColumnPatch(v);
+    }
+    if (v.type === _enum.TypeEnum.union) {
+      v.subquery = _patchMetas(v.subquery || []);
+    }
+    return v;
+  })) || [];
+};
+// export const patchMetas1 = (items: MetaListType[]) => {
+//   return (
+//     items?.map((v: MetaListType): MetaListType => {
+//       // if (v.type === TypeEnum.data) {
+//       //   v = dataPatch(v);
+//       // }
+//       // if (v.type === TypeEnum.joinData) {
+//       //   v = joinDataPatch(v);
+//       // }
+//       // if (v.type === TypeEnum.filter) {
+//       //   v = filterPatch(v);
+//       // }
+//       // if (v.type === TypeEnum.sort) {
+//       //   v = sortPatch(v);
+//       // }
+//       // if (v.type === TypeEnum.customColumn) {
+//       //   v = customColumnPatch(v);
+//       // }
+//       if (v.type === TypeEnum.union) {
+//         v.subquery = patchMetas(v.subquery || []);
+//       }
+//       return v;
+//     }) || []
+//   );
+// };

package/lib/cjs/hooks/use-state.js

@@ -18,6 +18,7 @@ var _utils = require("../utils");
 var _storage = _interopRequireDefault(require("../utils/storage"));
 var _cloneDeep = _interopRequireDefault(require("lodash/cloneDeep"));
 var _excluded = ["alias", "datasourceName", "datasourceId", "column"];
+// import { joinDataPatch, filterPatch, sortPatch, customColumnPatch, dataPatch } from './patch';
 var metaKey = 1;
 var SummarizeAlias = exports.SummarizeAlias = 'source';
 var useStore = function useStore() {

package/lib/cjs/index.js

@@ -94,12 +94,12 @@ var SqlVisionBuilder = _react["default"].forwardRef(function (props, ref) {
     store.setProps(props);
   }, [props]);
   (0, _react.useEffect)(function () {
-    var _value = (0, _utils.reassembleByUnion)((0, _utils.patchData)(value));
-    var source_value = (0, _utils.patchData)(value);
+    var _value = (0, _utils.reassembleByUnion)((0, _utils.patchData)(value, constantList, formulaTemplates));
+    var source_value = (0, _utils.patchData)(value, constantList, formulaTemplates);
     store.setPreData((0, _cloneDeep["default"])(_value), isSubquery, isExit);
     store.setSourceData(source_value);
     getExistsError && store.setExistsErrorFn(getExistsError, value);
-  }, [value]);
+  }, [value, constantList, formulaTemplates]);
   (0, _react.useEffect)(function () {
     store.setSourceList(isExit && exitSourceList && Array.from(exitSourceList).length > 0 ? exitSourceList || sourceList : sourceList);
   }, [sourceList, exitSourceList, isExit]);

package/lib/cjs/utils.d.ts

@@ -26,7 +26,8 @@ export declare function isValidSQLAlias(str: string): boolean;
 export declare const changeTableAlias: (list: MetaListType[] | [], curObj: Pick<MetaData_TableType, "tableUuid" | "alias">) => MetaListType[];
 export declare const changeFieldAlias: (list: MetaListType[], curObj: Pick<MetaData_ColumnsType, "fieldUuid" | "fieldAlias">) => MetaListType[];
 export declare function splitByUnion(data: any): any[];
-export declare const patchData: (metas: MetaListType[]) => MetaListType[];
+export declare const getObjTem: (arr: any[]) => any;
+export declare const patchData: (metas: MetaListType[], constantList?: any, formulaTemplates?: any) => MetaListType[];
 export declare function reassembleByUnion(target?: any[]): any[];
 export declare const buildSqlQuery: (data: MetaListType[] | undefined, type: string) => string;
 export declare const isError: (item: AtomsItem | AtomsItem[], data: DataType[]) => boolean;

package/lib/cjs/utils.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.changeTableAlias = exports.changeFieldAlias = exports.changeExistsCopyField = exports.changeCopyField = exports.buildSqlQuery = void 0;
 exports.containsSubset = containsSubset;
-exports.isExistsError = exports.isError = exports.isCanPaste = exports.getSubColumns = exports.getMetaTabels = exports.getHelper = exports.getColumnsTables = exports.findMetaKey = exports.findIndex = void 0;
+exports.isExistsError = exports.isError = exports.isCanPaste = exports.getSubColumns = exports.getObjTem = exports.getMetaTabels = exports.getHelper = exports.getColumnsTables = exports.findMetaKey = exports.findIndex = void 0;
 exports.isValidSQLAlias = isValidSQLAlias;
 exports.patchData = exports.metaIsCheck = void 0;
 exports.reassembleByUnion = reassembleByUnion;
@@ -513,12 +513,28 @@ function splitByUnion(data) {
   }
   return result;
 }
+var getObjTem = exports.getObjTem = function getObjTem(arr) {
+  var obj = {};
+  arr === null || arr === void 0 || arr.map(function (v) {
+    v.children.map(function (vv) {
+      if (vv.name) {
+        obj[vv.name] = vv;
+      }
+    });
+  });
+  return obj;
+};
 var patchData = exports.patchData = function patchData(metas) {
-  return metas;
+  var constantList = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var formulaTemplates = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  // return metas;
   var mainTable = metas[0] || {};
   var version = (mainTable === null || mainTable === void 0 ? void 0 : mainTable.patchVersion) || '';
-  if (version != '1.0.0') {
-    return (0, _patch.patchMetas)(metas);
+  // if (version != '1.0.0') {
+  //   return patchMetas(metas);
+  // }
+  if (version != '1.1.0') {
+    return (0, _patch.patchMetas)(metas, constantList, getObjTem(formulaTemplates));
   }
   return metas;
 };