befly 3.20.8 → 3.20.9

package/lib/dbHelper/dataOps.js

@@ -7,13 +7,102 @@ import { addDefaultStateFilter, buildInsertRow, buildPartialUpdateData, buildUpd
 import { assertBatchInsertRowsConsistent, assertNoUndefinedInRecord, validateGeneratedBatchId, validateIncrementOptions, validateInsertBatchSize, validateNoLeftJoinReadOptions, validatePageLimitRange, validateSafeFieldName, validateTableBatchDataOptions, validateTableDataOptions, validateTableName, validateTableWhereOptions } from "./validate.js";
 
 export const dataOpsMethods = {
+    prepareSingleTableWhere(table, where, useDefaultStateFilter = true) {
+        const snakeTable = snakeCase(table);
+        const snakeWhere = whereKeysToSnake(clearDeep(where || {}));
+
+        return {
+            snakeTable: snakeTable,
+            whereFiltered: useDefaultStateFilter ? addDefaultStateFilter(snakeWhere, snakeTable, false, this.beflyMode) : snakeWhere
+        };
+    },
+
+    async createInsertRows(table, snakeTable, dataList, now) {
+        if (this.beflyMode === "manual") {
+            return {
+                ids: [],
+                processedList: dataList.map((data) =>
+                    buildInsertRow({
+                        data: data,
+                        now: now,
+                        beflyMode: this.beflyMode
+                    })
+                )
+            };
+        }
+
+        const ids = [];
+        try {
+            for (let i = 0; i < dataList.length; i++) {
+                ids.push(await this.redis.genTimeID());
+            }
+        } catch (error) {
+            if (dataList.length === 1) {
+                throw new Error(`生成 ID 失败，Redis 可能不可用 (table: ${table})`, {
+                    cause: error,
+                    code: "runtime",
+                    subsystem: "db",
+                    operation: "genTimeId",
+                    table: table
+                });
+            }
+            throw error;
+        }
+
+        const processedList = dataList.map((data, index) => {
+            const id = ids[index];
+            if (dataList.length > 1) {
+                validateGeneratedBatchId(id, snakeTable, index);
+            }
+
+            return buildInsertRow({
+                data: data,
+                id: id,
+                now: now,
+                beflyMode: this.beflyMode
+            });
+        });
+
+        return {
+            ids: ids,
+            processedList: processedList
+        };
+    },
+
+    resolveInsertedData(table, count, executeRes, generatedIds, operation) {
+        const lastInsertRowidNum = normalizeSqlMetaNumber(executeRes.data?.lastInsertRowid);
+
+        if (this.beflyMode === "manual") {
+            if (lastInsertRowidNum <= 0) {
+                throw new Error(operation === "insBatch" ? `批量插入失败：beflyMode=manual 时无法获取 lastInsertRowid (table: ${table})` : `插入失败：beflyMode=manual 时无法获取 lastInsertRowid (table: ${table})`, {
+                    cause: null,
+                    code: "runtime"
+                });
+            }
+
+            if (count === 1) {
+                return lastInsertRowidNum;
+            }
+
+            const outIds = [];
+            for (let i = 0; i < count; i++) {
+                outIds.push(lastInsertRowidNum + i);
+            }
+            return outIds;
+        }
+
+        if (count === 1) {
+            const generatedId = generatedIds[0];
+            return (isNumber(generatedId) ? generatedId : 0) || lastInsertRowidNum || 0;
+        }
+
+        return generatedIds;
+    },
+
     // 读取操作
     async getCount(options) {
-        const { table, where, leftJoins, tableQualifier } = await this.prepareQueryOptions(options, "getCount.options");
-        const hasLeftJoin = Array.isArray(leftJoins) && leftJoins.length > 0;
-
-        const whereFiltered = addDefaultStateFilter(where, tableQualifier, hasLeftJoin, this.beflyMode);
-        const result = await this.fetchCount({ table: table, leftJoins: leftJoins }, whereFiltered, "COUNT(*) as count");
+        const { prepared, whereFiltered } = await this.prepareReadContext(options, "getCount.options");
+        const result = await this.fetchCount(prepared, whereFiltered, "COUNT(*) as count");
 
         return {
             data: result.total,
@@ -22,12 +111,9 @@ export const dataOpsMethods = {
     },
 
     async getOne(options) {
-        const { table, fields, where, leftJoins, tableQualifier } = await this.prepareQueryOptions(options, "getOne.options");
-        const hasLeftJoin = Array.isArray(leftJoins) && leftJoins.length > 0;
-
-        const whereFiltered = addDefaultStateFilter(where, tableQualifier, hasLeftJoin, this.beflyMode);
-        const builder = this.createSqlBuilder().select(fields).from(table).where(whereFiltered);
-        this.applyLeftJoins(builder, leftJoins);
+        const { prepared, whereFiltered } = await this.prepareReadContext(options, "getOne.options");
+        const builder = this.createSqlBuilder().select(prepared.fields).from(prepared.table).where(whereFiltered);
+        this.applyLeftJoins(builder, prepared.leftJoins);
 
         const { sql, params } = builder.toSelectSql();
         const executeRes = await this.execute(sql, params);
@@ -45,11 +131,8 @@ export const dataOpsMethods = {
     },
 
     async getList(options) {
-        const prepared = await this.prepareQueryOptions(options, "getList.options");
+        const { prepared, whereFiltered } = await this.prepareReadContext(options, "getList.options");
         validatePageLimitRange(prepared, options.table);
-
-        const hasLeftJoin = Array.isArray(prepared.leftJoins) && prepared.leftJoins.length > 0;
-        const whereFiltered = addDefaultStateFilter(prepared.where, prepared.tableQualifier, hasLeftJoin, this.beflyMode);
         const countResult = await this.fetchCount(prepared, whereFiltered, "COUNT(*) as total");
         const total = countResult.total;
 
@@ -98,10 +181,7 @@ export const dataOpsMethods = {
         const MAX_LIMIT = 100000;
         const WARNING_LIMIT = 10000;
         const prepareOptions = this.buildQueryOptions(options, { page: 1, limit: 10 });
-        const prepared = await this.prepareQueryOptions(prepareOptions, "getAll.options");
-
-        const hasLeftJoin = Array.isArray(prepared.leftJoins) && prepared.leftJoins.length > 0;
-        const whereFiltered = addDefaultStateFilter(prepared.where, prepared.tableQualifier, hasLeftJoin, this.beflyMode);
+        const { prepared, whereFiltered } = await this.prepareReadContext(prepareOptions, "getAll.options");
         const countResult = await this.fetchCount(prepared, whereFiltered, "COUNT(*) as total");
         const total = countResult.total;
 
@@ -147,11 +227,9 @@ export const dataOpsMethods = {
 
     async exists(options) {
         validateNoLeftJoinReadOptions(options, "exists", "exists 不支持 leftJoin（请使用显式 query 或拆分查询）");
-        const snakeTable = snakeCase(options.table);
-        const snakeWhere = whereKeysToSnake(clearDeep(options.where || {}));
-        const whereFiltered = addDefaultStateFilter(snakeWhere, snakeTable, false, this.beflyMode);
+        const prepared = this.prepareSingleTableWhere(options.table, options.where, true);
 
-        const builder = this.createSqlBuilder().selectRaw("COUNT(1) as cnt").from(snakeTable).where(whereFiltered).limit(1);
+        const builder = this.createSqlBuilder().selectRaw("COUNT(1) as cnt").from(prepared.snakeTable).where(prepared.whereFiltered).limit(1);
         const { sql, params } = builder.toSelectSql();
         const executeRes = await this.execute(sql, params);
         const exists = (executeRes.data?.[0]?.cnt || 0) > 0;
@@ -190,34 +268,8 @@ export const dataOpsMethods = {
         const { table, data } = options;
         const snakeTable = snakeCase(table);
         const now = Date.now();
-
-        let processed;
-        if (this.beflyMode === "manual") {
-            processed = buildInsertRow({
-                data: data,
-                now: now,
-                beflyMode: this.beflyMode
-            });
-        } else {
-            let id;
-            try {
-                id = await this.redis.genTimeID();
-            } catch (error) {
-                throw new Error(`生成 ID 失败，Redis 可能不可用 (table: ${table})`, {
-                    cause: error,
-                    code: "runtime",
-                    subsystem: "db",
-                    operation: "genTimeId",
-                    table: table
-                });
-            }
-            processed = buildInsertRow({
-                data: data,
-                id: id,
-                now: now,
-                beflyMode: this.beflyMode
-            });
-        }
+        const insertRows = await this.createInsertRows(table, snakeTable, [data], now);
+        const processed = insertRows.processedList[0];
 
         assertNoUndefinedInRecord(processed, `insData 插入数据 (table: ${snakeTable})`);
 
@@ -225,19 +277,8 @@ export const dataOpsMethods = {
         const { sql, params } = builder.toInsertSql(snakeTable, processed);
         const executeRes = await this.execute(sql, params);
 
-        const processedId = processed["id"];
-        const processedIdNum = isNumber(processedId) ? processedId : 0;
-        const lastInsertRowidNum = normalizeSqlMetaNumber(executeRes.data?.lastInsertRowid);
-
-        const insertedId = this.beflyMode === "manual" ? lastInsertRowidNum || 0 : processedIdNum || lastInsertRowidNum || 0;
-        if (this.beflyMode === "manual" && insertedId <= 0) {
-            throw new Error(`插入失败：beflyMode=manual 时无法获取 lastInsertRowid (table: ${table})`, {
-                cause: null,
-                code: "runtime"
-            });
-        }
         return {
-            data: insertedId,
+            data: this.resolveInsertedData(table, 1, executeRes, insertRows.ids, "insData"),
             sql: executeRes.sql
         };
     },
@@ -256,25 +297,8 @@ export const dataOpsMethods = {
 
         const snakeTable = snakeCase(table);
         const now = Date.now();
-        let ids = [];
-
-        let processedList;
-        if (this.beflyMode === "manual") {
-            processedList = dataList.map((data) => {
-                return buildInsertRow({ data: data, now: now, beflyMode: this.beflyMode });
-            });
-        } else {
-            const nextIds = [];
-            for (let i = 0; i < dataList.length; i++) {
-                nextIds.push(await this.redis.genTimeID());
-            }
-            ids = nextIds;
-            processedList = dataList.map((data, index) => {
-                const id = nextIds[index];
-                validateGeneratedBatchId(id, snakeTable, index);
-                return buildInsertRow({ data: data, id: id, now: now, beflyMode: this.beflyMode });
-            });
-        }
+        const insertRows = await this.createInsertRows(table, snakeTable, dataList, now);
+        const processedList = insertRows.processedList;
 
         const insertFields = assertBatchInsertRowsConsistent(processedList, { table: snakeTable });
         const builder = this.createSqlBuilder();
@@ -282,29 +306,8 @@ export const dataOpsMethods = {
 
         try {
             const executeRes = await this.execute(sql, params);
-
-            if (this.beflyMode === "manual") {
-                const firstId = normalizeSqlMetaNumber(executeRes.data?.lastInsertRowid);
-                if (firstId <= 0) {
-                    throw new Error(`批量插入失败：beflyMode=manual 时无法获取 lastInsertRowid (table: ${table})`, {
-                        cause: null,
-                        code: "runtime"
-                    });
-                }
-
-                const outIds = [];
-                for (let i = 0; i < dataList.length; i++) {
-                    outIds.push(firstId + i);
-                }
-
-                return {
-                    data: outIds,
-                    sql: executeRes.sql
-                };
-            }
-
             return {
-                data: ids,
+                data: this.resolveInsertedData(table, dataList.length, executeRes, insertRows.ids, "insBatch"),
                 sql: executeRes.sql
             };
         } catch (error) {
@@ -409,13 +412,11 @@ export const dataOpsMethods = {
         validateTableDataOptions(options, "updData");
         validateTableWhereOptions(options, "updData", true);
         const { table, data, where } = options;
-        const snakeTable = snakeCase(table);
-        const snakeWhere = whereKeysToSnake(clearDeep(where));
+        const prepared = this.prepareSingleTableWhere(table, where, true);
 
         const processed = buildUpdateRow({ data: data, now: Date.now(), allowState: true, beflyMode: this.beflyMode });
-        const whereFiltered = addDefaultStateFilter(snakeWhere, snakeTable, false, this.beflyMode);
-        const builder = this.createSqlBuilder().where(whereFiltered);
-        const { sql, params } = builder.toUpdateSql(snakeTable, processed);
+        const builder = this.createSqlBuilder().where(prepared.whereFiltered);
+        const { sql, params } = builder.toUpdateSql(prepared.snakeTable, processed);
 
         const executeRes = await this.execute(sql, params);
         const changes = normalizeSqlMetaNumber(executeRes.data?.affectedRows);
@@ -428,8 +429,7 @@ export const dataOpsMethods = {
     async delData(options) {
         validateTableWhereOptions(options, "delData", true);
         const { table, where } = options;
-        const snakeTable = snakeCase(table);
-        const snakeWhere = whereKeysToSnake(clearDeep(where));
+        const prepared = this.prepareSingleTableWhere(table, where, true);
         const now = Date.now();
         const processed = {
             state: 0,
@@ -440,9 +440,8 @@ export const dataOpsMethods = {
             processed.updated_at = now;
         }
 
-        const whereFiltered = addDefaultStateFilter(snakeWhere, snakeTable, false, this.beflyMode);
-        const builder = this.createSqlBuilder().where(whereFiltered);
-        const { sql, params } = builder.toUpdateSql(snakeTable, processed);
+        const builder = this.createSqlBuilder().where(prepared.whereFiltered);
+        const { sql, params } = builder.toUpdateSql(prepared.snakeTable, processed);
         const executeRes = await this.execute(sql, params);
         const changes = normalizeSqlMetaNumber(executeRes.data?.affectedRows);
 
@@ -456,11 +455,10 @@ export const dataOpsMethods = {
         validateTableWhereOptions(options, "delForce", true);
         const { table, where } = options;
 
-        const snakeTable = snakeCase(table);
-        const snakeWhere = whereKeysToSnake(clearDeep(where));
+        const prepared = this.prepareSingleTableWhere(table, where, false);
 
-        const builder = this.createSqlBuilder().where(snakeWhere);
-        const { sql, params } = builder.toDeleteSql(snakeTable);
+        const builder = this.createSqlBuilder().where(prepared.whereFiltered);
+        const { sql, params } = builder.toDeleteSql(prepared.snakeTable);
 
         const executeRes = await this.execute(sql, params);
         const changes = normalizeSqlMetaNumber(executeRes.data?.affectedRows);
@@ -498,15 +496,13 @@ export const dataOpsMethods = {
 
     async increment(table, field, where, value = 1) {
         validateIncrementOptions(table, field, where, value, "increment");
-        const snakeTable = snakeCase(table);
+        const prepared = this.prepareSingleTableWhere(table, where, true);
         const snakeField = snakeCase(field);
 
-        const snakeWhere = whereKeysToSnake(clearDeep(where));
-        const whereFiltered = addDefaultStateFilter(snakeWhere, snakeTable, false, this.beflyMode);
-        const builder = this.createSqlBuilder().where(whereFiltered);
+        const builder = this.createSqlBuilder().where(prepared.whereFiltered);
         const { sql: whereClause, params: whereParams } = builder.getWhereConditions();
 
-        const quotedTable = quoteIdentMySql(snakeTable);
+        const quotedTable = quoteIdentMySql(prepared.snakeTable);
         const quotedField = quoteIdentMySql(snakeField);
         const sql = whereClause ? `UPDATE ${quotedTable} SET ${quotedField} = ${quotedField} + ? WHERE ${whereClause}` : `UPDATE ${quotedTable} SET ${quotedField} = ${quotedField} + ?`;
 

package/lib/dbHelper/validate.js

@@ -1,6 +1,39 @@
 import { isFiniteNumber, isNonEmptyString, isNullable, isPlainObject, isString } from "../../utils/is.js";
 import { snakeCase } from "../../utils/util.js";
 
+function validateJoinFieldRef(value, label) {
+    if (!isNonEmptyString(value)) {
+        throw new Error(`${label} 不能为空`, {
+            cause: null,
+            code: "validation"
+        });
+    }
+
+    const parts = value.split(".").map((item) => item.trim());
+    if (parts.length !== 2 || !isNonEmptyString(parts[0]) || !isNonEmptyString(parts[1])) {
+        throw new Error(`${label} 必须是 alias.field 格式`, {
+            cause: null,
+            code: "validation"
+        });
+    }
+}
+
+function parseLeftJoinEquality(joinItem) {
+    if (!isNonEmptyString(joinItem)) {
+        return null;
+    }
+
+    const match = joinItem.match(/^([a-zA-Z_][a-zA-Z0-9_]*\.[a-zA-Z_][a-zA-Z0-9_]*) ([a-zA-Z_][a-zA-Z0-9_]*\.[a-zA-Z_][a-zA-Z0-9_]*)$/);
+    if (!match) {
+        return null;
+    }
+
+    return {
+        left: match[1],
+        right: match[2]
+    };
+}
+
 function assertNonEmptyString(value, label) {
     if (!isNonEmptyString(value)) {
         throw new Error(`${label} 必须是非空字符串`, {
@@ -147,30 +180,60 @@ function validateLeftJoinItems(leftJoin, label) {
             });
         }
 
-        const parts = joinItem.split(/\s+ON\s+/i);
-        if (parts.length !== 2) {
-            throw new Error(`${label}[${i}] 必须是 "table alias ON left.field = right.field" 格式`, {
+        const parsed = parseLeftJoinEquality(joinItem);
+        if (!parsed) {
+            throw new Error(`${label}[${i}] 必须是 "left.field right.field" 格式（空格表示等于）`, {
                 cause: null,
                 code: "validation"
             });
         }
 
-        const tableRef = parts[0]?.trim();
-        const on = parts[1]?.trim();
-        if (!isNonEmptyString(tableRef)) {
-            throw new Error(`${label}[${i}] 缺少 leftJoin 表名`, {
+        validateJoinFieldRef(parsed.left, `${label}[${i}] 左侧字段`);
+        validateJoinFieldRef(parsed.right, `${label}[${i}] 右侧字段`);
+    }
+}
+
+function validateQueryTableOption(table, leftJoin, label) {
+    if (Array.isArray(table)) {
+        if (table.length === 0) {
+            throw new Error(`${label}.table 不能为空数组`, {
                 cause: null,
                 code: "validation"
             });
         }
-        if (!isNonEmptyString(on)) {
-            throw new Error(`${label}[${i}] 缺少 leftJoin 的 ON 条件`, {
+
+        for (let i = 0; i < table.length; i++) {
+            assertNonEmptyString(table[i], `${label}.table[${i}]`);
+            parseTableRef(table[i]);
+        }
+
+        if (Array.isArray(leftJoin) && leftJoin.length > 0) {
+            if (table.length !== leftJoin.length + 1) {
+                throw new Error(`${label}.table 与 ${label}.leftJoin 数量不匹配，要求 table.length = leftJoin.length + 1`, {
+                    cause: null,
+                    code: "validation"
+                });
+            }
+            return;
+        }
+
+        if (table.length > 1) {
+            throw new Error(`${label}.table 为数组时必须配合 leftJoin 使用`, {
                 cause: null,
                 code: "validation"
             });
         }
+        return;
+    }
 
-        parseTableRef(tableRef);
+    assertNonEmptyString(table, `${label}.table`);
+    parseTableRef(table);
+
+    if (Array.isArray(leftJoin) && leftJoin.length > 0) {
+        throw new Error(`${label}.leftJoin 启用时，${label}.table 必须是数组`, {
+            cause: null,
+            code: "validation"
+        });
     }
 }
 
@@ -194,7 +257,7 @@ export function validateQueryOptions(options, label) {
         });
     }
 
-    assertNonEmptyString(options.table, `${label}.table`);
+    validateQueryTableOption(options.table, options.leftJoin, label);
 
     if (!isNullable(options.where)) {
         validateWhereObject(options.where, `${label}.where`);
@@ -232,11 +295,7 @@ export function validateQueryOptions(options, label) {
     }
 }
 
-export function validateWriteData(data, label) {
-    assertPlainObjectValue(data, label);
-}
-
-export function validateBatchDataList(dataList, label) {
+function validateBatchDataList(dataList, label) {
     if (!Array.isArray(dataList)) {
         throw new Error(`${label} 必须是数组`, {
             cause: null,
@@ -265,7 +324,7 @@ export function validateTableWhereOptions(options, label, required = false) {
 
 export function validateTableDataOptions(options, label) {
     validateTableName(options.table, `${label}.table`);
-    validateWriteData(options.data, `${label}.data`);
+    assertPlainObjectValue(options.data, `${label}.data`);
 }
 
 export function validateTableBatchDataOptions(table, dataList, label) {
@@ -274,20 +333,29 @@ export function validateTableBatchDataOptions(table, dataList, label) {
 }
 
 export function validateNoLeftJoinReadOptions(options, label, joinErrorMessage) {
-    validateTableWhereOptions(options, label, false);
+    validateTableName(options.table, `${label}.table`);
+    validateWhereObject(options.where, `${label}.where`, false);
     validateNoLeftJoin(options.leftJoin, joinErrorMessage);
     validateLegacyJoinOptions(options, label);
     validateSimpleTableName(options.table, label);
 }
 
 export function validateIncrementOptions(table, field, where, value, label) {
-    validateTableWhereOptions({ table: table, where: where }, label, true);
+    validateTableName(table, `${label}.table`);
+    validateWhereObject(where, `${label}.where`, true);
     validateSafeFieldName(snakeCase(table));
     validateSafeFieldName(snakeCase(field));
     validateIncrementValue(table, field, value);
 }
 
 export function validateSimpleTableName(rawTable, label) {
+    if (Array.isArray(rawTable)) {
+        throw new Error(`${label}.table 不支持数组`, {
+            cause: null,
+            code: "validation"
+        });
+    }
+
     const table = isString(rawTable) ? rawTable.trim() : "";
     if (!table) {
         throw new Error(`${label}.table 不能为空`, {
@@ -319,7 +387,7 @@ export function validateSafeFieldName(field) {
 }
 
 export function validatePageLimitRange(prepared, rawTable) {
-    if (prepared.page < 1 || prepared.page > 100000) {
+    if (prepared.page < 1 || prepared.page > 10000) {
         throw new Error(`页码必须在 1 到 10000 之间 (table: ${rawTable}, page: ${prepared.page}, limit: ${prepared.limit})`, {
             cause: null,
             code: "validation"

package/lib/sqlBuilder/batch.js

@@ -1,22 +1,21 @@
-import { SqlErrors } from "./errors.js";
 import { isNonEmptyString } from "../../utils/is.js";
 import { SqlCheck } from "./check.js";
 
 export function toDeleteInSql(options) {
     if (!isNonEmptyString(options.table)) {
-        throw new Error(SqlErrors.TO_DELETE_IN_NEED_TABLE(options.table), {
+        throw new Error(`toDeleteInSql 需要非空表名 (table: ${String(options.table)})`, {
             cause: null,
             code: "validation"
         });
     }
     if (!isNonEmptyString(options.idField)) {
-        throw new Error(SqlErrors.TO_DELETE_IN_NEED_ID_FIELD(options.idField), {
+        throw new Error(`toDeleteInSql 需要非空 idField (idField: ${String(options.idField)})`, {
             cause: null,
             code: "validation"
         });
     }
     if (!Array.isArray(options.ids)) {
-        throw new Error(SqlErrors.TO_DELETE_IN_NEED_IDS, {
+        throw new Error("toDeleteInSql 需要 ids 数组", {
             cause: null,
             code: "validation"
         });
@@ -36,19 +35,19 @@ export function toDeleteInSql(options) {
 
 export function toUpdateCaseByIdSql(options) {
     if (!isNonEmptyString(options.table)) {
-        throw new Error(SqlErrors.TO_UPDATE_CASE_NEED_TABLE(options.table), {
+        throw new Error(`toUpdateCaseByIdSql 需要非空表名 (table: ${String(options.table)})`, {
             cause: null,
             code: "validation"
         });
     }
     if (!isNonEmptyString(options.idField)) {
-        throw new Error(SqlErrors.TO_UPDATE_CASE_NEED_ID_FIELD(options.idField), {
+        throw new Error(`toUpdateCaseByIdSql 需要非空 idField (idField: ${String(options.idField)})`, {
             cause: null,
             code: "validation"
         });
     }
     if (!Array.isArray(options.rows)) {
-        throw new Error(SqlErrors.TO_UPDATE_CASE_NEED_ROWS, {
+        throw new Error("toUpdateCaseByIdSql 需要 rows 数组", {
             cause: null,
             code: "validation"
         });
@@ -57,7 +56,7 @@ export function toUpdateCaseByIdSql(options) {
         return { sql: "", params: [] };
     }
     if (!Array.isArray(options.fields)) {
-        throw new Error(SqlErrors.TO_UPDATE_CASE_NEED_FIELDS, {
+        throw new Error("toUpdateCaseByIdSql 需要 fields 数组", {
             cause: null,
             code: "validation"
         });