midway-fatcms 0.0.1-beta.1

package/src/libs/crud-pro/services/CrudProGenSqlCondition.ts

@@ -0,0 +1,373 @@
+import {SqlSegArg} from '../models/SqlSegArg';
+import {MixinUtils} from '../utils/MixinUtils';
+import {KeysOfConditions, SqlDbType} from '../models/keys';
+import {CommonException, Exceptions} from '../exceptions';
+import {ICompareCondition, IRequestCondition} from '../interfaces';
+import {TypeUtils} from '../utils/TypeUtils';
+import {SqlCfgModel} from "../models/SqlCfgModel";
+import {toSqlColumnName} from '../utils/sqlConvert/convertColumnName';
+
+const { equalsIgnoreCase, isEmpty, isNotEmpty } = MixinUtils;
+const { isBasicType, isNumber } = TypeUtils;
+
+const createFunc = (sqlCfg: SqlCfgModel) => {
+  return {
+    toSqlColumnName: (columnName: string): string => {
+      return toSqlColumnName(columnName, sqlCfg)
+    },
+    toMatchSqlColumnName: (columnName: string): string => {
+      const arr = columnName.split(',');
+      return arr
+        .map(s => toSqlColumnName(s.trim(), sqlCfg))
+        .join(',');
+    }
+  }
+}
+
+class ValueChecker {
+  checkBasicArrayAndNotEmpty(value0: any, message: string) {
+    // 不能为空
+    if (!value0 || !Array.isArray(value0) || value0.length === 0) {
+      throw new CommonException(Exceptions.REQUEST_PARAM_ERROR, message);
+    }
+
+    // 元素必须是基本数据类型
+    for (let i = 0; i < value0.length; i++) {
+      const value0Element = value0[i];
+      if (!TypeUtils.isBasicType(value0Element)) {
+        throw new CommonException(Exceptions.REQUEST_PARAM_ERROR, message);
+      }
+    }
+  }
+}
+
+function hasCompareKey(compare: string): boolean {
+  return KeysOfConditions.COMPARE_KEYS.has(compare);
+}
+
+const valueChecker = new ValueChecker();
+
+class CrudProGenSqlCondition {
+  private readonly sqlCfg: SqlCfgModel;
+  constructor(sqlCfg: SqlCfgModel) {
+    this.sqlCfg = sqlCfg;
+  }
+
+  generateCondition(condition: any): SqlSegArg {
+    if (isEmpty(condition)) {
+      return new SqlSegArg(' 1=1 ');
+    }
+    const sqlArgModel = this.generateByLogicalKey(condition);
+    const sql = ' 1=1 and ' + sqlArgModel.sql;
+    return new SqlSegArg(sql, sqlArgModel.args);
+  }
+
+  /**
+   * condition = {$or:[{name:'zhangsan'},{name:'lisi'},{age: {$gt:18}}],sex:1}
+   * where (name = 'zhangsan' or name = 'lisi' or age > 18) and sex = 1
+   * @param condition
+   * @private
+   */
+  private generateByLogicalKey(condition: IRequestCondition): SqlSegArg {
+    if (isEmpty(condition)) {
+      return null;
+    }
+    const { toSqlColumnName } = createFunc(this.sqlCfg);
+
+    const tmpSqlList = [];
+    const tmpArgList = [];
+
+    const keys = Object.keys(condition);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const value = condition[key];
+
+      if (!hasCompareKey(key)) {
+        // 第一层的key，不能是比较运算符。
+        // OR
+        if (equalsIgnoreCase(KeysOfConditions.$OR, key)) {
+          TypeUtils.assertJsonArray(value, Exceptions.REQUEST_OR_PARAM_MUST_ARRAY);
+
+          const a = this.generateByLogicalOR(value);
+          if (a != null) {
+            tmpSqlList.push(a.sql);
+            if (isNotEmpty(a.args)) {
+              tmpArgList.push(...a.args);
+            }
+          }
+        }
+
+        // AND
+        else if (TypeUtils.isBasicType(value)) {
+          tmpSqlList.push(toSqlColumnName(key) + '= ?');
+          tmpArgList.push(value);
+        } else {
+          // AND
+          const a = this.generateByCompareKey(key, value);
+
+          if (a != null) {
+            tmpSqlList.push(a.sql);
+            if (MixinUtils.isNotEmpty(a.args)) {
+              tmpArgList.push(...a.args);
+            }
+          }
+        }
+      }
+    }
+
+    if (isEmpty(tmpSqlList)) {
+      return null;
+    }
+
+    // const sql = "(" + StringUtils.join(tmpSqlList, " AND ") + ")";
+    const sql = '(' + tmpSqlList.join(' AND ') + ')';
+    return new SqlSegArg(sql, tmpArgList);
+  }
+
+  private generateByLogicalOR(jsonArray: IRequestCondition[]): SqlSegArg {
+    if (MixinUtils.isEmpty(jsonArray)) {
+      return null;
+    }
+
+    const tmpSqlList = [];
+    const tmpArgList = [];
+
+    for (let i = 0; i < jsonArray.length; i++) {
+      const jsonObject = jsonArray[i];
+      const a = this.generateByLogicalKey(jsonObject);
+      if (a != null) {
+        tmpSqlList.push(a.sql);
+        if (MixinUtils.isNotEmpty(a.args)) {
+          tmpArgList.push(...a.args);
+        }
+      }
+    }
+    const sql = '(' + tmpSqlList.join(' OR ') + ')';
+    return new SqlSegArg(sql, tmpArgList);
+  }
+
+  // 例如：
+  // {name:1, age:{"$gt":5, "$lt":10}, } ==>  name = 1 and (age > 5 and age < 10)
+  // {name:1, age:{"$nin":[1,2,3],"$lt":10} } ==>  name = 1 and (age not in (1,2,3) and age < 10)
+  // 比较运算符
+  private generateByCompareKey(key: string, map: ICompareCondition): SqlSegArg {
+    if (isEmpty(map)) {
+      return null;
+    }
+
+    const { toSqlColumnName, toMatchSqlColumnName } = createFunc(this.sqlCfg);
+
+    this.generateByCompareKeyCheckParam(key, map);
+
+    const tmpSqlList = [];
+    const tmpArgList = [];
+
+    let hasNoArgSql = false;
+    const compareSet = Object.keys(map);
+
+    for (let i = 0; i < compareSet.length; i++) {
+      const compare = compareSet[i];
+
+      if (hasCompareKey(compare)) {
+        const value0 = map[compare];
+
+        let tmpSql = '';
+
+        if (equalsIgnoreCase(KeysOfConditions.$NULL, compare)) {
+          tmpSql = `${toSqlColumnName(key)} is null `;
+          hasNoArgSql = true;
+        } else if (equalsIgnoreCase(KeysOfConditions.$NOT_NULL, compare)) {
+          tmpSql = `${toSqlColumnName(key)} is not null `;
+          hasNoArgSql = true;
+        } else if (equalsIgnoreCase(KeysOfConditions.$GT, compare)) {
+          tmpArgList.push(value0);
+          tmpSql = `${toSqlColumnName(key)} > ?`;
+        } else if (equalsIgnoreCase(KeysOfConditions.$GTE, compare)) {
+          tmpArgList.push(value0);
+          tmpSql = `${toSqlColumnName(key)} >= ?`;
+        } else if (equalsIgnoreCase(KeysOfConditions.$LT, compare)) {
+          tmpArgList.push(value0);
+          tmpSql = `${toSqlColumnName(key)} < ?`;
+        } else if (equalsIgnoreCase(KeysOfConditions.$LTE, compare)) {
+          tmpArgList.push(value0);
+          tmpSql = `${toSqlColumnName(key)} <= ?`;
+        } else if (equalsIgnoreCase(KeysOfConditions.$NE, compare)) {
+          tmpArgList.push(value0);
+          tmpSql = `${toSqlColumnName(key)} != ?`;
+        } else if (equalsIgnoreCase(KeysOfConditions.$IN, compare)) {
+          const array = [...value0];
+          if (isNotEmpty(array)) {
+            const pm = array.map(() => '?').join(',');
+            tmpSql = `${toSqlColumnName(key)} in (${pm})`;
+            tmpArgList.push(...array);
+          }
+        } else if (equalsIgnoreCase(KeysOfConditions.$NIN, compare)) {
+          const array = [...value0];
+          if (isNotEmpty(array)) {
+            const pm = array.map(() => '?').join(',');
+            tmpSql = `${toSqlColumnName(key)} not in (${pm})`;
+            tmpArgList.push(...array);
+          }
+        } else if (equalsIgnoreCase(KeysOfConditions.$LIKE, compare)) {
+          tmpArgList.push(value0);
+          tmpSql = `${toSqlColumnName(key)} COLLATE UTF8MB4_GENERAL_CI like concat(?, '%')`; // like前缀匹配
+
+          if (this.sqlCfg.sqlDdType === SqlDbType.postgres) {
+            tmpSql = `${toSqlColumnName(key)} like concat(?, '%')`; // like前缀匹配
+          }
+
+        } else if (equalsIgnoreCase(KeysOfConditions.$NOT_LIKE, compare)) {
+          tmpArgList.push(value0);
+          tmpSql = `${toSqlColumnName(key)} COLLATE UTF8MB4_GENERAL_CI not like concat(?, '%')`;
+
+
+          if (this.sqlCfg.sqlDdType === SqlDbType.postgres) {
+            tmpSql = `${toSqlColumnName(key)} not like concat(?, '%')`;
+          }
+
+        }
+
+
+        else if (equalsIgnoreCase(KeysOfConditions.$LIKE_INCLUDE, compare)) {
+          tmpArgList.push(value0);
+          tmpSql = `${toSqlColumnName(key)} COLLATE UTF8MB4_GENERAL_CI like concat('%', ?, '%')`; // like包含
+
+          if (this.sqlCfg.sqlDdType === SqlDbType.postgres) {
+            tmpSql = `${toSqlColumnName(key)} like concat('%', ?, '%')`; // like包含
+          }
+
+        } else if (equalsIgnoreCase(KeysOfConditions.$NOT_LIKE_INCLUDE, compare)) {
+          tmpArgList.push(value0);
+          tmpSql = `${toSqlColumnName(key)} COLLATE UTF8MB4_GENERAL_CI not like concat('%',?, '%')`;  // like不包含
+
+          if (this.sqlCfg.sqlDdType === SqlDbType.postgres) {
+            tmpSql = `${toSqlColumnName(key)} not like concat('%',?, '%')`;  // like不包含
+          }
+
+        }
+
+
+        else if (equalsIgnoreCase(KeysOfConditions.$MATCH, compare)) {
+          tmpArgList.push(value0);
+          tmpSql = `match(${toMatchSqlColumnName(key)}) against(?)`;
+        } else if (equalsIgnoreCase(KeysOfConditions.$MATCH_BOOL, compare)) {
+          tmpArgList.push(value0);
+          tmpSql = `match(${toMatchSqlColumnName(key)}) against( ? in boolean mode)`;
+        } else if (equalsIgnoreCase(KeysOfConditions.$RANGE, compare)) {
+          const array = [...value0];
+          if (isNotEmpty(array) && array.length === 2) {
+            tmpSql = `(${toSqlColumnName(key)} between ? and ? )`;
+            tmpArgList.push(...array);
+          }
+        }
+
+        tmpSqlList.push(tmpSql);
+      }
+    }
+
+    if (isEmpty(tmpArgList) && !hasNoArgSql) {
+      return null;
+    }
+
+    const sql = '( ' + tmpSqlList.join(' and ') + ' )';
+    return new SqlSegArg(sql, tmpArgList);
+  }
+
+  /**
+   * 参数校验
+   * @param key
+   * @param map
+   * @private
+   */
+  private generateByCompareKeyCheckParam(key: string, map: ICompareCondition) {
+    if (isEmpty(map)) {
+      return null;
+    }
+
+    const compareSet = Object.keys(map);
+
+    const throwCommonException = (name: string, type: string) => {
+      throw new CommonException(Exceptions.REQUEST_PARAM_ERROR, `${name}参数必须是${type}`);
+    };
+
+    for (let i = 0; i < compareSet.length; i++) {
+      const compare = compareSet[i];
+
+      if (hasCompareKey(compare)) {
+        const value0 = map[compare];
+
+        if (equalsIgnoreCase(KeysOfConditions.$GT, compare)) {
+          if (!isBasicType(value0)) {
+            throwCommonException(KeysOfConditions.$GT, '字符串、数字');
+          }
+        } else if (equalsIgnoreCase(KeysOfConditions.$GTE, compare)) {
+          if (!isBasicType(value0)) {
+            throwCommonException(KeysOfConditions.$GTE, '字符串、数字');
+          }
+        } else if (equalsIgnoreCase(KeysOfConditions.$LT, compare)) {
+          if (!isBasicType(value0)) {
+            throwCommonException(KeysOfConditions.$LT, '字符串、数字');
+          }
+        } else if (equalsIgnoreCase(KeysOfConditions.$LTE, compare)) {
+          if (!isBasicType(value0)) {
+            throwCommonException(KeysOfConditions.$LTE, '字符串、数字');
+          }
+        } else if (equalsIgnoreCase(KeysOfConditions.$NE, compare)) {
+          if (!isBasicType(value0)) {
+            throwCommonException(KeysOfConditions.$NE, '字符串、数字');
+          }
+        } else if (equalsIgnoreCase(KeysOfConditions.$IN, compare)) {
+          valueChecker.checkBasicArrayAndNotEmpty(value0, `操作符${compare}的参数必须是一个非空数组，且元素是基本数据类型（数字、字符串）`);
+        } else if (equalsIgnoreCase(KeysOfConditions.$NIN, compare)) {
+          valueChecker.checkBasicArrayAndNotEmpty(value0, `操作符${compare}的参数必须是一个非空数组，且元素是基本数据类型（数字、字符串）`);
+        } else if (equalsIgnoreCase(KeysOfConditions.$LIKE, compare)) {
+          if (!isBasicType(value0)) {
+            throwCommonException(KeysOfConditions.$LIKE, '字符串');
+          }
+        } else if (equalsIgnoreCase(KeysOfConditions.$NOT_LIKE, compare)) {
+          if (!isBasicType(value0)) {
+            throwCommonException(KeysOfConditions.$NOT_LIKE, '字符串');
+          }
+        }
+
+
+        else if (equalsIgnoreCase(KeysOfConditions.$LIKE_INCLUDE, compare)) {
+          if (!isBasicType(value0)) {
+            throwCommonException(KeysOfConditions.$LIKE_INCLUDE, '字符串');
+          }
+        } else if (equalsIgnoreCase(KeysOfConditions.$NOT_LIKE_INCLUDE, compare)) {
+          if (!isBasicType(value0)) {
+            throwCommonException(KeysOfConditions.$NOT_LIKE_INCLUDE, '字符串');
+          }
+        }
+
+
+        else if (equalsIgnoreCase(KeysOfConditions.$MATCH, compare)) {
+          if (!isBasicType(value0)) {
+            throwCommonException(KeysOfConditions.$MATCH, '字符串');
+          }
+        } else if (equalsIgnoreCase(KeysOfConditions.$MATCH_BOOL, compare)) {
+          if (!isBasicType(value0)) {
+            throwCommonException(KeysOfConditions.$MATCH_BOOL, '字符串');
+          }
+        } else if (equalsIgnoreCase(KeysOfConditions.$RANGE, compare)) {
+          valueChecker.checkBasicArrayAndNotEmpty(value0, `操作符${compare}的参数必须是一个非空数组，且元素是两个数字组成的数组`);
+
+          const array = [...value0];
+          if (isNotEmpty(array) && array.length === 2) {
+            for (let j = 0; j < array.length; j++) {
+              const arrayElement = array[j];
+              if (!isNumber(arrayElement)) {
+                throwCommonException(KeysOfConditions.$RANGE, '数组（两个数字）');
+              }
+            }
+          } else {
+            throwCommonException(KeysOfConditions.$RANGE, '数组（两个数字）');
+          }
+        }
+      }
+    }
+  }
+}
+
+export { CrudProGenSqlCondition };

package/src/libs/crud-pro/services/CrudProGenSqlService.ts

@@ -0,0 +1,202 @@
+import { CrudProServiceBase } from './CrudProServiceBase';
+import { CommonException, Exceptions } from '../exceptions';
+import { MixinUtils } from '../utils/MixinUtils';
+import {KeysOfSimpleSQL, KeysOfSqlResPicker, SqlDbType} from '../models/keys';
+import {RequestCfgModel} from "../models/RequestCfgModel";
+
+const { equalsIgnoreCase, isEmpty, isNotEmpty } = MixinUtils;
+
+class CrudProGenSqlService extends CrudProServiceBase {
+  public async generateSQLList() {
+    const exeCtx = this.getExecuteContext();
+    const reqCfg = exeCtx.getCfgModel();
+    const sqlSimpleName = reqCfg.sqlSimpleName;
+
+    // 简单模式
+    const isSimpleMode = isNotEmpty(sqlSimpleName) && sqlSimpleName.startsWith('SIMPLE_');
+
+    // 拼接简单模式的SQL
+    if (isSimpleMode) {
+      this.generateOriginSql();
+    }
+
+    await this.generateExecuteSql();
+  }
+
+  private generateOriginSql() {
+    const exeCtx = this.getExecuteContext();
+
+    const cfgModel = exeCtx.getCfgModel();
+    const simpleSqlName = cfgModel.sqlSimpleName;
+
+    // 只有当设置了simpleSqlName时，才启用内置的SQL生成
+    if (isEmpty(simpleSqlName)) {
+      return;
+    }
+
+    cfgModel.sqlCfgList = [];
+
+    let sql1 = null;
+    let sql2 = null;
+    let sql3 = null;
+    if (equalsIgnoreCase(KeysOfSimpleSQL.SIMPLE_QUERY, simpleSqlName)) {
+      sql1 = 'select @@columns from @@table where @@asWhere:condition @@orderBys @@offsetLimit';
+      cfgModel.addSqlCfgModel('rows', sql1);
+    } else if (equalsIgnoreCase(KeysOfSimpleSQL.SIMPLE_QUERY_ONE, simpleSqlName)) {
+      sql1 = 'select @@columns from @@table where @@asWhere:condition @@orderBys limit 1';
+      cfgModel.addSqlCfgModel('row', sql1, KeysOfSqlResPicker.RESULT_FIRST_ROW);
+    } else if (equalsIgnoreCase(KeysOfSimpleSQL.SIMPLE_QUERY_COUNT, simpleSqlName)) {
+      sql1 = 'select count(0) as total_count from @@table where @@asWhere:condition';
+
+      cfgModel.addSqlCfgModel('total_count', sql1, KeysOfSqlResPicker.RESULT_TOTAL_COUNT);
+    } else if (equalsIgnoreCase(KeysOfSimpleSQL.SIMPLE_QUERY_PAGE, simpleSqlName)) {
+      sql1 = 'select @@columns from @@table where @@asWhere:condition @@orderBys @@offsetLimit ';
+      sql2 = 'select count(0) as total_count from @@table where @@asWhere:condition';
+
+      cfgModel.addSqlCfgModel('rows', sql1);
+      cfgModel.addSqlCfgModel('total_count', sql2, KeysOfSqlResPicker.RESULT_TOTAL_COUNT);
+    } else if (equalsIgnoreCase(KeysOfSimpleSQL.SIMPLE_DELETE, simpleSqlName)) {
+      sql1 = this.generateOriginSqlForDelete(cfgModel);
+      cfgModel.addSqlCfgModel('affected', sql1, KeysOfSqlResPicker.UPDATE_RESULT);
+    } else if (equalsIgnoreCase(KeysOfSimpleSQL.SIMPLE_INSERT, simpleSqlName)) {
+      sql1 = this.generateOriginSqlForInsert(cfgModel);
+      cfgModel.addSqlCfgModel('affected', sql1, KeysOfSqlResPicker.UPDATE_RESULT);
+    } else if (equalsIgnoreCase(KeysOfSimpleSQL.SIMPLE_UPDATE, simpleSqlName)) {
+      sql1 = 'update @@table set @@asUpdate:data where @@asWhere:condition ';
+      cfgModel.addSqlCfgModel('affected', sql1, KeysOfSqlResPicker.UPDATE_RESULT);
+    } else if (equalsIgnoreCase(KeysOfSimpleSQL.SIMPLE_INSERT_ON_DUPLICATE_UPDATE, simpleSqlName)) {
+      sql1 = this.generateOriginSqlForDuplicateInsert(cfgModel);
+      cfgModel.addSqlCfgModel('affected', sql1, KeysOfSqlResPicker.UPDATE_RESULT);
+    } else if (equalsIgnoreCase(KeysOfSimpleSQL.SIMPLE_INSERT_OR_UPDATE, simpleSqlName)) {
+      sql1 = 'select count(0) as total_count from @@table where @@asWhere:condition ';
+      sql2 = 'insert into @@table ( @@asInsertKeys:data ) values( @@asInsertValues:data )';
+      sql3 = 'update @@table set @@asUpdate:data where @@asWhere:condition ';
+
+      const insertWhen2 = {
+        functionName: 'eq',
+        functionParams: [{ contextAsNumber: 'res.total_count' }, { constNumber: 0 }],
+      };
+      const updateWhen3 = {
+        functionName: 'gt',
+        functionParams: [{ contextAsNumber: 'res.total_count' }, { constNumber: 0 }],
+      };
+
+      cfgModel.addSqlCfgModel('total_count', sql1, KeysOfSqlResPicker.RESULT_TOTAL_COUNT);
+      cfgModel.addSqlCfgModel('insert_affected', sql2, KeysOfSqlResPicker.UPDATE_RESULT, insertWhen2);
+      cfgModel.addSqlCfgModel('update_affected', sql3, KeysOfSqlResPicker.UPDATE_RESULT, updateWhen3);
+    }
+
+    if (isEmpty(sql1)) {
+      throw new CommonException(Exceptions.CFG_NOT_SUPPORT_THE_SIMPLE_SQL, simpleSqlName);
+    }
+  }
+
+  /**
+   * 删除语句
+   * @param cfgModel
+   * @private
+   */
+  private generateOriginSqlForDelete(cfgModel: RequestCfgModel) : string {
+    if (cfgModel.sqlDdType === SqlDbType.postgres) {
+      return 'delete from @@table where @@asWhere:condition ';
+    }
+    if (cfgModel.sqlDdType === SqlDbType.sqlserver) {
+      return 'delete from @@table where @@asWhere:condition ';
+    }
+    return 'delete from @@table where @@asWhere:condition limit 100 '; // 删除操作，不能一次性删除太多
+  }
+
+  /**
+   * 创建插入OR更新语句
+   * @param cfgModel
+   * @private
+   */
+  private generateOriginSqlForDuplicateInsert(cfgModel: RequestCfgModel) : string {
+    if (cfgModel.sqlDdType === SqlDbType.postgres) {
+      const uniqueColumn = cfgModel.uniqueColumn ; // id
+      if (!Array.isArray(uniqueColumn) || uniqueColumn.length === 0) {
+        throw new CommonException(Exceptions.CFG_ERROR_POSTGRES_UNIQUE_COLUMNS_NULL)
+      }
+      const unique_column = uniqueColumn.map((s)=>{
+        return `"${s}"`;
+      }).join(",")
+      return `insert into @@table ( @@asInsertKeys:data ) values( @@asInsertValues:data ) ON CONFLICT (${unique_column}) DO UPDATE set @@asUpdate:data `; // 关键字的前后，必须有空格
+    }
+
+
+    if (cfgModel.sqlDdType === SqlDbType.sqlserver) {
+      const uniqueColumn = cfgModel.uniqueColumn ; // id
+      if (uniqueColumn.length !== 1) {
+        throw new CommonException(Exceptions.CFG_UNIQUE_COLUMN_COUNT_MUST_ONE);
+      }
+
+      const uniqueColumnStr = uniqueColumn[0];
+      const uniqueColumnVal = "@@data." + uniqueColumnStr;
+
+      const sql = "" +
+        `IF EXISTS (SELECT 1 FROM @@table WHERE [${uniqueColumnStr}] = ${uniqueColumnVal})` +
+        "BEGIN\n" +
+        "    UPDATE @@table\n" +
+        "    SET @@asUpdate:data\n" +
+        `    WHERE [${uniqueColumnStr}] = ${uniqueColumnVal} ;\n` +
+        "END\n" +
+        "ELSE\n" +
+        "BEGIN\n" +
+        "    INSERT INTO @@table ( @@asInsertKeys:data )\n" +
+        "    VALUES ( @@asInsertValues:data );\n" +
+        "END";
+
+      return sql;
+    }
+
+
+    return 'insert into @@table ( @@asInsertKeys:data ) values( @@asInsertValues:data )  on duplicate key update @@asUpdate:data '; // 关键字的前后，必须有空格
+  }
+
+
+  /**
+   * 创建插入语句
+   * @param cfgModel
+   * @private
+   */
+  private generateOriginSqlForInsert(cfgModel: RequestCfgModel): string {
+    if (cfgModel.sqlDdType === SqlDbType.postgres) {
+      return 'insert into @@table ( @@asInsertKeys:data ) values( @@asInsertValues:data ) RETURNING * ';
+    }
+    if (cfgModel.sqlDdType === SqlDbType.sqlserver) {
+      return 'insert into @@table ( @@asInsertKeys:data ) OUTPUT INSERTED.* values( @@asInsertValues:data ) ';
+    }
+    return 'insert into @@table ( @@asInsertKeys:data ) values( @@asInsertValues:data )'; // 关键字的前后，必须有空格
+  }
+
+
+
+
+  private async generateExecuteSql() {
+    const exeCtx = this.getExecuteContext();
+
+    const reqCfgModel = exeCtx.getCfgModel();
+    const sqlCfgList = reqCfgModel.sqlCfgList || [];
+    const { sqlTable, sqlSchema, sqlDatabase, sqlDdType, maxLimit, columns, columnsRelation } = reqCfgModel;
+
+    for (let i = 0; i < sqlCfgList.length; i++) {
+      const sqlCfgModel = sqlCfgList[i];
+
+      sqlCfgModel.sqlDdType = MixinUtils.selectNotEmpty(sqlCfgModel.sqlDdType, sqlDdType);
+      sqlCfgModel.sqlDatabase = MixinUtils.selectNotEmpty(sqlCfgModel.sqlDatabase, sqlDatabase);
+      sqlCfgModel.sqlSchema = MixinUtils.selectNotEmpty(sqlCfgModel.sqlSchema, sqlSchema);
+      sqlCfgModel.sqlTable = MixinUtils.selectNotEmpty(sqlCfgModel.sqlTable, sqlTable);
+      sqlCfgModel.maxLimit = MixinUtils.selectNotEmpty(sqlCfgModel.maxLimit, maxLimit);
+      sqlCfgModel.columns = MixinUtils.selectNotEmpty(sqlCfgModel.columns, columns);
+      sqlCfgModel.columnsRelation = MixinUtils.selectNotEmpty(sqlCfgModel.columnsRelation, columnsRelation);
+
+      await this.serviceHub.convertOriginToExecuteSql(sqlCfgModel);
+
+      exeCtx.getSqlCfgModels().push(sqlCfgModel);
+    }
+  }
+
+
+}
+
+export { CrudProGenSqlService };