@gingkoo/pandora-metabase 1.0.14 → 1.0.16

package/lib/cjs/utils.js

@@ -81,20 +81,20 @@ var getSubColumns = exports.getSubColumns = function getSubColumns(metaList) {
   if (ExistAboveGroupBy) {
     var _prevGroupBy$group, _prevGroupBy$by;
     var _data = {
-      table: prevGroupBy.alias,
-      tableId: prevGroupBy.alias,
-      tableUuid: (0, _helper2.uuidv4)('table'),
       alias: prevGroupBy.alias,
+      name: prevGroupBy.alias,
+      name_zh: prevGroupBy.alias,
+      tableUuid: (0, _helper2.uuidv4)('table'),
+      id: prevGroupBy.alias,
       columns: []
     };
     if (prevGroupBy !== null && prevGroupBy !== void 0 && (_prevGroupBy$group = prevGroupBy.group) !== null && _prevGroupBy$group !== void 0 && _prevGroupBy$group.length) {
       _data.columns = _data.columns.concat(prevGroupBy.group.map(function (v) {
         var _v$sql;
-        return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({
-          name_zh: v.quotes
-        }, v), {}, {
-          name: v.fieldAlias || v.name,
-          fieldAlias: '',
+        return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, v), {}, {
+          name: v.name || v.quotes,
+          name_zh: v.name_zh || v.quotes,
+          id: v.id || v.fieldId,
           // fieldUuid: uuidv4('field'),
           realName: ((_v$sql = v.sql) === null || _v$sql === void 0 || (_v$sql = _v$sql.split(' AS ')) === null || _v$sql === void 0 ? void 0 : _v$sql[1]) || '',
           // name_zh: '',
@@ -107,12 +107,10 @@ var getSubColumns = exports.getSubColumns = function getSubColumns(metaList) {
     if (prevGroupBy !== null && prevGroupBy !== void 0 && (_prevGroupBy$by = prevGroupBy.by) !== null && _prevGroupBy$by !== void 0 && _prevGroupBy$by.length) {
       _data.columns = _data.columns.concat(prevGroupBy.by.map(function (v) {
         var _v$sql2;
-        return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({
-          name_zh: v.quotes
-        }, v), {}, {
-          name: v.fieldAlias || v.name,
-          fieldAlias: '',
-          // fieldUuid: uuidv4('field'),
+        return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, v), {}, {
+          name: v.name || v.quotes,
+          name_zh: v.name_zh || v.quotes,
+          id: v.id || v.fieldId,
           realName: ((_v$sql2 = v.sql) === null || _v$sql2 === void 0 || (_v$sql2 = _v$sql2.split(' AS ')) === null || _v$sql2 === void 0 ? void 0 : _v$sql2[1]) || '',
           // name_zh: '',
           database_type: (v === null || v === void 0 ? void 0 : v.database_type) || _enum.SQL_COLUMN_TYPE.FLOAT,
@@ -216,6 +214,46 @@ var getSubColumns = exports.getSubColumns = function getSubColumns(metaList) {
 // summarize = 'summarize',
 // sort = 'sort',
 // rowLimit = 'rowLimit',
+var AliasType;
+(function (AliasType) {
+  AliasType["table"] = "table";
+  AliasType["field"] = "field";
+})(AliasType || (AliasType = {}));
+// 修改别名
+var _changeAlias = function changeAlias(items, val, type) {
+  return items.map(function (v) {
+    if (v.type === _types.AtomsTypeEnum.JOIN_DEFAULT || v.type === _types.AtomsTypeEnum.EXPRESSION) {
+      return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, v), {}, {
+        lhs: _changeAlias(v.lhs, val, type),
+        rhs: _changeAlias(v.rhs, val, type)
+      });
+    } else if (v.type === _types.AtomsTypeEnum.FIELD) {
+      if (type === AliasType.table && v.tableUuid === val.uuid) {
+        v.tableAlias = val.alias;
+      }
+      if (type === AliasType.field && v.fieldUuid === val.uuid) {
+        v.fieldAlias = val.alias;
+      }
+      return v;
+    } else if (v.type === _types.AtomsTypeEnum.EXISTS || v.type === _types.AtomsTypeEnum.NOT_EXISTS) {
+      if (type === AliasType.table) {
+        v.notExists = changeTableAlias(v.notExists || [], {
+          tableUuid: val.uuid,
+          alias: val.alias
+        });
+      }
+      if (type === AliasType.field) {
+        v.notExists = changeFieldAlias(v.notExists || [], {
+          fieldUuid: val.uuid,
+          fieldAlias: val.alias
+        });
+      }
+      return v;
+    } else {
+      return v;
+    }
+  });
+};
 var changeTableAlias = exports.changeTableAlias = function changeTableAlias(list, curObj) {
   var _cloneDeep = (0, _cloneDeep3["default"])(curObj),
     tableUuid = _cloneDeep.tableUuid,
@@ -228,21 +266,29 @@ var changeTableAlias = exports.changeTableAlias = function changeTableAlias(list
       }
     }
     if (v.type === _enum.TypeEnum.joinData) {
+      var _v$expressions;
       if (v.table1.tableUuid === tableUuid) {
         v.table1.alias = alias;
       }
       if (v.table2.tableUuid === tableUuid) {
         v.table2.alias = alias;
       }
+      if (((_v$expressions = v.expressions) === null || _v$expressions === void 0 ? void 0 : _v$expressions.length) > 0) {
+        v.expressions = _changeAlias(v.expressions, {
+          uuid: tableUuid,
+          alias: alias
+        }, AliasType.table);
+      }
     }
     if (v.type === _enum.TypeEnum.customColumn) {
       v.customColumn.map(function (item) {
         var _item$formulaList;
-        (_item$formulaList = item.formulaList) === null || _item$formulaList === void 0 || _item$formulaList.map(function (formula) {
-          if (formula.expression && formula.expression.tableUuid === tableUuid) {
-            formula.expression.alias = alias;
-          }
-        });
+        if (item !== null && item !== void 0 && item.formulaList && ((_item$formulaList = item.formulaList) === null || _item$formulaList === void 0 ? void 0 : _item$formulaList.length) > 0) {
+          item.formulaList = _changeAlias(item.formulaList, {
+            uuid: tableUuid,
+            alias: alias
+          }, AliasType.table);
+        }
       });
     }
     if (v.type === _enum.TypeEnum.permissionTable) {
@@ -252,13 +298,13 @@ var changeTableAlias = exports.changeTableAlias = function changeTableAlias(list
     }
     if (v.type === _enum.TypeEnum.rowLimit) {}
     if (v.type === _enum.TypeEnum.sort) {
-      v.sort.map(function (sort) {
-        if (sort.alias === _helper.SummarizeAlias) {} else {
-          if (sort.tableUuid === tableUuid) {
-            sort.alias = alias;
-            sort.sql = "".concat(alias, ".").concat(sort.name);
-          }
-        }
+      v.sort = v.sort.map(function (sort) {
+        return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, sort), {}, {
+          expression: _changeAlias(sort.expression, {
+            uuid: tableUuid,
+            alias: alias
+          }, AliasType.table)
+        });
       });
     }
     if (v.type === _enum.TypeEnum.summarize) {
@@ -276,47 +322,12 @@ var changeTableAlias = exports.changeTableAlias = function changeTableAlias(list
       });
     }
     if (v.type === _enum.TypeEnum.filter) {
-      v.filter.map(function (item) {
-        if (item.tableUuid === tableUuid) {
-          // if (item.alias === SummarizeAlias) {
-          //   //有groupBy 特殊处理
-          //   const { prevGroupBy } = getHelper(list, v);
-          //   let groupBy: any =
-          //     prevGroupBy?.by.filter((v) => v.fieldUuid === item.fieldUuid)[0] ||
-          //     prevGroupBy?.group.filter((v) => v.fieldUuid === item.fieldUuid)[0] ||
-          //     null;
-          //   groupBy.alias = alias;
-          //   const sql = groupBy.sql;
-          //   if (groupBy) {
-          //     item.sql = sql;
-          //     item.groupSql = sql;
-          //   }
-          // }
-          item.alias = alias;
-          item.sql = '';
-        }
-        if (item.table2 && item.table2.tableUuid === tableUuid) {
-          // if (item.table2.alias === SummarizeAlias) {
-          //   //有groupBy 特殊处理
-          //   const { prevGroupBy } = getHelper(list, v);
-          //   let groupBy: any =
-          //     prevGroupBy?.by.filter((v) => v.fieldUuid === item.table2?.fieldUuid)[0] ||
-          //     prevGroupBy?.group.filter((v) => v.fieldUuid === item.table2?.fieldUuid)[0] ||
-          //     null;
-          //   groupBy.alias = alias;
-          //   const sql = groupBy.sql;
-          //   if (groupBy) {
-          //     item.table2.sql = sql;
-          //     item.table2.groupSql = sql;
-          //   }
-          // }
-          item.table2.alias = alias;
-          // item.table2.sql = '';
-        }
-        // if (item.subquery) {
-        //   item.subquery = changeTableAlias(item.subquery || [], curObj);
-        // }
-      });
+      if (v.filter && v.filter.length > 0) {
+        v.filter = _changeAlias(v.filter, {
+          uuid: tableUuid,
+          alias: alias
+        }, AliasType.table);
+      }
     }
     // if ((v as MetaData | MetaJoin).subquery) {
     //   (v as MetaData | MetaJoin).subquery = changeTableAlias(
@@ -327,136 +338,66 @@ var changeTableAlias = exports.changeTableAlias = function changeTableAlias(list
     return v;
   })) || [];
 };
-var _changeFieldAlias = exports.changeFieldAlias = function changeFieldAlias(list, curObj) {
+var changeFieldAlias = exports.changeFieldAlias = function changeFieldAlias(list, curObj) {
   var _cloneDeep2 = (0, _cloneDeep3["default"])(curObj),
-    fieldUuid = _cloneDeep2.fieldUuid,
-    fieldAlias = _cloneDeep2.fieldAlias;
+    uuid = _cloneDeep2.fieldUuid,
+    alias = _cloneDeep2.fieldAlias;
   var newList = (0, _cloneDeep3["default"])(list);
   return (newList === null || newList === void 0 ? void 0 : newList.map(function (v) {
     if (v.type === _enum.TypeEnum.data) {}
     if (v.type === _enum.TypeEnum.joinData) {
-      var _v$expressions;
-      if (v.table1.fieldUuid === fieldUuid) {
-        v.table1.fieldAlias = fieldAlias;
+      if (v.expressions && v.expressions.length > 0) {
+        v.expressions = _changeAlias(v.expressions, {
+          uuid: uuid,
+          alias: alias
+        }, AliasType.field);
       }
-      if (v.table2.fieldUuid === fieldUuid) {
-        v.table2.fieldAlias = fieldAlias;
-      }
-      v.table1.fields.map(function (field) {
-        if (field.fieldUuid === fieldUuid) {
-          field.fieldAlias = fieldAlias;
-        }
-      });
-      v.table2.fields.map(function (field) {
-        if (field.fieldUuid === fieldUuid) {
-          field.fieldAlias = fieldAlias;
-        }
-      });
-      (_v$expressions = v.expressions) === null || _v$expressions === void 0 || _v$expressions.map(function (column) {
-        column.left_fields.map(function (field) {
-          if (field.fieldUuid === fieldUuid) {
-            field.fieldAlias = fieldAlias;
-          }
-        });
-        column.right_fields.map(function (field) {
-          if (field.fieldUuid === fieldUuid) {
-            field.fieldAlias = fieldAlias;
-          }
-        });
-        if ((column === null || column === void 0 ? void 0 : column.left_fieldUuid) === fieldUuid) {
-          column.left_fieldAlias = fieldAlias;
-        }
-        if ((column === null || column === void 0 ? void 0 : column.right_fieldUuid) === fieldUuid) {
-          column.right_fieldAlias = fieldAlias;
-        }
-      });
-      // if (v.table1.tableUuid === tableUuid) {
-      //   v.table1.alias = alias;
-      // }
     }
     if (v.type === _enum.TypeEnum.customColumn) {
       v.customColumn.map(function (item) {
-        var _item$formulaList2;
-        (_item$formulaList2 = item.formulaList) === null || _item$formulaList2 === void 0 || _item$formulaList2.map(function (formula) {
-          if (formula.expression && formula.expression.fieldUuid === fieldUuid) {
-            formula.expression.fieldAlias = fieldAlias;
-          }
-        });
+        if (item.formulaList && item.formulaList.length > 0) {
+          item.formulaList = _changeAlias(item.formulaList, {
+            uuid: uuid,
+            alias: alias
+          }, AliasType.field);
+        }
       });
     }
-    // if (v.type === TypeEnum.permissionTable) {
-    //   if (v.table.tableUuid === tableUuid) {
-    //     v.table.alias = alias;
-    //   }
-    // }
     if (v.type === _enum.TypeEnum.rowLimit) {}
-    // if (v.type === TypeEnum.sort) {
-    //   v.sort.map((sort) => {
-    //     if (sort.alias === SummarizeAlias) {
-    //     } else {
-    //       if (sort.tableUuid === tableUuid) {
-    //         sort.alias = alias;
-    //         sort.sql = `${alias}.${sort.name}`;
-    //       }
-    //     }
-    //   });
-    // }
     if (v.type === _enum.TypeEnum.summarize) {
       v.group.map(function (group) {
-        if (group.fieldUuid === fieldUuid) {
-          group.fieldAlias = fieldAlias;
+        if (group.fieldUuid === uuid) {
+          group.fieldAlias = alias;
           group.sql = (0, _helper.summarizeToSql)(v.group, group).sql;
         }
       });
       v.by.map(function (by) {
-        if (by.fieldUuid === fieldUuid) {
-          by.fieldAlias = fieldAlias;
+        if (by.fieldUuid === uuid) {
+          by.fieldAlias = alias;
           by.sql = "".concat(by.alias, ".").concat(by.realName || by.name);
         }
       });
     }
     if (v.type === _enum.TypeEnum.filter) {
-      v.filter.map(function (item) {
-        if (item.fieldUuid === fieldUuid) {
-          item.fieldAlias = fieldAlias;
-          if (item.alias === _helper.SummarizeAlias) {
-            //有groupBy 特殊处理
-            var _getHelper2 = getHelper(list, v),
-              prevGroupBy = _getHelper2.prevGroupBy;
-            var groupBy = (prevGroupBy === null || prevGroupBy === void 0 ? void 0 : prevGroupBy.by.filter(function (v) {
-              return v.fieldUuid === item.fieldUuid;
-            })[0]) || (prevGroupBy === null || prevGroupBy === void 0 ? void 0 : prevGroupBy.group.filter(function (v) {
-              return v.fieldUuid === item.fieldUuid;
-            })[0]) || null;
-            if (groupBy) {
-              groupBy.fieldAlias = fieldAlias;
-              var sql = groupBy.sql;
-              item.sql = sql;
-              item.groupSql = sql;
-            }
-          }
-        }
-        if (item.table2 && item.table2.fieldUuid === fieldUuid) {
-          item.table2.fieldAlias = fieldAlias;
-          // if (item.table2.alias === SummarizeAlias) {
-          //   //有groupBy 特殊处理
-          //   const { prevGroupBy } = getHelper(list, v);
-          //   let groupBy: any =
-          //     prevGroupBy?.by.filter((v) => v.fieldUuid === item.table2?.fieldUuid)[0] ||
-          //     prevGroupBy?.group.filter((v) => v.fieldUuid === item.table2?.fieldUuid)[0] ||
-          //     null;
-          //   groupBy.fieldAlias = fieldAlias;
-          //   const sql = groupBy.sql;
-          //   if (groupBy) {
-          //     item.table2.sql = sql;
-          //     item.table2.groupSql = sql;
-          //   }
-          // }
-        }
-        if (item.notExists) {
-          item.notExists = _changeFieldAlias(item.notExists || [], curObj);
-        }
-      });
+      if (v.filter && v.filter.length > 0) {
+        console.log(v.filter);
+        v.filter = _changeAlias(v.filter, {
+          uuid: uuid,
+          alias: alias
+        }, AliasType.field);
+      }
+    }
+    if (v.type === _enum.TypeEnum.sort) {
+      if (v.sort && v.sort.length > 0) {
+        v.sort = v.sort.map(function (sort) {
+          return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, sort), {}, {
+            expression: _changeAlias(sort.expression, {
+              uuid: uuid,
+              alias: alias
+            }, AliasType.field)
+          });
+        });
+      }
     }
     return (0, _objectSpread2["default"])({}, v);
   })) || [];
@@ -586,7 +527,7 @@ var buildSqlQuery = exports.buildSqlQuery = function buildSqlQuery() {
   var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   var type = arguments.length > 1 ? arguments[1] : undefined;
   if (!data || data.length === 0) return '';
-  var name = type === _types.Filter_TypeEnum.EXISTS ? 'EXISTS' : 'NOT EXISTS';
+  var name = type === _types.AtomsTypeEnum.EXISTS ? 'EXISTS' : 'NOT EXISTS';
   var sqlClauses = ["".concat(name, " (")];
   var tables = [];
   var joins = [];
@@ -605,29 +546,53 @@ var buildSqlQuery = exports.buildSqlQuery = function buildSqlQuery() {
       var alias2 = _meta.table2.alias ? " AS ".concat(_meta.table2.alias) : '';
       var table2 = "".concat(_meta.table2.alias || _meta.table2.name);
       var table1 = "".concat(_meta.table1.alias || _meta.table1.name);
-      joins.push("LEFT JOIN ".concat(table2Name).concat(alias2, " ON ").concat(table1, ".").concat(_meta.table1.fieldAlias, " = ").concat(table2, ".").concat(_meta.table2.fieldAlias));
+      joins.push("LEFT JOIN ".concat(table2Name).concat(alias2, " ON "));
       if (Array.isArray(item.expressions) && ((_item$expressions = item.expressions) === null || _item$expressions === void 0 ? void 0 : _item$expressions.length) > 0) {
         var _item$expressions2;
         (_item$expressions2 = item.expressions) === null || _item$expressions2 === void 0 || _item$expressions2.forEach(function (expression) {
           var left = '',
             right = '';
-          if (expression.left_type === 'field') {
-            left = "".concat(table1, ".").concat(expression.left_fieldAlias);
-          } else {
-            left = expression.left_string;
-          }
-          if (expression.right_type === 'field') {
-            right = "".concat(table2, ".").concat(expression.right_fieldAlias);
-          } else {
-            right = expression.right_string;
+          if (expression.type === _types.AtomsTypeEnum.JOIN_DEFAULT) {
+            if (expression.lhs[0].type === _types.AtomsTypeEnum.FIELD) {
+              left = expression.lhs.map(function (v) {
+                if (v.type === _types.AtomsTypeEnum.FIELD) {
+                  return v.fieldName;
+                } else {
+                  return '';
+                }
+              }).join(' || ');
+            } else if (expression.lhs[0].type === _types.AtomsTypeEnum.CONSTANT || expression.lhs[0].type === _types.AtomsTypeEnum.INPUT_STRING) {
+              left = expression.lhs[0].val;
+            }
+            if (expression.rhs[0].type === _types.AtomsTypeEnum.FIELD) {
+              right = expression.rhs.map(function (v) {
+                if (v.type === _types.AtomsTypeEnum.FIELD) {
+                  return v.fieldName;
+                } else {
+                  return '';
+                }
+              }).join(' || ');
+            } else if (expression.rhs[0].type === _types.AtomsTypeEnum.CONSTANT || expression.rhs[0].type === _types.AtomsTypeEnum.INPUT_STRING) {
+              right = expression.rhs[0].val;
+            }
           }
-          joins.push("AND ".concat(left, " = ").concat(right));
+          joins.push("".concat(left, " = ").concat(right));
         });
       }
     }
     if (item.type === _enum.TypeEnum.filter) {
       var filterStrings = item.filter.map(function (f) {
-        return f.quotes;
+        if (f.type === _types.AtomsTypeEnum.FIELD) {
+          return f.fieldName;
+        } else if (f.type === _types.AtomsTypeEnum.EXPRESSION || f.type === _types.AtomsTypeEnum.EXISTS || f.type === _types.AtomsTypeEnum.NOT_EXISTS) {
+          return f.quotes;
+        } else if (f.type === _types.AtomsTypeEnum.JOIN_DEFAULT) {
+          return '';
+        } else if (f.type === _types.AtomsTypeEnum.INPUT_NUMBER || f.type === _types.AtomsTypeEnum.INPUT_NUMBER_LIST || f.type === _types.AtomsTypeEnum.INPUT_STRING_LIST) {
+          return '';
+        } else {
+          return f.val;
+        }
       }).filter(Boolean);
       if (filterStrings.length > 0) {
         wheres.push.apply(wheres, (0, _toConsumableArray2["default"])(filterStrings));

package/lib/es/common/SplitView/index.js

@@ -51,17 +51,17 @@ var SplitView = React.forwardRef(function (props, ref) {
     hMaximum = _useState8[0],
     setHMaximum = _useState8[1];
   var _useState9 = useState(false),
-    _useState10 = _slicedToArray(_useState9, 2),
-    vMinimum = _useState10[0],
-    setVMinimum = _useState10[1];
-  var _useState11 = useState(false),
+    _useState0 = _slicedToArray(_useState9, 2),
+    vMinimum = _useState0[0],
+    setVMinimum = _useState0[1];
+  var _useState1 = useState(false),
+    _useState10 = _slicedToArray(_useState1, 2),
+    vMaximum = _useState10[0],
+    setVMaximum = _useState10[1];
+  var _useState11 = useState(0),
     _useState12 = _slicedToArray(_useState11, 2),
-    vMaximum = _useState12[0],
-    setVMaximum = _useState12[1];
-  var _useState13 = useState(0),
-    _useState14 = _slicedToArray(_useState13, 2),
-    bottomHeight = _useState14[0],
-    setBottomHeight = _useState14[1];
+    bottomHeight = _useState12[0],
+    setBottomHeight = _useState12[1];
   React.useImperativeHandle(ref, function () {
     return {
       open: function open() {

package/lib/es/components/dialog/custom-column/expressions/suggest.js

@@ -114,7 +114,7 @@ var Suggest = /*#__PURE__*/function () {
                 type: OptionsTypeEnum.FUNCTION,
                 list: Object.keys(functions)
               }, {
-                name: __('customColumn.other'),
+                name: __('customColumn.operatorMore'),
                 type: OptionsTypeEnum.OTHER,
                 list: ['(']
               }]

package/lib/es/components/dialog/{select-filter → expression}/index.d.ts

@@ -2,12 +2,12 @@
  * 关联模块 选择表字段
  */
 import './index.less';
-import { MetaFilter_Item } from '../../../store/types';
-import { DataType } from '../select-join-column';
+import { AtomsExpression } from '../../../store/types';
+import { DataType } from '../select-column-multiple';
 interface PropsType {
     data: DataType[];
-    value: MetaFilter_Item;
-    onChange: (reocrd: MetaFilter_Item) => void;
+    value: AtomsExpression;
+    onChange: (reocrd: AtomsExpression) => void;
     didUpdate?: Function;
     isCustom?: boolean;
     container?: any;