midway-fatcms 0.0.5 → 0.0.7

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

@@ -201,7 +201,15 @@ class CrudProExecuteSqlService extends CrudProServiceBase {
   }
 
   private toQueryResByResPicker(rows: any[], originRes: any, sqlCfgModel: SqlCfgModel) {
-    const resPicker = sqlCfgModel.resPicker;
+    let resPicker = sqlCfgModel.resPicker;
+
+    // resPicker 未设置时，根据 SQL 类型自动推断
+    if (isEmpty(resPicker)) {
+      const crudType = sqlCfgModel.getCrudType();
+      if (crudType === KeyOfCrudTypes.INSERT || crudType === KeyOfCrudTypes.UPDATE || crudType === KeyOfCrudTypes.DELETE) {
+        resPicker = KeysOfSqlResPicker.UPDATE_RESULT;
+      }
+    }
 
     // 返回第一行
     if (KeysOfSqlResPicker.RESULT_FIRST_ROW === resPicker) {
@@ -220,6 +228,19 @@ class CrudProExecuteSqlService extends CrudProServiceBase {
       return Number(map0['total_count'] || 0);
     }
 
+    // 判断元素是否存在，返回 boolean
+    if (KeysOfSqlResPicker.RESULT_IS_EXIST === resPicker) {
+      if (isEmpty(rows) || rows.length === 0) {
+        return false;
+      }
+      const val = rows[0]['is_exist'];
+      // MySQL/SQLServer 返回 0/1，PostgreSQL 返回 false/true
+      if (typeof val === 'boolean') {
+        return val;
+      }
+      return Number(val) > 0;
+    }
+
     // 增删改res的内容是修改结果：包括： insert\delete\update
     if (KeysOfSqlResPicker.UPDATE_RESULT === resPicker) {
       if (sqlCfgModel.sqlDbType === SqlDbType.postgres) {
@@ -248,6 +269,8 @@ class CrudProExecuteSqlService extends CrudProServiceBase {
       return rows;
     }
 
+
+
     //其他配置：形如： sqlRes[0].total_count
     if (typeof resPicker === 'string') {
       if (resPicker.startsWith('sqlRes')) {

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

@@ -2,7 +2,7 @@ import { RequestModel } from '../models/RequestModel';
 import { CrudProServiceBase } from './CrudProServiceBase';
 import { RequestCfgModel } from '../models/RequestCfgModel';
 import { MixinUtils } from '../utils/MixinUtils';
-import { KeysOfConditions, KeysOfValidators } from '../models/keys';
+import { KeysOfConditions, KeysOfSimpleSQL, KeysOfValidators } from '../models/keys';
 import { CommonException, Exceptions } from '../exceptions';
 import { ModelUtils } from '../utils/ModelUtils';
 import { ICustomValidateFunc, IFuncCfgModel, IValidatorCfgItem } from '../interfaces';
@@ -175,6 +175,58 @@ class CrudProFieldValidateService extends CrudProServiceBase {
       }
     }
   }
+
+  /**
+   * 校验 data 字段类型是否符合 sqlSimpleName 的要求
+   * 
+   * - SIMPLE_BATCH_INSERT: data 必须是数组
+   * - 其他 INSERT/UPDATE 类型: data 必须是普通对象
+   */
+  validateDataType(cfgModel: RequestCfgModel, reqModel: RequestModel): void {
+    const sqlSimpleName = cfgModel.sqlSimpleName;
+    if (!sqlSimpleName) {
+      return;
+    }
+
+    const data = reqModel.data;
+
+    const isArrayData = Array.isArray(data);
+
+    if (sqlSimpleName === KeysOfSimpleSQL.SIMPLE_BATCH_INSERT) {
+      if (!isArrayData || data.length === 0) {
+        throw new CommonException(
+          Exceptions.CFG_INVALID_DATA_TYPE,
+          `${sqlSimpleName} 要求 data 必须是数组。并且不能为空数组。`
+        );
+      }
+      return;
+    }
+
+    const needsObjectData = [
+      KeysOfSimpleSQL.SIMPLE_INSERT,
+      KeysOfSimpleSQL.SIMPLE_UPDATE,
+      KeysOfSimpleSQL.SIMPLE_INSERT_ON_DUPLICATE_UPDATE,
+      KeysOfSimpleSQL.SIMPLE_INSERT_OR_UPDATE,
+    ].includes(sqlSimpleName as KeysOfSimpleSQL);
+
+
+    if(needsObjectData && (!data || Object.keys(data).length === 0)) {
+      throw new CommonException(
+        Exceptions.CFG_INVALID_DATA_TYPE,
+        `${sqlSimpleName} 要求 data 必须是对象，不能为空`
+      );
+    }
+
+    if (needsObjectData && isArrayData) {
+      throw new CommonException(
+        Exceptions.CFG_INVALID_DATA_TYPE,
+        `${sqlSimpleName} 要求 data 必须是普通对象，不能是数组`
+      );
+    }
+
+
+
+  }
 }
 
 export { CrudProFieldValidateService };

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

@@ -39,7 +39,11 @@ class CrudProGenSqlService extends CrudProServiceBase {
     let sql1 = null;
     let sql2 = null;
     let sql3 = null;
-    if (equalsIgnoreCase(KeysOfSimpleSQL.SIMPLE_QUERY, simpleSqlName)) {
+
+    if (equalsIgnoreCase(KeysOfSimpleSQL.SIMPLE_QUERY_EXIST, simpleSqlName)) {
+      sql1 = this.generateOriginSqlForIsExist(cfgModel);
+      cfgModel.addSqlCfgModel('is_exist', sql1, KeysOfSqlResPicker.RESULT_IS_EXIST);
+    } else 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)) {
@@ -61,6 +65,9 @@ class CrudProGenSqlService extends CrudProServiceBase {
     } else if (equalsIgnoreCase(KeysOfSimpleSQL.SIMPLE_INSERT, simpleSqlName)) {
       sql1 = this.generateOriginSqlForInsert(cfgModel);
       cfgModel.addSqlCfgModel('affected', sql1, KeysOfSqlResPicker.UPDATE_RESULT);
+    } else if (equalsIgnoreCase(KeysOfSimpleSQL.SIMPLE_BATCH_INSERT, simpleSqlName)) {
+      sql1 = this.generateOriginSqlForBatchInsert(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);
@@ -68,20 +75,21 @@ class CrudProGenSqlService extends CrudProServiceBase {
       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 )';
+      
+      sql1 = this.generateOriginSqlForIsExist(cfgModel); // 判断元素是否存在
+      sql2 = this.generateOriginSqlForInsert(cfgModel); // 插入语句
       sql3 = 'update @@table set @@asUpdate:data where @@asWhere:condition ';
 
       const insertWhen2 = {
         functionName: 'eq',
-        functionParams: [{ contextAsNumber: 'res.total_count' }, { constNumber: 0 }],
+        functionParams: [{ contextAsBool: 'res.is_exist' }, { constBool: false }],
       };
       const updateWhen3 = {
-        functionName: 'gt',
-        functionParams: [{ contextAsNumber: 'res.total_count' }, { constNumber: 0 }],
+        functionName: 'eq',
+        functionParams: [{ contextAsBool: 'res.is_exist' }, { constBool: true }],
       };
 
-      cfgModel.addSqlCfgModel('total_count', sql1, KeysOfSqlResPicker.RESULT_TOTAL_COUNT);
+      cfgModel.addSqlCfgModel('is_exist', sql1, KeysOfSqlResPicker.RESULT_IS_EXIST);
       cfgModel.addSqlCfgModel('insert_affected', sql2, KeysOfSqlResPicker.UPDATE_RESULT, insertWhen2);
       cfgModel.addSqlCfgModel('update_affected', sql3, KeysOfSqlResPicker.UPDATE_RESULT, updateWhen3);
     }
@@ -91,6 +99,27 @@ class CrudProGenSqlService extends CrudProServiceBase {
     }
   }
 
+
+
+
+
+  /**
+   * 判断元素是否存在
+   * 使用 SELECT EXISTS 子查询，数据库引擎找到第一条匹配记录即停止扫描，比 COUNT(*) 更高效
+   * @param cfgModel
+   * @private
+   */
+  private generateOriginSqlForIsExist(cfgModel: RequestCfgModel): string {
+    if (cfgModel.sqlDbType === SqlDbType.postgres) {
+      return 'SELECT EXISTS(SELECT 1 FROM @@table WHERE @@asWhere:condition) AS is_exist';
+    }
+    if (cfgModel.sqlDbType === SqlDbType.sqlserver) {
+      return 'SELECT CASE WHEN EXISTS(SELECT 1 FROM @@table WHERE @@asWhere:condition) THEN 1 ELSE 0 END AS is_exist';
+    }
+    return 'SELECT EXISTS(SELECT 1 FROM @@table WHERE @@asWhere:condition) AS is_exist';
+  }
+
+
   /**
    * 删除语句
    * @param cfgModel
@@ -157,6 +186,21 @@ class CrudProGenSqlService extends CrudProServiceBase {
     return 'insert into @@table ( @@asInsertKeys:data ) values( @@asInsertValues:data )'; // 关键字的前后，必须有空格
   }
 
+  /**
+   * 创建批量插入语句
+   * @param cfgModel
+   * @private
+   */
+  private generateOriginSqlForBatchInsert(cfgModel: RequestCfgModel): string {
+    if (cfgModel.sqlDbType === SqlDbType.postgres) {
+      return 'insert into @@table ( @@asBatchInsertKeys:data ) values @@asBatchInsertValues:data RETURNING * ';
+    }
+    if (cfgModel.sqlDbType === SqlDbType.sqlserver) {
+      return 'insert into @@table ( @@asBatchInsertKeys:data ) OUTPUT INSERTED.* values @@asBatchInsertValues:data ';
+    }
+    return 'insert into @@table ( @@asBatchInsertKeys:data ) values @@asBatchInsertValues:data '; // MySQL 默认语法
+  }
+
   private async generateExecuteSql() {
     const exeCtx = this.getExecuteContext();
 

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

@@ -3,7 +3,7 @@ import { SqlCfgModel } from '../models/SqlCfgModel';
 import { ITableMetaQuery } from '../interfaces';
 import { MixinUtils } from '../utils/MixinUtils';
 import { SqlSegArg } from '../models/SqlSegArg';
-import { KeysOfCustomSQL, SqlDbType } from '../models/keys';
+import { KeysOfCustomSQL, KeyOfCrudTypes, SqlDbType } from '../models/keys';
 import { RequestModel } from '../models/RequestModel';
 import { CommonException, Exceptions } from '../exceptions';
 import { RequestCfgModel } from '../models/RequestCfgModel';
@@ -73,7 +73,43 @@ class CrudProOriginToExecuteSql extends CrudProServiceBase {
     }
 
     sqlCfgModel.executeSqlArgs = argList;
-    sqlCfgModel.executeSql = executeSql;
+    sqlCfgModel.executeSql = this.appendDialectClause(executeSql, sqlCfgModel);
+  }
+
+  /**
+   * 对于自定义 INSERT SQL，自动追加数据库方言子句：
+   * - PostgreSQL: RETURNING *
+   * - SQL Server: OUTPUT INSERTED.*
+   * - MySQL: 无需追加，驱动自动返回 insertId
+   * 
+   * 仅当 originSql 中用户未手动添加这些子句时才追加
+   */
+  private appendDialectClause(executeSql: string, sqlCfgModel: SqlCfgModel): string {
+    const sqlDbType = sqlCfgModel.sqlDbType;
+    const sqlUpper = executeSql.trim().toUpperCase();
+
+    if (!sqlUpper.startsWith(KeyOfCrudTypes.INSERT)) {
+      return executeSql;
+    }
+
+    if (sqlDbType === SqlDbType.postgres) {
+      if (sqlUpper.indexOf('RETURNING') < 0) {
+        return executeSql + ' RETURNING *';
+      }
+    } else if (sqlDbType === SqlDbType.sqlserver) {
+      if (sqlUpper.indexOf('OUTPUT INSERTED') < 0) {
+        // SQL Server: OUTPUT INSERTED.* 需放在 VALUES 之前
+        // INSERT INTO table (...) OUTPUT INSERTED.* VALUES (...)
+        const valuesIndex = sqlUpper.lastIndexOf('VALUES');
+        if (valuesIndex > 0) {
+          const beforeValues = executeSql.substring(0, valuesIndex);
+          const fromValues = executeSql.substring(valuesIndex);
+          return beforeValues + ' OUTPUT INSERTED.* ' + fromValues;
+        }
+      }
+    }
+
+    return executeSql;
   }
 
   private async generateWordMap(originSql: string, sqlCfgModel: SqlCfgModel): Promise<Record<string, SqlSegArg>> {
@@ -123,6 +159,10 @@ class CrudProOriginToExecuteSql extends CrudProServiceBase {
       return this.generateDataAsInsertKeys(reqModel, sqlCfg, MixinUtils.removeStringPrefix(word, KeysOfCustomSQL.SQL_AS_INSERT_KEYS));
     } else if (word.startsWith(KeysOfCustomSQL.SQL_AS_INSERT_VALUES)) {
       return this.generateDataAsInsertValues(reqModel, MixinUtils.removeStringPrefix(word, KeysOfCustomSQL.SQL_AS_INSERT_VALUES));
+    } else if (word.startsWith(KeysOfCustomSQL.SQL_AS_BATCH_INSERT_KEYS)) {
+      return this.generateDataAsBatchInsertKeys(reqModel, sqlCfg, MixinUtils.removeStringPrefix(word, KeysOfCustomSQL.SQL_AS_BATCH_INSERT_KEYS));
+    } else if (word.startsWith(KeysOfCustomSQL.SQL_AS_BATCH_INSERT_VALUES)) {
+      return this.generateDataAsBatchInsertValues(reqModel, MixinUtils.removeStringPrefix(word, KeysOfCustomSQL.SQL_AS_BATCH_INSERT_VALUES));
     } else if (word.startsWith(KeysOfCustomSQL.SQL_FUNCTION)) {
       return this.generateSqlJavaFunction(reqCfg, MixinUtils.removeStringPrefix(word, KeysOfCustomSQL.SQL_FUNCTION));
     } else {
@@ -334,6 +374,123 @@ class CrudProOriginToExecuteSql extends CrudProServiceBase {
     return new SqlSegArg(sql, argList);
   }
 
+  /**
+   * 获取批量插入的字段名列表
+   * 
+   * 策略：
+   * - 如果指定了 columns，直接使用 columns（允许数据行包含额外字段，仅插入指定列）
+   * - 否则取第一条数据的 keys，并校验后续行是否一致（严格模式）
+   * 
+   * 严格模式限制：
+   * - 所有数据行必须包含完全相同的字段
+   * - 字段数量必须一致
+   * - 字段名必须一致（顺序可不同）
+   * - 若不一致，抛出 BATCH_INSERT_KEYS_MISMATCH 异常
+   * 
+   * @param req RequestModel 请求模型
+   * @param dataArray 数据数组
+   * @returns 排序后的字段名数组
+   */
+  private getBatchInsertKeys(req: RequestModel, dataArray: Record<string, any>[]): string[] {
+    // 如果指定了 columns，直接使用
+    if (MixinUtils.isNotEmpty(req.columns) && req.columns.length > 0) {
+      return [...req.columns].sort();
+    }
+
+    // 严格模式：取第一条数据的 keys，并校验后续行
+    const firstRow = dataArray[0];
+    const keys = Object.keys(firstRow).sort();
+
+    for (let i = 1; i < dataArray.length; i++) {
+      const row = dataArray[i];
+      const rowKeys = Object.keys(row).sort();
+
+      if (rowKeys.length !== keys.length) {
+        throw new CommonException(
+          Exceptions.BATCH_INSERT_KEYS_MISMATCH,
+          `批量插入第 ${i + 1} 行数据字段数量不一致，期望 ${keys.length} 个，实际 ${rowKeys.length} 个`
+        );
+      }
+
+      for (let j = 0; j < keys.length; j++) {
+        if (rowKeys[j] !== keys[j]) {
+          throw new CommonException(
+            Exceptions.BATCH_INSERT_KEYS_MISMATCH,
+            `批量插入第 ${i + 1} 行数据字段不一致，缺少字段 "${keys[j]}" 或包含额外字段`
+          );
+        }
+      }
+    }
+
+    return keys;
+  }
+
+  /**
+   * 批量插入：生成列名部分
+   * 
+   * 列名获取策略：
+   * - 优先使用 req.columns（若指定）
+   * - 否则使用严格模式：取第一条数据的 keys，校验后续行字段一致性
+   */
+  private generateDataAsBatchInsertKeys(req: RequestModel, sqlCfgModel: SqlCfgModel, dataName: string): SqlSegArg {
+    const dataArray = req.getCondOrDataAsArray(dataName);
+
+    if (MixinUtils.isEmpty(dataArray) || dataArray.length === 0) {
+      throw new CommonException(Exceptions.DATA_GET_DATA_EMPTY_ON_INSERT_KEYS, dataName);
+    }
+
+    const keys = this.getBatchInsertKeys(req, dataArray);
+
+    const columnList = keys.map(columnName => {
+      return toSqlColumnName(columnName, sqlCfgModel);
+    });
+
+    const sql = columnList.join(','); // `column1`,`column2`,`column3`
+    return new SqlSegArg(sql);
+  }
+
+  /**
+   * 批量插入：生成值部分，格式为 (?,?,?),(?,?,?),...
+   * 
+   * 列名获取策略：
+   * - 优先使用 req.columns（若指定）
+   * - 否则使用严格模式：取第一条数据的 keys，校验后续行字段一致性
+   */
+  private generateDataAsBatchInsertValues(req: RequestModel, dataName: string): SqlSegArg {
+    const dataArray = req.getCondOrDataAsArray(dataName);
+
+    if (MixinUtils.isEmpty(dataArray) || dataArray.length === 0) {
+      throw new CommonException(Exceptions.DATA_GET_DATA_EMPTY_ON_INSERT_VALUES, dataName);
+    }
+
+    const keys = this.getBatchInsertKeys(req, dataArray);
+
+    const valueGroups: string[] = [];
+    const argList: any[] = [];
+
+    for (let i = 0; i < dataArray.length; i++) {
+      const row = dataArray[i];
+      const rowValues: string[] = [];
+
+      for (let j = 0; j < keys.length; j++) {
+        const key = keys[j];
+        const arg = row[key];
+
+        if (sqlFuncUtils.isSqlFuncArg(arg)) {
+          rowValues.push(sqlFuncUtils.toFuncSQL(arg));
+        } else {
+          rowValues.push('?');
+          argList.push(arg);
+        }
+      }
+
+      valueGroups.push('(' + rowValues.join(',') + ')');
+    }
+
+    const sql = valueGroups.join(','); // "(?,?,?),(?,?,?),..."
+    return new SqlSegArg(sql, argList);
+  }
+
   private generateSqlJavaFunction(requestCfg: RequestCfgModel, tmpFuncName: string): SqlSegArg {
     const exeCtx = this.getExecuteContext();
 

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

@@ -1,13 +1,16 @@
 import { CrudProServiceBase } from './CrudProServiceBase';
-import { IExecuteUnsafeQueryCtx, ITableColumn, ITableMeta, ITableMetaQuery } from '../interfaces';
+import { IExecuteUnsafeQueryCtx, ITableColumn, ITableInfo, ITableListResult, ITableMeta, ITableMetaQuery, ITableNamesQuery, ITableNamesOptions } from '../interfaces';
 import { SqlDbType } from '../models/keys';
 // import { pickAndConvertRowsByMix } from '../utils/sqlConvert/convertMix';
 
 class CrudProTableMetaCache {
   private cacheMap: Record<string, ITableMeta> = {};
+  private tableInfoCacheMap: Record<string, { tableInfos: ITableListResult; expiredTime: number }> = {};
+
   private getCacheKey(query: ITableMetaQuery) {
     return `${query.sqlDatabase}:::${query.sqlSchema}:::${query.sqlDbType}:::${query.sqlTable}`;
   }
+
   public getMeta(query: ITableMetaQuery) {
     const cacheKey = this.getCacheKey(query);
     const obj = this.cacheMap[cacheKey];
@@ -21,6 +24,21 @@ class CrudProTableMetaCache {
     const cacheKey = this.getCacheKey(query);
     this.cacheMap[cacheKey] = metaObj;
   }
+
+  public getTableInfos(cacheKey: string): ITableListResult | null {
+    const cached = this.tableInfoCacheMap[cacheKey];
+    if (cached && cached.expiredTime > Date.now()) {
+      return cached.tableInfos;
+    }
+    return null;
+  }
+
+  public setTableInfos(cacheKey: string, tableInfos: ITableListResult, cacheTime: number): void {
+    this.tableInfoCacheMap[cacheKey] = {
+      tableInfos,
+      expiredTime: Date.now() + cacheTime,
+    };
+  }
 }
 
 const metaCache = new CrudProTableMetaCache();
@@ -35,6 +53,126 @@ class CrudProTableMetaService extends CrudProServiceBase {
     return obj;
   }
 
+  // ============ 获取表和视图信息（带类型） ============
+
+
+  /**
+   * 获取数据库所有表和视图信息（包含类型）
+   *
+   * @param query 数据库查询参数
+   * @param options 缓存控制选项
+   *   - skipCache: 跳过缓存，直接查询数据库
+   *   - refreshCache: 查询后更新缓存
+   */
+  public async getAllTableInfos(
+    query: ITableNamesQuery,
+    options: ITableNamesOptions = {}
+  ): Promise<ITableListResult> {
+    const { skipCache = false, refreshCache = false } = options;
+
+    // 1. 尝试从缓存获取（使用独立的缓存key）
+    const cacheKey = this.getTableInfoCacheKey(query);
+    if (!skipCache) {
+      const cached = metaCache.getTableInfos(cacheKey);
+      if (cached) {
+        return cached;
+      }
+    }
+
+    // 2. 查询数据库
+    const result = await this.loadAllTableInfos(query);
+
+    // 3. 更新缓存
+    if (!skipCache || refreshCache) {
+      const { tableMetaCacheTime } = this.getContextCfg();
+      metaCache.setTableInfos(cacheKey, result, tableMetaCacheTime || 3600000);
+    }
+
+    return result;
+  }
+
+  private getTableInfoCacheKey(query: ITableNamesQuery): string {
+    return `tableInfo:::${query.sqlDatabase}:::${query.sqlSchema || 'public'}:::${query.sqlDbType}`;
+  }
+
+  private async loadAllTableInfos(query: ITableNamesQuery): Promise<ITableListResult> {
+    const { sqlDbType } = query;
+
+    if (sqlDbType === SqlDbType.mysql) {
+      return this.loadMySQLAllTableInfos(query);
+    } else if (sqlDbType === SqlDbType.postgres) {
+      return this.loadPostgreSQLAllTableInfos(query);
+    } else if (sqlDbType === SqlDbType.sqlserver) {
+      return this.loadSQLServerAllTableInfos(query);
+    }
+
+    throw new Error('暂不支持的数据库类型：' + sqlDbType);
+  }
+
+  private async loadMySQLAllTableInfos(query: ITableNamesQuery): Promise<ITableListResult> {
+    const dbUtil = { sqlDatabase: query.sqlDatabase, sqlDbType: query.sqlDbType } as IExecuteUnsafeQueryCtx;
+
+    // 获取物理表
+    const tableSql = `SHOW TABLES FROM ${query.sqlDatabase}`;
+    const tableRes = await this.executeUnsafeQuery(dbUtil, tableSql);
+    const tableNames: string[] = (tableRes.rows || []).map((row: any) => Object.values(row)[0] as string);
+
+    // 获取视图
+    const viewSql = `SHOW FULL TABLES FROM ${query.sqlDatabase} WHERE Table_type = 'VIEW'`;
+    const viewRes = await this.executeUnsafeQuery(dbUtil, viewSql);
+    const viewNames: string[] = (viewRes.rows || []).map((row: any) => Object.values(row)[0] as string);
+
+    const tables: ITableInfo[] = [
+      ...tableNames.map(name => ({ name, tableType: 'table' })),
+      ...viewNames.map(name => ({ name, tableType: 'view' })),
+    ];
+
+    return { tables, tableNames, viewNames };
+  }
+
+  private async loadPostgreSQLAllTableInfos(query: ITableNamesQuery): Promise<ITableListResult> {
+    const schema = query.sqlSchema || 'public';
+    const dbUtil = { sqlDatabase: query.sqlDatabase, sqlDbType: query.sqlDbType } as IExecuteUnsafeQueryCtx;
+
+    // 获取物理表
+    const tableSql = `SELECT tablename FROM pg_tables WHERE schemaname = '${schema}' ORDER BY tablename`;
+    const tableRes = await this.executeUnsafeQuery(dbUtil, tableSql);
+    const tableNames: string[] = (tableRes.rows || []).map((row: any) => row.tablename);
+
+    // 获取视图
+    const viewSql = `SELECT viewname FROM pg_views WHERE schemaname = '${schema}' ORDER BY viewname`;
+    const viewRes = await this.executeUnsafeQuery(dbUtil, viewSql);
+    const viewNames: string[] = (viewRes.rows || []).map((row: any) => row.viewname);
+
+    const tables: ITableInfo[] = [
+      ...tableNames.map(name => ({ name, tableType: 'table' })),
+      ...viewNames.map(name => ({ name, tableType: 'view' })),
+    ];
+
+    return { tables, tableNames, viewNames };
+  }
+
+  private async loadSQLServerAllTableInfos(query: ITableNamesQuery): Promise<ITableListResult> {
+    const dbUtil = { sqlDatabase: query.sqlDatabase, sqlDbType: query.sqlDbType } as IExecuteUnsafeQueryCtx;
+
+    // 获取物理表
+    const tableSql = `SELECT name FROM sys.tables`;
+    const tableRes = await this.executeUnsafeQuery(dbUtil, tableSql);
+    const tableNames: string[] = (tableRes.rows || []).map((row: any) => row.name);
+
+    // 获取视图
+    const viewSql = `SELECT name FROM sys.views`;
+    const viewRes = await this.executeUnsafeQuery(dbUtil, viewSql);
+    const viewNames: string[] = (viewRes.rows || []).map((row: any) => row.name);
+
+    const tables: ITableInfo[] = [
+      ...tableNames.map(name => ({ name, tableType: 'table' })),
+      ...viewNames.map(name => ({ name, tableType: 'view' })),
+    ];
+
+    return { tables, tableNames, viewNames };
+  }
+
   private async loadTableMeta(query: ITableMetaQuery): Promise<ITableMeta> {
     const { tableMetaCacheTime } = this.getContextCfg();
 

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

@@ -1,4 +1,4 @@
-import { IFuncCfgModel, IRequestCfgModel, ISqlCfgModel, ITableMeta, ITableMetaQuery } from '../interfaces';
+import { IFuncCfgModel, IRequestCfgModel, ISqlCfgModel, ITableListResult, ITableMeta, ITableMetaQuery, ITableNamesOptions, ITableNamesQuery } from '../interfaces';
 import { RequestModel } from '../models/RequestModel';
 import { CrudProFieldValidateService } from './CrudProFieldValidateService';
 import { CrudProFieldUpdateService } from './CrudProFieldUpdateService';
@@ -14,6 +14,7 @@ import { FuncContext } from '../models/FuncContext';
 import { CrudProExecuteFuncService } from './CrudProExecuteFuncService';
 import { CrudProTableMetaService } from './CrudProTableMetaService';
 import { CrudProDataFilterService } from './CrudProDataFilterService';
+import { CrudProDataTypeConvertService } from './CrudProDataTypeConvertService';
 
 class CurdProServiceHub implements ICurdProServiceHub {
   private readonly executeContext: ExecuteContext;
@@ -27,6 +28,7 @@ class CurdProServiceHub implements ICurdProServiceHub {
   private readonly executeFuncService: CrudProExecuteFuncService;
   private readonly tableMetaService: CrudProTableMetaService;
   private readonly dataFilterService: CrudProDataFilterService;
+  private readonly dataTypeConvertService: CrudProDataTypeConvertService;
 
   constructor(executeContext: ExecuteContext) {
     this.executeContext = executeContext;
@@ -39,6 +41,7 @@ class CurdProServiceHub implements ICurdProServiceHub {
     this.executeFuncService = new CrudProExecuteFuncService(this);
     this.tableMetaService = new CrudProTableMetaService(this);
     this.dataFilterService = new CrudProDataFilterService(this);
+    this.dataTypeConvertService = new CrudProDataTypeConvertService(this);
   }
 
   getExecuteContext(): ExecuteContext {
@@ -57,6 +60,10 @@ class CurdProServiceHub implements ICurdProServiceHub {
     return this.fieldValidateService.validateByCfg(cfgModel, reqModel);
   }
 
+  validateDataType(cfgModel: RequestCfgModel, reqModel: RequestModel) {
+    return this.fieldValidateService.validateDataType(cfgModel, reqModel);
+  }
+
   async validateByAuthCfg(cfgModel: RequestCfgModel, reqModel: RequestModel): Promise<any> {
     const contextFunc = this.executeContext.contextFunc;
     if (contextFunc && contextFunc.validateByAuthCfg) {
@@ -91,9 +98,17 @@ class CurdProServiceHub implements ICurdProServiceHub {
     return await this.tableMetaService.getTableMeta(query);
   }
 
+  async getAllTableInfos(query: ITableNamesQuery, options?: ITableNamesOptions): Promise<ITableListResult> {
+    return await this.tableMetaService.getAllTableInfos(query, options);
+  }
+
   async filterDataByTableMeta(data: Record<string, any>, sqlCfgModel: ISqlCfgModel | SqlCfgModel): Promise<Record<string, any>> {
     return await this.dataFilterService.filterDataByTableMeta(data, sqlCfgModel);
   }
+
+  async convertDataTypeByTableMeta(reqModel: RequestModel, cfgModel: RequestCfgModel): Promise<void> {
+    return await this.dataTypeConvertService.convertDataTypeByTableMeta(reqModel, cfgModel);
+  }
 }
 
 export { CurdProServiceHub };

package/src/libs/crud-pro/utils/DateTimeUtils.ts

@@ -5,6 +5,9 @@ const DateTimeUtils = {
   getCurrentTimeStampMs(): number {
     return Date.now();
   },
+  getCurrentTimeString(): string {
+    return moment().format('YYYY-MM-DD HH:mm:ss');
+  },
   // 以秒为单位的时间戳
   getCurrentTimeStampSecond(): number {
     return Math.floor(Date.now() / 1000);