jsql-neo 6.4.1 → 6.4.3

package/README.md

@@ -3,7 +3,7 @@
 > **One engine to rule them all** — a Rust-powered embedded database that speaks your language:
 > MySQL, PostgreSQL, MongoDB, Redis, SQL, TypeScript, **and the browser**.
 
-> **v6.4.1** — official release build · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo) · [jsql.vexify.top](https://jsql.vexify.top)
+> **v6.4.3** — official release build · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo) · [jsql.vexify.top](https://jsql.vexify.top)
 
 ![Engines](https://img.shields.io/badge/engines-Native%20%7C%20WASM%20%7C%20Pure%20JS-7ee787)
 ![MySQL](https://img.shields.io/badge/protocol-MySQL%20compatible-1f6feb)

package/index.js

@@ -1,5 +1,5 @@
 /**
- * JSQL-NEO v6.4.1 — Rust-Powered Embedded Database (WASM + HTTP)
+ * JSQL-NEO v6.4.3 — Rust-Powered Embedded Database (WASM + HTTP)
  *
  * @example
  * const jsql = require('jsql-neo');

package/lib/database.js

@@ -666,7 +666,12 @@ class Database {
                 // 重命名也要能回放：否则崩溃恢复后表名会退回去，
                 // 而后续的 insert/update 记录全都打在新名字上，全部丢失。
                 if (op.from && op.to && this._tables[op.from] && !this._tables[op.to]) {
-                    this.renameTable(op.from, op.to);
+                    // renameTable 是 async 的（内部 await _runHooks），而本回放路径
+                    // 是同步的，没法 await。**注意不能把 promise 直接 return** ——
+                    // `if (promise)` 恒为真，失败会被当成成功。
+                    // 这里同步发起并接住 rejection，避免未处理的 Promise 拒绝
+                    // 把进程打崩；真失败了会体现在后续按新表名的记录上。
+                    Promise.resolve(this.renameTable(op.from, op.to)).catch(() => {});
                 }
                 return true;
 

package/lib/native_client.js

@@ -490,7 +490,10 @@ class JSQL {
   }
 
   async _insertBatch(table, rows) {
+    // 直接传 JSON 字符串，让 Rust 处理 schema 映射和插入
+    // 消除 JS encodeBatch 二进制序列化和 Rust 解码的开销
     const schema = this._schemas[table];
+    // 对 JSON/array/object 列保留 safeStringify 以给出可读错误（环形对象等）
     if (schema) {
       rows = rows.map(row => {
         const out = {};
@@ -510,8 +513,17 @@ class JSQL {
         return out;
       });
     }
-    const bin = encodeBatch(rows);
-    const r = safeParse(this._n('jsqlInsertBuf', table, bin));
+    const rawJson = JSON.stringify(rows);
+    // 优先用 jsqlInsertRaw（Rust 直接 JSON 解析，消除二进制序列化）
+    // 旧环境未编译 jsqlInsertRaw 时 fallback 到 jsqlInsertBuf
+    let r;
+    if (typeof native.jsqlInsertRaw === 'function') {
+      r = safeParse(this._n('jsqlInsertRaw', table, rawJson));
+    } else {
+      // fallback: 用 encodeBatch 二进制格式（向后兼容）
+      const bin = encodeBatch(rows);
+      r = safeParse(this._n('jsqlInsertBuf', table, bin));
+    }
     if (r && r.error) throw new Error(r.error);
     if (r && Array.isArray(r) && !this._pkAutoIncrement(table)) {
       const pk = this._pkOf(table);

package/lib/sql.js

@@ -131,6 +131,40 @@ function nameOfToken(t) {
   return t && t.text !== undefined ? t.text : (t ? t.value : undefined);
 }
 
+/**
+ * 按 JSONPath 取值（$.a、$.a.b、$.a[0].b、$）。
+ *
+ * 原先是 JSON_EXTRACT 里的一段内联逻辑。`->` / `->>` 同样接受 JSONPath
+ * （MySQL 5.7+ 的写法，也是 doc/sql-reference.md 里给出的示例），
+ * 但此前把 '$' 开头的路径当成字面键名去取（v['$.name']），永远取不到 ——
+ * 所以抽出来共用，避免两处实现漂移。
+ */
+function jsonPathGet(data, path) {
+  const p = path == null ? '' : String(path);
+  if (p === '$' || p === '') return data;
+  const m = p.match(/^\$\.?([^.\[]+)/);
+  if (!m) return null;
+  let current = data;
+  for (const seg of p.replace(/^\$\.?/, '').split('.')) {
+    if (current === null || current === undefined) return null;
+    const arrMatch = seg.match(/^([^\[]*)\[(\d+)\]$/);
+    if (arrMatch) {
+      const key = arrMatch[1];
+      const idx = parseInt(arrMatch[2], 10);
+      if (key) {
+        if (typeof current !== 'object' || current === null) return null;
+        current = current[key];
+      }
+      if (!Array.isArray(current)) return null;
+      current = current[idx];
+    } else {
+      if (typeof current !== 'object' || current === null) return null;
+      current = current[seg];
+    }
+  }
+  return current === undefined ? null : current;
+}
+
 function tokenize(sql) {
   const tokens = [];
   let i = 0;
@@ -2986,6 +3020,14 @@ function resolveOperand(operand, row, ctx) {
       if (typeof base === 'string') {
         try { base = JSON.parse(base); } catch (e) { return null; }
       }
+      // '$' 开头是 JSONPath（MySQL 5.7+ 的写法，`d->>'$.name'`、`d->>'$.a.b'`）。
+      // 此前把它当字面键名去取（v['$.name']），于是文档里那条示例永远返回 null。
+      if (!operand.isPath && typeof operand.key === 'string' && operand.key.trim().charAt(0) === '$') {
+        const jv = jsonPathGet(base, operand.key.trim());
+        if (jv === null || jv === undefined) return null;
+        if (operand.asText) return typeof jv === 'object' ? JSON.stringify(jv) : String(jv);
+        return jv;
+      }
       const keys = operand.isPath ? parsePgPath(operand.key) : [operand.key];
       let v = base;
       for (const key of keys) {
@@ -3607,6 +3649,55 @@ function applyScalarFunction(fnNode, row, ctx) {
       return idx + 1;
     }
     case 'REVERSE': return args[0] == null ? null : String(args[0]).split('').reverse().join('');
+
+    // ---- 以下这批此前没有实现：调用时静默返回 null（不报错），
+    //      只有拿标准答案对照才发现。语义按 MySQL 8.0。
+    case 'ASCII': {
+      // 最左字符的数值；空串返回 0，NULL 返回 NULL
+      if (args[0] == null) return null;
+      const s = String(args[0]);
+      return s.length ? s.charCodeAt(0) : 0;
+    }
+    case 'ORD': {
+      if (args[0] == null) return null;
+      const s = String(args[0]);
+      return s.length ? s.codePointAt(0) : 0;
+    }
+    case 'CHAR': {
+      // CHAR(65,66) → 'AB'；跳过 NULL 参数
+      const codes = args.filter(a => a != null).map(a => Number(a));
+      if (!codes.length) return '';
+      return codes.map(n => String.fromCharCode(n)).join('');
+    }
+    case 'SPACE': {
+      if (args[0] == null) return null;
+      const n = Math.max(0, Math.floor(Number(args[0])) || 0);
+      return ' '.repeat(n);
+    }
+    case 'FIELD': {
+      // FIELD(x, a, b, ...) → x 在列表中的 1 基下标；找不到返回 0；x 为 NULL 返回 NULL
+      if (args[0] == null) return null;
+      const needle = String(args[0]);
+      for (let i = 1; i < args.length; i++) {
+        if (args[i] != null && String(args[i]) === needle) return i;
+      }
+      return 0;
+    }
+    case 'ELT': {
+      // ELT(n, a, b, ...) → 第 n 个；越界或 n 为 NULL 返回 NULL
+      if (args[0] == null) return null;
+      const idx = Math.floor(Number(args[0]));
+      if (!Number.isFinite(idx) || idx < 1 || idx >= args.length) return null;
+      return args[idx] == null ? null : String(args[idx]);
+    }
+    case 'JSON_ARRAY_LENGTH': {
+      if (args[0] == null) return null;
+      let v = args[0];
+      if (typeof v === 'string') {
+        try { v = JSON.parse(v); } catch (e) { return null; }
+      }
+      return Array.isArray(v) ? v.length : null;
+    }
     case 'LPAD': {
       if (args[0] == null) return null;
       let s = String(args[0]);
@@ -3685,34 +3776,7 @@ function applyScalarFunction(fnNode, row, ctx) {
       if (typeof json === 'string') {
         try { data = JSON.parse(json); } catch (e) { return null; }
       }
-      // 解析 JSONPath: $.key 或 $.a.b 或 $.a[0].b
-      const m = path.match(/^\$\.?([^.\[]+)/);
-      if (!m) {
-        // 尝试 $ 开头后直接跟 key
-        if (path === '$') return data;
-        return null;
-      }
-      const firstKey = m[1];
-      if (firstKey === '') return data;
-      let current = data;
-      // 逐段解析路径
-      const segments = path.replace(/^\$\.?/, '').split('.');
-      for (const seg of segments) {
-        if (current == null) return null;
-        // 处理数组索引: key[0] 或 [0]
-        const arrMatch = seg.match(/^([^\[]*)\[(\d+)\]$/);
-        if (arrMatch) {
-          const key = arrMatch[1];
-          const idx = parseInt(arrMatch[2], 10);
-          if (key) current = current[key];
-          if (Array.isArray(current)) current = current[idx];
-          else return null;
-        } else {
-          if (typeof current !== 'object' || current === null) return null;
-          current = current[seg];
-        }
-      }
-      return current === undefined ? null : current;
+      return jsonPathGet(data, path);
     }
     case 'JSON_KEYS': {
       // JSON_KEYS(json) → [key1, key2, ...]
@@ -4255,11 +4319,22 @@ function evaluateExpr(expr, row, ctx) {
       if (v === null || v === undefined) return null;  // NULL IN (...) → NULL（三值逻辑）
       if (expr.subquery && expr.subquery._values !== undefined) expr.list = expr.subquery._values;
       if (!expr.list) return expr.not ? true : false;
-      // 列表中出现 NULL 时：三值逻辑 → NULL IN (1,2,NULL) 为 NULL（UNKNOWN）
+
+      // 先找匹配：只要有一个非 NULL 元素等于 v，整个 IN 就是 TRUE ——
+      // 列表里别的位置有没有 NULL 都不影响。
+      //
+      // 此前是先判「列表里有 NULL 就返回 NULL」，于是 `v IN (10, NULL)`
+      // 连 v=10 的行都匹配不上（实测返回 0 行，应为 2 行）。
+      // 三值逻辑里 NULL 只在**没匹配上**的时候才让结果变 UNKNOWN。
+      const matched = expr.list.some(x =>
+        x !== null && x !== undefined && (x === v || String(x) === String(v))
+      );
+      if (matched) return expr.not ? false : true;
+
+      // 没匹配上：列表里有 NULL → UNKNOWN，否则是确定的 FALSE
       const hasNull = expr.list.some(x => x === null || x === undefined);
       if (hasNull) return null;
-      const r = expr.list.some(x => x === v || String(x) === String(v));
-      return expr.not ? !r : r;
+      return expr.not ? true : false;
     }
     case 'like': {
       const v = resolveOperand(expr.operand, row, ctx);
@@ -4579,7 +4654,10 @@ class SQLExecutor {
               if (typeof this.engine.renameTable !== 'function') {
                 throw new Error(`ALTER TABLE ... RENAME is not supported by this engine (no renameTable method)`);
               }
-              this.engine.renameTable(statement.name, op.newName);
+              // renameTable 是 async 的（它要 await _runHooks），漏了 await 会让
+              // 它抛出的错变成未处理的 Promise 拒绝：SQL 这边照常返回 ok:true，
+              // 调用方以为改名成功，而进程随后被 rejection 打崩。
+              await this.engine.renameTable(statement.name, op.newName);
               table = this.engine._tables[op.newName] || table;
               statement.name = op.newName;
               break;
@@ -6482,7 +6560,26 @@ class SQLExecutor {
         // 帧范围（ROWS 帧；RANGE 在当前实现下退化为整个分区，保守处理）
         const frameIdx = (i) => {
           const f = w.over.frame;
-          if (!f) return { start: 0, end: ordered.length - 1 };
+          if (!f) {
+            // 没显式写帧时的默认帧，按 SQL 标准分两种情况：
+            //   有 ORDER BY → RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
+            //   无 ORDER BY → 整个分区
+            //
+            // 此前一律返回整个分区，于是
+            //   SUM(sal) OVER (PARTITION BY dept ORDER BY id)
+            // 得到的是分区总和（500）而不是累计值（100/300/500）。
+            //
+            // 用 RANGE 而非 ROWS 语义：ORDER BY 值相同的行互为 peer，
+            // 要一并纳入当前行（这正是 RANGE 与 ROWS 的区别）。
+            if (!orderBy.length) return { start: 0, end: ordered.length - 1 };
+            const curKey = this._windowPeerKey(rows[ordered[i]], orderBy, this.ctx);
+            let end = i;
+            while (end + 1 < ordered.length &&
+                   this._windowPeerKey(rows[ordered[end + 1]], orderBy, this.ctx) === curKey) {
+              end++;
+            }
+            return { start: 0, end };
+          }
           let start = 0, end = ordered.length - 1;
           const apply = (b, isStart) => {
             if (!b) return isStart ? 0 : ordered.length - 1;

package/lib/table.js

@@ -9,6 +9,19 @@ const BTree = require('./btree');
 const { validateDateType, now } = require('./date-types');
 const { createError } = require('./errors');
 
+/**
+ * 会被 _compileMatcher 编译成快路径的操作符。
+ *
+ * 收录标准：语义简单、求值廉价，且能在编译期确定目标值。
+ * 不在表内的操作符（$inSub / $elemMatch / $textSearch / $expr / 作为值级
+ * 逻辑的 $and $or $not …）走退回路径，逐字段交给 _matchOperator，语义不变。
+ */
+const FAST_MATCH_OPS = new Set([
+    '$eq', '$ne', '$gt', '$gte', '$lt', '$lte',
+    '$in', '$nin', '$between', '$exists', '$isNull',
+    '$startsWith', '$endsWith', '$contains', '$type', '$size',
+]);
+
 function isSafeRegex(pattern) {
     if (typeof pattern !== 'string') return false;
     if (pattern.length > 256) return false;
@@ -1020,14 +1033,179 @@ class Table {
         return this._applyFilter(rows, query);
     }
 
+    /**
+     * 把 filter 编译成一个谓词函数。
+     *
+     * 动机（实测数据，10 万行）：
+     *   _matchRow 每行都要做 Object.entries(query)、Object.keys(condition)、
+     *   以及一串 startswith 判断。这部分占单次全表扫描耗时的 **98%** ——
+     *   点查 13.9ms/次，其中 13.6ms 是反射；同样语义的手写循环只要 0.28ms。
+     *   $like / $regex 更糟：正则每行每字段重编一次。
+     *
+     * 做法：编译一次，把字段、路径、操作符、正则全部预先解析好，
+     * 循环里只剩取值和比较。语义与 _matchRow 逐一对应。
+     *
+     * 遇到冷门操作符（$inSub / $elemMatch / $textSearch / $expr …）
+     * 时**只把那一个字段**退回 _matchRow，其余字段仍走快路径 ——
+     * 既保住语义，也不让混合查询整体退回。
+     */
+    _compileMatcher(query) {
+        const self = this;
+        const parts = [];
+        for (const [field, condition] of Object.entries(query)) {
+            // --- 顶层逻辑操作符 ---
+            if (field === '$or' || field === '$and') {
+                if (!Array.isArray(condition)) { parts.push({ k: 0 }); continue; }   // 原实现直接 return false
+                parts.push({ k: field === '$or' ? 3 : 4, subs: condition.map(c => self._compileMatcher(c)) });
+                continue;
+            }
+            if (field === '$not') {
+                // $not 的条件形态太多（对象/标量都合法），整体退回，保证逐字一致
+                parts.push({ k: 7, q: { $not: condition } });
+                continue;
+            }
+
+            // --- 字段路径：点号路径预先切好，循环里不再 split/includes ---
+            const path = (field.indexOf('.') !== -1 && field[0] !== '$') ? field.split('.') : null;
+
+            const plainObj = condition !== null && typeof condition === 'object'
+                && !Array.isArray(condition) && !(condition instanceof RegExp);
+
+            if (!plainObj) {
+                parts.push({ k: 1, path, field, target: condition });   // 等值
+                continue;
+            }
+
+            const keys = Object.keys(condition);
+            const isOp = keys.length > 0 && keys.every(k => k[0] === '$');
+            if (!isOp) {
+                // 嵌套对象匹配
+                parts.push({ k: 5, path, field, sub: self._compileMatcher(condition) });
+                continue;
+            }
+
+            // --- 操作符：能编译的编译，不能的整体退回这一字段 ---
+            const ops = [];
+            let ok = true;
+            for (const [op, target] of Object.entries(condition)) {
+                if (op === '$like' && typeof target === 'string') {
+                    const escaped = target
+                        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+                        .replace(/%/g, '.*')
+                        .replace(/_/g, '.');
+                    ops.push({ op, re: new RegExp('^' + escaped + '$', 'i') });
+                } else if (op === '$regex' && !(target instanceof RegExp) && typeof target === 'string') {
+                    if (!isSafeRegex(target)) throw createError('ER_BAD_REGEX', String(target));
+                    ops.push({ op, re: new RegExp(target) });
+                } else if (FAST_MATCH_OPS.has(op)) {
+                    ops.push({ op, target });
+                } else {
+                    ok = false;
+                    break;
+                }
+            }
+            if (!ok) { parts.push({ k: 7, q: { [field]: condition } }); continue; }
+            parts.push({ k: 2, path, field, ops });
+        }
+
+        return function match(row) {
+            for (let i = 0; i < parts.length; i++) {
+                const p = parts[i];
+                switch (p.k) {
+                    case 1: {   // 等值
+                        const v = p.path ? self._walk(row, p.path) : row[p.field];
+                        if (v !== p.target) return false;
+                        break;
+                    }
+                    case 2: {   // 操作符
+                        const v = p.path ? self._walk(row, p.path) : row[p.field];
+                        const ops = p.ops;
+                        for (let j = 0; j < ops.length; j++) {
+                            const o = ops[j];
+                            const op = o.op;
+                            if (op === '$eq') { if (v !== o.target) return false; }
+                            else if (op === '$ne') { if (v === o.target) return false; }
+                            else if (op === '$gt') { if (!(v > o.target)) return false; }
+                            else if (op === '$gte') { if (!(v >= o.target)) return false; }
+                            else if (op === '$lt') { if (!(v < o.target)) return false; }
+                            else if (op === '$lte') { if (!(v <= o.target)) return false; }
+                            else if (op === '$in') { if (!Array.isArray(o.target) || o.target.indexOf(v) === -1) return false; }
+                            else if (op === '$nin') {
+                                // 非数组 target 时原实现返回 false（不匹配），不能当成通过
+                                if (!Array.isArray(o.target) || o.target.indexOf(v) !== -1) return false;
+                            }
+                            else if (op === '$between') {
+                                if (!Array.isArray(o.target) || o.target.length !== 2
+                                    || !(v >= o.target[0]) || !(v <= o.target[1])) return false;
+                            }
+                            else if (op === '$exists') { if (o.target ? v === undefined : v !== undefined) return false; }
+                            else if (op === '$isNull') {
+                                const isn = v === null || v === undefined;
+                                if (o.target ? !isn : isn) return false;
+                            }
+                            else if (op === '$startsWith') { if (typeof v !== 'string' || !v.startsWith(o.target)) return false; }
+                            else if (op === '$endsWith') { if (typeof v !== 'string' || !v.endsWith(o.target)) return false; }
+                            else if (op === '$contains') { if (!Array.isArray(v) || v.indexOf(o.target) === -1) return false; }
+                            else if (op === '$type') { if (typeof v !== o.target) return false; }
+                            else if (op === '$size') { if (!Array.isArray(v) || v.length !== o.target) return false; }
+                            else if (op === '$like') {
+                                if (typeof v !== 'string') return false;
+                                if (!o.re.test(v)) return false;
+                            }
+                            else if (op === '$regex') {
+                                if (o.re instanceof RegExp) { if (!o.re.test(String(v))) return false; }
+                                else if (!o.re.test(v)) return false;
+                            }
+                            else { if (!self._matchOperator(v, op, o.target)) return false; }
+                        }
+                        break;
+                    }
+                    case 3: {   // $or
+                        let hit = false;
+                        for (let j = 0; j < p.subs.length; j++) { if (p.subs[j](row)) { hit = true; break; } }
+                        if (!hit) return false;
+                        break;
+                    }
+                    case 4: {   // $and
+                        for (let j = 0; j < p.subs.length; j++) if (!p.subs[j](row)) return false;
+                        break;
+                    }
+                    case 5: {   // 嵌套对象
+                        const v = p.path ? self._walk(row, p.path) : row[p.field];
+                        if (v === null || typeof v !== 'object') return false;
+                        if (!p.sub(v)) return false;
+                        break;
+                    }
+                    case 7: {   // 退回原有逐字段求值
+                        if (!self._matchRow(row, p.q)) return false;
+                        break;
+                    }
+                    default: return false;   // k===0：原实现直接 return false
+                }
+            }
+            return true;
+        };
+    }
+
+    /** 点号路径取值，与 _resolvePath 的分支语义一致 */
+    _walk(row, parts) {
+        let v = row;
+        for (let i = 0; i < parts.length; i++) {
+            if (v === null || v === undefined) return undefined;
+            v = v[parts[i]];
+        }
+        return v;
+    }
+
     _applyFilter(rows, query) {
+        const match = this._compileMatcher(query);
+        const soft = this._softDelete;
         const result = [];
         for (let i = 0; i < rows.length; i++) {
+            const r = rows[i];
             // 软删除行不应出现在任何查询结果中
-            if (this._softDelete && rows[i]._deleted) continue;
-            if (this._matchRow(rows[i], query)) {
-                result.push(rows[i]);
-            }
+            if (soft && r._deleted) continue;
+            if (match(r)) result.push(r);
         }
         return result;
     }

package/lib/wasm_client.js

@@ -481,6 +481,7 @@ class JSQL {
   }
 
   async _insertBatch(table, rows) {
+    // schema-aware 转换：JSON 列用 safeStringify 给出可读错误（环形对象等）
     const schema = this._schemas[table];
     if (schema) {
       rows = rows.map(row => {
@@ -501,7 +502,8 @@ class JSQL {
         return out;
       });
     }
-    const r = safeJsonParse(wasmBindings.jsql_insert_json(table, safeStringify(rows, table, '<rows>')));
+    const rawJson = JSON.stringify(rows);
+    const r = safeJsonParse(wasmBindings.jsql_insert_json(table, rawJson));
     if (r && r.error) throw new Error(r.error);
     if (r && Array.isArray(r) && !this._pkAutoIncrement(table)) {
       const pk = this._pkOf(table);

package/nativesrc/jsql-neo-core/src/engine/mod.rs

@@ -41,6 +41,15 @@ pub trait Engine {
     fn list_tables(&self) -> Vec<String>;
 
     fn insert(&mut self, table: &str, fields: Vec<HashMap<String, serde_json::Value>>) -> Result<Vec<u64>, String>;
+    /// 接收原始 JSON 数组字符串，直接解析并存入（消除 JS encodeBatch 二进制序列化开销）
+    fn insert_raw(&mut self, table: &str, raw_json: &str) -> Result<Vec<u64>, String> {
+        let rows: Vec<serde_json::Value> = serde_json::from_str(raw_json)
+            .map_err(|e| format!("invalid JSON array: {}", e))?;
+        let batch: Vec<HashMap<String, serde_json::Value>> = rows.into_iter()
+            .map(|v| v.as_object().map(|m| m.clone().into_iter().collect()).unwrap_or_else(HashMap::new))
+            .collect();
+        self.insert(table, batch)
+    }
     fn find_by_id(&self, table: &str, id: u64) -> Result<Option<Row>, String>;
     fn find_by_id_json(&self, table: &str, id: u64) -> Result<Option<String>, String>;
     fn find_by_ids_json(&self, table: &str, ids: &[u64]) -> Result<String, String>;

package/nativesrc/jsql-neo-native/src/lib.rs

@@ -274,6 +274,23 @@ fn do_insert_buf(eng: &mut HybridEngine, table: &str, buf_val: napi::JsBufferVal
     safe_json_result(res)
 }
 
+#[napi]
+pub fn jsql_insert_raw(table: String, raw_json: String) -> String {
+    with_engine_mut(|eng| do_insert_raw(eng, &table, &raw_json))
+}
+
+#[napi]
+pub fn jsql_insert_raw_h(handle: u32, table: String, raw_json: String) -> String {
+    with_engine_handle_mut(handle, |eng| do_insert_raw(eng, &table, &raw_json))
+}
+
+fn do_insert_raw(eng: &mut HybridEngine, table: &str, raw_json: &str) -> String {
+    match eng.insert_raw(table, raw_json) {
+        Ok(ids) => serde_json::to_string(&ids).unwrap_or_else(|_| "[]".to_string()),
+        Err(e) => format!(r#"{{"error":"{}"}}"#, e.replace('"', r#"\""#)),
+    }
+}
+
 napi_engine_fn!(jsql_find, jsql_find_h,
     (table: String, filter_json: String, limit: i32, offset: i32) => |eng| {
         let filter: Option<HashMap<String, serde_json::Value>> =

package/nativesrc/jsql-neo-wasm/src/lib.rs

@@ -76,96 +76,18 @@ pub fn jsql_insert(table: &str, data_json: &str) -> String {
 #[wasm_bindgen]
 pub fn jsql_insert_json(table: &str, json: &str) -> String {
     ENGINE.with(|eng| {
-        let res = (|| -> Result<Vec<u64>, String> {
-            let mut eng = eng.borrow_mut();
-            let t = eng.tables.get_mut(table).ok_or_else(|| format!("table '{}' not found", table))?;
-
-            let data: Vec<serde_json::Value> = serde_json::from_str(json)
-                .map_err(|e| format!("invalid JSON: {}", e))?;
-            let n = data.len();
-            if n == 0 { return Ok(Vec::new()); }
-
-            let first = data[0].as_object()
-                .ok_or_else(|| "expected array of objects".to_string())?;
-            let field_names: Vec<String> = first.keys().cloned().collect();
-
-            let remap: Vec<Option<usize>> = t.field_order.iter()
-                .map(|name| field_names.iter().position(|n| n == name))
-                .collect();
-
-            let pk_idx = t.pk_field.as_ref().and_then(|pk| {
-                t.schema.get(pk.as_str()).and_then(|fs| {
-                    if fs.auto_increment { t.field_index.get(pk.as_str()).copied() } else { None }
-                })
-            });
-
-            let now = js_sys::Date::now() as u64;
-            let start_id = t.next_id;
-            t.next_id += n as u64;
-            t.pk_index.reserve(n);
-            t.rows.reserve(n);
-            t.values.reserve(t.field_order.len());
-            let start_ri = t.rows.len();
-
-            for (ri, row_val) in data.iter().enumerate() {
-                let auto_id = start_id + ri as u64;
-                let mut id = auto_id;
-                let obj = row_val.as_object()
-                    .ok_or_else(|| "non-object in array".to_string())?;
-
-                let mut values = Vec::with_capacity(t.field_order.len());
-                for (i, rp) in remap.iter().enumerate() {
-                    if let Some(fi) = rp {
-                        let key = &field_names[*fi];
-                        if let Some(jv) = obj.get(key) {
-                            values.push(FieldValue::from_json(jv.clone()));
-                            continue;
-                        }
-                    } else if let Some(pi) = pk_idx {
-                        if pi == i {
-                            values.push(FieldValue::Int(id as i64));
-                            continue;
-                        }
-                    }
-                    if let Some(name) = t.field_order.get(i) {
-                        if let Some(fs) = t.schema.get(name) {
-                            if let Some(ref default) = fs.default {
-                                values.push(FieldValue::from_json(default.clone()));
-                                continue;
-                            }
-                            if !fs.nullable {
-                                values.push(default_value(&fs.field_type));
-                                continue;
-                            }
-                        }
-                    }
-                    values.push(FieldValue::Null);
-                }
-
-                // auto-increment PK: keep explicit positive value, else fill with auto id
-                if let Some(pi) = pk_idx {
-                    if let Some(v) = values.get_mut(pi) {
-                        match v {
-                            FieldValue::Null => *v = FieldValue::Int(id as i64),
-                            FieldValue::Int(e) if *e > 0 => {
-                                id = *e as u64;
-                                t.next_id = t.next_id.max(id + 1);
-                            }
-                            _ => {}
-                        }
-                    }
-                }
-
-                t.pk_index.insert(id, start_ri + ri);
-                let vs = t.values.len();
-                t.values.extend(values);
-                t.rows.push(RowStore { id, values_start: vs, num_values: t.field_order.len(), created_at: now, updated_at: now });
-            }
+        match eng.borrow_mut().insert_raw(table, json) {
+            Ok(ids) => serde_json::to_string(&ids).unwrap_or_else(|_| "[]".to_string()),
+            Err(e) => format!(r#"{{"error":"{}"}}"#, e),
+        }
+    })
+}
 
-            let ids: Vec<u64> = (start_id..start_id + n as u64).collect();
-            Ok(ids)
-        })();
-        match res {
+/// JSON 字符串直接插入（绕过 JS encodeBatch 二进制序列化）
+#[wasm_bindgen]
+pub fn jsql_insert_raw(table: &str, raw_json: &str) -> String {
+    ENGINE.with(|eng| {
+        match eng.borrow_mut().insert_raw(table, raw_json) {
             Ok(ids) => serde_json::to_string(&ids).unwrap_or_else(|_| "[]".to_string()),
             Err(e) => format!(r#"{{"error":"{}"}}"#, e),
         }