midway-fatcms 0.0.4 → 0.0.6

package/dist/libs/crud-pro/services/CrudProDataTypeConvertService.d.ts

@@ -0,0 +1,52 @@
+import { CrudProServiceBase } from './CrudProServiceBase';
+import { RequestModel } from '../models/RequestModel';
+import { RequestCfgModel } from '../models/RequestCfgModel';
+/**
+ * 数据类型转换服务
+ * 根据表结构字段类型，在 INSERT/UPDATE 操作前自动转换数据格式，确保数据与数据库方言兼容
+ *
+ * 当前支持的转换：
+ * - PostgreSQL ARRAY 类型：JSON 数组 → PG 数组字面量 {"a","b","c"}
+ */
+declare class CrudProDataTypeConvertService extends CrudProServiceBase {
+    /**
+     * 根据表结构字段类型自动转换 reqModel.data 中的数据格式
+     * 仅对 PostgreSQL 的 INSERT/UPDATE 类型操作生效
+     *
+     * @param reqModel 请求模型
+     * @param cfgModel 配置模型
+     */
+    convertDataTypeByTableMeta(reqModel: RequestModel, cfgModel: RequestCfgModel): Promise<void>;
+    /**
+     * 遍历数据对象中的 ARRAY 类型字段，将 JSON 数组转为 PG 数组字面量格式
+     */
+    private convertArrayFields;
+    /**
+     * 尝试将值解析为数组
+     * 支持：数组对象、JSON 数组字符串
+     */
+    private tryParseArray;
+    /**
+     * 将 JS 数组转为 PostgreSQL 数组字面量格式
+     *
+     * PG 数组字面量规则：
+     * - 字符串：双引号包裹，内部 " 转义为 \"，\ 转义为 \\   例：{"hello","world"}
+     * - 数字：不加引号                                                    例：{1,2,3}
+     * - 布尔：转为 t/f 不加引号                                           例：{t,f}
+     * - null/undefined：输出 NULL 不加引号                                例：{1,NULL,3}
+     * - 空数组：输出 {}
+     *
+     * @param arr JS 数组
+     * @returns PG 数组字面量字符串
+     */
+    private toPgArrayLiteral;
+    /**
+     * 将单个 JS 值转为 PG 数组元素的字面量表示
+     */
+    private toPgArrayItem;
+    /**
+     * 判断 sqlSimpleName 是否为 INSERT/UPDATE 类型
+     */
+    private isInsertOrUpdateType;
+}
+export { CrudProDataTypeConvertService };

package/dist/libs/crud-pro/services/CrudProDataTypeConvertService.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrudProDataTypeConvertService = void 0;
+const CrudProServiceBase_1 = require("./CrudProServiceBase");
+const keys_1 = require("../models/keys");
+/**
+ * 数据类型转换服务
+ * 根据表结构字段类型，在 INSERT/UPDATE 操作前自动转换数据格式，确保数据与数据库方言兼容
+ *
+ * 当前支持的转换：
+ * - PostgreSQL ARRAY 类型：JSON 数组 → PG 数组字面量 {"a","b","c"}
+ */
+class CrudProDataTypeConvertService extends CrudProServiceBase_1.CrudProServiceBase {
+    /**
+     * 根据表结构字段类型自动转换 reqModel.data 中的数据格式
+     * 仅对 PostgreSQL 的 INSERT/UPDATE 类型操作生效
+     *
+     * @param reqModel 请求模型
+     * @param cfgModel 配置模型
+     */
+    async convertDataTypeByTableMeta(reqModel, cfgModel) {
+        if (cfgModel.sqlDbType !== keys_1.SqlDbType.postgres) {
+            return;
+        }
+        const sqlSimpleName = cfgModel.sqlSimpleName;
+        if (!this.isInsertOrUpdateType(sqlSimpleName)) {
+            return;
+        }
+        if (!reqModel.data) {
+            return;
+        }
+        const query = {
+            sqlTable: cfgModel.sqlTable,
+            sqlDatabase: cfgModel.sqlDatabase,
+            sqlDbType: cfgModel.sqlDbType,
+            sqlSchema: cfgModel.sqlSchema,
+        };
+        const tableMeta = await this.serviceHub.getTableMeta(query);
+        if (!tableMeta || !tableMeta.columnDetails || tableMeta.columnDetails.length === 0) {
+            this.logger.warn('CrudProDataTypeConvertService: 无法获取表结构信息，跳过数据类型转换', cfgModel.sqlTable);
+            return;
+        }
+        const arrayFieldSet = new Set();
+        for (const col of tableMeta.columnDetails) {
+            if (('' + col.type).toUpperCase() === 'ARRAY') {
+                arrayFieldSet.add(col.name);
+            }
+        }
+        if (arrayFieldSet.size === 0) {
+            return;
+        }
+        const data = reqModel.data;
+        if (Array.isArray(data)) {
+            for (const row of data) {
+                this.convertArrayFields(row, arrayFieldSet);
+            }
+        }
+        else {
+            this.convertArrayFields(data, arrayFieldSet);
+        }
+    }
+    /**
+     * 遍历数据对象中的 ARRAY 类型字段，将 JSON 数组转为 PG 数组字面量格式
+     */
+    convertArrayFields(dataObj, arrayFieldSet) {
+        const keys = Object.keys(dataObj);
+        for (const key of keys) {
+            if (!arrayFieldSet.has(key)) {
+                continue;
+            }
+            const value = dataObj[key];
+            const parsed = this.tryParseArray(value);
+            if (Array.isArray(parsed)) {
+                dataObj[key] = this.toPgArrayLiteral(parsed);
+            }
+        }
+    }
+    /**
+     * 尝试将值解析为数组
+     * 支持：数组对象、JSON 数组字符串
+     */
+    tryParseArray(value) {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        if (Array.isArray(value)) {
+            return value;
+        }
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            if (trimmed.startsWith('[')) {
+                try {
+                    return JSON.parse(trimmed);
+                }
+                catch (e) {
+                    return null;
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * 将 JS 数组转为 PostgreSQL 数组字面量格式
+     *
+     * PG 数组字面量规则：
+     * - 字符串：双引号包裹，内部 " 转义为 \"，\ 转义为 \\   例：{"hello","world"}
+     * - 数字：不加引号                                                    例：{1,2,3}
+     * - 布尔：转为 t/f 不加引号                                           例：{t,f}
+     * - null/undefined：输出 NULL 不加引号                                例：{1,NULL,3}
+     * - 空数组：输出 {}
+     *
+     * @param arr JS 数组
+     * @returns PG 数组字面量字符串
+     */
+    toPgArrayLiteral(arr) {
+        if (arr.length === 0) {
+            return '{}';
+        }
+        const items = arr.map(v => this.toPgArrayItem(v));
+        return '{' + items.join(',') + '}';
+    }
+    /**
+     * 将单个 JS 值转为 PG 数组元素的字面量表示
+     */
+    toPgArrayItem(value) {
+        if (value === null || value === undefined) {
+            return 'NULL';
+        }
+        if (typeof value === 'number') {
+            return '' + value;
+        }
+        if (typeof value === 'boolean') {
+            return value ? 't' : 'f';
+        }
+        // 字符串及其它类型：转义后用双引号包裹
+        const escaped = ('' + value)
+            .replace(/\\/g, '\\\\')
+            .replace(/"/g, '\\"');
+        return '"' + escaped + '"';
+    }
+    /**
+     * 判断 sqlSimpleName 是否为 INSERT/UPDATE 类型
+     */
+    isInsertOrUpdateType(sqlSimpleName) {
+        if (!sqlSimpleName) {
+            return false;
+        }
+        const types = [
+            keys_1.KeysOfSimpleSQL.SIMPLE_INSERT,
+            keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE,
+            keys_1.KeysOfSimpleSQL.SIMPLE_INSERT_ON_DUPLICATE_UPDATE,
+            keys_1.KeysOfSimpleSQL.SIMPLE_INSERT_OR_UPDATE,
+            keys_1.KeysOfSimpleSQL.SIMPLE_BATCH_INSERT,
+        ];
+        return types.includes(sqlSimpleName);
+    }
+}
+exports.CrudProDataTypeConvertService = CrudProDataTypeConvertService;

package/dist/libs/crud-pro/services/CrudProExecuteSqlService.js

@@ -169,7 +169,14 @@ class CrudProExecuteSqlService extends CrudProServiceBase_1.CrudProServiceBase {
         return result === true;
     }
     toQueryResByResPicker(rows, originRes, sqlCfgModel) {
-        const resPicker = sqlCfgModel.resPicker;
+        let resPicker = sqlCfgModel.resPicker;
+        // resPicker 未设置时，根据 SQL 类型自动推断
+        if (isEmpty(resPicker)) {
+            const crudType = sqlCfgModel.getCrudType();
+            if (crudType === keys_1.KeyOfCrudTypes.INSERT || crudType === keys_1.KeyOfCrudTypes.UPDATE || crudType === keys_1.KeyOfCrudTypes.DELETE) {
+                resPicker = keys_1.KeysOfSqlResPicker.UPDATE_RESULT;
+            }
+        }
         // 返回第一行
         if (keys_1.KeysOfSqlResPicker.RESULT_FIRST_ROW === resPicker) {
             if (rows && rows.length > 0) {
@@ -185,6 +192,18 @@ class CrudProExecuteSqlService extends CrudProServiceBase_1.CrudProServiceBase {
             const map0 = rows[0];
             return Number(map0['total_count'] || 0);
         }
+        // 判断元素是否存在，返回 boolean
+        if (keys_1.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 (keys_1.KeysOfSqlResPicker.UPDATE_RESULT === resPicker) {
             if (sqlCfgModel.sqlDbType === keys_1.SqlDbType.postgres) {

package/dist/libs/crud-pro/services/CrudProFieldValidateService.d.ts

@@ -9,5 +9,12 @@ declare class CrudProFieldValidateService extends CrudProServiceBase {
     private validateByCfgString;
     private validateByCfgFunc;
     private validateRequired;
+    /**
+     * 校验 data 字段类型是否符合 sqlSimpleName 的要求
+     *
+     * - SIMPLE_BATCH_INSERT: data 必须是数组
+     * - 其他 INSERT/UPDATE 类型: data 必须是普通对象
+     */
+    validateDataType(cfgModel: RequestCfgModel, reqModel: RequestModel): void;
 }
 export { CrudProFieldValidateService };

package/dist/libs/crud-pro/services/CrudProFieldValidateService.js

@@ -144,5 +144,37 @@ class CrudProFieldValidateService extends CrudProServiceBase_1.CrudProServiceBas
             }
         }
     }
+    /**
+     * 校验 data 字段类型是否符合 sqlSimpleName 的要求
+     *
+     * - SIMPLE_BATCH_INSERT: data 必须是数组
+     * - 其他 INSERT/UPDATE 类型: data 必须是普通对象
+     */
+    validateDataType(cfgModel, reqModel) {
+        const sqlSimpleName = cfgModel.sqlSimpleName;
+        if (!sqlSimpleName) {
+            return;
+        }
+        const data = reqModel.data;
+        const isArrayData = Array.isArray(data);
+        if (sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_BATCH_INSERT) {
+            if (!isArrayData || data.length === 0) {
+                throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_INVALID_DATA_TYPE, `${sqlSimpleName} 要求 data 必须是数组。并且不能为空数组。`);
+            }
+            return;
+        }
+        const needsObjectData = [
+            keys_1.KeysOfSimpleSQL.SIMPLE_INSERT,
+            keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE,
+            keys_1.KeysOfSimpleSQL.SIMPLE_INSERT_ON_DUPLICATE_UPDATE,
+            keys_1.KeysOfSimpleSQL.SIMPLE_INSERT_OR_UPDATE,
+        ].includes(sqlSimpleName);
+        if (needsObjectData && (!data || Object.keys(data).length === 0)) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_INVALID_DATA_TYPE, `${sqlSimpleName} 要求 data 必须是对象，不能为空`);
+        }
+        if (needsObjectData && isArrayData) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_INVALID_DATA_TYPE, `${sqlSimpleName} 要求 data 必须是普通对象，不能是数组`);
+        }
+    }
 }
 exports.CrudProFieldValidateService = CrudProFieldValidateService;

package/dist/libs/crud-pro/services/CrudProGenSqlService.d.ts

@@ -2,6 +2,13 @@ import { CrudProServiceBase } from './CrudProServiceBase';
 declare class CrudProGenSqlService extends CrudProServiceBase {
     generateSQLList(): Promise<void>;
     private generateOriginSql;
+    /**
+     * 判断元素是否存在
+     * 使用 SELECT EXISTS 子查询，数据库引擎找到第一条匹配记录即停止扫描，比 COUNT(*) 更高效
+     * @param cfgModel
+     * @private
+     */
+    private generateOriginSqlForIsExist;
     /**
      * 删除语句
      * @param cfgModel
@@ -20,6 +27,12 @@ declare class CrudProGenSqlService extends CrudProServiceBase {
      * @private
      */
     private generateOriginSqlForInsert;
+    /**
+     * 创建批量插入语句
+     * @param cfgModel
+     * @private
+     */
+    private generateOriginSqlForBatchInsert;
     private generateExecuteSql;
 }
 export { CrudProGenSqlService };

package/dist/libs/crud-pro/services/CrudProGenSqlService.js

@@ -31,7 +31,11 @@ class CrudProGenSqlService extends CrudProServiceBase_1.CrudProServiceBase {
         let sql1 = null;
         let sql2 = null;
         let sql3 = null;
-        if (equalsIgnoreCase(keys_1.KeysOfSimpleSQL.SIMPLE_QUERY, simpleSqlName)) {
+        if (equalsIgnoreCase(keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_EXIST, simpleSqlName)) {
+            sql1 = this.generateOriginSqlForIsExist(cfgModel);
+            cfgModel.addSqlCfgModel('is_exist', sql1, keys_1.KeysOfSqlResPicker.RESULT_IS_EXIST);
+        }
+        else if (equalsIgnoreCase(keys_1.KeysOfSimpleSQL.SIMPLE_QUERY, simpleSqlName)) {
             sql1 = 'select @@columns from @@table where @@asWhere:condition @@orderBys @@offsetLimit';
             cfgModel.addSqlCfgModel('rows', sql1);
         }
@@ -57,6 +61,10 @@ class CrudProGenSqlService extends CrudProServiceBase_1.CrudProServiceBase {
             sql1 = this.generateOriginSqlForInsert(cfgModel);
             cfgModel.addSqlCfgModel('affected', sql1, keys_1.KeysOfSqlResPicker.UPDATE_RESULT);
         }
+        else if (equalsIgnoreCase(keys_1.KeysOfSimpleSQL.SIMPLE_BATCH_INSERT, simpleSqlName)) {
+            sql1 = this.generateOriginSqlForBatchInsert(cfgModel);
+            cfgModel.addSqlCfgModel('affected', sql1, keys_1.KeysOfSqlResPicker.UPDATE_RESULT);
+        }
         else if (equalsIgnoreCase(keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE, simpleSqlName)) {
             sql1 = 'update @@table set @@asUpdate:data where @@asWhere:condition ';
             cfgModel.addSqlCfgModel('affected', sql1, keys_1.KeysOfSqlResPicker.UPDATE_RESULT);
@@ -66,18 +74,18 @@ class CrudProGenSqlService extends CrudProServiceBase_1.CrudProServiceBase {
             cfgModel.addSqlCfgModel('affected', sql1, keys_1.KeysOfSqlResPicker.UPDATE_RESULT);
         }
         else if (equalsIgnoreCase(keys_1.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, keys_1.KeysOfSqlResPicker.RESULT_TOTAL_COUNT);
+            cfgModel.addSqlCfgModel('is_exist', sql1, keys_1.KeysOfSqlResPicker.RESULT_IS_EXIST);
             cfgModel.addSqlCfgModel('insert_affected', sql2, keys_1.KeysOfSqlResPicker.UPDATE_RESULT, insertWhen2);
             cfgModel.addSqlCfgModel('update_affected', sql3, keys_1.KeysOfSqlResPicker.UPDATE_RESULT, updateWhen3);
         }
@@ -85,6 +93,21 @@ class CrudProGenSqlService extends CrudProServiceBase_1.CrudProServiceBase {
             throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_NOT_SUPPORT_THE_SIMPLE_SQL, simpleSqlName);
         }
     }
+    /**
+     * 判断元素是否存在
+     * 使用 SELECT EXISTS 子查询，数据库引擎找到第一条匹配记录即停止扫描，比 COUNT(*) 更高效
+     * @param cfgModel
+     * @private
+     */
+    generateOriginSqlForIsExist(cfgModel) {
+        if (cfgModel.sqlDbType === keys_1.SqlDbType.postgres) {
+            return 'SELECT EXISTS(SELECT 1 FROM @@table WHERE @@asWhere:condition) AS is_exist';
+        }
+        if (cfgModel.sqlDbType === keys_1.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
@@ -143,6 +166,20 @@ class CrudProGenSqlService extends CrudProServiceBase_1.CrudProServiceBase {
         }
         return 'insert into @@table ( @@asInsertKeys:data ) values( @@asInsertValues:data )'; // 关键字的前后，必须有空格
     }
+    /**
+     * 创建批量插入语句
+     * @param cfgModel
+     * @private
+     */
+    generateOriginSqlForBatchInsert(cfgModel) {
+        if (cfgModel.sqlDbType === keys_1.SqlDbType.postgres) {
+            return 'insert into @@table ( @@asBatchInsertKeys:data ) values @@asBatchInsertValues:data RETURNING * ';
+        }
+        if (cfgModel.sqlDbType === keys_1.SqlDbType.sqlserver) {
+            return 'insert into @@table ( @@asBatchInsertKeys:data ) OUTPUT INSERTED.* values @@asBatchInsertValues:data ';
+        }
+        return 'insert into @@table ( @@asBatchInsertKeys:data ) values @@asBatchInsertValues:data '; // MySQL 默认语法
+    }
     async generateExecuteSql() {
         const exeCtx = this.getExecuteContext();
         const reqCfgModel = exeCtx.getCfgModel();

package/dist/libs/crud-pro/services/CrudProOriginToExecuteSql.d.ts

@@ -2,6 +2,15 @@ import { CrudProServiceBase } from './CrudProServiceBase';
 import { SqlCfgModel } from '../models/SqlCfgModel';
 declare class CrudProOriginToExecuteSql extends CrudProServiceBase {
     convertOriginToExecuteSql(sqlCfgModel: SqlCfgModel): Promise<void>;
+    /**
+     * 对于自定义 INSERT SQL，自动追加数据库方言子句：
+     * - PostgreSQL: RETURNING *
+     * - SQL Server: OUTPUT INSERTED.*
+     * - MySQL: 无需追加，驱动自动返回 insertId
+     *
+     * 仅当 originSql 中用户未手动添加这些子句时才追加
+     */
+    private appendDialectClause;
     private generateWordMap;
     private generateWord;
     private generateDataAsInsertKeys;
@@ -21,6 +30,40 @@ declare class CrudProOriginToExecuteSql extends CrudProServiceBase {
     private generateGetAttr;
     private generateDataUpdate;
     private generateDataAsInsertValues;
+    /**
+     * 获取批量插入的字段名列表
+     *
+     * 策略：
+     * - 如果指定了 columns，直接使用 columns（允许数据行包含额外字段，仅插入指定列）
+     * - 否则取第一条数据的 keys，并校验后续行是否一致（严格模式）
+     *
+     * 严格模式限制：
+     * - 所有数据行必须包含完全相同的字段
+     * - 字段数量必须一致
+     * - 字段名必须一致（顺序可不同）
+     * - 若不一致，抛出 BATCH_INSERT_KEYS_MISMATCH 异常
+     *
+     * @param req RequestModel 请求模型
+     * @param dataArray 数据数组
+     * @returns 排序后的字段名数组
+     */
+    private getBatchInsertKeys;
+    /**
+     * 批量插入：生成列名部分
+     *
+     * 列名获取策略：
+     * - 优先使用 req.columns（若指定）
+     * - 否则使用严格模式：取第一条数据的 keys，校验后续行字段一致性
+     */
+    private generateDataAsBatchInsertKeys;
+    /**
+     * 批量插入：生成值部分，格式为 (?,?,?),(?,?,?),...
+     *
+     * 列名获取策略：
+     * - 优先使用 req.columns（若指定）
+     * - 否则使用严格模式：取第一条数据的 keys，校验后续行字段一致性
+     */
+    private generateDataAsBatchInsertValues;
     private generateSqlJavaFunction;
     /**
      * 不会返回空。

package/dist/libs/crud-pro/services/CrudProOriginToExecuteSql.js

@@ -60,7 +60,40 @@ class CrudProOriginToExecuteSql extends CrudProServiceBase_1.CrudProServiceBase
             });
         }
         sqlCfgModel.executeSqlArgs = argList;
-        sqlCfgModel.executeSql = executeSql;
+        sqlCfgModel.executeSql = this.appendDialectClause(executeSql, sqlCfgModel);
+    }
+    /**
+     * 对于自定义 INSERT SQL，自动追加数据库方言子句：
+     * - PostgreSQL: RETURNING *
+     * - SQL Server: OUTPUT INSERTED.*
+     * - MySQL: 无需追加，驱动自动返回 insertId
+     *
+     * 仅当 originSql 中用户未手动添加这些子句时才追加
+     */
+    appendDialectClause(executeSql, sqlCfgModel) {
+        const sqlDbType = sqlCfgModel.sqlDbType;
+        const sqlUpper = executeSql.trim().toUpperCase();
+        if (!sqlUpper.startsWith(keys_1.KeyOfCrudTypes.INSERT)) {
+            return executeSql;
+        }
+        if (sqlDbType === keys_1.SqlDbType.postgres) {
+            if (sqlUpper.indexOf('RETURNING') < 0) {
+                return executeSql + ' RETURNING *';
+            }
+        }
+        else if (sqlDbType === keys_1.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;
     }
     async generateWordMap(originSql, sqlCfgModel) {
         // ['@@columns', '@@table', '@@asWhere:condition', '@@orderBys']
@@ -115,6 +148,12 @@ class CrudProOriginToExecuteSql extends CrudProServiceBase_1.CrudProServiceBase
         else if (word.startsWith(keys_1.KeysOfCustomSQL.SQL_AS_INSERT_VALUES)) {
             return this.generateDataAsInsertValues(reqModel, MixinUtils_1.MixinUtils.removeStringPrefix(word, keys_1.KeysOfCustomSQL.SQL_AS_INSERT_VALUES));
         }
+        else if (word.startsWith(keys_1.KeysOfCustomSQL.SQL_AS_BATCH_INSERT_KEYS)) {
+            return this.generateDataAsBatchInsertKeys(reqModel, sqlCfg, MixinUtils_1.MixinUtils.removeStringPrefix(word, keys_1.KeysOfCustomSQL.SQL_AS_BATCH_INSERT_KEYS));
+        }
+        else if (word.startsWith(keys_1.KeysOfCustomSQL.SQL_AS_BATCH_INSERT_VALUES)) {
+            return this.generateDataAsBatchInsertValues(reqModel, MixinUtils_1.MixinUtils.removeStringPrefix(word, keys_1.KeysOfCustomSQL.SQL_AS_BATCH_INSERT_VALUES));
+        }
         else if (word.startsWith(keys_1.KeysOfCustomSQL.SQL_FUNCTION)) {
             return this.generateSqlJavaFunction(reqCfg, MixinUtils_1.MixinUtils.removeStringPrefix(word, keys_1.KeysOfCustomSQL.SQL_FUNCTION));
         }
@@ -287,6 +326,98 @@ class CrudProOriginToExecuteSql extends CrudProServiceBase_1.CrudProServiceBase
         const sql = sqlList.join(','); // "?,?,?,?"
         return new SqlSegArg_1.SqlSegArg(sql, argList);
     }
+    /**
+     * 获取批量插入的字段名列表
+     *
+     * 策略：
+     * - 如果指定了 columns，直接使用 columns（允许数据行包含额外字段，仅插入指定列）
+     * - 否则取第一条数据的 keys，并校验后续行是否一致（严格模式）
+     *
+     * 严格模式限制：
+     * - 所有数据行必须包含完全相同的字段
+     * - 字段数量必须一致
+     * - 字段名必须一致（顺序可不同）
+     * - 若不一致，抛出 BATCH_INSERT_KEYS_MISMATCH 异常
+     *
+     * @param req RequestModel 请求模型
+     * @param dataArray 数据数组
+     * @returns 排序后的字段名数组
+     */
+    getBatchInsertKeys(req, dataArray) {
+        // 如果指定了 columns，直接使用
+        if (MixinUtils_1.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 exceptions_1.CommonException(exceptions_1.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 exceptions_1.CommonException(exceptions_1.Exceptions.BATCH_INSERT_KEYS_MISMATCH, `批量插入第 ${i + 1} 行数据字段不一致，缺少字段 "${keys[j]}" 或包含额外字段`);
+                }
+            }
+        }
+        return keys;
+    }
+    /**
+     * 批量插入：生成列名部分
+     *
+     * 列名获取策略：
+     * - 优先使用 req.columns（若指定）
+     * - 否则使用严格模式：取第一条数据的 keys，校验后续行字段一致性
+     */
+    generateDataAsBatchInsertKeys(req, sqlCfgModel, dataName) {
+        const dataArray = req.getCondOrDataAsArray(dataName);
+        if (MixinUtils_1.MixinUtils.isEmpty(dataArray) || dataArray.length === 0) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.DATA_GET_DATA_EMPTY_ON_INSERT_KEYS, dataName);
+        }
+        const keys = this.getBatchInsertKeys(req, dataArray);
+        const columnList = keys.map(columnName => {
+            return (0, convertColumnName_1.toSqlColumnName)(columnName, sqlCfgModel);
+        });
+        const sql = columnList.join(','); // `column1`,`column2`,`column3`
+        return new SqlSegArg_1.SqlSegArg(sql);
+    }
+    /**
+     * 批量插入：生成值部分，格式为 (?,?,?),(?,?,?),...
+     *
+     * 列名获取策略：
+     * - 优先使用 req.columns（若指定）
+     * - 否则使用严格模式：取第一条数据的 keys，校验后续行字段一致性
+     */
+    generateDataAsBatchInsertValues(req, dataName) {
+        const dataArray = req.getCondOrDataAsArray(dataName);
+        if (MixinUtils_1.MixinUtils.isEmpty(dataArray) || dataArray.length === 0) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.DATA_GET_DATA_EMPTY_ON_INSERT_VALUES, dataName);
+        }
+        const keys = this.getBatchInsertKeys(req, dataArray);
+        const valueGroups = [];
+        const argList = [];
+        for (let i = 0; i < dataArray.length; i++) {
+            const row = dataArray[i];
+            const rowValues = [];
+            for (let j = 0; j < keys.length; j++) {
+                const key = keys[j];
+                const arg = row[key];
+                if (SqlFuncUtils_1.sqlFuncUtils.isSqlFuncArg(arg)) {
+                    rowValues.push(SqlFuncUtils_1.sqlFuncUtils.toFuncSQL(arg));
+                }
+                else {
+                    rowValues.push('?');
+                    argList.push(arg);
+                }
+            }
+            valueGroups.push('(' + rowValues.join(',') + ')');
+        }
+        const sql = valueGroups.join(','); // "(?,?,?),(?,?,?),..."
+        return new SqlSegArg_1.SqlSegArg(sql, argList);
+    }
     generateSqlJavaFunction(requestCfg, tmpFuncName) {
         const exeCtx = this.getExecuteContext();
         const functionCfg = requestCfg.functionCfg;

package/dist/libs/crud-pro/services/CrudProTableMetaService.d.ts

@@ -1,7 +1,21 @@
 import { CrudProServiceBase } from './CrudProServiceBase';
-import { ITableMeta, ITableMetaQuery } from '../interfaces';
+import { ITableListResult, ITableMeta, ITableMetaQuery, ITableNamesQuery, ITableNamesOptions } from '../interfaces';
 declare class CrudProTableMetaService extends CrudProServiceBase {
     getTableMeta(query: ITableMetaQuery): Promise<ITableMeta>;
+    /**
+     * 获取数据库所有表和视图信息（包含类型）
+     *
+     * @param query 数据库查询参数
+     * @param options 缓存控制选项
+     *   - skipCache: 跳过缓存，直接查询数据库
+     *   - refreshCache: 查询后更新缓存
+     */
+    getAllTableInfos(query: ITableNamesQuery, options?: ITableNamesOptions): Promise<ITableListResult>;
+    private getTableInfoCacheKey;
+    private loadAllTableInfos;
+    private loadMySQLAllTableInfos;
+    private loadPostgreSQLAllTableInfos;
+    private loadSQLServerAllTableInfos;
     private loadTableMeta;
     private loadTableColumnDetails;
     private loadMySQLColumnDetails;