jsql-neo 6.5.22 → 6.5.23

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.5.22** — stable release · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo) · [jsql.vexify.top](https://jsql.vexify.top)
+> **v6.5.23** — stable release · [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.5.22 — Rust-Powered Embedded Database (WASM + HTTP)
+ * JSQL-NEO v6.5.23 — Rust-Powered Embedded Database (WASM + HTTP)
  *
  * @example
  * const jsql = require('jsql-neo');

package/lib/bigint_json.js

@@ -0,0 +1,39 @@
+// © Vexify 2026 All Rights Reserved.
+/**
+ * BigInt 安全的 JSON 序列化（Issue #38）。
+ *
+ * 行数据里可能出现 >2^53 的 BigInt（integer/int/bigint 列）。原生
+ * JSON.stringify 遇到 BigInt 直接抛 "Do not know how to serialize a BigInt"，
+ * 于是 WAL、事务快照、统计等路径会整条失败。
+ *
+ * 这里用一个单键标记对象 `{ __jsql_bigint__: "9223372036854775807" }`
+ * 在 JSON 中无损往返；反序列化时还原成 BigInt。只有「对象恰好只有这一个键」
+ * 时才还原，尽量避免误伤用户自己的同名字段。
+ */
+
+const MARKER = '__jsql_bigint__';
+
+function replacer(_key, value) {
+    if (typeof value === 'bigint') return { [MARKER]: value.toString() };
+    return value;
+}
+
+function reviver(_key, value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        const keys = Object.keys(value);
+        if (keys.length === 1 && keys[0] === MARKER && typeof value[MARKER] === 'string') {
+            try { return BigInt(value[MARKER]); } catch (_) { return value; }
+        }
+    }
+    return value;
+}
+
+function stringify(value, space) {
+    return JSON.stringify(value, replacer, space);
+}
+
+function parse(text) {
+    return JSON.parse(text, reviver);
+}
+
+module.exports = { stringify, parse, MARKER };

package/lib/database.js

@@ -10,6 +10,7 @@ const os = require('os');
 const crypto = require('crypto');
 const Table = require('./table');
 const { createError, JSQL_Error, ErrorCodes } = require('./errors');
+const bigintJson = require('./bigint_json');
 
 /**
  * 构造带补充说明的错误。
@@ -463,7 +464,7 @@ class Database {
             // 只追加尚未落盘的记录
             const pending = this._walOps.slice(this._walFlushedCount);
             if (pending.length === 0) return;
-            const lines = pending.map(o => JSON.stringify(o)).join('\n') + '\n';
+            const lines = pending.map(o => bigintJson.stringify(o)).join('\n') + '\n';
             const fd = fs.openSync(this._walPath, 'a');
             try {
                 fs.writeSync(fd, lines, null, 'utf8');
@@ -528,7 +529,7 @@ class Database {
         const trimmed = raw.trim();
         if (trimmed.startsWith('[')) {
             try {
-                const parsed = JSON.parse(trimmed);
+                const parsed = bigintJson.parse(trimmed);
                 if (Array.isArray(parsed)) {
                     ops = parsed.filter(o => o && typeof o.op === 'string');
                 }
@@ -541,7 +542,7 @@ class Database {
                 const t = line.trim();
                 if (!t) continue;
                 try {
-                    const o = JSON.parse(t);
+                    const o = bigintJson.parse(t);
                     if (o && typeof o.op === 'string') ops.push(o);
                 } catch (e) {
                     // 崩溃时写半的尾行，丢弃
@@ -1129,7 +1130,7 @@ class Database {
             const rowCount = table._rows.length;
             const indexCount = Object.keys(table._indexes).length;
             const btreeCount = Object.keys(table._btrees).length;
-            const sizeEstimate = JSON.stringify(table._rows).length;
+            const sizeEstimate = bigintJson.stringify(table._rows).length;
             tableStats[name] = {
                 rowCount,
                 indexCount: indexCount + btreeCount,
@@ -1263,7 +1264,7 @@ class Database {
         const snap = {};
         for (const [name, table] of Object.entries(this._tables)) {
             snap[name] = {
-                rows: JSON.parse(JSON.stringify(table.toJSON())),
+                rows: bigintJson.parse(bigintJson.stringify(table.toJSON())),
                 schema: table._schema,
                 // 自增计数器也要存：否则回滚掉刚插入的行之后，
                 // 下一次插入会跳过已用过的号（用户看到 id 从 2 开始会困惑）。
@@ -1290,7 +1291,7 @@ class Database {
             if (!snap[name]) delete this._tables[name];
         }
         for (const [name, entry] of Object.entries(snap)) {
-            const rows = JSON.parse(JSON.stringify(entry.rows));
+            const rows = bigintJson.parse(bigintJson.stringify(entry.rows));
             let table = this._tables[name];
             if (!table) {
                 table = new Table(name, entry.schema, this);
@@ -1507,7 +1508,7 @@ class Database {
 
         if (table._rows.length === 0) return;
 
-        const currentHash = JSON.stringify(table._rows);
+        const currentHash = bigintJson.stringify(table._rows);
         const versions = this._versions[tableName];
         if (versions.length > 0 && versions[versions.length - 1]._hash === currentHash) return;
 
@@ -2234,8 +2235,8 @@ class Database {
     backup(filePath) {
         const data = this.export();
         const json = this._options.pretty
-            ? JSON.stringify(data, null, 2)
-            : JSON.stringify(data);
+            ? bigintJson.stringify(data, 2)
+            : bigintJson.stringify(data);
         this._writeFile(filePath, json);
         return filePath;
     }
@@ -2245,7 +2246,7 @@ class Database {
             throw createError('ER_FILE_NOT_FOUND', filePath);
         }
         const json = this._readFile(filePath);
-        const data = JSON.parse(json);
+        const data = bigintJson.parse(json);
         for (const [name, rows] of Object.entries(data)) {
             if (this._tables[name]) {
                 this._tables[name]._loadRows(rows);
@@ -2296,8 +2297,8 @@ class Database {
         }
 
         const json = this._options.pretty
-            ? JSON.stringify(data, null, 2)
-            : JSON.stringify(data);
+            ? bigintJson.stringify(data, 2)
+            : bigintJson.stringify(data);
         this._writeFile(this._filePath, json);
         this._dirty = false;
 
@@ -2328,7 +2329,7 @@ class Database {
             }
 
             const json = this._readFile(this._filePath);
-            const data = JSON.parse(json);
+            const data = bigintJson.parse(json);
 
             if (data.__schema__) {
                 for (const [name, schema] of Object.entries(data.__schema__)) {

package/lib/jsql_format.js

@@ -25,6 +25,7 @@ function tag(v) {
     }
     return TYPE.F64;
   }
+  if (typeof v==='bigint') return TYPE.I64;
   if (typeof v==='string') return TYPE.STR;
   if (v instanceof Buffer) return TYPE.BUF;
   return Array.isArray(v)?TYPE.ARR:TYPE.OBJ;
@@ -51,7 +52,12 @@ function dec(buf, off) {
     case TYPE.NUL: return {v:null,off};
     case TYPE.BOL: return {v:buf[off]!==0,off:off+1};
     case TYPE.I32: return {v:buf.readInt32LE(off),off:off+4};
-    case TYPE.I64: return {v:Number(buf.readBigInt64LE(off)),off:off+8};
+    case TYPE.I64: {
+      // 安全范围内的值仍还原成 number（兼容旧数据/行为）；超出范围返回 BigInt，避免精度丢失（Issue #38）
+      const b = buf.readBigInt64LE(off);
+      const safe = b >= BigInt(Number.MIN_SAFE_INTEGER) && b <= BigInt(Number.MAX_SAFE_INTEGER);
+      return {v: safe ? Number(b) : b, off:off+8};
+    }
     case TYPE.F64: return {v:buf.readDoubleLE(off),off:off+8};
     case TYPE.STR: { const l=buf.readUInt32LE(off);off+=4; return {v:buf.toString('utf8',off,off+l),off:off+l}; }
     case TYPE.BUF: { const l=buf.readUInt32LE(off);off+=4; return {v:Buffer.from(buf.subarray(off,off+l)),off:off+l}; }
@@ -78,6 +84,10 @@ function writeEnc(buf, off, v) {
     }
     buf[off] = 3; buf.writeDoubleLE(v, off+1); return off + 9;
   }
+  if (typeof v === 'bigint') {
+    // Issue #38：64 位整数精确保存，读回时再决定还原成 number 还是 BigInt
+    buf[off] = 8; buf.writeBigInt64LE(v, off+1); return off + 9;
+  }
   if (typeof v === 'string') {
     buf[off] = 4;
     const encoded = Buffer.from(v, 'utf8');

package/lib/sql.js

@@ -201,6 +201,19 @@ function jsonPathGet(data, path) {
   return current === undefined ? null : current;
 }
 
+/**
+ * 16 进制整数字面量（0x?? / X'??'）的精确解析（Issue #38）。
+ *
+ * 旧的 parseInt(hexStr, 16) 在 >2^53 时直接丢精度，且与十进制字面量
+ * （已被解析成 BigInt）行为不一致；这里统一成同样的规则：
+ * 安全范围内 → number；超出 → BigInt（精确值保留给 int64 列）。
+ */
+function parseHexIntegerLiteral(hexStr) {
+  if (hexStr.length === 0) throw new Error('Invalid hexadecimal literal');
+  const b = BigInt('0x' + hexStr);
+  return b <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(b) : b;
+}
+
 function tokenize(sql) {
   const tokens = [];
   let i = 0;
@@ -303,7 +316,7 @@ function tokenize(sql) {
         while (j < n && /[0-9A-Fa-f]/.test(sql[j])) j++;
         if (j === i + 2) throw new Error(`Invalid hexadecimal literal at position ${i}`);
         const hexStr = sql.slice(i + 2, j);
-        const numVal = parseInt(hexStr, 16);
+        const numVal = parseHexIntegerLiteral(hexStr);
         tokens.push(new SQLToken('number', numVal, i));
         i = j;
         continue;
@@ -317,7 +330,7 @@ function tokenize(sql) {
           j++;
         }
         if (j >= n) throw new Error(`Unterminated hexadecimal literal at position ${i}`);
-        const numVal = parseInt(hexStr, 16);
+        const numVal = parseHexIntegerLiteral(hexStr);
         tokens.push(new SQLToken('number', numVal, i));
         i = j + 1;
         continue;
@@ -3121,6 +3134,26 @@ function mysqlNum(v) {
   return 0;
 }
 
+/**
+ * BigInt 参与的整数算术（Issue #38）。
+ *
+ * BigInt 与 number 不能直接运算（TypeError），而 Number(BigInt) 会丢精度。
+ * 两侧都是整数（BigInt 或整数值 number）且至少一侧是 BigInt 时，用 BigInt
+ * 精确计算；否则返回 undefined，调用方退回 double 语义。
+ */
+function bigintExactArith(l, r, op) {
+  if (typeof l !== 'bigint' && typeof r !== 'bigint') return undefined;
+  const lb = typeof l === 'bigint' ? l : (typeof l === 'number' && Number.isInteger(l) ? BigInt(l) : null);
+  const rb = typeof r === 'bigint' ? r : (typeof r === 'number' && Number.isInteger(r) ? BigInt(r) : null);
+  if (lb === null || rb === null) return undefined;
+  switch (op) {
+    case '+': return lb + rb;
+    case '-': return lb - rb;
+    case '*': return lb * rb;
+    default: return undefined;
+  }
+}
+
 function resolveOperand(operand, row, ctx) {
   if (operand === null || operand === undefined) return null;
   if (typeof operand === 'string') return resolveOperand({ type: 'column', name: operand }, row, ctx);
@@ -3203,6 +3236,8 @@ function resolveOperand(operand, row, ctx) {
         // 数字与字符串混合的算术会一路错下去。
         // 判据：任一侧是 number，或字符串能被完整解析为数字 → 走数值加法。
         case '+': {
+          const bx = bigintExactArith(l, r, '+');
+          if (bx !== undefined) return bx;
           // MySQL / SQLite 语义（已用 sqlite3 实测核对）：
           //   '5' + 5 = 10   '5' + '5' = 10   'abc' + 1 = 1   'a' + 'b' = 0
           // 任一侧是「数值」时做算术加法，另一侧非数值按 0；
@@ -3217,12 +3252,16 @@ function resolveOperand(operand, row, ctx) {
           return 0;
         }
         case '-': {
+          const bx = bigintExactArith(l, r, '-');
+          if (bx !== undefined) return bx;
           // P1-21: 'abc'-1 → NaN，应返回 null
           const ln = Number(l), rn = Number(r);
           if (isNaN(ln) || isNaN(rn)) return null;
           return ln - rn;
         }
         case '*': {
+          const bx = bigintExactArith(l, r, '*');
+          if (bx !== undefined) return bx;
           const ln = Number(l), rn = Number(r);
           if (isNaN(ln) || isNaN(rn)) return null;
           return ln * rn;
@@ -3270,6 +3309,8 @@ function resolveOperand(operand, row, ctx) {
       if (l === null || r === null || l === undefined || r === undefined) return null;
       switch (operand.op) {
         case '+': {
+          const bx = bigintExactArith(l, r, '+');
+          if (bx !== undefined) return bx;
           if (typeof l === 'number' || typeof r === 'number') {
             const ln = numericIfNumeric(l), rn = numericIfNumeric(r);
             return (ln === null ? 0 : ln) + (rn === null ? 0 : rn);
@@ -3279,8 +3320,8 @@ function resolveOperand(operand, row, ctx) {
           if (rn !== null) return rn;
           return 0;
         }
-        case '-': { const ln = Number(l), rn = Number(r); return isNaN(ln) || isNaN(rn) ? null : ln - rn; }
-        case '*': { const ln = Number(l), rn = Number(r); return isNaN(ln) || isNaN(rn) ? null : ln * rn; }
+        case '-': { const bx = bigintExactArith(l, r, '-'); if (bx !== undefined) return bx; const ln = Number(l), rn = Number(r); return isNaN(ln) || isNaN(rn) ? null : ln - rn; }
+        case '*': { const bx = bigintExactArith(l, r, '*'); if (bx !== undefined) return bx; const ln = Number(l), rn = Number(r); return isNaN(ln) || isNaN(rn) ? null : ln * rn; }
         case '/': { const ln = Number(l), rn = Number(r); return isNaN(ln) || isNaN(rn) || rn === 0 ? null : ln / rn; }
         case '%': { const ln = Number(l), rn = Number(r); return isNaN(ln) || isNaN(rn) || rn === 0 ? null : ln % rn; }
         case 'DIV': return r === 0 ? null : Math.trunc(Number(l) / Number(r));
@@ -4880,6 +4921,8 @@ function evaluateExpr(expr, row, ctx) {
       if (l === null || r === null || l === undefined || r === undefined) return null;
       switch (expr.op) {
         case '+': {
+          const bx = bigintExactArith(l, r, '+');
+          if (bx !== undefined) return bx;
           if (typeof l === 'number' || typeof r === 'number') {
             const ln = numericIfNumeric(l), rn = numericIfNumeric(r);
             return (ln === null ? 0 : ln) + (rn === null ? 0 : rn);
@@ -4889,8 +4932,8 @@ function evaluateExpr(expr, row, ctx) {
           if (rn !== null) return rn;
           return 0;
         }
-        case '-': { const ln = Number(l), rn = Number(r); return isNaN(ln) || isNaN(rn) ? null : ln - rn; }
-        case '*': { const ln = Number(l), rn = Number(r); return isNaN(ln) || isNaN(rn) ? null : ln * rn; }
+        case '-': { const bx = bigintExactArith(l, r, '-'); if (bx !== undefined) return bx; const ln = Number(l), rn = Number(r); return isNaN(ln) || isNaN(rn) ? null : ln - rn; }
+        case '*': { const bx = bigintExactArith(l, r, '*'); if (bx !== undefined) return bx; const ln = Number(l), rn = Number(r); return isNaN(ln) || isNaN(rn) ? null : ln * rn; }
         case '/': { const ln = Number(l), rn = Number(r); return isNaN(ln) || isNaN(rn) || rn === 0 ? null : ln / rn; }
         case '%': { const ln = Number(l), rn = Number(r); return isNaN(ln) || isNaN(rn) || rn === 0 ? null : ln % rn; }
         case 'DIV': return r === 0 ? null : Math.trunc(Number(l) / Number(r));
@@ -6108,6 +6151,14 @@ class SQLExecutor {
     const type = colDef && colDef.type;
     if (!type) return val;
     if (type === 'integer' || type === 'int' || type === 'bigint' || type === 'smallint' || type === 'tinyint') {
+      // BigInt 必须原样保留：Number(val) 会在 >2^53 时丢精度，
+      // 下推成索引后与行里的 BigInt 严格比较永远不相等（Issue #38）。
+      if (typeof val === 'bigint') return val;
+      // 十进制字符串（参数内联后常见）同样要精确解析，不能用 Number()
+      if (typeof val === 'string' && /^[+-]?\d+$/.test(val.trim())) {
+        const b = BigInt(val.trim());
+        return (b >= BigInt(Number.MIN_SAFE_INTEGER) && b <= BigInt(Number.MAX_SAFE_INTEGER)) ? Number(b) : b;
+      }
       const n = Number(val);
       return Number.isNaN(n) ? val : n;
     }
@@ -8045,6 +8096,7 @@ function escapeId(name) {
 
 function escapeValue(value) {
   if (value === null || value === undefined) return 'NULL';
+  if (typeof value === 'bigint') return value.toString();   // Issue #38：精确的整数字面量
   if (typeof value === 'number') return Number.isFinite(value) ? String(value) : 'NULL';
   if (typeof value === 'boolean') return value ? 'true' : 'false';
   if (value instanceof Date) {

package/lib/table.js

@@ -9,6 +9,45 @@ const BTree = require('./btree');
 const { validateDateType, now } = require('./date-types');
 const { createError } = require('./errors');
 
+// ---------------------------------------------------------------------------
+// 64 位整数（Issue #38）
+//
+// JS 的 number 只能精确表示 |v| <= 2^53-1。integer/int/bigint 列原先用
+// Number(v) 归一，>2^53 的输入（无论 number 还是十进制字符串）都会被静默
+// 截断成 53 位浮点，SQL 路径则因为字面量被解析成 BigInt 而报 1292 —— 两条
+// 路径行为不一致且都丢精度。
+//
+// 现在的语义：
+//   • BigInt 输入      → 精确接受（在 int64 范围内）；
+//   • 十进制字符串输入 → 精确解析成 BigInt，安全范围内仍存成 number（兼容旧行为）；
+//   • 超安全范围的 number → 明确报 1292（调用方在 JS 层就已丢精度，不能静默入库）；
+//   • 超出 int64 范围 → 明确报 1292（持久化格式是 8 字节有符号整数）。
+// ---------------------------------------------------------------------------
+const INT64_MIN = -9223372036854775808n;
+const INT64_MAX = 9223372036854775807n;
+const SAFE_INT_MIN = BigInt(Number.MIN_SAFE_INTEGER);
+const SAFE_INT_MAX = BigInt(Number.MAX_SAFE_INTEGER);
+const DECIMAL_INT_RE = /^[+-]?\d+$/;
+
+function integerError(type, v) {
+    return createError('ER_TRUNCATED_WRONG_VALUE', type, v);
+}
+
+/**
+ * 把已经确认是十进制整数的字符串/BigInt 归一成 number（安全范围内）或 BigInt。
+ * 超出 int64 抛 1292，避免持久化时被 BigInt64 写入静默回绕。
+ */
+function normalizeInteger(v, type) {
+    let b;
+    if (typeof v === 'bigint') b = v;
+    else {
+        try { b = BigInt(v); } catch (_) { throw integerError(type, v); }
+    }
+    if (b < INT64_MIN || b > INT64_MAX) throw integerError(type, b.toString());
+    if (b >= SAFE_INT_MIN && b <= SAFE_INT_MAX) return Number(b);
+    return b;
+}
+
 /**
  * 会被 _compileMatcher 编译成快路径的操作符。
  *
@@ -318,10 +357,14 @@ class Table {
                     uniqueTracker[field].add(data[field]);
                 }
                 if (def.length && typeof data[field] === 'string' && data[field].length > def.length) throw createError('ER_DATA_TOO_LONG', field);
-                if (def.type === 'integer' || def.type === 'number') {
-                    const v = def.type === 'integer' ? Number(data[field]) : data[field];
-                    if (data[field] !== undefined && data[field] !== null && def.min !== undefined && v < def.min) throw createError('ER_OUT_OF_RANGE', field);
-                    if (data[field] !== undefined && data[field] !== null && def.max !== undefined && v > def.max) throw createError('ER_OUT_OF_RANGE', field);
+                if (def.type === 'integer' || def.type === 'int' || def.type === 'bigint' || def.type === 'number') {
+                    const raw = data[field];
+                    // BigInt 与 number 的 </> 比较是精确的，不要先 Number() 丢精度
+                    const v = typeof raw === 'bigint' ? raw : (def.type === 'number' ? raw : Number(raw));
+                    const min = typeof raw === 'bigint' && Number.isInteger(def.min) ? BigInt(def.min) : def.min;
+                    const max = typeof raw === 'bigint' && Number.isInteger(def.max) ? BigInt(def.max) : def.max;
+                    if (raw !== undefined && raw !== null && def.min !== undefined && v < min) throw createError('ER_OUT_OF_RANGE', field);
+                    if (raw !== undefined && raw !== null && def.max !== undefined && v > max) throw createError('ER_OUT_OF_RANGE', field);
                 }
                 if (def.check && data[field] !== undefined && !def.check(data[field], data)) throw createError('ER_CHECK_CONSTRAINT', this._name + '.' + field);
             }
@@ -1430,10 +1473,14 @@ class Table {
             }
 
             // 数值范围
-            if (def.type === 'integer' && data[field] !== undefined && data[field] !== null) {
-                const v = Number(data[field]);
-                if (def.min !== undefined && v < def.min) throw createError('ER_OUT_OF_RANGE', field);
-                if (def.max !== undefined && v > def.max) throw createError('ER_OUT_OF_RANGE', field);
+            if ((def.type === 'integer' || def.type === 'int' || def.type === 'bigint')
+                && data[field] !== undefined && data[field] !== null) {
+                const raw = data[field];
+                const v = typeof raw === 'bigint' ? raw : Number(raw);
+                const min = typeof raw === 'bigint' && Number.isInteger(def.min) ? BigInt(def.min) : def.min;
+                const max = typeof raw === 'bigint' && Number.isInteger(def.max) ? BigInt(def.max) : def.max;
+                if (def.min !== undefined && v < min) throw createError('ER_OUT_OF_RANGE', field);
+                if (def.max !== undefined && v > max) throw createError('ER_OUT_OF_RANGE', field);
             }
         }
 
@@ -1537,14 +1584,20 @@ class Table {
             if (v === undefined || v === null) continue;
             const t = String(def.type || '').toLowerCase();
             if (t === 'integer' || t === 'int' || t === 'bigint') {
-                if (typeof v === 'boolean') throw createError('ER_TRUNCATED_WRONG_VALUE', t, v);
-                if (typeof v === 'number') {
-                    if (Number.isInteger(v)) result[field] = v;
-                    else throw createError('ER_TRUNCATED_WRONG_VALUE', t, v);
-                } else if (typeof v === 'string' && v.trim() !== '' && Number.isInteger(Number(v))) {
-                    result[field] = Number(v);
+                if (typeof v === 'boolean') throw integerError(t, v);
+                if (typeof v === 'bigint') {
+                    // 显式 BigInt：>2^53 也能精确保存（Issue #38）。
+                    result[field] = normalizeInteger(v, t);
+                } else if (typeof v === 'number') {
+                    if (!Number.isInteger(v)) throw integerError(t, v);
+                    // 超过 2^53-1 的 number 在调用方就已经丢失精度，不能再假装
+                    // 存进去了：明确报错，要求传 BigInt 或十进制字符串。
+                    if (!Number.isSafeInteger(v)) throw integerError(t, v);
+                    result[field] = v;
+                } else if (typeof v === 'string' && DECIMAL_INT_RE.test(v.trim())) {
+                    result[field] = normalizeInteger(v.trim(), t);
                 } else {
-                    throw createError('ER_TRUNCATED_WRONG_VALUE', t, v);
+                    throw integerError(t, v);
                 }
             } else if (t === 'float' || t === 'double' || t === 'number' || t === 'real') {
                 if (typeof v === 'boolean') throw createError('ER_TRUNCATED_WRONG_VALUE', t, v);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsql-neo",
-  "version": "6.5.22",
+  "version": "6.5.23",
   "description": "JSQL-NEO \u2014 Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
   "main": "index.js",
   "types": "index.d.ts",
@@ -50,12 +50,12 @@
   "scripts": {
     "postinstall": "node postinstall.js",
     "build:native": "node scripts/build-native.js",
-    "test": "node test/smoke.js && node test/native.test.js && node test/json-functions.test.js && node test/sql-parser.test.js && node test/readme-audit.test.js && node test/query-opt.test.js && node test/wal-recovery.test.js && node test/mysql-compat-hijack.test.js && node test/dml-constraints.test.js && node test/star-nag.test.js && node test/plugin-xql.test.js && node test/bug-regression-2.test.js && node test/issue-34-35-36.test.js && node test/issue-g4.test.js && node test/issue-39.test.js && node test/issue-40.test.js",
+    "test": "node test/smoke.js && node test/native.test.js && node test/json-functions.test.js && node test/sql-parser.test.js && node test/readme-audit.test.js && node test/query-opt.test.js && node test/wal-recovery.test.js && node test/mysql-compat-hijack.test.js && node test/dml-constraints.test.js && node test/star-nag.test.js && node test/plugin-xql.test.js && node test/bug-regression-2.test.js && node test/issue-34-35-36.test.js && node test/issue-g4.test.js && node test/issue-38.test.js && node test/issue-39.test.js && node test/issue-40.test.js",
     "test:parser": "node test/sql-parser.test.js",
     "test:btree": "node test/btree.test.js",
     "test:native": "node test/native.test.js",
     "test:regress": "node test/regress-5.1.0.js",
-    "test:all": "node test/smoke.js && node test/sql-parser.test.js && node test/readme-audit.test.js && node test/native.test.js && node test/native-multi-instance.test.js && node test/wal-recovery.test.js && node test/mysql-compat-hijack.test.js && node test/wasm.test.js && node test/coverage.js && node test/regress-5.1.0.js && node test/join.test.js && node test/btree.test.js && node test/dml-constraints.test.js && node test/savepoint.test.js && node test/alter-table.test.js && node test/null-semantics.test.js && node test/identifier-keywords.test.js && node test/sql-semantics.test.js && node test/extra-coverage.test.js && node test/filter-compile.test.js && node test/recursive-cte.test.js && node test/index-ddl.test.js && node test/mongo-group.test.js && node test/multiprotocol.test.js && node test/issue-34-35-36.test.js && node test/issue-39.test.js && node test/issue-40.test.js",
+    "test:all": "node test/smoke.js && node test/sql-parser.test.js && node test/readme-audit.test.js && node test/native.test.js && node test/native-multi-instance.test.js && node test/wal-recovery.test.js && node test/mysql-compat-hijack.test.js && node test/wasm.test.js && node test/coverage.js && node test/regress-5.1.0.js && node test/join.test.js && node test/btree.test.js && node test/dml-constraints.test.js && node test/savepoint.test.js && node test/alter-table.test.js && node test/null-semantics.test.js && node test/identifier-keywords.test.js && node test/issue-34-35-36.test.js && node test/sql-semantics.test.js && node test/extra-coverage.test.js && node test/filter-compile.test.js && node test/recursive-cte.test.js && node test/index-ddl.test.js && node test/mongo-group.test.js && node test/multiprotocol.test.js && node test/issue-g4.test.js && node test/issue-38.test.js && node test/issue-39.test.js && node test/issue-40.test.js",
     "test:coverage": "c8 --all --include='lib/**' --exclude='lib/web_ui.js' --reporter=text --reporter=lcov node test/coverage.js",
     "test:orms": "node examples/orms/run-all.js",
     "test:dml": "node test/dml-constraints.test.js",

package/test/issue-38.test.js

@@ -0,0 +1,279 @@
+/*
+ * Regression tests for issue #38.
+ *   node test/issue-38.test.js
+ *
+ * #38 INTEGER / INT / BIGINT 列无法保存 > 2^53 的整数：
+ *     · SQL 路径抛 ER_TRUNCATED_WRONG_VALUE (1292)
+ *     · 编程式 API 静默截断成 53 位浮点（最危险）
+ *
+ * 修复后的约定：
+ *     · BigInt / 十进制字符串 → 精确入库，安全范围内仍以 number 返回；
+ *     · 超出 2^53 的值以 BigInt 保存，持久化格式是 8 字节有符号整数；
+ *     · 调用方直接传「已经丢精度」的 unsafe number → 明确报 1292，不静默截断；
+ *     · SQL 与 API 对越界值给出一致的 1292。
+ */
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const ROOT = path.join(__dirname, '..');
+
+let passed = 0, failed = 0;
+function ok(name, cond, extra) {
+    if (cond) { passed++; console.log('[OK]', name); }
+    else { failed++; console.log('[FAIL]', name, extra !== undefined ? JSON.stringify(extra, (k, v) => typeof v === 'bigint' ? v.toString() + 'n' : v) : ''); }
+}
+
+// 所有测试共用独立临时目录，结束后清理
+const TMP = fs.mkdtempSync(path.join(os.tmpdir(), 'jsql-i38-'));
+process.on('exit', () => { try { fs.rmSync(TMP, { recursive: true, force: true }); } catch (_) { } });
+
+function tmpPath(name) { return path.join(TMP, name); }
+function fresh(name, opts) {
+    const p = tmpPath(name);
+    try { fs.rmSync(p, { recursive: true, force: true }); } catch (_) { }
+    return p;
+}
+
+function codeOf(e) { return e && (e.code !== undefined ? e.code : (e.details && e.details.code)); }
+
+async function makeDb() {
+    const Database = require(path.join(ROOT, 'lib', 'database'));
+    const db = new Database(':memory:');
+    await db.createTable('big', {
+        id: { type: 'integer', primaryKey: true, autoIncrement: true },
+        v: { type: 'bigint' }
+    });
+    return db;
+}
+
+/* ---------- 编程式 API 路径 ---------- */
+async function testApi() {
+    const db = await makeDb();
+    const t = db.big;
+
+    // 1. BigInt 精确保存
+    const r1 = t.insert({ v: 9223372036854775807n });
+    ok('#38 API BigInt int64 max stored exactly', r1.v === 9223372036854775807n, r1);
+
+    // 2. 十进制字符串精确保存（>2^53）
+    const r2 = t.insert({ v: '9007199254740993' });
+    ok('#38 API numeric string >2^53 stored exactly', r2.v === 9007199254740993n, r2);
+    ok('#38 API numeric string is not rounded to 9007199254740992', r2.v !== 9007199254740992, r2.v);
+
+    // 3. unsafe number 明确报错，不静默截断
+    let threw = null;
+    try { t.insert({ v: 9007199254740993 }); } catch (e) { threw = e; }
+    ok('#38 API unsafe number throws 1292', threw && codeOf(threw) === 1292, threw && threw.message);
+    ok('#38 API unsafe number does not insert a rounded row', t.count() === 2, t.count());
+
+    // 4. 超出 int64 报 1292（持久化是 8 字节整数，不能回绕）
+    threw = null;
+    try { t.insert({ v: '9223372036854775808' }); } catch (e) { threw = e; }
+    ok('#38 API string beyond int64 throws 1292', threw && codeOf(threw) === 1292, threw && threw.message);
+
+    // 5. 安全范围内的 number 保持旧行为（number，不是 BigInt）
+    const r3 = t.insert({ v: 42 });
+    ok('#38 API safe number stays number', typeof r3.v === 'number' && r3.v === 42, typeof r3.v);
+
+    // 6. 更新路径同样精确
+    t.update({ id: r2.id }, { v: '9223372036854775806' });
+    ok('#38 API update accepts decimal string exactly', t.findById(r2.id).v === 9223372036854775806n, t.findById(r2.id).v);
+
+    // 7. 过滤条件用 BigInt 可以命中（索引/快路径不受影响）
+    const hit = t.find({ v: 9223372036854775807n });
+    ok('#38 API filter with BigInt matches', hit.length === 1 && hit[0].id === r1.id, hit);
+
+    // 8. 非法值仍然报错
+    threw = null;
+    try { t.insert({ v: 1.5 }); } catch (e) { threw = e; }
+    ok('#38 API float into bigint column throws 1292', threw && codeOf(threw) === 1292);
+    threw = null;
+    try { t.insert({ v: true }); } catch (e) { threw = e; }
+    ok('#38 API boolean into bigint column throws 1292', threw && codeOf(threw) === 1292);
+
+    // 9. 负数边界
+    const r4 = t.insert({ v: -9223372036854775808n });
+    ok('#38 API int64 min stored exactly', r4.v === -9223372036854775808n, r4);
+}
+
+/* ---------- SQL 路径 ---------- */
+async function testSql() {
+    const db = await makeDb();
+
+    // INSERT 十进制字面量（>2^53）不再报 1292
+    const ins = await db.query('INSERT INTO big (v) VALUES (9007199254740993), (9223372036854775807)');
+    ok('#38 SQL insert >2^53 literals succeed', ins.ok === true && ins.affectedRows === 2, ins);
+
+    // SELECT 输出为精确十进制字符串（BigInt 无法 JSON 序列化，输出层转字符串）
+    const sel = await db.query('SELECT v FROM big ORDER BY v');
+    ok('#38 SQL select keeps exact digits', sel.rows[0][0] === '9007199254740993', sel.rows);
+    ok('#38 SQL select int64 max exact', sel.rows[1][0] === '9223372036854775807', sel.rows);
+
+    // 底层行仍是 BigInt（不是字符串），与 API 一致
+    const raw = db.big.find({});
+    ok('#38 SQL insert stores BigInt in row', raw[0].v === 9007199254740993n, raw[0].v);
+
+    // WHERE = 字面量：下推过滤不能把 BigInt 转成 number
+    const eq = await db.query('SELECT v FROM big WHERE v = 9007199254740993');
+    ok('#38 SQL WHERE = large literal matches', eq.rows.length === 1 && eq.rows[0][0] === '9007199254740993', eq.rows);
+
+    // WHERE = 参数（参数内联成字符串，仍需精确比较）
+    const eqp = await db.query('SELECT v FROM big WHERE v = ?', [9007199254740993n]);
+    ok('#38 SQL WHERE = BigInt param matches', eqp.rows.length === 1 && eqp.rows[0][0] === '9007199254740993', eqp.rows);
+
+    // 算术保持精度
+    const plus = await db.query('SELECT v + 1 AS x FROM big WHERE v = 9007199254740993');
+    ok('#38 SQL v + 1 exact', plus.rows[0][0] === '9007199254740994', plus.rows);
+
+    // 16 进制字面量同样精确（0x20000000000001 = 9007199254740993）
+    await db.query('DELETE FROM big WHERE id > 0');
+    const hex = await db.query("INSERT INTO big (v) VALUES (0x20000000000001)");
+    ok('#38 SQL hex literal insert succeeds', hex.ok === true, hex);
+    const hexSel = await db.query('SELECT v FROM big');
+    ok('#38 SQL hex literal keeps precision', hexSel.rows[0][0] === '9007199254740993', hexSel.rows);
+    const hexQ = await db.query("INSERT INTO big (v) VALUES (X'7FFFFFFFFFFFFFFF')");
+    ok("#38 SQL X'' literal insert succeeds", hexQ.ok === true, hexQ);
+
+    // 越界：SQL 与 API 都报 1292
+    let sqlErr = null;
+    try { await db.query('INSERT INTO big (v) VALUES (9223372036854775808)'); } catch (e) { sqlErr = e; }
+    ok('#38 SQL beyond int64 throws 1292', sqlErr && codeOf(sqlErr) === 1292, sqlErr && sqlErr.message);
+
+    // SQL 与 API 对 unsafe number 的错误码一致
+    let apiErr = null;
+    try { db.big.insert({ v: 9223372036854775807 }); } catch (e) { apiErr = e; }
+    ok('#38 SQL and API error codes agree (1292)',
+        sqlErr && apiErr && codeOf(sqlErr) === codeOf(apiErr) && codeOf(apiErr) === 1292,
+        { sql: codeOf(sqlErr), api: codeOf(apiErr) });
+
+    // 小数/非整数字符串仍拒绝
+    let e2 = null;
+    try { await db.query("INSERT INTO big (v) VALUES ('1.5')"); } catch (e) { e2 = e; }
+    ok('#38 SQL non-integer string rejected', e2 && codeOf(e2) === 1292);
+}
+
+/* ---------- 持久化（.jsql / JSON / dir 模式） ---------- */
+async function testPersistence() {
+    const Database = require(path.join(ROOT, 'lib', 'database'));
+
+    // .jsql 单文件（I64 编码）
+    {
+        const p = fresh('big.jsql');
+        let db = new Database(p);
+        await db.createTable('big', {
+            id: { type: 'integer', primaryKey: true, autoIncrement: true },
+            v: { type: 'bigint' }
+        });
+        db.big.insert({ v: 9223372036854775807n });
+        db.big.insert({ v: -9223372036854775808n });
+        db.save();
+
+        db = new Database(p);
+        const rows = db.big.find({}).sort((a, b) => (a.v < b.v ? -1 : 1));
+        ok('#38 .jsql persistence keeps int64 min/max',
+            rows.length === 2 && rows[0].v === -9223372036854775808n && rows[1].v === 9223372036854775807n, rows);
+    }
+
+    // 单文件 JSON（bigint_json 标记往返）
+    {
+        const p = fresh('big.json');
+        let db = new Database(p);
+        await db.createTable('big', {
+            id: { type: 'integer', primaryKey: true, autoIncrement: true },
+            v: { type: 'bigint' }
+        });
+        db.big.insert({ v: '9007199254740993' });
+        db.save();
+
+        db = new Database(p);
+        ok('#38 JSON persistence keeps >2^53 exactly', db.big.find({})[0].v === 9007199254740993n, db.big.find({}));
+    }
+
+    // dir 模式（disk）逐表 .jsql
+    {
+        const dir = fresh('big-dir');
+        fs.mkdirSync(dir, { recursive: true });
+        let db = new Database(dir, { mode: 'disk' });
+        await db.createTable('big', {
+            id: { type: 'integer', primaryKey: true, autoIncrement: true },
+            v: { type: 'bigint' }
+        });
+        db.big.insert({ v: 9007199254740993n });
+        db.save();
+
+        db = new Database(dir, { mode: 'disk' });
+        ok('#38 dir-mode persistence keeps >2^53 exactly', db.big.find({})[0].v === 9007199254740993n, db.big.find({}));
+    }
+}
+
+/* ---------- BigInt 与事务 / 统计 / 备份 ---------- */
+async function testBigIntJsonPaths() {
+    const Database = require(path.join(ROOT, 'lib', 'database'));
+
+    // REPEATABLE_READ 事务快照（内部 JSON 深拷贝）不能因 BigInt 抛错
+    {
+        const db = await makeDb();
+        db.big.insert({ v: 9007199254740993n });
+        db.begin('REPEATABLE_READ');
+        db.big.insert({ v: 9223372036854775807n });
+        db.rollback();
+        const rows = db.big.find({});
+        ok('#38 tx snapshot/rollback with BigInt works', rows.length === 1 && rows[0].v === 9007199254740993n, rows);
+    }
+
+    // stats() 里的 JSON.stringify 不能因 BigInt 抛错
+    {
+        const db = await makeDb();
+        db.big.insert({ v: 9007199254740993n });
+        let threw = null, st = null;
+        try { st = db.stats(); } catch (e) { threw = e; }
+        ok('#38 stats() tolerates BigInt rows', !threw && st && st.tableStats && st.tableStats.big && st.tableStats.big.rowCount === 1 && st.tableStats.big.sizeEstimate > 0,
+            threw ? threw.message : st && st.tableStats);
+    }
+
+    // backup/restore 往返
+    {
+        const db = await makeDb();
+        db.big.insert({ v: '9007199254740993' });
+        const bak = tmpPath('backup.json');
+        db.backup(bak);
+        db.big.remove({});
+        db.restore(bak);
+        ok('#38 backup/restore keeps >2^53 exactly', db.big.find({})[0].v === 9007199254740993n, db.big.find({}));
+    }
+}
+
+/* ---------- 回归：普通类型不受影响 ---------- */
+async function testNoRegression() {
+    const Database = require(path.join(ROOT, 'lib', 'database'));
+    const db = new Database(':memory:');
+    await db.createTable('t', {
+        id: { type: 'integer', primaryKey: true, autoIncrement: true },
+        n: { type: 'integer' },
+        f: { type: 'float' },
+        s: { type: 'string' }
+    });
+    db.t.insert({ n: 42, f: 1.5, s: 'hello' });
+    db.t.insert({ n: '43', f: '2.5', s: 7 });
+    const rows = db.t.find({});
+    ok('#38 regression integer/float/string coercion intact',
+        rows.length === 2 && rows[0].n === 42 && rows[1].n === 43 && rows[1].f === 2.5 && rows[1].s === '7', rows);
+    ok('#38 regression integer still rejects 1.5', (() => {
+        try { db.t.insert({ n: 1.5 }); return false; } catch (e) { return codeOf(e) === 1292; }
+    })());
+}
+
+(async () => {
+    try {
+        await testApi();
+        await testSql();
+        await testPersistence();
+        await testBigIntJsonPaths();
+        await testNoRegression();
+    } catch (e) {
+        failed++;
+        console.log('[FAIL] unexpected exception:', e && e.stack || e);
+    }
+    console.log(`\n${passed} passed, ${failed} failed`);
+    if (failed > 0) process.exit(1);
+})();