@gingkoo/pandora-metabase 1.0.117 → 1.0.119

package/lib/es/locale/zh.js

@@ -62,6 +62,11 @@ export default register('zh', {
   'customColumn.cancel': '取消',
   'customColumn.somethingAwesomeToDocument': '一些超棒的、值得记录的东西',
   'customColumn.expression': '表达式',
+  'customColumn.caseWhen': 'CASE WHEN',
+  'customColumn.andOr': 'AND / OR',
+  'customColumn.logicStart': '逻辑开始',
+  'customColumn.caseCondition': '判断',
+  'customColumn.caseResult': '结果',
   'customColumn.selectField': '选择列',
   'customColumn.selectOperator': '选择操作符',
   'customColumn.pleaseSelect': '请选择',

package/lib/es/sql-formula.js

@@ -1,4 +1,3 @@
-// 自定义列函数 tips
 export var functions = {
   abs: {
     tip: 'abs(列)',

package/lib/es/store/enum.d.ts

@@ -5,7 +5,7 @@ export declare enum SortEnum {
 export declare enum TypeEnum {
     data = "data",
     joinData = "joinData",
-    permissionTable = "permissionTable",// 权限表
+    permissionTable = "permissionTable",
     customColumn = "customColumn",
     filter = "filter",
     summarize = "summarize",
@@ -44,13 +44,13 @@ export declare enum SQL_GROUP_TYPE {
     DATE = "date"
 }
 export declare enum DataTypeEnum {
-    float = "float",// 小数
-    string = "string",// 字符
-    date = "date",// 日期
-    long = "long",// 整数
+    float = "float",
+    string = "string",
+    date = "date",
+    long = "long",
     currency = "currency"
 }
 export declare enum EleComponentEnum {
-    text = "text",// 文本框
+    text = "text",
     select = "select"
 }

package/lib/es/store/enum.js

@@ -45,24 +45,12 @@ export var SQL_COLUMN_TYPE;
   SQL_COLUMN_TYPE["LONG"] = "LONG";
   SQL_COLUMN_TYPE["CURRENCY"] = "CURRENCY";
 })(SQL_COLUMN_TYPE || (SQL_COLUMN_TYPE = {}));
-// 之前的 SQL_COLUMN_TYPE
-// export enum SQL_COLUMN_TYPE {
-//   BIGINT = 'BIGINT',
-//   SMALLINT = 'SMALLINT',
-//   DOUBLE = 'DOUBLE',
-//   INTEGER = 'INTEGER',
-//   CLOB = 'CLOB',
-//   CHAR = 'CHAR',
-//   VARCHAR = 'VARCHAR',
-//   TIMESTAMP = 'TIMESTAMP',
-// }
 export var SQL_GROUP_TYPE;
 (function (SQL_GROUP_TYPE) {
   SQL_GROUP_TYPE["NUMBER"] = "number";
   SQL_GROUP_TYPE["STRING"] = "string";
   SQL_GROUP_TYPE["DATE"] = "date";
 })(SQL_GROUP_TYPE || (SQL_GROUP_TYPE = {}));
-// 字段数据类型
 export var DataTypeEnum;
 (function (DataTypeEnum) {
   DataTypeEnum["float"] = "float";
@@ -71,7 +59,6 @@ export var DataTypeEnum;
   DataTypeEnum["long"] = "long";
   DataTypeEnum["currency"] = "currency";
 })(DataTypeEnum || (DataTypeEnum = {}));
-// 字段控件类型
 export var EleComponentEnum;
 (function (EleComponentEnum) {
   EleComponentEnum["text"] = "text";

package/lib/es/store/helper.d.ts

@@ -1,8 +1,9 @@
-import { MetaListType, MetaSummarize_Group } from './types';
+import { MetaListType, MetaSummarize_Group, MetaSummarize_By } from './types';
 export declare const SummarizeAlias = "source";
 export declare const summarizeToSql: (arr: MetaSummarize_Group[], record: MetaSummarize_Group) => {
     sql: string;
     fieldAlias: string;
 };
+export declare const summarizeByToSql: (record: MetaSummarize_By) => string;
 export declare const compressionStructure: (data: MetaListType[]) => string;
 export declare const restoreStructure: (data: string) => MetaListType[];

package/lib/es/store/helper.js

@@ -2,120 +2,14 @@ import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 var _excluded = ["children"],
   _excluded2 = ["metaKey"];
-// import { SummarizeAlias } from './index';
 import { TypeEnum, SQL_COLUMN_TYPE } from './enum';
+import { handleBaseType2Sql } from '../utils/transformSql';
 export var SummarizeAlias = 'source';
 var NUMBER_GROUP = [SQL_COLUMN_TYPE.FLOAT, SQL_COLUMN_TYPE.LONG, SQL_COLUMN_TYPE.CURRENCY];
 var STRING_GROUP = [SQL_COLUMN_TYPE.STRING];
 var DATE_GROUP = [SQL_COLUMN_TYPE.DATE];
-// 过滤器对象转sql语句
-// export const filterToSql = (record: AtomsItem): string => {
-//   let { alias, name, condition, val, groupSql, database_type } = record;
-//   let [condition_1, condition_2] = val;
-//   let columnName: string;
-//   if (alias === SummarizeAlias) {
-//     columnName = `${alias}.${groupSql?.split(' AS ')?.[1] || ''}`;
-//   } else {
-//     columnName = `${alias}.${name}`;
-//   }
-//   let sql: string = '';
-//   let group: SQL_GROUP_TYPE = SQL_GROUP_TYPE.STRING;
-//   if (~NUMBER_GROUP.indexOf(database_type as SQL_COLUMN_TYPE)) {
-//     group = SQL_GROUP_TYPE.NUMBER;
-//   }
-//   if (~DATE_GROUP.indexOf(database_type as SQL_COLUMN_TYPE)) {
-//     group = SQL_GROUP_TYPE.DATE;
-//   }
-//   if (group === SQL_GROUP_TYPE.STRING) {
-//     switch (condition) {
-//       // string
-//       case '是':
-//         sql = `${columnName} = '${condition_1}'`;
-//         break;
-//       case '不是':
-//         sql = `${columnName} <> '${condition_1}'`;
-//         break;
-//       case '包含':
-//         sql = `(${columnName} like '%${condition_1}%')`;
-//         break;
-//       case '不包含':
-//         sql = `(NOT ${columnName} like '%${condition_1}%')`;
-//         break;
-//       case '为空':
-//         sql = `${columnName} IS NULL`;
-//         break;
-//       case '不为空':
-//         sql = `${columnName} IS NOT NULL`;
-//         break;
-//       case '以...开始':
-//         sql = `(${columnName} like '${condition_1}%')`;
-//         break;
-//       case '以...结束':
-//         sql = `(${columnName} like '%${condition_1}')`;
-//         break;
-//     }
-//   }
-//   if (group === SQL_GROUP_TYPE.NUMBER) {
-//     switch (condition) {
-//       // number
-//       case '等于':
-//         sql = `${columnName} = ${condition_1}`;
-//         break;
-//       case '不等于':
-//         sql = `${columnName} <> ${condition_1}`;
-//         break;
-//       case '大于':
-//         sql = `${columnName} > ${condition_1}`;
-//         break;
-//       case '小于':
-//         sql = `${columnName} < ${condition_1}`;
-//         break;
-//       case '介于之间':
-//         sql = `${columnName} BETWEEN ${condition_1} AND ${condition_2}`;
-//         break;
-//       case '大于或等于':
-//         sql = `${columnName} >= ${condition_1}`;
-//         break;
-//       case '小于或等于':
-//         sql = `${columnName} <= ${condition_1}`;
-//         break;
-//       case '为空':
-//         sql = `${columnName} IS NULL`;
-//         break;
-//       case '不为空':
-//         sql = `${columnName} IS NOT NULL`;
-//         break;
-//     }
-//   }
-//   if (group === SQL_GROUP_TYPE.DATE) {
-//     function transformDate(dataStr: string) {
-//       return dataStr.replace(/-/g, '').replace(/:/g, '').replace(' ', '') + '00';
-//     }
-//     let c_1 = transformDate(condition_1 || '');
-//     let c_2 = transformDate(condition_2 || '');
-//     switch (condition) {
-//       // date
-//       case '早于':
-//         sql = `${columnName} < '${c_1}'`;
-//         break;
-//       case '晚于':
-//         sql = `${columnName} >= '${c_1}'`;
-//         break;
-//       case '介于之间':
-//         sql = `(${columnName} >= '${c_1}' AND ${columnName} < '${c_2}')`;
-//         break;
-//       case '是空的':
-//         sql = `${columnName} IS NULL`;
-//         break;
-//       case '不是空的':
-//         sql = `${columnName} IS NOT NULL`;
-//         break;
-//     }
-//   }
-//   return sql;
-// };
-// 聚合转sql语句
 export var summarizeToSql = function summarizeToSql(arr, record) {
+  var _record$atoms;
   var condition = record.condition,
     alias = record.alias,
     name = record.name,
@@ -126,6 +20,9 @@ export var summarizeToSql = function summarizeToSql(arr, record) {
   var sql = '';
   var as = '';
   var field = "".concat(alias, ".").concat(realName || name);
+  if ((_record$atoms = record.atoms) !== null && _record$atoms !== void 0 && _record$atoms.length && !['总行数', '累积行数'].includes(condition)) {
+    field = handleBaseType2Sql(record.atoms).sql.trim() || field;
+  }
   switch (condition) {
     case '总行数':
     case '累积行数':
@@ -182,10 +79,17 @@ export var summarizeToSql = function summarizeToSql(arr, record) {
   as = as + (count ? '_' + (count + 1) : '');
   return {
     sql: sql,
-    // + ' AS ' + as,
     fieldAlias: as
   };
 };
+export var summarizeByToSql = function summarizeByToSql(record) {
+  var _record$atoms2;
+  var sql = "".concat(record.alias, ".").concat(record.realName || record.name);
+  if ((_record$atoms2 = record.atoms) !== null && _record$atoms2 !== void 0 && _record$atoms2.length) {
+    sql = handleBaseType2Sql(record.atoms).sql.trim() || sql;
+  }
+  return sql;
+};
 var _flatArr2 = function _flatArr(data, arr) {
   var children = data.children,
     res = _objectWithoutProperties(data, _excluded);
@@ -201,18 +105,15 @@ var _recursionArr2 = function _recursionArr(arr) {
   }
   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 === TypeEnum.joinData) {
       if (res[meta.type]) {
         res[meta.type].push(meta);
@@ -220,15 +121,12 @@ var _layeredData = function layeredData(list) {
         res[meta.type] = [meta];
       }
     } else {
-      // @ts-ignore
       res[meta.type] = meta;
     }
     if (meta.type === TypeEnum.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 === TypeEnum.rowLimit) {
           res[nextMeta.type] = nextMeta;
@@ -256,115 +154,6 @@ var _layeredData = function layeredData(list) {
   }
   return res;
 };
-// 处理数据格式 - (这里才是真正处理成后端需要的格式 前面两步都是准备工作)
-// const handleNesting = (data: LooseObject): ParamsStruct => {
-//   let hasInnerSql = Boolean(data.children);
-//   let obj: ParamsStruct = {
-//     hasInnerSql,
-//     innerSqlStruct: hasInnerSql ? handleNesting(data.children as LooseObject) : null,
-//   };
-//   let tableData: MetaData | undefined = data[TypeEnum.data];
-//   let joinData: MetaJoin[] = data[TypeEnum.joinData] || [];
-//   let permissionTable: MetaPermissionTable | undefined = data[TypeEnum.permissionTable];
-//   let customColumn: MetaCustom | undefined = data[TypeEnum.customColumn];
-//   let filterData: MetaFilter | undefined = data[TypeEnum.filter];
-//   let summarize: MetaSummarize | undefined = data[TypeEnum.summarize];
-//   let sortData: MetaSort | undefined = data[TypeEnum.sort];
-//   let rowLimit: MetaLimit | undefined = data[TypeEnum.rowLimit];
-//   if (tableData) {
-//     obj.alias = tableData.table.alias;
-//     obj.tableName = tableData.table.name;
-//     obj.datasourceId = tableData.table.datasourceId;
-//     if (!summarize || (!summarize.group.length && !summarize.by.length)) {
-//       obj.queryColumns = tableData.columns
-//         .filter((v) => v.select)
-//         .map((v) => `${tableData?.table?.alias}.${v.name}`);
-//     }
-//   } else {
-//     if (!summarize || (!summarize.group.length && !summarize.by.length)) {
-//       obj.alias = SummarizeAlias;
-//     }
-//   }
-//   if (joinData.length) {
-//     obj.joinTables = joinData
-//       .filter((v) => v.table2.name)
-//       .map((v) => {
-//         let joinCondition: string;
-//         if (v.table1.alias === SummarizeAlias) {
-//           joinCondition = `ON ${SummarizeAlias}.${v.table1.groupSql} = ${v.table2.alias}.${v.table2.column}`;
-//         } else {
-//           joinCondition = `ON ${v.table1.alias}.${v.table1.column} = ${v.table2.alias}.${v.table2.column}`;
-//         }
-//         return {
-//           alias: v.table2.alias,
-//           tableName: v.table2.name,
-//           datasourceId: v.table2.datasourceId || '',
-//           joinCondition,
-//           joinType: v.joinType,
-//           queryColumns: v.columns.filter((o) => o.select).map((o) => `${v.table2.alias}.${o.name}`),
-//         };
-//       });
-//   }
-//   if (customColumn && customColumn.customColumn.length) {
-//     obj.customColumns = customColumn.customColumn.map((v) => {
-//       return {
-//         alias: v.name,
-//         // formula: v.formula.replace(/\[.*?\]/g, (column: string): string => {
-//         //   let str = column.substr(1, column.length - 2);
-//         //   if (~str.indexOf('->')) {
-//         //     let _str = str.replace(/ /g, '').split('->');
-//         //     return `${_str[0]}.${_str[1]}`;
-//         //   }
-//         //   return str;
-//         // }),
-//       };
-//     });
-//   }
-//   if (filterData && filterData.filter.length) {
-//     obj.filters = 'WHERE ' + filterData.filter.map((v) => filterToSql(v)).join(' AND ');
-//     if (permissionTable) {
-//       obj.filters += ` @{_DATA_I_PRIV_COND:${permissionTable.table.alias}}`;
-//     }
-//   }
-//   if (summarize && (summarize.group.length || summarize.by.length)) {
-//     obj.groupBy = {
-//       calcColumns: [],
-//       groupColumns: [],
-//     };
-//     let queryColumns: string[] = [];
-//     if (summarize.group.length) {
-//       obj.groupBy.calcColumns = summarize.group.map((v) => {
-//         return v.sql;
-//       });
-//       queryColumns = [...obj.groupBy.calcColumns];
-//     }
-//     if (summarize.by.length) {
-//       obj.groupBy.groupColumns = summarize.by.map((v) => {
-//         queryColumns.push(`${v.sql}`);
-//         return `${v.alias}.${v.realName || v.name}`;
-//       });
-//     }
-//     obj.queryColumns = queryColumns;
-//     if (!tableData) {
-//       obj.alias = summarize.alias;
-//     }
-//   }
-//   if (sortData && sortData.sort.length) {
-//     obj.orderInfos = `ORDER BY ${sortData.sort
-//       .map((v: MetaSort_Item) => `${v.sql} ${v.sort}`)
-//       .join(', ')}`;
-//   }
-//   if (rowLimit) {
-//     obj.limit = Number(rowLimit.limit);
-//   }
-//   if (permissionTable) {
-//     obj.privilegeTable = `@{_DATA_I_PRIV_COND:${permissionTable.table.alias}}`;
-//   }
-//   return obj;
-// };
-// export const handleSqlStruct = (list: MetaListType[]) =>
-//   handleNesting(reverseData(layeredData(list)));
-// 压缩结构
 export var compressionStructure = function compressionStructure(data) {
   var _data = JSON.parse(JSON.stringify(data)).map(function (v) {
     var metaKey = v.metaKey,

package/lib/es/store/types.d.ts

@@ -1,19 +1,19 @@
 import type { DatasourceType } from '../types';
 import { TypeEnum, SpecialType, JoinEnum, SQL_COLUMN_TYPE, SortEnum } from './enum';
 export declare enum FormulaTypeEnum {
-    CUSTOM = "custom",// 自定义表达式
-    FILTER = "filter",// 过滤器
-    FORMULA = "formula",// 公式
-    JOIN_DATA = "joinData",// 关联
+    CUSTOM = "custom",
+    FILTER = "filter",
+    FORMULA = "formula",
+    JOIN_DATA = "joinData",
     ALL = "all"
 }
 export declare enum ChangeType {
-    fieldAlias = "fieldAlias",// 修改字段别名
-    tableAlias = "tableAlias",// 修改字段别名
-    customColumn = "customColumn",// 自定义列
+    fieldAlias = "fieldAlias",
+    tableAlias = "tableAlias",
+    customColumn = "customColumn",
     formula = "formula",
-    field = "field",// 修改字段别名
-    expressions = "expressions",// expressions
+    field = "field",
+    expressions = "expressions",
     table1 = "table1",
     table2 = "table2",
     joinType = "joinType",
@@ -26,21 +26,23 @@ export declare enum ChangeType {
     group = "group"
 }
 export declare enum AtomsTypeEnum {
-    JOIN_DEFAULT = "joinDefault",// join默认
-    EXISTS = "exists",// notExists
-    NOT_EXISTS = "notExists",// notExists
-    FIELD = "field",// 字段
-    EXPRESSION = "expression",// 表达式
-    INPUT_STRING = "inputString",// 字符串输入框
-    INPUT_STRING_LIST = "inputStringList",// 字符串输入框
-    INPUT_NUMBER_LIST = "inputNumberList",// 数字输入框
-    INPUT_NUMBER = "inputNumber",// 数字输入框
-    CONSTANT = "constant",//  常量
-    OPERATOR = "operator",// 运算符
-    UNKNOWN = "unknown",//未选具体类型
-    SELECT = "select",// select 选择框
+    JOIN_DEFAULT = "joinDefault",
+    EXISTS = "exists",
+    NOT_EXISTS = "notExists",
+    FIELD = "field",
+    EXPRESSION = "expression",
+    CASE_WHEN = "caseWhen",
+    AND_OR = "andOr",
+    INPUT_STRING = "inputString",
+    INPUT_STRING_LIST = "inputStringList",
+    INPUT_NUMBER_LIST = "inputNumberList",
+    INPUT_NUMBER = "inputNumber",
+    CONSTANT = "constant",
+    OPERATOR = "operator",
+    UNKNOWN = "unknown",
+    SELECT = "select",
     FORMULA = "FORMULA",
-    SUB_QUERY = "subquery",// notExists
+    SUB_QUERY = "subquery",
     COLLECTION = "collection"
 }
 export interface AtomsSubQuery {
@@ -83,6 +85,23 @@ export interface AtomsExpression {
     formula?: Filter_Formula;
     type: AtomsTypeEnum.EXPRESSION;
 }
+export interface AtomsCaseWhenBranch {
+    when: AtomsItem[];
+    then: AtomsItem[];
+}
+export interface AtomsCaseWhen {
+    caseValue?: AtomsItem[];
+    branches: AtomsCaseWhenBranch[];
+    elseValue?: AtomsItem[];
+    quotes: string;
+    type: AtomsTypeEnum.CASE_WHEN;
+}
+export interface AtomsAndOr {
+    operator: 'and' | 'or';
+    list: AtomsItem[];
+    quotes: string;
+    type: AtomsTypeEnum.AND_OR;
+}
 export interface AtomsJoinDefault {
     lhs: AtomsItem[];
     condition: string;
@@ -151,7 +170,7 @@ export interface AtomsSelect {
     fixed?: boolean;
     type: AtomsTypeEnum.SELECT;
 }
-export type AtomsItem = AtomsSubQuery | AtomsNotExists | AtomsExists | AtomsJoinDefault | AtomsExpression | AtomsFormula | AtomsField | AtomsInputString | AtomsInputStringList | AtomsInputNumberList | AtomsInputNumber | AtomsOprator | AtomsConstant | AtomsUnknown | AtomsCollection | AtomsSelect;
+export type AtomsItem = AtomsSubQuery | AtomsNotExists | AtomsExists | AtomsJoinDefault | AtomsExpression | AtomsCaseWhen | AtomsAndOr | AtomsFormula | AtomsField | AtomsInputString | AtomsInputStringList | AtomsInputNumberList | AtomsInputNumber | AtomsOprator | AtomsConstant | AtomsUnknown | AtomsCollection | AtomsSelect;
 export type ToolbarType = TypeEnum | 'filter' | 'summarize' | 'joinData' | 'permissionTable' | 'customColumn' | 'sort' | 'rowLimit' | 'union';
 export type MetaListType = MetaData | MetaJoin | MetaCustom | MetaFilter | MetaSummarize | MetaSort | MetaLimit | MetaPermissionTable | MetaUnion;
 export type initColumnsType = MetaData_ColumnsType;
@@ -264,6 +283,7 @@ export interface MetaSummarize_Group {
     quotes: string;
     datasourceId: string;
     datasourceName: string;
+    atoms?: AtomsItem[];
     summarizeType: MetaSummarize_Enum;
     [params: string]: any;
 }
@@ -285,6 +305,7 @@ export interface MetaSummarize_By {
     database_type: SQL_COLUMN_TYPE | '';
     condition: string;
     quotes: string;
+    atoms?: AtomsItem[];
     summarizeType: MetaSummarize_Enum;
 }
 export interface MetaSummarize {
@@ -386,46 +407,3 @@ export interface FormulaTemplates {
     children: FormulaTemplatesItem[];
 }
 export {};
-/**
-let a = {
-  "idxId": "string",
-  "sqlStruct": {
-    "alias": "string",// 主表别名 只有最外层可以没有
-    "tableName": "string",// 主表名 除了最内层 都可以没有
-    "queryColumns": [
-      "string"// 第一层放 主表选择的字段，其他的放 groupby 的两个字段别名
-    ],
-    "groupBy": {// 聚合
-      "calcColumns": [// 左边
-        "string"
-      ],
-      "groupColumns": [// 右边
-        "string"
-      ]
-    },
-    "customColumns": [// 自定义列
-      {
-        "alias": "string",
-        "formula": "string"
-      }
-    ],
-    "filters": "string",// filter 用 on 分隔
-    "hasInnerSql": false,// 是否有嵌套
-    "innerSqlStruct": {},// 嵌套内容
-    "joinTables": [// 关联
-      {
-        "alias": "string",
-        "joinCondition": "a.a = b.b",
-        "joinType": "string",
-        "queryColumns": [
-          "string"
-        ],
-        "tableName": "string"
-      }
-    ],
-    "limit": 0,
-    "orderInfos": "string",
-    
-  },
-}
-*/

package/lib/es/store/types.js

@@ -1,4 +1,3 @@
-// 表达式类型
 export var FormulaTypeEnum;
 (function (FormulaTypeEnum) {
   FormulaTypeEnum["CUSTOM"] = "custom";
@@ -7,7 +6,6 @@ export var FormulaTypeEnum;
   FormulaTypeEnum["JOIN_DATA"] = "joinData";
   FormulaTypeEnum["ALL"] = "all";
 })(FormulaTypeEnum || (FormulaTypeEnum = {}));
-// 修改类型
 export var ChangeType;
 (function (ChangeType) {
   ChangeType["fieldAlias"] = "fieldAlias";
@@ -27,7 +25,6 @@ export var ChangeType;
   ChangeType["by"] = "by";
   ChangeType["group"] = "group";
 })(ChangeType || (ChangeType = {}));
-// 表达式类型
 export var AtomsTypeEnum;
 (function (AtomsTypeEnum) {
   AtomsTypeEnum["JOIN_DEFAULT"] = "joinDefault";
@@ -35,7 +32,8 @@ export var AtomsTypeEnum;
   AtomsTypeEnum["NOT_EXISTS"] = "notExists";
   AtomsTypeEnum["FIELD"] = "field";
   AtomsTypeEnum["EXPRESSION"] = "expression";
-  // FUNCTION = 'function', // 函数
+  AtomsTypeEnum["CASE_WHEN"] = "caseWhen";
+  AtomsTypeEnum["AND_OR"] = "andOr";
   AtomsTypeEnum["INPUT_STRING"] = "inputString";
   AtomsTypeEnum["INPUT_STRING_LIST"] = "inputStringList";
   AtomsTypeEnum["INPUT_NUMBER_LIST"] = "inputNumberList";
@@ -48,52 +46,8 @@ export var AtomsTypeEnum;
   AtomsTypeEnum["SUB_QUERY"] = "subquery";
   AtomsTypeEnum["COLLECTION"] = "collection";
 })(AtomsTypeEnum || (AtomsTypeEnum = {}));
-// ----------- 第五个模块 聚合模块 ------------
 export var MetaSummarize_Enum;
 (function (MetaSummarize_Enum) {
   MetaSummarize_Enum["GROUP"] = "group";
   MetaSummarize_Enum["BY"] = "by";
-})(MetaSummarize_Enum || (MetaSummarize_Enum = {}));
-/**
-let a = {
-  "idxId": "string",
-  "sqlStruct": {
-    "alias": "string",// 主表别名 只有最外层可以没有
-    "tableName": "string",// 主表名 除了最内层 都可以没有
-    "queryColumns": [
-      "string"// 第一层放 主表选择的字段，其他的放 groupby 的两个字段别名
-    ],
-    "groupBy": {// 聚合
-      "calcColumns": [// 左边
-        "string"
-      ],
-      "groupColumns": [// 右边
-        "string"
-      ]
-    },
-    "customColumns": [// 自定义列
-      {
-        "alias": "string",
-        "formula": "string"
-      }
-    ],
-    "filters": "string",// filter 用 on 分隔
-    "hasInnerSql": false,// 是否有嵌套
-    "innerSqlStruct": {},// 嵌套内容
-    "joinTables": [// 关联
-      {
-        "alias": "string",
-        "joinCondition": "a.a = b.b",
-        "joinType": "string",
-        "queryColumns": [
-          "string"
-        ],
-        "tableName": "string"
-      }
-    ],
-    "limit": 0,
-    "orderInfos": "string",
-    
-  },
-}
-*/
+})(MetaSummarize_Enum || (MetaSummarize_Enum = {}));

package/lib/es/types.d.ts

@@ -63,6 +63,7 @@ export interface MetabaseProps {
     getExistsError?: (params: MetaListType[]) => Promise<any[]>;
     operatorList?: any[];
     otherTypes?: any[];
+    popupZIndex?: number;
 }
 export interface OptionItem {
     value?: string;

package/lib/es/types.js

@@ -1,18 +1 @@
-export {};
-// {
-//   name: 'LENGTH', // 函数名
-//   args: [
-//     {
-//       type: 'field', // 参数类型
-//       check: 'string', // null 啥都可以， string 字符串， number 数字， (默认不传是 null)
-//     },
-//     {
-//       type: 'constant', // 参数类型
-//       check: null, // null 啥都可以， string 字符串， number 数字， (默认不传是 null)
-//     },
-//   ],
-//   arity: { max: 4 },
-//   output: 'number', // string | number| null  （默认是 null）
-//   description: '返回字符串的长度',
-//   example: 'LENGTH("hello")',
-// },
+export {};

package/lib/es/utils/cookies.js

@@ -1,9 +1,6 @@
-//获取指定名称的cookie值
 export function getCookie(name) {
-  // (^| )name=([^;]*)(;|$),match[0]为与整个正则表达式匹配的字符串，match[i]为正则表达式捕获数组相匹配的数组；
   var arr = document.cookie.match(new RegExp('(^| )' + name + '=([^;]*)(;|$)'));
   if (arr != null) {
-    console.log(arr);
     return arr[2];
   }
   return null;