@gingkoo/pandora-metabase 1.0.26 → 1.0.28

package/lib/cjs/utils/transformSql.js

@@ -0,0 +1,968 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformSql = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectWithoutProperties"));
+var _excluded = ["children"];
+var procEnum = {
+  mysql: 'mysql',
+  oracle: 'oracle',
+  sqlserver: 'sqlserver'
+};
+var MetabaseTypeEnum = {
+  data: 'data',
+  joinData: 'joinData',
+  customColumn: 'customColumn',
+  filter: 'filter',
+  summarize: 'summarize',
+  sort: 'sort',
+  rowLimit: 'rowLimit',
+  union: 'union',
+  permissionTable: 'permissionTable'
+};
+// 数据基础类型
+var BlockTypeEnum = {
+  joinDefault: 'joinDefault',
+  // 简单的表达式
+  expression: 'expression',
+  // 表达式
+  operator: 'operator',
+  // 操作符
+  field: 'field',
+  // 字段
+  inputNumber: 'inputNumber',
+  // 数字输入框
+  inputString: 'inputString',
+  // 字符串输入框
+  constant: 'constant',
+  // 常量
+  inputStringList: 'inputStringList',
+  // 多个字符串输入框
+  inputNumberList: 'inputNumberList',
+  // 多个数字输入框
+  unknown: 'unknown',
+  // 未知
+  notExists: 'notExists',
+  exists: 'exists',
+  FORMULA: 'FORMULA',
+  collection: 'collection'
+};
+var SummarizeAlias = 'source';
+var SQL_GROUP_TYPE = {
+  NUMBER: 'number',
+  STRING: 'string',
+  DATE: 'date'
+};
+var SQL_COLUMN_TYPE = {
+  STRING: 'STRING',
+  DATE: 'DATE',
+  FLOAT: 'FLOAT',
+  LONG: 'LONG',
+  CURRENCY: 'CURRENCY'
+};
+var DATE_GROUP = [SQL_COLUMN_TYPE.DATE];
+var NUMBER_GROUP = [SQL_COLUMN_TYPE.FLOAT, SQL_COLUMN_TYPE.LONG, SQL_COLUMN_TYPE.CURRENCY];
+var STRING_GROUP = [SQL_COLUMN_TYPE.STRING];
+var _flatArr2 = function _flatArr(data, arr) {
+  var children = data.children,
+    res = (0, _objectWithoutProperties2["default"])(data, _excluded);
+  arr.push(res);
+  if (children) {
+    _flatArr2(children, arr);
+  }
+};
+var _recursionArr2 = function _recursionArr(arr) {
+  var obj = (0, _objectSpread2["default"])({}, arr[0]);
+  if (arr.length > 1) {
+    obj.children = _recursionArr2(arr.slice(1));
+  }
+  return obj;
+};
+var _handleBaseType2Sql9 = function _handleBaseType2Sql(list) {
+  var db = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : procEnum.mysql;
+  var sql = '';
+  var constants = [];
+  var sql_items = []; // 这个是 给 list  单一类型用的，字符串输入框 类型也不加''
+  if (!Array.isArray(list)) {
+    return {
+      sql: sql,
+      sql_items: sql_items,
+      constants: constants
+    };
+  }
+  list.forEach(function (item) {
+    var _condition_, _condition_2;
+    var type = item.type;
+    if (type === BlockTypeEnum.unknown) {}
+    if (type === BlockTypeEnum.operator) {
+      sql += " ".concat(item.val);
+      sql_items.push(item.val);
+    }
+    if (type === BlockTypeEnum.field) {
+      var fileName = item.fieldName;
+      if (item.tableAlias === SummarizeAlias && item.fieldAlias) {
+        fileName = item.fieldAlias;
+      }
+      sql += " ".concat(item.tableAlias, ".").concat(fileName);
+      sql_items.push("".concat(item.tableAlias, ".").concat(fileName));
+    }
+    if (type === BlockTypeEnum.inputNumber) {
+      sql += " ".concat(item.val);
+      sql_items.push("".concat(item.val));
+    }
+    if (type === BlockTypeEnum.inputString) {
+      if (item.val && (/^'.*'$/.test(item.val) || /^".*"$/.test(item.val))) {
+        sql += " ".concat(item.val);
+      } else {
+        sql += " '".concat(item.val, "'");
+      }
+      sql_items.push("".concat(item.val));
+    }
+    if (type === BlockTypeEnum.constant) {
+      sql += " ".concat(item.val);
+      sql_items.push("".concat(item.val));
+      constants.push(item.val);
+    }
+    if (type === BlockTypeEnum.inputStringList) {
+      // 这个如果存在 list 数组中，那么 list 数组种 只能有他，因为他太特殊了，现在就表达式在用
+      if (Array.isArray(item.val) && item.val.length) {
+        item.val.forEach(function (v) {
+          // 这里虽然是字符串 但是不加 ''了 因为他太特殊了 不通用
+          sql_items.push("".concat(v));
+        });
+      }
+    }
+    if (type === BlockTypeEnum.inputNumberList) {
+      // 这个如果存在 list 数组中，那么 list 数组种 只能有他，因为他太特殊了，现在就表达式在用
+      if (Array.isArray(item.val) && item.val.length) {
+        item.val.forEach(function (v) {
+          // 这里虽然是字符串 但是不加 ''了 因为他太特殊了 不通用
+          sql_items.push("".concat(v));
+        });
+      }
+    }
+    if (type === BlockTypeEnum.joinDefault) {
+      var lhs = item.lhs,
+        rhs = item.rhs;
+      // 他很特殊 左边里面只有一种类型 右边面只有一种类型
+      var _handleBaseType2Sql2 = _handleBaseType2Sql9(lhs, db),
+        leftSql = _handleBaseType2Sql2.sql,
+        leftSqlItems = _handleBaseType2Sql2.sql_items,
+        joinDefaultLeftConstants = _handleBaseType2Sql2.constants;
+      var _handleBaseType2Sql3 = _handleBaseType2Sql9(rhs, db),
+        rightSql = _handleBaseType2Sql3.sql,
+        rightSqlItems = _handleBaseType2Sql3.sql_items,
+        joinDefaultRightConstants = _handleBaseType2Sql3.constants;
+      constants.push.apply(constants, (0, _toConsumableArray2["default"])(joinDefaultLeftConstants));
+      constants.push.apply(constants, (0, _toConsumableArray2["default"])(joinDefaultRightConstants));
+      var left_condition = leftSql;
+      var right_condition = rightSql;
+      if (leftSqlItems.length > 1) {
+        // 多个肯定是字段
+        if (db === procEnum.mysql) {
+          left_condition = "CONCAT(".concat(leftSqlItems.join(','), ")");
+        }
+        if (db === procEnum.oracle) {
+          left_condition = "".concat(leftSqlItems.join(' || '));
+        }
+        if (db === procEnum.sqlserver) {
+          left_condition = "".concat(leftSqlItems.join(' + '));
+        }
+      }
+      if (rightSqlItems.length > 1) {
+        // 多个肯定是字段
+        if (db === procEnum.mysql) {
+          right_condition = "CONCAT(".concat(rightSqlItems.join(','), ")");
+        }
+        if (db === procEnum.oracle) {
+          right_condition = "".concat(rightSqlItems.join(' || '));
+        }
+        if (db === procEnum.sqlserver) {
+          right_condition = "".concat(rightSqlItems.join(' + '));
+        }
+      }
+      sql += " ".concat(left_condition, " = ").concat(right_condition);
+    }
+    if (type === BlockTypeEnum.expression) {
+      var _lhs = item.lhs,
+        _rhs = item.rhs,
+        condition = item.condition,
+        database_type = item.database_type,
+        formula = item.formula;
+      var _handleBaseType2Sql4 = _handleBaseType2Sql9(_lhs, db),
+        _leftSql = _handleBaseType2Sql4.sql,
+        _leftSqlItems = _handleBaseType2Sql4.sql_items,
+        _joinDefaultLeftConstants = _handleBaseType2Sql4.constants;
+      var _handleBaseType2Sql5 = _handleBaseType2Sql9(_rhs, db),
+        _rightSql = _handleBaseType2Sql5.sql,
+        _rightSqlItems = _handleBaseType2Sql5.sql_items,
+        _joinDefaultRightConstants = _handleBaseType2Sql5.constants;
+      constants.push.apply(constants, (0, _toConsumableArray2["default"])(_joinDefaultLeftConstants));
+      constants.push.apply(constants, (0, _toConsumableArray2["default"])(_joinDefaultRightConstants));
+      var _left_condition = _leftSql;
+      var _right_condition = '';
+      if (_leftSqlItems.length > 1) {
+        // 多个肯定是字段
+        if (db === procEnum.mysql) {
+          _left_condition = "CONCAT(".concat(_leftSqlItems.join(','), ")");
+        }
+        if (db === procEnum.oracle) {
+          _left_condition = "".concat(_leftSqlItems.join(' || '));
+        }
+        if (db === procEnum.sqlserver) {
+          _left_condition = "".concat(_leftSqlItems.join(' + '));
+        }
+      }
+      if (formula && formula.type && formula.params) {
+        // 目前只有一个 SUBSTR, 也不想再加函数了，函数不在这里加
+        var formulaType = formula.type;
+        if (db === procEnum.sqlserver && formulaType === 'SUBSTR') {
+          formulaType = 'SUBSTRING';
+        }
+        _left_condition = "".concat(formulaType, "(").concat(formula.params.map(function (it, i) {
+          if (!i) {
+            // 字段
+            return _left_condition;
+          } else {
+            return it;
+          }
+        }).join(', '), ")");
+      }
+      function getGroupType(database_type) {
+        var group = SQL_GROUP_TYPE.STRING;
+        if (~NUMBER_GROUP.indexOf(database_type)) {
+          group = SQL_GROUP_TYPE.NUMBER;
+        }
+        if (~DATE_GROUP.indexOf(database_type)) {
+          group = SQL_GROUP_TYPE.DATE;
+        }
+        return group;
+      }
+      var group = getGroupType(database_type);
+      if (group === SQL_GROUP_TYPE.STRING) {
+        var condition_1 = (_rightSqlItems === null || _rightSqlItems === void 0 ? void 0 : _rightSqlItems[0]) || '';
+        switch (condition) {
+          // string
+          case '等于':
+            _right_condition = "= ".concat(_rightSql);
+            break;
+          case '不等于':
+            _right_condition = "!= ".concat(_rightSql);
+            break;
+          case '包含':
+            // 去掉引号
+            _right_condition = "LIKE '%".concat(condition_1, "%'");
+            break;
+          case '不包含':
+            _right_condition = "NOT LIKE '%".concat(condition_1, "%'");
+            break;
+          case '为空':
+            _right_condition = "IS NULL";
+            break;
+          case '不为空':
+            _right_condition = "IS NOT NULL";
+            break;
+          case '以...开始':
+            _right_condition = "LIKE '".concat(condition_1, "%'");
+            break;
+          case '以...结束':
+            _right_condition = "LIKE '%".concat(condition_1, "'");
+            break;
+          case '不以...开始':
+            _right_condition = "NOT LIKE '".concat(condition_1, "%'");
+            break;
+          case '不以...结束':
+            _right_condition = "NOT LIKE '%".concat(condition_1, "'");
+            break;
+          case 'In':
+            condition_1 = (_condition_ = condition_1) === null || _condition_ === void 0 || (_condition_ = _condition_.split(',')) === null || _condition_ === void 0 || (_condition_ = _condition_.map(function (v) {
+              var _v;
+              v = (_v = v) === null || _v === void 0 ? void 0 : _v.trim();
+              // 如果已经加了引号
+              if (v && (/^'.*'$/.test(v) || /^".*"$/.test(v))) {
+                return "".concat(v);
+              } else {
+                return "'".concat(v, "'");
+              }
+            })) === null || _condition_ === void 0 ? void 0 : _condition_.join(',');
+            _right_condition = "IN (".concat(condition_1, ")");
+            break;
+          case 'Not In':
+            condition_1 = (_condition_2 = condition_1) === null || _condition_2 === void 0 || (_condition_2 = _condition_2.split(',')) === null || _condition_2 === void 0 || (_condition_2 = _condition_2.map(function (v) {
+              var _v2;
+              v = (_v2 = v) === null || _v2 === void 0 ? void 0 : _v2.trim();
+              if (v && (/^'.*'$/.test(v) || /^".*"$/.test(v))) {
+                return "".concat(v);
+              } else {
+                return "'".concat(v, "'");
+              }
+            })) === null || _condition_2 === void 0 ? void 0 : _condition_2.join(',');
+            _right_condition = "NOT IN (".concat(condition_1, ")");
+            break;
+          case '正则匹配':
+            if (db === procEnum.mysql) {
+              _right_condition = "REGEXP '".concat(condition_1, "'");
+            }
+            if (db === procEnum.oracle) {
+              _right_condition = "REGEXP_LIKE(".concat(_left_condition, ", '").concat(condition_1, "')");
+              _left_condition = '';
+            }
+            if (db === procEnum.sqlserver) {
+              _right_condition = "PATINDEX('".concat(condition_1, "', ").concat(_left_condition, ") = 1");
+              _left_condition = '';
+            }
+            break;
+        }
+      }
+      if (group === SQL_GROUP_TYPE.NUMBER) {
+        var _condition_3 = (_rightSqlItems === null || _rightSqlItems === void 0 ? void 0 : _rightSqlItems[0]) || '';
+        var condition_2 = (_rightSqlItems === null || _rightSqlItems === void 0 ? void 0 : _rightSqlItems[1]) || '';
+        switch (condition) {
+          // number
+          case '等于':
+            _right_condition = "= ".concat(_condition_3);
+            break;
+          case '不等于':
+            _right_condition = "!= ".concat(_condition_3);
+            break;
+          case '大于':
+            _right_condition = "> ".concat(_condition_3);
+            break;
+          case '小于':
+            _right_condition = "< ".concat(_condition_3);
+            break;
+          case '介于之间':
+            _right_condition = "BETWEEN ".concat(_condition_3, " AND ").concat(condition_2);
+            break;
+          case '大于或等于':
+            _right_condition = ">= ".concat(_condition_3);
+            break;
+          case '小于或等于':
+            _right_condition = "<= ".concat(_condition_3);
+            break;
+          case '为空':
+            _right_condition = "IS NULL";
+            break;
+          case '不为空':
+            _right_condition = "IS NOT NULL";
+            break;
+          case '以...开始':
+            if (db === procEnum.mysql) {
+              _right_condition = "CAST(".concat(_left_condition, " AS CHAR) LIKE '").concat(_condition_3, "%'");
+              _left_condition = '';
+            }
+            if (db === procEnum.oracle) {
+              _right_condition = "TO_CHAR(".concat(_left_condition, ") LIKE '").concat(_condition_3, "%'");
+              _left_condition = '';
+            }
+            if (db === procEnum.sqlserver) {
+              _right_condition = "CONVERT(VARCHAR, ".concat(_left_condition, ") LIKE '").concat(_condition_3, "%'");
+              _left_condition = '';
+            }
+            break;
+          case '以...结束':
+            if (db === procEnum.mysql) {
+              _right_condition = "CAST(".concat(_left_condition, " AS CHAR) LIKE '%").concat(_condition_3, "'");
+              _left_condition = '';
+            }
+            if (db === procEnum.oracle) {
+              _right_condition = "TO_CHAR(".concat(_left_condition, ") LIKE '%").concat(_condition_3, "'");
+              _left_condition = '';
+            }
+            if (db === procEnum.sqlserver) {
+              _right_condition = "CONVERT(VARCHAR, ".concat(_left_condition, ") LIKE '%").concat(_condition_3, "'");
+              _left_condition = '';
+            }
+            break;
+          case '不以...开始':
+            if (db === procEnum.mysql) {
+              _right_condition = "CAST(".concat(_left_condition, " AS CHAR) NOT LIKE '").concat(_condition_3, "%'");
+              _left_condition = '';
+            }
+            if (db === procEnum.oracle) {
+              _right_condition = "TO_CHAR(".concat(_left_condition, ") NOT LIKE '").concat(_condition_3, "%'");
+              _left_condition = '';
+            }
+            if (db === procEnum.sqlserver) {
+              _right_condition = "CONVERT(VARCHAR, ".concat(_left_condition, ") NOT LIKE '").concat(_condition_3, "%'");
+              _left_condition = '';
+            }
+            break;
+          case '不以...结束':
+            if (db === procEnum.mysql) {
+              _right_condition = "CAST(".concat(_left_condition, " AS CHAR) NOT LIKE '%").concat(_condition_3, "'");
+              _left_condition = '';
+            }
+            if (db === procEnum.oracle) {
+              _right_condition = "TO_CHAR(".concat(_left_condition, ") NOT LIKE '%").concat(_condition_3, "'");
+              _left_condition = '';
+            }
+            if (db === procEnum.sqlserver) {
+              _right_condition = "CONVERT(VARCHAR, ".concat(_left_condition, ") NOT LIKE '%").concat(_condition_3, "'");
+              _left_condition = '';
+            }
+            break;
+          case 'In':
+            _right_condition = "IN (".concat(_condition_3, ")");
+            break;
+          case 'Not In':
+            _right_condition = "NOT IN (".concat(_condition_3, ")");
+            break;
+          case '正则匹配':
+            if (db === procEnum.mysql) {
+              _right_condition = "CAST(".concat(_left_condition, " AS CHAR) REGEXP '").concat(_condition_3, "'");
+            }
+            if (db === procEnum.oracle) {
+              _right_condition = "REGEXP_LIKE(TO_CHAR(".concat(_left_condition, "), '").concat(_condition_3, "')");
+            }
+            if (db === procEnum.sqlserver) {
+              _right_condition = "PATINDEX('".concat(_condition_3, "', CONVERT(VARCHAR, ").concat(_left_condition, ")) = 1");
+            }
+            _left_condition = '';
+            break;
+        }
+      }
+      if (group === SQL_GROUP_TYPE.DATE) {
+        function transformDate(dataStr) {
+          return dataStr.replace(/-/g, '').replace(/:/g, '').replace(' ', '') + '00';
+        }
+        var _condition_4 = (_rightSqlItems === null || _rightSqlItems === void 0 ? void 0 : _rightSqlItems[0]) || '';
+        var _condition_5 = (_rightSqlItems === null || _rightSqlItems === void 0 ? void 0 : _rightSqlItems[1]) || '';
+        if (/^[\d- :]+$/.test(_condition_4)) {
+          // 日期
+          _condition_4 = "'".concat(transformDate(_condition_4), "'");
+        }
+        if (/^[\d- :]+$/.test(_condition_5)) {
+          // 日期
+          _condition_5 = "'".concat(transformDate(_condition_5), "'");
+        }
+        switch (condition) {
+          // date
+          case '等于':
+            _right_condition = "= ".concat(_condition_4);
+            break;
+          case '早于':
+            _right_condition = "< ".concat(_condition_4);
+            break;
+          case '晚于':
+            _right_condition = ">= ".concat(_condition_4);
+            break;
+          case '介于之间':
+            _right_condition = "(".concat(_left_condition, " >= ").concat(_condition_4, " AND ").concat(_left_condition, " < ").concat(_condition_5, ")");
+            _left_condition = '';
+            break;
+          case '是空的':
+            _right_condition = "IS NULL";
+            break;
+          case '不是空的':
+            _right_condition = "IS NOT NULL";
+            break;
+        }
+      }
+      sql += " ".concat(_left_condition, " ").concat(_right_condition);
+    }
+    if ([BlockTypeEnum.notExists, BlockTypeEnum.exists].includes(type)) {
+      var notExists = item.notExists;
+      if (notExists && notExists !== null && notExists !== void 0 && notExists.length) {
+        var _mainTable$table, _mainTable$table2;
+        var mainTable = notExists.find(function (v) {
+          return v.type === MetabaseTypeEnum.data;
+        });
+        var filterMeta = notExists.find(function (v) {
+          return v.type === MetabaseTypeEnum.filter;
+        });
+        var where = '';
+        if (filterMeta && filterMeta.filter && Array.isArray(filterMeta.filter) && filterMeta.filter.length) {
+          var _handleBaseType2Sql6 = _handleBaseType2Sql9(filterMeta.filter, db),
+            notExistsSql = _handleBaseType2Sql6.sql,
+            constInNotExistsFilter = _handleBaseType2Sql6.constants;
+          constants.push.apply(constants, (0, _toConsumableArray2["default"])(constInNotExistsFilter));
+          where = "WHERE ".concat(notExistsSql);
+        }
+        if (type === BlockTypeEnum.notExists) {
+          sql += ' NOT EXISTS';
+        } else {
+          sql += ' EXISTS';
+        }
+        sql += " (SELECT 1 FROM ".concat(mainTable === null || mainTable === void 0 || (_mainTable$table = mainTable.table) === null || _mainTable$table === void 0 ? void 0 : _mainTable$table.name, " AS ").concat(mainTable === null || mainTable === void 0 || (_mainTable$table2 = mainTable.table) === null || _mainTable$table2 === void 0 ? void 0 : _mainTable$table2.alias, " ").concat(where, ")");
+      }
+    }
+    if (type === BlockTypeEnum.FORMULA) {
+      var _handleBaseType2Sql7 = _handleBaseType2Sql9(item.args, db),
+        argSql = _handleBaseType2Sql7.sql,
+        formulaConstants = _handleBaseType2Sql7.constants;
+      sql += " ".concat(item.name, "(").concat(argSql, ")");
+      constants.push.apply(constants, (0, _toConsumableArray2["default"])(formulaConstants));
+    }
+    if (type === BlockTypeEnum.collection) {
+      var _handleBaseType2Sql8 = _handleBaseType2Sql9(item.list, db),
+        collectionSql = _handleBaseType2Sql8.sql,
+        collectionConstants = _handleBaseType2Sql8.constants;
+      sql += " ".concat(collectionSql);
+      constants.push.apply(constants, (0, _toConsumableArray2["default"])(collectionConstants));
+    }
+  });
+  return {
+    sql: sql,
+    sql_items: sql_items,
+    constants: constants
+  };
+};
+var _handleJoinData = function _handleJoinData(joinData) {
+  var db = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : procEnum.mysql;
+  var constants = [];
+  var joinList = joinData.filter(function (v) {
+    return v.table2.name;
+  }).map(function (v) {
+    var expressions = v.expressions,
+      isSubquery = v.isSubquery,
+      subquery = v.subquery;
+    var subQuery = null;
+    if (isSubquery) {
+      subQuery = subquery;
+    }
+    var _handleBaseType2Sql0 = _handleBaseType2Sql9(expressions, db),
+      sql = _handleBaseType2Sql0.sql,
+      joinConstants = _handleBaseType2Sql0.constants;
+    var joinCondition = "on ".concat(sql);
+    constants = joinConstants;
+    return {
+      alias: v.table2.alias,
+      tableName: v.table2.name,
+      tableName_zh: v.table2.name_zh,
+      datasourceId: v.table2.datasourceId || '',
+      datasourceName: v.table2.datasourceName || '',
+      joinCondition: joinCondition,
+      joinType: v.joinType,
+      subQuery: subQuery,
+      queryColumns: v.columns.filter(function (o) {
+        return o.select;
+      }).map(function (o) {
+        var tableAlias = v.table2.alias;
+        var fieldAlias = o.fieldAlias || o.name;
+        return {
+          field_sql: "".concat(tableAlias ? "".concat(tableAlias, ".").concat(o.name) : o.name, " as ").concat(fieldAlias),
+          read_name: o.name,
+          // 原字段名
+          name: fieldAlias,
+          name_zh: o.name_zh,
+          id: o.id
+        };
+      })
+    };
+  });
+  return {
+    joinList: joinList,
+    constants: constants
+  };
+};
+// 处理数据格式 - (这里才是真正处理成后端需要的格式 前面两步都是准备工作)
+var _handleNesting = function handleNesting(data) {
+  var db = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : procEnum.mysql;
+  var hasInnerSql = Boolean(data.children);
+  var obj = {
+    hasInnerSql: hasInnerSql,
+    innerSqlStruct: hasInnerSql ? _handleNesting(data.children) : null
+  };
+  var tableData = data[MetabaseTypeEnum.data];
+  var joinData = data[MetabaseTypeEnum.joinData] || [];
+  var customColumn = data[MetabaseTypeEnum.customColumn];
+  var filterData = data[MetabaseTypeEnum.filter];
+  var summarize = data[MetabaseTypeEnum.summarize];
+  var sortData = data[MetabaseTypeEnum.sort];
+  var rowLimit = data[MetabaseTypeEnum.rowLimit];
+  if (tableData) {
+    obj.alias = tableData.table.alias;
+    obj.tableName = tableData.table.name;
+    obj.tableId = tableData.table.id;
+    obj.datasourceId = tableData.table.datasourceId;
+    obj.datasourceName = tableData.table.datasourceName;
+    if (tableData.isSubquery && Array.isArray(tableData.subquery)) {
+      // 主表是子查询
+      obj.tableSubQuery = tableData.subquery;
+    }
+    if (!summarize || !summarize.group.length && !summarize.by.length) {
+      obj.queryColumns = tableData.columns.filter(function (v) {
+        return v.select;
+      }).map(function (v) {
+        var _tableData$table;
+        var tableAlias = tableData === null || tableData === void 0 || (_tableData$table = tableData.table) === null || _tableData$table === void 0 ? void 0 : _tableData$table.alias;
+        var fieldAlias = v.fieldAlias || v.name;
+        return {
+          field_sql: "".concat(tableAlias ? "".concat(tableAlias, ".").concat(v.name) : v.name, " as ").concat(fieldAlias),
+          // 生成 sql 放 select 后面的
+          read_name: v.name,
+          // 原字段名
+          name: fieldAlias,
+          // 输出字段名
+          name_zh: v.name_zh,
+          // 字段中文名
+          id: v.id // 字段原 DATA_ID
+        };
+      });
+    }
+  } else {
+    if (!summarize || !summarize.group.length && !summarize.by.length) {
+      obj.alias = SummarizeAlias;
+    }
+  }
+  if (joinData.length) {
+    obj.joinTables = _handleJoinData(joinData, db).joinList;
+  }
+  if (customColumn && customColumn.customColumn.length) {
+    var customColumnsConstants = [];
+    var handleCustomColumn = function handleCustomColumn(data) {
+      return data.map(function (it) {
+        var _handleBaseType2Sql1 = _handleBaseType2Sql9(it.formulaList, db),
+          field_sql = _handleBaseType2Sql1.sql,
+          constants = _handleBaseType2Sql1.constants;
+        customColumnsConstants.push.apply(customColumnsConstants, (0, _toConsumableArray2["default"])(constants));
+        return {
+          field_sql: "".concat(field_sql, " as ").concat(it.name),
+          read_name: it.name,
+          name: it.name,
+          name_zh: it.name,
+          id: ''
+        };
+      });
+    };
+    obj.customColumns = handleCustomColumn(customColumn.customColumn);
+    obj.customColumnsConstants = customColumnsConstants;
+  }
+  if (filterData && filterData.filter.length) {
+    var _handleBaseType2Sql10 = _handleBaseType2Sql9(filterData.filter, db),
+      sql = _handleBaseType2Sql10.sql,
+      constants = _handleBaseType2Sql10.constants;
+    obj.filters = 'WHERE ' + sql;
+    obj.filtersConstants = constants;
+  }
+  if (summarize && (summarize.group.length || summarize.by.length)) {
+    obj.groupBy = {
+      calcColumns: [],
+      groupColumns: []
+    };
+    var queryColumns = [];
+    if (summarize.group.length) {
+      obj.groupBy.calcColumns = summarize.group.map(function (v) {
+        queryColumns.push({
+          field_sql: "".concat(v.sql, " as ").concat(v.fieldAlias),
+          read_name: '',
+          // 原字段名
+          name: v.fieldAlias,
+          name_zh: v.fieldAlias,
+          // v.quotes,
+          id: ''
+        });
+        return v.sql;
+      });
+    }
+    if (summarize.by.length) {
+      obj.groupBy.groupColumns = summarize.by.map(function (v) {
+        queryColumns.push({
+          field_sql: "".concat(v.sql, " as ").concat(v.fieldAlias),
+          read_name: '',
+          // 原字段名
+          name: v.fieldAlias,
+          name_zh: v.fieldAlias,
+          // v.name_zh,
+          id: v.id
+        });
+        return "".concat(v.alias, ".").concat(v.realName || v.name);
+      });
+    }
+    obj.queryColumns = queryColumns;
+    if (!tableData) {
+      obj.alias = summarize.alias;
+    }
+  }
+  if (sortData && sortData.sort.length) {
+    obj.orderInfos = "ORDER BY ".concat(sortData.sort.map(function (v) {
+      var _handleBaseType2Sql11 = _handleBaseType2Sql9(v.expression, db),
+        sql = _handleBaseType2Sql11.sql;
+      return "".concat(sql, " ").concat(v.sort);
+    }).join(', '));
+  }
+  if (rowLimit) {
+    obj.limit = Number(rowLimit.limit);
+  }
+  return obj;
+};
+// 反转顺序 - （将原本嵌套的顺序完全反转 最内层变成最外层）别问为什么 问就是接口需要
+var reverseData = function reverseData(data) {
+  var arr = [];
+  _flatArr2(data, arr);
+  return _recursionArr2(arr.reverse());
+};
+// 分层 - （将原本平铺的格式转成 嵌套的格式）
+var _layeredData = function layeredData(list) {
+  var res = {};
+  for (var i = 0; i < list.length; i++) {
+    var meta = list[i];
+    // @ts-ignore
+    if (meta.type === MetabaseTypeEnum.joinData) {
+      if (res[meta.type]) {
+        res[meta.type].push(meta);
+      } else {
+        res[meta.type] = [meta];
+      }
+    } else {
+      // @ts-ignore
+      res[meta.type] = meta;
+    }
+    if (meta.type === MetabaseTypeEnum.summarize) {
+      var nextMeta = list[i + 1];
+      var nextNextMeta = list[i + 2];
+      var nextNextNextMeta = list[i + 3];
+      // 将sort 和 rowLimit 归到上一层 （虽然他们两在 summarize 后面）
+      // 处理完 sort 和 rowLimit 之后 如果数组后面还有元素则进入下一层循环
+      if (nextMeta) {
+        if (nextMeta.type === MetabaseTypeEnum.rowLimit) {
+          res[nextMeta.type] = nextMeta;
+          if (nextNextMeta) {
+            res.children = _layeredData(list.slice(i + 2));
+          }
+        } else if (nextMeta.type === MetabaseTypeEnum.sort) {
+          res[nextMeta.type] = nextMeta;
+          if (nextNextMeta) {
+            if (nextNextMeta.type === MetabaseTypeEnum.rowLimit) {
+              res[nextNextMeta.type] = nextNextMeta;
+              if (nextNextNextMeta) {
+                res.children = _layeredData(list.slice(i + 3));
+              }
+            } else {
+              res.children = _layeredData(list.slice(i + 2));
+            }
+          }
+        } else {
+          res.children = _layeredData(list.slice(i + 1));
+        }
+      }
+      break;
+    }
+  }
+  return res;
+};
+var handleSqlStruct = function handleSqlStruct(list) {
+  var db = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : procEnum.mysql;
+  return _handleNesting(reverseData(_layeredData(list)), db);
+};
+// 处理 union
+var handleSqlUnion = function handleSqlUnion(metas) {
+  var db = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : procEnum.mysql;
+  var unionMetas = metas.filter(function (it) {
+    return it.type === MetabaseTypeEnum.union;
+  });
+  var baseMetas = metas.filter(function (it) {
+    return it.type !== MetabaseTypeEnum.union;
+  });
+  var data = handleSqlStruct(baseMetas, db);
+  var _sqlStruct2text = _sqlStruct2text3(data, 0, db),
+    sql = _sqlStruct2text.sql,
+    fields = _sqlStruct2text.fields;
+  var union_fields = [fields];
+  if (unionMetas.length) {
+    // 用到了 union
+    unionMetas.forEach(function (it) {
+      if (Array.isArray(it.subquery) && it.subquery.length) {
+        var u_data = handleSqlStruct(it.subquery, db);
+        var _sqlStruct2text2 = _sqlStruct2text3(u_data, 0, db),
+          u_sqltext = _sqlStruct2text2.sql,
+          u_fields = _sqlStruct2text2.fields;
+        union_fields.push(u_fields);
+        sql += "".concat(it.union, " ").concat(u_sqltext);
+      }
+    });
+  }
+  return {
+    sql: sql,
+    fields: fields,
+    union_fields: union_fields
+  };
+};
+/**
+ * 拼 sql
+ * @param {meta[]} data
+ * @param {boolean} indent 0 是第一次进来 非 0 是第N次进来
+ */
+var _sqlStruct2text3 = function sqlStruct2text(data) {
+  var indent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var db = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : procEnum.mysql;
+  var sql = '';
+  var hasInnerSql = data.hasInnerSql,
+    innerSqlStruct = data.innerSqlStruct,
+    alias = data.alias,
+    tableName = data.tableName,
+    tableSubQuery = data.tableSubQuery,
+    queryColumns = data.queryColumns,
+    joinTables = data.joinTables,
+    filters = data.filters,
+    orderInfos = data.orderInfos,
+    limit = data.limit,
+    customColumns = data.customColumns,
+    groupBy = data.groupBy;
+  sql += "SELECT ";
+  var firstEntry = !indent;
+  // -------- 处理 fields --------
+  // 情况一、一层 带聚合  字段是 聚合字段
+  // 情况二、一层 不带聚合  字段是 主表和关联表的字段
+  // 情况三、二层 带聚合 第一层 聚合字段 + 关联表字段 第二层 聚合字段  第三层 聚合字段
+  var flag = false; // 是否加逗号
+  if (limit && db === procEnum.sqlserver) {
+    sql += "TOP(".concat(limit, ") ");
+  }
+  if (hasInnerSql) {
+    // 情况三  innerSqlStruct.queryColumns 是内层 聚合输出的字段,这种字段虽说是内层的，但是其实外层也需要
+    if (innerSqlStruct.queryColumns && innerSqlStruct.queryColumns.length) {
+      sql += innerSqlStruct.queryColumns.map(function (v) {
+        return "".concat(alias, ".").concat(v.name, " as ").concat(v.name);
+      }).join(', ') + ' ';
+      flag = true;
+    }
+  } else {
+    if (Array.isArray(queryColumns) && queryColumns.length) {
+      // 情况一  queryColumns 是聚合字段
+      // 情况二  queryColumns 是主表字段
+      // 情况三  queryColumns 是聚合字段
+      flag = true;
+      sql += queryColumns.map(function (v) {
+        return v.field_sql;
+      }).join(', ') + ' ';
+    }
+  }
+  if (firstEntry && joinTables && !groupBy) {
+    // 情况二  joinTables 是关联表字段
+    // 情况三  joinTables 是关联表字段
+    joinTables.forEach(function (it) {
+      if (Array.isArray(it.queryColumns) && it.queryColumns.length) {
+        if (flag) {
+          sql += ', ';
+        }
+        sql += it.queryColumns.map(function (v) {
+          return v.field_sql;
+        }).join(', ') + ' ';
+        flag = true;
+      }
+    });
+  }
+  if (customColumns && customColumns.length) {
+    if (flag) {
+      sql += ', ';
+    }
+    sql += customColumns.map(function (v) {
+      return v.field_sql;
+    }).join(', ') + ' ';
+  }
+  // -------- 处理 main table --------
+  sql += 'FROM ';
+  var as = db === procEnum.oracle ? '' : 'AS ';
+  if (hasInnerSql) {
+    sql += "(".concat(_sqlStruct2text3(innerSqlStruct, indent + 1, db).sql, ") ").concat(as).concat(alias, " ");
+  } else {
+    if (tableSubQuery) {
+      // 子查询
+      sql += "(".concat(handleSqlUnion(tableSubQuery, db).sql, ") ").concat(as).concat(alias, " ");
+    } else {
+      sql += "".concat(tableName, " ").concat(as).concat(alias, " ");
+    }
+  }
+  // -------- 处理 left join --------
+  if (joinTables) {
+    joinTables.forEach(function (it) {
+      if (it.subQuery) {
+        // 子查询
+        sql += "".concat(it.joinType, " (").concat(handleSqlUnion(it.subQuery, db).sql, ") ").concat(as).concat(it.alias, " ").concat(it.joinCondition, " ");
+      } else {
+        sql += "".concat(it.joinType, " ").concat(it.tableName, " ").concat(as).concat(it.alias, " ").concat(it.joinCondition, " ");
+      }
+    });
+  }
+  // -------- 处理 where --------
+  if (filters) {
+    sql += "".concat(filters, " ");
+    if (limit && db === procEnum.oracle) {
+      if (filters) {
+        sql += "AND ROWNUM <= ".concat(limit, " ");
+      } else {
+        sql += "WHERE ROWNUM <= ".concat(limit, " ");
+      }
+    }
+  }
+  // -------- 处理 group by --------
+  if (Array.isArray(groupBy === null || groupBy === void 0 ? void 0 : groupBy.groupColumns) && groupBy.groupColumns.length) {
+    sql += "GROUP BY ".concat(groupBy.groupColumns.map(function (it) {
+      return it;
+    }).join(', '), " ");
+  }
+  // -------- 处理 orderby --------
+  if (orderInfos) {
+    sql += "".concat(orderInfos, " ");
+  }
+  // -------- 处理 limit --------
+  if (limit && db === procEnum.mysql) {
+    sql += "LIMIT ".concat(limit, " ");
+  }
+  // -------- 获取 字段列表 --------
+  var fields = [];
+  if (firstEntry) {
+    function addFields(data) {
+      var name = data.name,
+        name_zh = data.name_zh,
+        _data$id = data.id,
+        id = _data$id === void 0 ? '' : _data$id;
+      fields.push({
+        FIELD_ID: name,
+        FIELD_NAME: name_zh,
+        id: id
+      });
+    }
+    if (hasInnerSql) {
+      if (innerSqlStruct.queryColumns && innerSqlStruct.queryColumns.length) {
+        innerSqlStruct.queryColumns.map(function (v) {
+          return addFields(v);
+        });
+      }
+    } else {
+      if (Array.isArray(queryColumns) && queryColumns.length) {
+        queryColumns.map(function (v) {
+          return addFields(v);
+        });
+      }
+    }
+    if (joinTables && !groupBy) {
+      joinTables.forEach(function (it) {
+        if (Array.isArray(it.queryColumns) && it.queryColumns.length) {
+          it.queryColumns.map(function (v) {
+            return addFields(v);
+          });
+        }
+      });
+    }
+    if (customColumns && customColumns.length) {
+      customColumns.map(function (v) {
+        return addFields(v);
+      });
+    }
+  }
+  return {
+    sql: sql,
+    fields: fields
+  };
+};
+var transformSql = exports.transformSql = function transformSql(metas) {
+  var db = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : procEnum.mysql;
+  // let new_metas = upgradeLegacyData(metas);
+  var _handleSqlUnion = handleSqlUnion(metas, db),
+    sql = _handleSqlUnion.sql,
+    fields = _handleSqlUnion.fields,
+    union_fields = _handleSqlUnion.union_fields;
+  return {
+    sql: sql,
+    fields: fields,
+    union_fields: union_fields
+  };
+};