@maiyunnet/kebab 9.15.1 → 9.15.2

package/sys/mod.d.ts

@@ -44,6 +44,8 @@ export default class Mod {
     protected static _$pre?: string;
     /** --- 要 update 的内容 --- */
     protected _updates: Record<string, boolean>;
+    /** --- 要在数据库边界序列化的 JSON 字段 --- */
+    protected _jsonUpdates: Record<string, boolean>;
     /** --- 模型获取的属性 --- */
     protected _data: Record<string, any>;
     /** --- 当前选择的分表 _ 后缀，多个代表联查 --- */
@@ -97,7 +99,7 @@ export default class Mod {
         'token': string;
         'value': kebab.DbValue;
     };
-    /** --- 创建 JSON 字符串对象，用于 PGSQL 的 jsonb 字段 --- */
+    /** --- 标记 JSON 字段；模型内保持原始对象，写入数据库时再序列化 --- */
     static json<T>(obj: T): T;
     /**
      * --- 添加一个序列（允许超过 65536 的占位符会被拆分多次执行） ---
@@ -181,9 +183,10 @@ export default class Mod {
     }): lSql.Sql;
     /**
      * --- 批量更新数据 ---
-     * @param db 数据库对象
+     * @param db 数据库对象；多批次需要整体原子性时应传入 Transaction
      * @param data 数据列表，每个元素必须包含 key 字段，其余字段为要更新的列；
-     *             支持稀疏数据（不同元素可以拥有不同的列集合），内部会自动按列集合分组批量执行
+     *             支持稀疏数据（不同元素可以拥有不同的列集合），内部会自动按列集合分组批量执行；
+     *             相同 key 会按输入顺序合并，后出现的同名字段覆盖先出现的值
      * @param key 用于定位待更新记录的字段名，通常为主键或唯一键，至少必须建立索引；
      *            该参数是字段名而不是索引名，仅参与 ON / WHERE 条件匹配，不会被更新；
      *            data 中每个元素都必须包含此字段，否则该元素会被跳过
@@ -304,6 +307,12 @@ export default class Mod {
      * @param obj 要转换的 kv 数据列表
      */
     static toArrayByRecord<T extends Mod>(obj: Record<string, T>): Record<string, Record<string, any>>;
+    /**
+     * --- 设置单个模型属性，并记录是否需要在数据库边界序列化 ---
+     * @param key 字段名
+     * @param value 字段值
+     */
+    private _setProperty;
     set<T extends this, TK extends keyof T>(n: Record<TK, T[TK] | undefined>): void;
     set<T extends this, TK extends keyof T>(n: TK, v: T[TK]): void;
     /**

package/sys/mod.js

@@ -5,6 +5,7 @@
  */
 import * as lSql from '#kebab/lib/sql.js';
 import * as lDb from '#kebab/lib/db.js';
+import * as lSqlValue from '#kebab/lib/sql/value.js';
 import * as lCore from '#kebab/lib/core.js';
 import * as lText from '#kebab/lib/text.js';
 /** --- 条数列表 --- */
@@ -58,6 +59,8 @@ export default class Mod {
     static _$pre;
     /** --- 要 update 的内容 --- */
     _updates = {};
+    /** --- 要在数据库边界序列化的 JSON 字段 --- */
+    _jsonUpdates = {};
     /** --- 模型获取的属性 --- */
     _data = {};
     /** --- 当前选择的分表 _ 后缀，多个代表联查 --- */
@@ -127,7 +130,7 @@ export default class Mod {
     static value(val) {
         return lSql.value(val);
     }
-    /** --- 创建 JSON 字符串对象，用于 PGSQL 的 jsonb 字段 --- */
+    /** --- 标记 JSON 字段；模型内保持原始对象，写入数据库时再序列化 --- */
     static json(obj) {
         return lSql.json(obj);
     }
@@ -308,9 +311,10 @@ export default class Mod {
     }
     /**
      * --- 批量更新数据 ---
-     * @param db 数据库对象
+     * @param db 数据库对象；多批次需要整体原子性时应传入 Transaction
      * @param data 数据列表，每个元素必须包含 key 字段，其余字段为要更新的列；
-     *             支持稀疏数据（不同元素可以拥有不同的列集合），内部会自动按列集合分组批量执行
+     *             支持稀疏数据（不同元素可以拥有不同的列集合），内部会自动按列集合分组批量执行；
+     *             相同 key 会按输入顺序合并，后出现的同名字段覆盖先出现的值
      * @param key 用于定位待更新记录的字段名，通常为主键或唯一键，至少必须建立索引；
      *            该参数是字段名而不是索引名，仅参与 ON / WHERE 条件匹配，不会被更新；
      *            data 中每个元素都必须包含此字段，否则该元素会被跳过
@@ -320,9 +324,23 @@ export default class Mod {
         if (!data.length) {
             return true;
         }
+        // --- 先按 key 合并，避免 UPDATE JOIN / UPDATE FROM 一对多匹配时结果不确定 ---
+        const items = new Map();
+        for (const item of data) {
+            if (!Object.hasOwn(item, key) || item[key] === undefined || item[key] === null) {
+                continue;
+            }
+            const current = items.get(item[key]);
+            if (current) {
+                Object.assign(current, item);
+            }
+            else {
+                items.set(item[key], { ...item });
+            }
+        }
         // --- 按列集合分组（处理稀疏数据，保证每组内所有行的列完全一致）---
         const groups = new Map();
-        for (const item of data) {
+        for (const item of items.values()) {
             const itemCols = Object.keys(item).filter(k => k !== key).sort();
             if (itemCols.length === 0) {
                 continue;
@@ -343,10 +361,14 @@ export default class Mod {
             const service = db.getService() ?? lDb.ESERVICE.PGSQL;
             /** --- 每行占位符数量 = key + 所有列，分批避免超出数据库参数上限 --- */
             const maxBatchSize = Math.floor(65000 / allCols.length);
-            // --- MySQL 单条 UPDATE 太大时解析、物化、锁持有都会变慢，默认小批量多次执行更稳定；
-            //     PostgreSQL 的 VALUES UPDATE 执行计划较稳定，默认尽量吃满参数上限减少网络往返 ---
-            const defaultBatchSize = service === lDb.ESERVICE.MYSQL ? 200 : maxBatchSize;
-            const batchSize = Math.max(1, Math.min(opt.batchSize ?? defaultBatchSize, maxBatchSize));
+            // --- 控制单条 SQL 的解析、临时数据和持锁规模；PostgreSQL 不应默认吃满协议参数上限 ---
+            const defaultBatchSize = service === lDb.ESERVICE.MYSQL ? 200 : 1_000;
+            const requestedBatchSize = opt.batchSize;
+            const normalizedBatchSize = (requestedBatchSize !== undefined &&
+                Number.isSafeInteger(requestedBatchSize) &&
+                requestedBatchSize > 0) ?
+                requestedBatchSize : defaultBatchSize;
+            const batchSize = Math.max(1, Math.min(normalizedBatchSize, maxBatchSize));
             for (let i = 0; i < groupItems.length; i += batchSize) {
                 const batch = groupItems.slice(i, i + batchSize);
                 const sq = lSql.get({
@@ -528,6 +550,25 @@ export default class Mod {
         }
         return rtn;
     }
+    // --- 动态方法 ---
+    /**
+     * --- 设置单个模型属性，并记录是否需要在数据库边界序列化 ---
+     * @param key 字段名
+     * @param value 字段值
+     */
+    _setProperty(key, value) {
+        const isJson = lSqlValue.isJson(value);
+        const rawValue = isJson ? lSqlValue.unwrapJson(value) : value;
+        this._updates[key] = true;
+        if (isJson) {
+            this._jsonUpdates[key] = true;
+        }
+        else {
+            delete this._jsonUpdates[key];
+        }
+        this._data[key] = rawValue;
+        this[key] = rawValue;
+    }
     /**
      * --- 设置一个/多个属性，值为 undefined 则不会被更新 ---
      * @param n 字符串或键/值
@@ -542,9 +583,7 @@ export default class Mod {
                     continue;
                 }
                 // --- 强制更新，因为有的可能就是要强制更新既然设置了 ---
-                this._updates[k] = true;
-                this._data[k] = v;
-                this[k] = v;
+                this._setProperty(k, v);
             }
         }
         else {
@@ -555,9 +594,7 @@ export default class Mod {
             if (typeof n !== 'string') {
                 return;
             }
-            this._updates[n] = true;
-            this._data[n] = v;
-            this[n] = v;
+            this._setProperty(n, v);
         }
     }
     /**
@@ -575,7 +612,7 @@ export default class Mod {
         const cstr = this.constructor;
         const updates = {};
         for (const k in this._updates) {
-            updates[k] = this._data[k];
+            updates[k] = this._jsonUpdates[k] ? lSql.json(this._data[k]) : this._data[k];
         }
         let r = null;
         if ((cstr._$key !== '') && (updates[cstr._$key] === undefined)) {
@@ -647,6 +684,7 @@ export default class Mod {
         }
         if (r.packet?.affected) {
             this._updates = {};
+            this._jsonUpdates = {};
             this._data[cstr._$primary] = r.packet.insert;
             this[cstr._$primary] = this._data[cstr._$primary];
             return true;
@@ -681,6 +719,7 @@ export default class Mod {
             }
             where[field] = this._data[field];
             delete this._updates[field];
+            delete this._jsonUpdates[field];
         }
         return this.save(where);
     }
@@ -730,7 +769,7 @@ export default class Mod {
         }
         const updates = {};
         for (const k in this._updates) {
-            updates[k] = this._data[k];
+            updates[k] = this._jsonUpdates[k] ? lSql.json(this._data[k]) : this._data[k];
         }
         this._sql.update(cstr._$table + (this._index ? ('_' + this._index[0]) : ''), [updates]).where(where ?? {
             [cstr._$primary]: this._data[cstr._$primary]
@@ -742,6 +781,7 @@ export default class Mod {
         }
         if (r.packet.affected) {
             this._updates = {};
+            this._jsonUpdates = {};
             return true;
         }
         else {

package/www/example/ctr/test.js

@@ -687,7 +687,7 @@ Result:<pre id="result">Nothing.</pre>` + this._getEnd();
                     { 'x': 3, 'y': 3 },
                     { 'x': 1, 'y': 1 },
                 ],
-                'json': { 'x': { 'y': 'abc' } },
+                'json': mTest.json({ 'x': { 'y': 'abc' } }),
                 'time_add': time,
             });
             const result = await test.create();
@@ -704,7 +704,7 @@ test.set({
         { 'x': 3, 'y': 3 },
         { 'x': 1, 'y': 1 },
     ],
-    'json': { 'x': { 'y': 'abc' } },
+    'json': mTest.json({ 'x': { 'y': 'abc' } }),
     'time_add': time,
 });
 const result = await test.create();
@@ -800,7 +800,7 @@ await ft.save();</pre>`);
                         { 'x': 7, 'y': 3 },
                         { 'x': 5, 'y': 1 }
                     ],
-                    'json': { 'x': { 'y': 'def' } }
+                    'json': mTest.json({ 'x': { 'y': 'def' } })
                 });
                 await ft.save();
                 await ft.refresh();
@@ -815,7 +815,7 @@ await ft.save();</pre>`);
         { 'x': 7, 'y': 3 },
         { 'x': 5, 'y': 1 }
     ],
-    'json': { 'x': { 'y': 'def' } }
+    'json': mTest.json({ 'x': { 'y': 'def' } })
 });
 await ft.save();
 await ft.refresh();</pre>`);
@@ -2672,7 +2672,7 @@ Result:<pre id="result">Nothing.</pre>`);
                             { 'x': 3, 'y': 3 },
                             { 'x': 1, 'y': 1 }
                         ],
-                        { 'x': { 'y': 'ghi' } }
+                        lSql.json({ 'x': { 'y': 'ghi' } })
                     ],
                     [
                         'POINT B', ['ST_POINTFROMTEXT(?)', ['POINT(123.147775 30.625016)']], { 'x': 1, 'y': 1 }, null, null
@@ -2687,7 +2687,7 @@ Result:<pre id="result">Nothing.</pre>`);
             { 'x': 3, 'y': 3 },
             { 'x': 1, 'y': 1 }
         ],
-        { 'x': { 'y': 'ghi' } }
+        lSql.json({ 'x': { 'y': 'ghi' } })
     ],
     [
         'POINT B', ['ST_POINTFROMTEXT(?)', ['POINT(123.147775 30.625016)']], { 'x': 1, 'y': 1 }, null, null
@@ -2794,10 +2794,22 @@ Result:<pre id="result">Nothing.</pre>`);
 <b>getSql() :</b> ${s}<br>
 <b>getData():</b> <pre>${JSON.stringify(sd, undefined, 4)}</pre>
 <b>format() :</b> ${sql.format(s, sd)}`);
-                // --- json ---
-                s = sql.update('json', { 'json1': { 'key': 'val', 'key2': 'val2' }, 'json2': [{ 'k1': 'v1' }, { 'k2': 'v2' }], 'json3': { 'x': 1, 'y': 2 }, 'json4': [], 'json5': {} }).where({ 'id': 1 }).getSql();
+                // --- JSON/jsonb 字段使用 json() 显式标记 ---
+                s = sql.update('json', {
+                    'json1': lSql.json({ 'key': 'val', 'key2': 'val2' }),
+                    'json2': lSql.json([{ 'k1': 'v1' }, { 'k2': 'v2' }]),
+                    'json3': lSql.json({ 'x': 1, 'y': 2 }),
+                    'json4': lSql.json([]),
+                    'json5': lSql.json({})
+                }).where({ 'id': 1 }).getSql();
                 sd = sql.getData();
-                echo.push(`<pre>sql.update('json', { 'json1': { 'key': 'val', 'key2': 'val2' }, 'json2': [ { 'k1': 'v1' }, { 'k2': 'v2' } ], 'json3': { 'x': 1, 'y': 2 }, 'json4': [], 'json5': {} }).where({ 'id': 1 });</pre>
+                echo.push(`<pre>sql.update('json', {
+    'json1': lSql.json({ 'key': 'val', 'key2': 'val2' }),
+    'json2': lSql.json([ { 'k1': 'v1' }, { 'k2': 'v2' } ]),
+    'json3': lSql.json({ 'x': 1, 'y': 2 }),
+    'json4': lSql.json([]),
+    'json5': lSql.json({})
+}).where({ 'id': 1 });</pre>
 <b>getSql() :</b> ${s}<br>
 <b>getData():</b> <pre>${JSON.stringify(sd, undefined, 4)}</pre>
 <b>format() :</b> ${sql.format(s, sd)}`);