jsql-neo 6.5.9 → 6.5.11

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

package/lib/sql.js

@@ -708,6 +708,11 @@ class Parser {
         break;
       } else {
         const col = this.parseTableName();
+        // 重复列名必须报错：对象键覆盖会静默丢列（schema[col] = def 直接覆盖），
+        // 用户 CREATE TABLE d(a INT, a INT) 会悄悄变成单列 a。
+        if (schema[col] !== undefined) {
+          throw new Error(`Duplicate column name '${col}' in table '${name}'`);
+        }
         const def = this.parseColumnDef();
         schema[col] = def;
         if (def.primaryKey) hasPk = true;
@@ -755,6 +760,8 @@ class Parser {
     const mapped = typeMap[type];
     if (!mapped) throw new Error(`Unsupported column type: ${typeTok.value}`);
     def.type = mapped;
+    // JSON / JSONB 列保留原始标记，供数据层校验非法 JSON（{bad json 这类字符串会被 JSON.parse 拒绝）
+    if (type === 'json' || type === 'jsonb') def.jsonType = true;
     if (/^(BIG)?SERIAL$/i.test(typeRaw)) { def.autoIncrement = true; def.required = true; }
 
     // 长度限制: TEXT(255) / VARCHAR(100) / INTEGER(11) ...
@@ -1079,6 +1086,22 @@ class Parser {
   }
 
   parseValueAtom() {
+    // MySQL 前缀运算符：BINARY expr —— 强制大小写敏感比较。
+    // 仅当后面确实是值起始 token 才当作运算符，避免误吞裸列名 `binary`
+    // （`SELECT binary FROM t` / `WHERE binary = 1` 仍按列名解析）。
+    if (this.isWord('BINARY')) {
+      const nt = this.peek(1);
+      const startVal = nt && (nt.type === 'number' || nt.type === 'string' || nt.type === 'ident' || nt.type === 'param' ||
+        (nt.type === 'op' && (nt.value === '(' || nt.value === '-' || nt.value === '+')) ||
+        (nt.type === 'keyword' && (nt.value === 'NULL' || nt.value === 'TRUE' || nt.value === 'FALSE' || nt.value === 'DEFAULT')));
+      if (startVal) {
+        this.next(); // 消费 BINARY
+        const lt = this.peek();
+        if (lt.type === 'string' || lt.type === 'number') { const lit = this.next(); return { type: 'binary', operand: { type: 'literal', value: lit.value } }; }
+        const operand = this.parseValue();
+        return { type: 'binary', operand };
+      }
+    }
     const t = this.next();
     if (t.type === 'number' || t.type === 'string') return t.value;
     // MySQL: ON DUPLICATE KEY UPDATE col = VALUES(col) —— 引用"本次本应插入的值"
@@ -1583,9 +1606,30 @@ class Parser {
     let where = null;
     if (this.isKeyword('WHERE')) { this.next(); where = this.parseExpr(); }
     else console.warn(`⚠️  UPDATE without WHERE clause — this will modify ALL rows in '${table}'`);
+    // UPDATE ... ORDER BY ... LIMIT n（与 DELETE 对称；按排序后的前 n 行更新）
+    let orderBy = null, limit = null;
+    if (this.isKeyword('ORDER')) {
+      this.next(); this.expectKeyword('BY');
+      orderBy = [];
+      for (;;) {
+        const col = this.parseColumnRef();
+        let dir = 'asc';
+        if (this.isKeyword('ASC')) this.next();
+        else if (this.isKeyword('DESC')) { this.next(); dir = 'desc'; }
+        orderBy.push({ column: col, dir });
+        if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
+        break;
+      }
+    }
+    if (this.isKeyword('LIMIT')) {
+      this.next();
+      limit = this.parseValue();
+      if (typeof limit === 'bigint') limit = Number(limit <= BigInt(Number.MAX_SAFE_INTEGER) ? limit : BigInt(Number.MAX_SAFE_INTEGER));
+      if (typeof limit === 'number' && limit < 0) throw new Error(`LIMIT must be a non-negative integer, got ${limit}`);
+    }
     const returning = this.parseOptionalReturning();
     this.optionalTailSemicolon();
-    return { type: 'update', table, assignments, where, returning };
+    return { type: 'update', table, assignments, where, orderBy, limit, returning };
   }
 
   parseDelete() {
@@ -2191,6 +2235,37 @@ class Parser {
   }
 
   parseOperand() {
+    // MySQL 前缀运算符：BINARY expr —— 强制大小写敏感比较。
+    if (this.isWord('BINARY')) {
+      const nt = this.peek(1);
+      const startVal = nt && (nt.type === 'number' || nt.type === 'string' || nt.type === 'ident' || nt.type === 'param' ||
+        (nt.type === 'op' && (nt.value === '(' || nt.value === '-' || nt.value === '+')) ||
+        (nt.type === 'keyword' && (nt.value === 'NULL' || nt.value === 'TRUE' || nt.value === 'FALSE' || nt.value === 'DEFAULT')));
+      if (startVal) {
+        this.next(); // 消费 BINARY
+        // 字面量要包成 literal，否则 resolveOperand 把 'ABC' 当列名
+        const lt = this.peek();
+        if (lt.type === 'string' || lt.type === 'number') { const lit = this.next(); return { type: 'binary', operand: { type: 'literal', value: lit.value } }; }
+        const operand = this.parseValue();
+        return { type: 'binary', operand };
+      }
+    }
+    // MySQL 区间字面量：INTERVAL n UNIT（date + INTERVAL 3 DAY / date - INTERVAL 1 MONTH）
+    if (this.isWord('INTERVAL')) {
+      this.next();
+      const nTok = this.peek();
+      let nVal;
+      if (nTok.type === 'op' && (nTok.value === '-' || nTok.value === '+')) {
+        this.next();
+        const numTok = this.next();
+        nVal = (nTok.value === '-' ? -1 : 1) * Number(numTok.value);
+      } else {
+        this.next();
+        nVal = Number(nTok.value);
+      }
+      const unitTok = this.next();
+      return { type: 'interval', value: nVal, unit: String(unitTok.value).toUpperCase() };
+    }
     const t = this.next();
     // P1-20: SELECT -col 报错——parseOperand 不处理负号
     if (t.type === 'op' && t.value === '-') {
@@ -2871,6 +2946,8 @@ function resolveOperand(operand, row, ctx) {
     case 'value':
     case 'literal':
       return operand.value;
+    case 'binary':
+      return resolveOperand(operand.operand, row, ctx);
     case 'sysvar': {
       const s = (ctx && ctx.session && ctx.session.sysvars) || {};
       const name = String(operand.name).toLowerCase();
@@ -2909,6 +2986,32 @@ function resolveOperand(operand, row, ctx) {
       return undefined;
     }
     case 'arith': {
+      // date + INTERVAL n UNIT / date - INTERVAL n UNIT（MySQL 区间算术）
+      const lIv = operand.left && operand.left.type === 'interval';
+      const rIv = operand.right && operand.right.type === 'interval';
+      if ((operand.op === '+' || operand.op === '-') && (lIv || rIv)) {
+        if (lIv && operand.op === '-') return null; // INTERVAL - date 无意义
+        const ivNode = lIv ? operand.left : operand.right;
+        const dateSide = lIv ? resolveOperand(operand.right, row, ctx) : resolveOperand(operand.left, row, ctx);
+        const base = parseSqlDate(dateSide);
+        if (!base) return null;
+        const sign = operand.op === '-' ? -1 : 1;
+        const isDateOnly = String(dateSide).trim().length <= 10;
+        const d = new Date(base.getTime());
+        const n = sign * Number(ivNode.value || 0);
+        switch (String(ivNode.unit || '').toUpperCase()) {
+          case 'DAY': case 'DAYS': d.setDate(d.getDate() + n); break;
+          case 'WEEK': case 'WEEKS': d.setDate(d.getDate() + n * 7); break;
+          case 'MONTH': case 'MONTHS': addMonthsClamped(d, n); break;
+          case 'QUARTER': addMonthsClamped(d, n * 3); break;
+          case 'YEAR': case 'YEARS': addMonthsClamped(d, n * 12); break;
+          case 'HOUR': case 'HOURS': d.setHours(d.getHours() + n); break;
+          case 'MINUTE': case 'MINUTES': d.setMinutes(d.getMinutes() + n); break;
+          case 'SECOND': case 'SECONDS': d.setSeconds(d.getSeconds() + n); break;
+          default: return null;
+        }
+        return fmtSqlDate(isDateOnly, d);
+      }
       const l = resolveOperand(operand.left, row, ctx);
       const r = resolveOperand(operand.right, row, ctx);
       if (l === null || r === null || l === undefined || r === undefined) return null;
@@ -3014,10 +3117,6 @@ function resolveOperand(operand, row, ctx) {
     // 布尔类节点出现在"取值"位置时（如 IF(status = 'paid', ...)、SUM(IF(a > b,1,0))），
     // 求值成 true/false 供上层按真值判断
     case 'compare':
-    case 'and':
-    case 'or':
-    case 'xor':
-    case 'not':
     case 'in':
     case 'isNull':
     case 'isTruth':
@@ -3026,6 +3125,25 @@ function resolveOperand(operand, row, ctx) {
     case 'like':
     case 'between':
       return evaluateExpr(operand, row, ctx);
+    case 'and': {
+      const a = sqlTruthy(resolveOperand(operand.left, row, ctx));
+      const b = sqlTruthy(resolveOperand(operand.right, row, ctx));
+      return sqlAnd(a, b);
+    }
+    case 'or': {
+      const a = sqlTruthy(resolveOperand(operand.left, row, ctx));
+      const b = sqlTruthy(resolveOperand(operand.right, row, ctx));
+      return sqlOr(a, b);
+    }
+    case 'xor': {
+      const a = sqlTruthy(resolveOperand(operand.left, row, ctx));
+      const b = sqlTruthy(resolveOperand(operand.right, row, ctx));
+      return sqlXor(a, b);
+    }
+    case 'not': {
+      const v = sqlTruthy(resolveOperand(operand.expr, row, ctx));
+      return v === null ? null : (v ? 0 : 1);
+    }
     case 'unit': {
       // 裸时间单位（MONTH / DAY …）：优先当列取，取不到就返回单位名本身
       const lower = String(operand.name).toLowerCase();
@@ -4313,6 +4431,46 @@ function normalizeCmpValue(a, other) {
   return otherIsNumeric ? (a ? 1 : 0) : a;
 }
 
+// MySQL 默认 collation（utf8mb4_general_ci）下字符串比较不区分大小写，
+// 与 LIKE 保持一致。cs=true 表示显式 BINARY/COLLATE 强制大小写敏感。
+function ciEq(a, b, cs) {
+  if (cs) return a === b;
+  if (typeof a === 'string' && typeof b === 'string') return a.toLowerCase() === b.toLowerCase();
+  return String(a) === String(b);
+}
+function ciCompare(a, b, cs) {
+  if (cs) return a === b ? 0 : (a < b ? -1 : 1);
+  const as = String(a).toLowerCase(), bs = String(b).toLowerCase();
+  return as === bs ? 0 : (as < bs ? -1 : 1);
+}
+
+// ── 三值逻辑（SQL 标准：TRUE / FALSE / UNKNOWN）──────────────────────
+// NULL 参与布尔运算时结果不是 0/1，而是 UNKNOWN（用 null 表示）。
+// 此前 resolveOperand 没有 and/or/xor/not 分支，SELECT TRUE AND TRUE 落到
+// default 返回 undefined → 数值化成 0，所有布尔表达式全部失效。
+function sqlTruthy(v) {
+  if (v === null || v === undefined) return null;
+  if (typeof v === 'boolean') return v;
+  if (typeof v === 'number') return v !== 0;
+  if (typeof v === 'string') return v !== '' && !(Number(v) === 0 && String(v).trim() !== '');
+  return Boolean(v);
+}
+// 三值真值表，入参已归一化为 true / false / null，返回 1 / 0 / null
+function sqlAnd(a, b) {
+  if (a === false || b === false) return 0;
+  if (a === null || b === null) return null;
+  return 1;
+}
+function sqlOr(a, b) {
+  if (a === true || b === true) return 1;
+  if (a === null || b === null) return null;
+  return 0;
+}
+function sqlXor(a, b) {
+  if (a === null || b === null) return null;
+  return a !== b ? 1 : 0;
+}
+
 function evaluateExpr(expr, row, ctx) {
   if (expr === null || expr === undefined) return false;
   switch (expr.type) {
@@ -4329,12 +4487,14 @@ function evaluateExpr(expr, row, ctx) {
     case 'compare': {
       const l = resolveOperand(expr.left, row, ctx);
       const r = resolveOperand(expr.right, row, ctx);
+      // BINARY 限定符：任一侧是 BINARY 操作数即强制大小写敏感
+      const cs = !!(expr.cs || (expr.left && expr.left.type === 'binary') || (expr.right && expr.right.type === 'binary'));
       // MySQL NULL 安全相等：NULL <=> NULL 为真；NULL <=> 值 为假
       if (expr.op === '<=>') {
         const ln = l === null || l === undefined;
         const rn = r === null || r === undefined;
         if (ln || rn) return ln && rn;
-        return l === r || String(l) === String(r);
+        return ciEq(l, r, cs);
       }
       // SQL 标准：与 NULL 的比较结果是 UNKNOWN，这里用 null 表示。
       // 不能返回 false —— 否则 NOT (a > 1) 会把 a 为 NULL 的行错误纳入结果。
@@ -4349,11 +4509,19 @@ function evaluateExpr(expr, row, ctx) {
       const mixedNum = (isNum(nl) && isNumStr(nr)) || (isNumStr(nl) && isNum(nr));
       if (expr.op === '=') {
         if (mixedNum) return Number(nl) === Number(nr);
-        return nl === nr || String(nl) === String(nr);
+        return ciEq(nl, nr, cs);
+      }
+      if (mixedNum) { const fn = OPERATORS[expr.op]; return fn(Number(nl), Number(nr)); }
+      if (typeof nl === 'number' && typeof nr === 'number') { const fn = OPERATORS[expr.op]; return fn(nl, nr); }
+      const c = ciCompare(nl, nr, cs);
+      switch (expr.op) {
+        case '!=': case '<>': return c !== 0;
+        case '<': return c < 0;
+        case '<=': return c <= 0;
+        case '>': return c > 0;
+        case '>=': return c >= 0;
+        default: return c === 0;
       }
-      const fn = OPERATORS[expr.op];
-      if (mixedNum) return fn(Number(nl), Number(nr));
-      return typeof nl === 'number' && typeof nr === 'number' ? fn(nl, nr) : fn(String(nl), String(nr));
     }
     case 'isNull': {
       const v = resolveOperand(expr.operand, row, ctx);
@@ -4365,6 +4533,8 @@ 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;
+      const cs = !!(expr.cs || (expr.operand && expr.operand.type === 'binary') ||
+        (expr.list && expr.list.some(x => x && x.type === 'binary')));
 
       // 先找匹配：只要有一个非 NULL 元素等于 v，整个 IN 就是 TRUE ——
       // 列表里别的位置有没有 NULL 都不影响。
@@ -4372,9 +4542,12 @@ function evaluateExpr(expr, row, ctx) {
       // 此前是先判「列表里有 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))
-      );
+      const matched = expr.list.some(x => {
+        // list 元素可能是表达式节点（如 IN (BINARY 'ABC')），需先求值；
+        // 原始字面量（'ABC' / 10）直接比较，不能走 resolveOperand（会把字符串当列名）。
+        const xv = (x && typeof x === 'object') ? resolveOperand(x, row, ctx) : x;
+        return xv !== null && xv !== undefined && (xv === v || ciEq(xv, v, cs));
+      });
       if (matched) return expr.not ? false : true;
 
       // 没匹配上：列表里有 NULL → UNKNOWN，否则是确定的 FALSE
@@ -5255,22 +5428,38 @@ class SQLExecutor {
           throw createError('ER_PARSE_ERROR', `Table '${statement.table}' has no primary key, UPDATE requires a primary key`);
         }
         const all = (await this.engine.find(statement.table, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
+        // UPDATE ... ORDER BY ... LIMIT n：先过滤、排序、截取，再逐行更新
+        let candidates = all.filter(row => !statement.where || evaluateExpr(statement.where, row, this.ctx));
+        if (statement.orderBy) {
+          const cmp = (a, b) => {
+            for (const o of statement.orderBy) {
+              const av = resolveOperand({ type: 'column', name: o.column }, a, this.ctx);
+              const bv = resolveOperand({ type: 'column', name: o.column }, b, this.ctx);
+              if (av === bv) continue;
+              if (av === undefined || av === null) return o.dir === 'asc' ? -1 : 1;
+              if (bv === undefined || bv === null) return o.dir === 'asc' ? 1 : -1;
+              const d = typeof av === 'number' && typeof bv === 'number' ? av - bv : String(av).localeCompare(String(bv));
+              if (d !== 0) return o.dir === 'asc' ? d : -d;
+            }
+            return 0;
+          };
+          candidates = candidates.slice().sort(cmp);
+        }
+        if (typeof statement.limit === 'number') candidates = candidates.slice(0, statement.limit);
         let count = 0;
-        for (const row of all) {
-          if (!statement.where || evaluateExpr(statement.where, row, this.ctx)) {
-            const id = this._rowPkId(row, pkCols);
-            if (id !== undefined) {
-              const data = {};
-              for (const [col, val] of statement.assignments) {
-                data[col] = typeof val === 'object' && val !== null && val.type ? resolveOperand(val, row, this.ctx) : val;
-              }
-              // 必须 await：wasm / native client 的 updateById 是异步的，
-              // 不等就会把「主键/唯一约束冲突」的异常变成未处理的 Promise 拒绝 ——
-              // 表现为 UPDATE 静默成功、产生两行同主键，而调用方拿不到任何错误。
-              // lib/database.js 的实现是同步的，await 同步值同样安全。
-              await this.engine.updateById(statement.table, id, data);
-              count++;
+        for (const row of candidates) {
+          const id = this._rowPkId(row, pkCols);
+          if (id !== undefined) {
+            const data = {};
+            for (const [col, val] of statement.assignments) {
+              data[col] = typeof val === 'object' && val !== null && val.type ? resolveOperand(val, row, this.ctx) : val;
             }
+            // 必须 await：wasm / native client 的 updateById 是异步的，
+            // 不等就会把「主键/唯一约束冲突」的异常变成未处理的 Promise 拒绝 ——
+            // 表现为 UPDATE 静默成功、产生两行同主键，而调用方拿不到任何错误。
+            // lib/database.js 的实现是同步的，await 同步值同样安全。
+            await this.engine.updateById(statement.table, id, data);
+            count++;
           }
         }
         await this.engine.flush();
@@ -5670,17 +5859,26 @@ class SQLExecutor {
     // - 带表限定的条件（如 "o.amount"）：检查表名/别名是否匹配
     // - 不带表限定的条件（如 "amount"）：检查当前表的 schema 是否包含该列
     const filter = {};
+    // 字符串列默认 collation 为 CI（大小写不敏感），而存储层 find 的等值
+    // 过滤是严格比较（CS）。字符串等值若下推会被 CS 预筛，绕过 evaluateExpr 的
+    // ciEq，导致 `code = 'abc'` 匹配不到 'ABC'。所以字符串/JSON 列不参与下推，
+    // 交给 evaluateExpr 按 CI 求值；数值/布尔仍下推走索引。
+    const isNonPushdownCol = (d) => {
+      const t = String((d && d.type) || '').toLowerCase();
+      return t === 'text' || t === 'varchar' || t === 'char' || t === 'string' ||
+        t === 'blob' || t === 'clob' || t === 'json' || t === 'object' || t === 'array';
+    };
     for (const [key, val] of Object.entries(allFilters)) {
       if (key.includes('.')) {
         // 带表限定：检查是否匹配当前表的别名或表名
         const tablePart = key.slice(0, key.lastIndexOf('.'));
         if (tablePart === alias || tablePart === table) {
           const colPart = key.slice(key.lastIndexOf('.') + 1);
-          if (schema[colPart]) filter[colPart] = this._coerceValue(val, schema[colPart]);
+          if (schema[colPart] && !isNonPushdownCol(schema[colPart])) filter[colPart] = this._coerceValue(val, schema[colPart]);
         }
       } else {
         // 不带表限定：只下推到持有该列的表
-        if (schema[key]) filter[key] = this._coerceValue(val, schema[key]);
+        if (schema[key] && !isNonPushdownCol(schema[key])) filter[key] = this._coerceValue(val, schema[key]);
       }
     }
     const useIndex = Object.keys(filter).length > 0 &&
@@ -6198,6 +6396,18 @@ class SQLExecutor {
     walk(statement.where);
     walk(statement.having);
     walk(statement.orderBy);
+    // ORDER BY 的列在解析器里是裸字符串（非 {type:'column'} 对象），walk 检不到。
+    // 字符串可能是输出别名/位置序号（已在 known 里豁免），也可能是真实列；
+    // 两者都不是 → 必须报错（此前静默忽略，用户 ORDER BY nonexistent_col 拿到原序）。
+    if (Array.isArray(statement.orderBy)) {
+      for (const o of statement.orderBy) {
+        const c = o && o.column;
+        if (typeof c !== 'string') continue; // 位置序号（数字）跳过
+        const n = c.toLowerCase();
+        const base = n.indexOf('.') >= 0 ? n.slice(n.indexOf('.') + 1) : n;
+        if (!known.has(n) && !known.has(base)) throw new Error(`no such column: ${c}`);
+      }
+    }
     if (Array.isArray(statement.groupBy)) {
       // groupBy 是列名字符串数组
       for (const g of statement.groupBy) {
@@ -7208,24 +7418,42 @@ class SQLExecutor {
        * 同时按「投影列名 → 下标」解析；命中就直接 `row[idx]`，
        * 不再走 resolveOperand 的通用路径。
        */
+      // 把 ORDER BY 引用的输出列（别名或位置序号）解析回该列的**底层取值**。
+      // 非分组路径的行对象键是底层列名（如 'v'），不是别名（'val'），
+      // 直接 r['val'] 会取到 undefined，导致 ORDER BY 静默不排序。
+      const resolveByColumn = (c) => {
+        if (!c) return (r) => null;
+        if (typeof c.expr === 'string' && c.expr !== '*') {
+          const name = c.expr;
+          const node = { type: 'column', name };
+          return (r) => {
+            const v = (r == null) ? undefined : r[name];
+            return v !== undefined ? v : resolveOperand(node, r, this.ctx);
+          };
+        }
+        if (c.scalar) return (r) => resolveOperand(c.scalar, r, this.ctx);
+        if (c.aggregate) return (r) => this._aggValue([r], c.aggregate, c.column, c.distinct, c.separator, c.orderBy);
+        const nm = c.alias;
+        return (r) => (r == null ? null : r[nm]);
+      };
       const ordKeys = statement.orderBy.map(o => {
         const dir = o.dir === 'asc' ? 1 : -1;
-        // 位置序号：ORDER BY 1
+        // 位置序号：ORDER BY 1（1-based，指第 N 个输出列）
         const pos = (o.column && typeof o.column === 'object' && o.column.type === 'value' && typeof o.column.value === 'number')
           ? o.column.value
           : (typeof o.column === 'number' ? o.column : null);
         if (pos !== null && pos !== undefined) {
-          const name = ordNames[pos - 1];
-          return { dir, at: (name === undefined || name === null) ? () => null : (r) => (r == null ? null : r[name]) };
+          return { dir, at: resolveByColumn(statement.columns[pos - 1]) };
         }
         if (typeof o.column === 'string') {
           const f = o.column;
-          // 节点对象提到循环外复用 —— 此前每次比较都新建一个 {type:'column',name}
+          // 命中某个输出列的别名/列名 → 用该列的底层取值（修复别名排序）
+          const idx = ordNames.findIndex(n => n === f);
+          if (idx >= 0) return { dir, at: resolveByColumn(statement.columns[idx]) };
           const node = { type: 'column', name: f };
           return {
             dir,
             at: (r) => {
-              // 先按字段名直取；取不到再走 resolveOperand（点号路径、表达式等）
               const v = (r == null) ? undefined : r[f];
               return v !== undefined ? v : resolveOperand(node, r, this.ctx);
             },
@@ -7709,6 +7937,30 @@ async function inferColumnTypes(engine, stmt, r) {
   });
 }
 
+// 结果里的大整数（> MAX_SAFE_INTEGER 的 BigInt）在 JSON.stringify / wasm 绑定下
+// 无法序列化（"Do not know how to serialize a BigInt"）。输出前递归转成字符串，
+// 保留精度且可序列化；内部运算仍走 BigInt，精度不丢。
+function finalizeBigInts(value, seen) {
+  if (typeof value === 'bigint') return value.toString();
+  if (Array.isArray(value)) {
+    if (!seen) seen = new Set();
+    if (seen.has(value)) return value;
+    seen.add(value);
+    for (let i = 0; i < value.length; i++) value[i] = finalizeBigInts(value[i], seen);
+    return value;
+  }
+  if (value && typeof value === 'object') {
+    // Buffer / Date / RegExp 等特殊对象不深入（Buffer 是 Uint8Array，逐字节递归会爆栈）
+    if (value instanceof Buffer || value instanceof Date || value instanceof RegExp) return value;
+    if (!seen) seen = new Set();
+    if (seen.has(value)) return value;
+    seen.add(value);
+    for (const k of Object.keys(value)) value[k] = finalizeBigInts(value[k], seen);
+    return value;
+  }
+  return value;
+}
+
 async function executeSQL(engine, sql, paramsOrOpts, opts = {}) {
   // 参数守卫：engine 必须是引擎对象，sql 必须是字符串。误用时报清晰错误，
   // 而不是在后续像 `reading 'length'` 那样抛出令人费解的 TypeError。
@@ -7767,6 +8019,7 @@ async function executeSQL(engine, sql, paramsOrOpts, opts = {}) {
     let r = await executor.execute(stmt);
     const durationMs = Number(process.hrtime.bigint() - t0) / 1e6;
     r = buildResultEnvelope(stmt, r, Math.round(durationMs * 1000) / 1000);
+    r = finalizeBigInts(r);
     if (r && r.columns && r.columnTypes === undefined) {
       r.columnTypes = await inferColumnTypes(engine, stmt, r);
     }

package/lib/table.js

@@ -1543,6 +1543,11 @@ class Table {
                 else if (typeof v === 'number' || typeof v === 'boolean' || v instanceof Date) result[field] = String(v);
                 else if (Buffer.isBuffer(v)) result[field] = v.toString('utf8');
                 else throw createError('ER_TRUNCATED_WRONG_VALUE', t, v);
+            } else if ((t === 'object' || t === 'array' || t === 'json') && (def.jsonType || t === 'json')) {
+                // JSON / JSONB 列：字符串形式必须是合法 JSON（{bad json 这类会被 JSON.parse 拒绝）
+                if (typeof v === 'string') {
+                    try { JSON.parse(v); } catch (e) { throw createError('ER_TRUNCATED_WRONG_VALUE', t, v); }
+                }
             }
         }
         return result;

package/lib/wasm_client.js

@@ -561,6 +561,18 @@ class JSQL {
     // 难以定位的 "Cannot convert undefined or null to object"，这里直接给明确 TypeError
     const arr = Array.isArray(data) ? data : [data];
     arr.forEach((row, i) => assertRowObject(row, i, arr.length > 1 || Array.isArray(data)));
+    // JSON / JSONB 列：字符串形式必须是合法 JSON（{bad json 这类会被 JSON.parse 拒绝）
+    const schema = this._schemas[table];
+    if (schema) {
+      for (const row of arr) {
+        for (const [f, def] of Object.entries(schema)) {
+          if (def && def.jsonType && typeof row[f] === 'string') {
+            try { JSON.parse(row[f]); }
+            catch (e) { throw new Error(`Truncated incorrect object value: '${row[f]}'`); }
+          }
+        }
+      }
+    }
     if (!(await this._runHooks('beforeInsert', [table, arr]))) return [];
     if (arr.length > 1) {
       await this._flush();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsql-neo",
-  "version": "6.5.9",
+  "version": "6.5.11",
   "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",

package/test/bug-regression.test.js

@@ -0,0 +1,87 @@
+/*
+ * Bug 回归测试：此前发现的 5 个缺陷，逐一固化，防止回退。
+ *
+ *   1. 布尔求值器整体失效：TRUE AND TRUE → 0、NULL AND TRUE → 0、NULL OR FALSE → 0。
+ *      正确三值逻辑：1 / NULL / NULL。根因是 resolveOperand 没有 and/or/xor/not 分支，
+ *      落到 default 返回 undefined → 数值化成 0。
+ *   2. CREATE TABLE d(a INT, a INT) 不拒绝重复列名（对象键覆盖静默丢列）。
+ *   3. JSONB 列能塞进 {bad json 这种非法 JSON（两引擎：Database _validateDataTypes + wasm insert）。
+ *   4. ORDER BY 不存在的列静默忽略（解析产物是裸字符串，_validateColumnRefs 的 walk 检不到）。
+ *   5. SELECT 超大整数抛 "Do not know how to serialize a BigInt"（输出前应转字符串）。
+ */
+const path = require('path');
+
+const ROOT = path.join(__dirname, '..');
+const { JSQL } = require(path.join(ROOT, 'index.js'));
+const { executeSQL } = require(path.join(ROOT, 'lib/sql.js'));
+
+const OPTS = { safety: false };
+let pass = 0, fail = 0;
+
+function ok(name, cond, extra) {
+  if (cond) { pass++; console.log('[OK]  ', name); }
+  else { fail++; console.log('[FAIL]', name, extra !== undefined ? '-> ' + JSON.stringify(extra).slice(0, 150) : ''); }
+}
+const eq = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+
+(async () => {
+  const db = new JSQL(':memory:');
+  await db.start();
+  const q = (sql) => executeSQL(db, sql, OPTS);
+  const rows = async (sql) => (await q(sql)).rows;
+  const one = async (sql) => (await q(sql)).rows[0][0];
+  const fails = async (sql) => { try { await q(sql); return null; } catch (e) { return e.message; } };
+
+  // ── 1. 三值布尔逻辑 ────────────────────────────────────────────
+  console.log('--- 1. 布尔三值逻辑 ---');
+  ok('TRUE AND TRUE = 1', (await one('SELECT TRUE AND TRUE')) === 1);
+  ok('TRUE AND FALSE = 0', (await one('SELECT TRUE AND FALSE')) === 0);
+  ok('NULL AND TRUE = NULL', (await one('SELECT NULL AND TRUE')) === null);
+  ok('NULL AND FALSE = 0', (await one('SELECT NULL AND FALSE')) === 0);
+  ok('NULL OR FALSE = NULL', (await one('SELECT NULL OR FALSE')) === null);
+  ok('NULL OR TRUE = 1', (await one('SELECT NULL OR TRUE')) === 1);
+  ok('FALSE OR FALSE = 0', (await one('SELECT FALSE OR FALSE')) === 0);
+  ok('NOT TRUE = 0', (await one('SELECT NOT TRUE')) === 0);
+  ok('NOT NULL = NULL', (await one('SELECT NOT NULL')) === null);
+  ok('1 AND 0 = 0', (await one('SELECT 1 AND 0')) === 0);
+  ok('1 XOR 0 = 1', (await one('SELECT 1 XOR 0')) === 1);
+  ok('TRUE OR NULL = 1', (await one('SELECT TRUE OR NULL')) === 1);
+
+  // ── 2. CREATE TABLE 重复列名 ───────────────────────────────────
+  console.log('--- 2. 重复列名 ---');
+  ok('d(a INT, a INT) 报错', /Duplicate column/i.test(await fails('CREATE TABLE r1(a INT, a INT)')));
+  ok('d(x,y,x) 报错', /Duplicate column/i.test(await fails('CREATE TABLE r2(x INT, y INT, x INT)')));
+  ok('正常列不报错', (await fails('CREATE TABLE r3(a INT, b TEXT)')) === null);
+  ok('id PRIMARY KEY + id 重复报错', /Duplicate column/i.test(await fails('CREATE TABLE r4(id INT PRIMARY KEY, id INT)')));
+
+  // ── 3. JSONB 非法 JSON ─────────────────────────────────────────
+  console.log('--- 3. JSONB 校验 ---');
+  await q('CREATE TABLE rj(c JSONB)');
+  ok('{bad json 拒绝', /Truncated incorrect object value/.test(await fails(`INSERT INTO rj VALUES ('{bad json')`)));
+  ok('[1,2 拒绝', /Truncated incorrect object value/.test(await fails(`INSERT INTO rj VALUES ('[1,2')`)));
+  ok('合法 {"a":1} 通过', (await fails(`INSERT INTO rj VALUES ('{"a":1}')`)) === null);
+  await q('CREATE TABLE rj2(c JSON)');
+  ok('JSON 列 nope 拒绝', /Truncated incorrect object value/.test(await fails(`INSERT INTO rj2 VALUES ('nope')`)));
+
+  // ── 4. ORDER BY 不存在列 ───────────────────────────────────────
+  console.log('--- 4. ORDER BY 校验 ---');
+  await q('CREATE TABLE ro (id INT PRIMARY KEY, v INT, s TEXT)');
+  await q('INSERT INTO ro VALUES (1,2,\'x\'),(2,1,\'y\')');
+  ok('ORDER BY nonexistent_col 报错', /no such column: nonexistent_col/.test(await fails('SELECT id FROM ro ORDER BY nonexistent_col')));
+  ok('WHERE 不存在列报错', /no such column: nosuch/.test(await fails('SELECT id FROM ro WHERE nosuch > 1')));
+  ok('ORDER BY 真列 v 正常', eq(await rows('SELECT id FROM ro ORDER BY v'), [[2], [1]]));
+  ok('ORDER BY 位置序号 1 正常', eq(await rows('SELECT id FROM ro ORDER BY 1'), [[1], [2]]));
+  ok('ORDER BY 输出别名 vv 正常', eq(await rows('SELECT v AS vv FROM ro ORDER BY vv'), [[1], [2]]));
+
+  // ── 5. 超大整数序列化 ──────────────────────────────────────────
+  console.log('--- 5. 超大整数 ---');
+  const big = await one('SELECT 1000000000000000000000');
+  ok('超大整数可序列化（字符串）', typeof big === 'string' && big === '1000000000000000000000');
+  ok('超界精确值 9007199254740993', (await one('SELECT 9007199254740993')) === '9007199254740993');
+  const bigRows = await rows('SELECT 1000000000000000000000');
+  ok('JSON.stringify 不炸', (() => { try { JSON.stringify(bigRows); return true; } catch (e) { return false; } })());
+
+  await db.stop();
+  console.log(`\nRESULT: ${pass} passed, ${fail} failed`);
+  process.exit(fail ? 1 : 0);
+})().catch((e) => { console.error('FATAL', e); process.exit(1); });