@maiyunnet/kebab 9.15.1 → 9.15.3

package/lib/sql.js

@@ -1,5 +1,6 @@
 import * as lText from '#kebab/lib/text.js';
 import * as lCore from '#kebab/lib/core.js';
+import * as lSqlValue from '#kebab/lib/sql/value.js';
 // --- 第三方 ---
 import * as mysql2 from 'mysql2/promise';
 /** --- 服务商定义 --- */
@@ -198,7 +199,7 @@ export class Sql {
     /**
      * --- 批量 UPDATE，以子查询作为数据源，纯更新语义（不会插入新行）---
      * --- MySQL: UPDATE t INNER JOIN (SELECT col AS alias ... UNION ALL SELECT ...) AS tmp ON t.key=tmp.key SET t.c=tmp.c ---
-     * --- PostgreSQL: UPDATE t SET c=tmp.c FROM (VALUES ($1,...)) AS tmp(cols) WHERE t.key=tmp.key ---
+     * --- PostgreSQL: UPDATE t SET c=tmp.c FROM (VALUES (typed nulls), ($1,...)) AS tmp(cols) WHERE t.key=tmp.key ---
      * @param table 表名
      * @param key 用于定位待更新记录的字段名，通常为主键或唯一键，至少必须建立索引；
      *         该参数是字段名而不是索引名，仅参与 ON / WHERE 匹配，不会被更新
@@ -234,17 +235,18 @@ export class Sql {
             this._sql = [`UPDATE (${selectParts.join(' UNION ALL ')}) AS tmp STRAIGHT_JOIN ${quotedTable} t ON t.${quotedKey} = tmp.${quotedKey} SET ${setClauses}`];
         }
         else {
-            // --- PostgreSQL 使用 UPDATE FROM (VALUES ...) ---
+            // --- PostgreSQL 使用 UPDATE FROM (VALUES ...)；首行从目标表复合类型取得真实列类型，
+            //     避免按 JS 值猜测类型时 uuid、日期、枚举、数组或 NULL 列无法匹配 ---
             const valueParts = [];
-            for (let ri = 0; ri < rows.length; ri++) {
-                const row = rows[ri];
+            const typeParts = allCols.map(c => `(NULL::${quotedTable}).${this.field(c)}`);
+            valueParts.push(`(${typeParts.join(', ')})`);
+            for (const row of rows) {
                 const parts = row.map(v => {
                     const result = this._processValue(v);
                     if (result.data.length > 0) {
                         this._data.push(...result.data);
                     }
-                    // --- 第一行加显式类型转换，帮助 PostgreSQL 推断 VALUES 派生表的列类型 ---
-                    return ri === 0 ? result.sql + this._pgCastSuffix(v) : result.sql;
+                    return result.sql;
                 });
                 valueParts.push(`(${parts.join(', ')})`);
             }
@@ -309,16 +311,15 @@ export class Sql {
     _updateSub(s) {
         /*
         [
-            ['total', '+', '1'],    // 1, '1' 可能也是 1 数字类型
+            ['total', '+', '1'],
             {
-                'type': '6',        // 2
-                'type': column('type2'),   // 3
-                // 'type': ['type3'],  // 4 - 此写法已被禁止，请用 (3) 代替
-                'type': ['(CASE `id` WHEN 1 THEN ? WHEN 2 THEN ? END)', ['val1', 'val2']],     // 5
-                'point': { 'x': 0, 'y': 0 },  // 6
-                'polygon': [ [ { 'x': 0, 'y': 0 }, { ... } ], [ ... ] ],          // 7
-                'json': { 'a': 1, 'b': { 'c': 2 }, 'c': [ { 'c': 2 } ] },         // 8 - 对象类 json，可能为空对象
-                'json2': ['abc']    // 9 - 数组类 json，可能为空数组
+                'type': '6',
+                'type': column('type2'),
+                'type': ['(CASE `id` WHEN 1 THEN ? WHEN 2 THEN ? END)', ['val1', 'val2']],
+                'point': { 'x': 0, 'y': 0 },
+                'polygon': [ [ { 'x': 0, 'y': 0 }, { ... } ], [ ... ] ],
+                'json': json({ 'a': 1, 'b': { 'c': 2 }, 'c': [ { 'c': 2 } ] }),
+                'json2': json(['abc'])
             }
         ]
         */
@@ -327,7 +328,7 @@ export class Sql {
         for (const k in s) {
             const v = s[k];
             if (/^[0-9]+$/.test(k)) {
-                // --- 1 ---
+                // --- 数组运算式：[字段, 运算符, 值] ---
                 const nv = v[2];
                 const isf = this._isField(nv);
                 if (isf) {
@@ -339,17 +340,22 @@ export class Sql {
                     }
                 }
                 else {
+                    /** --- JSON 标记值需要生成 ::jsonb；普通运算值保持原占位符行为 --- */
+                    const result = lSqlValue.isJson(nv) ? this._processValue(nv) : {
+                        'sql': this._placeholder(),
+                        'data': [nv],
+                    };
                     if (v[1] === '=') {
-                        sql += this.field(v[0]) + ' = ' + this._placeholder() + ', ';
+                        sql += this.field(v[0]) + ' = ' + result.sql + ', ';
                     }
                     else {
-                        sql += this.field(v[0]) + ' = ' + this.field(v[0]) + ' ' + v[1] + ' ' + this._placeholder() + ', ';
+                        sql += this.field(v[0]) + ' = ' + this.field(v[0]) + ' ' + v[1] + ' ' + result.sql + ', ';
                     }
-                    this._data.push(nv);
+                    this._data.push(...result.data);
                 }
             }
             else {
-                // --- 2, 3, 4, 5, 6, 7, 8 ---
+                // --- 对象赋值式：{字段: 值} ---
                 sql += this.field(k) + ' = ';
                 const result = this._processValue(v);
                 sql += result.sql + ', ';
@@ -497,14 +503,13 @@ export class Sql {
     _whereDataPosition = [0, 0];
     /**
      * --- 筛选器 ---
-     * --- 1. 'city': 'bj', 'type': '2' ---
-     * --- 2. ['type', '>', '1'] ---
-     * --- 3. ['type', 'in', ['1', '2']] ---
-     * --- 4. 'type': ['1', '2'] ---
-     * --- 5. '$or': [{'city': 'bj'}, {'city': 'sh'}, [['age', '>', '10']]], 'type': '2' ---
-     * --- 6. 'city_in': column('city_out') ---
-     * --- 7. ['JSON_CONTAINS(`uid`, ?)', ['hello']] ---
-     * --- 8. ['info', 'json', {'a': 1}] ---
+     * --- 标量相等：'city': 'bj', 'type': '2' ---
+     * --- 运算符条件：['type', '>', '1'] ---
+     * --- 集合条件：['type', 'in', ['1', '2']] 或 'type': ['1', '2'] ---
+     * --- 逻辑分组：'$or': [{'city': 'bj'}, {'city': 'sh'}, [['age', '>', '10']]] ---
+     * --- 字段比较：'city_in': column('city_out') ---
+     * --- 原始条件：['JSON_CONTAINS(`uid`, ?)', ['hello']] ---
+     * --- JSON 条件：['info', 'json', {'a': 1}] ---
      * @param s 筛选数据
      */
     where(s) {
@@ -546,18 +551,18 @@ export class Sql {
         for (const k in s) {
             const v = s[k];
             if (/^[0-9]+$/.test(k)) {
-                // --- 2, 3, 7 ---
+                // --- 数组条件或原始 SQL 条件 ---
                 if (v[2] === undefined) {
-                    // --- 7 ---
+                    // --- 原始 SQL 条件及参数 ---
                     sql += this.field(v[0]) + ' AND ';
                     if (v[1] !== undefined) {
                         data.push(...v[1]);
                     }
                 }
                 else if (typeof v[1] === 'string' && ['json', 'json_in', 'json_key', 'json_any', 'json_all', 'json_overlaps'].includes(v[1].toLowerCase())) {
-                    // --- json ---
+                    // --- JSON 操作符条件 ---
                     const op = v[1].toLowerCase();
-                    const nv = v[2];
+                    const nv = lSqlValue.unwrapJson(v[2]);
                     if (op === 'json') {
                         if (this._service === ESERVICE.MYSQL) {
                             sql += `JSON_CONTAINS(${this.field(v[0])}, ${this._placeholder()}) AND `;
@@ -614,7 +619,7 @@ export class Sql {
                     }
                 }
                 else if (v[2] === null) {
-                    // --- 3: null ---
+                    // --- NULL 比较 ---
                     let opera = v[1];
                     if (opera === '!=' || opera === '!==' || opera === '<>') {
                         opera = 'IS NOT';
@@ -628,7 +633,7 @@ export class Sql {
                     sql += this.field(v[0]) + ' ' + opera + ' NULL AND ';
                 }
                 else if (Array.isArray(v[2])) {
-                    // --- 3 ---
+                    // --- IN 等集合比较 ---
                     sql += this.field(v[0]) + ' ' + v[1].toUpperCase() + ' (';
                     for (const v1 of v[2]) {
                         if (Array.isArray(v1)) {
@@ -647,7 +652,7 @@ export class Sql {
                     sql = sql.slice(0, -2) + ') AND ';
                 }
                 else {
-                    // --- 2, 6 ---
+                    // --- 普通运算符或字段比较 ---
                     const nv = v[2];
                     // --- v[0] 也可以是 value() 包裹的字面量值，而不一定是字段名 ---
                     const isv0 = this._isValue(v[0]);
@@ -657,19 +662,23 @@ export class Sql {
                     }
                     const isf = this._isField(nv);
                     if (isf) {
-                        // --- 6. field ---
+                        // --- 字段比较 ---
                         sql += v0sql + ' ' + v[1] + ' ' + this.field(nv.value) + ' AND ';
                     }
                     else {
-                        sql += v0sql + ' ' + v[1] + ' ' + this._placeholder() + ' AND ';
-                        data.push(nv);
+                        const result = lSqlValue.isJson(nv) ? this._processValue(nv) : {
+                            'sql': this._placeholder(),
+                            'data': [nv],
+                        };
+                        sql += v0sql + ' ' + v[1] + ' ' + result.sql + ' AND ';
+                        data.push(...result.data);
                     }
                 }
             }
             else {
-                // --- 1, 4, 5, 6 ---
+                // --- 字段映射、逻辑分组与 IN 查询 ---
                 if (k.startsWith('$')) {
-                    // --- 5 - '$or': [{'city': 'bj'}, {'city': 'sh'}] ---
+                    // --- 逻辑条件分组，如 $or ---
                     const sp = ' ' + k.slice(1).split('-')[0].toUpperCase() + ' ';
                     sql += '(';
                     for (let v1 of v) {
@@ -685,21 +694,28 @@ export class Sql {
                     sql = sql.slice(0, -sp.length) + ') AND ';
                 }
                 else {
-                    // --- 1, 4, 6 ---
+                    // --- 单字段条件 ---
                     if (v === null) {
+                        // --- NULL 判断 ---
                         sql += this.field(k) + ' IS NULL AND ';
                     }
                     else if (typeof v === 'string' || typeof v === 'number') {
-                        // --- 1 ---
+                        // --- 标量相等 ---
                         sql += this.field(k) + ' = ' + this._placeholder() + ' AND ';
                         data.push(v);
                     }
+                    else if (lSqlValue.isJson(v)) {
+                        // --- JSON 相等 ---
+                        const result = this._processValue(v);
+                        sql += this.field(k) + ' = ' + result.sql + ' AND ';
+                        data.push(...result.data);
+                    }
                     else if (this._isField(v)) {
-                        // --- 6 ---
+                        // --- 字段相等 ---
                         sql += this.field(k) + ' = ' + this.field(v.value) + ' AND ';
                     }
                     else {
-                        // --- 4 - 'type': ['1', '2'] ---
+                        // --- IN 查询，如 'type': ['1', '2'] ---
                         if (v.length > 0) {
                             sql += this.field(k) + ' IN (';
                             for (const v1 of v) {
@@ -935,7 +951,7 @@ export class Sql {
      * --- 获取全部 data ---
      */
     getData() {
-        return this._data;
+        return lSqlValue.serializeList(this._data) ?? [];
     }
     /**
      * --- 获取定义的 pre ---
@@ -1096,48 +1112,6 @@ export class Sql {
     _placeholder() {
         return this._service === ESERVICE.MYSQL ? '?' : `$${this._placeholderCounter++}`;
     }
-    /**
-     * --- 返回 PostgreSQL VALUES 第一行的显式类型转换后缀，用于帮助 PostgreSQL 推断 VALUES 派生表列类型 ---
-     * @param v 要处理的值
-     */
-    _pgCastSuffix(v) {
-        if (v === null || v === undefined) {
-            return '';
-        }
-        if (typeof v === 'number') {
-            return Number.isInteger(v) ? '::bigint' : '::float8';
-        }
-        if (typeof v === 'boolean') {
-            return '::boolean';
-        }
-        if (v instanceof Buffer) {
-            return '::bytea';
-        }
-        if (Array.isArray(v)) {
-            // --- 函数式语法 ['FUNC(?)', [...]]，不加转换 ---
-            if (typeof v[0] === 'string' && v[0].includes('(')) {
-                return '';
-            }
-            // --- POLYGON ---
-            if (v[0]?.y !== undefined) {
-                return '::polygon';
-            }
-            // --- JSON 数组或 PG 原生数组（text[]、int[] 等），
-            //     不加转换，由 pg 驱动与目标列类型决定 ---
-            return '';
-        }
-        if (typeof v === 'object') {
-            // --- POINT ---
-            if (v.y !== undefined) {
-                return '::point';
-            }
-            // --- JSON 对象（用户应通过 sql.json() 包裹为字符串后传入），不加转换 ---
-            return '';
-        }
-        // --- string：保持 unknown 类型，兼容 text/varchar/jsonb 等目标列类型；
-        //     使用 sql.json() 包裹的 jsonb 数据经此路径，unknown 可隐式 cast 到 jsonb ---
-        return '';
-    }
     /**
      * --- 处理单个值,检测数据类型并返回 SQL 和 data ---
      * @param v 要处理的值
@@ -1151,6 +1125,12 @@ export class Sql {
         else if (v === null) {
             return { 'sql': 'NULL', 'data': [] };
         }
+        else if (lSqlValue.isJson(v)) {
+            return {
+                'sql': this._placeholder() + (this._service === ESERVICE.PGSQL ? '::jsonb' : ''),
+                'data': [lSqlValue.serialize(v)]
+            };
+        }
         else if (typeof v === 'string' || typeof v === 'number') {
             return { 'sql': this._placeholder(), 'data': [v] };
         }
@@ -1278,6 +1258,7 @@ export function get(opt) {
  * @param service 服务商，默认 MySQL
  */
 export function format(sql, data, service = ESERVICE.MYSQL) {
+    data = lSqlValue.serializeList(data) ?? [];
     if (service === ESERVICE.MYSQL) {
         return mysql2.format(sql, data);
     }
@@ -1359,9 +1340,10 @@ export function value(val) {
     };
 }
 /**
- * --- 将对象转换为 JSON 字符串并避开类型检查，用于适配 PostgreSQL 的 jsonb 字段 ---
- * @param obj 要转换的 JSON 对象
+ * --- 标记需要写入 JSON/jsonb 字段的值；实际序列化延迟到数据库边界 ---
+ * @param obj 原始 JSON 值
+ * @returns 类型保持不变的 JSON 包装值
  */
 export function json(obj) {
-    return lText.stringifyJson(obj);
+    return lSqlValue.json(obj);
 }

package/lib/undici/response.d.ts

@@ -31,7 +31,7 @@ export declare class Response {
     /**
      * --- 获取响应读取流对象 ---
      */
-    getStream(): zlib.BrotliDecompress | zlib.Gunzip | zlib.Inflate | (import("undici/types/readable").default & undici.Dispatcher.BodyMixin) | null;
+    getStream(): (import("undici/types/readable").default & undici.Dispatcher.BodyMixin) | zlib.Gunzip | zlib.Inflate | zlib.BrotliDecompress | null;
     /**
      * --- 获取原生响应读取流对象 ---
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maiyunnet/kebab",
-  "version": "9.15.1",
+  "version": "9.15.3",
   "description": "Simple, easy-to-use, and fully-featured Node.js framework that is ready-to-use out of the box.",
   "type": "module",
   "keywords": [

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)}`);