jsql-neo 6.5.8 → 6.5.10

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.8** — stable release · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo) · [jsql.vexify.top](https://jsql.vexify.top)
+> **v6.5.10** — 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)
@@ -188,3 +188,6 @@ Apache-2.0 License — contributions welcome!
 - **GitHub:** [vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo)
 - **Issues:** [Open an issue](https://github.com/vexify-org/JSQL-neo/issues)
 - **PRs:** Fork → branch → PR — thank you!
+- **Contributing:** [CONTRIBUTING.md](CONTRIBUTING.md)
+- **Code of Conduct:** [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md)
+- **Security:** [SECURITY.md](SECURITY.md) — please report vulnerabilities privately

package/index.js

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

package/lib/btree.js

@@ -173,7 +173,7 @@ class BTree {
                 const s = k === undefined || k === null ? '' : String(k);
                 // 不能假设键按字典序排序（数字键按数值序），必须检查所有键
                 if (s.startsWith(p)) {
-                    result.push(...node.values[i]);
+                    for (const __e of node.values[i]) result.push(__e);
                 }
             }
             node = node.next;
@@ -193,7 +193,7 @@ class BTree {
                 const k = node.keys[i];
                 if (k > max) return result;
                 if (k >= min) {
-                    result.push(...node.values[i]);
+                    for (const __e of node.values[i]) result.push(__e);
                 }
             }
             node = node.next;
@@ -209,7 +209,7 @@ class BTree {
         let node = this._findLeaf(min);
         while (node) {
             for (let i = 0; i < node.keys.length; i++) {
-                if (node.keys[i] > min) result.push(...node.values[i]);
+                if (node.keys[i] > min) for (const __e of node.values[i]) result.push(__e);
             }
             node = node.next;
         }
@@ -221,7 +221,7 @@ class BTree {
         let node = this._findLeaf(min);
         while (node) {
             for (let i = 0; i < node.keys.length; i++) {
-                if (node.keys[i] >= min) result.push(...node.values[i]);
+                if (node.keys[i] >= min) for (const __e of node.values[i]) result.push(__e);
             }
             node = node.next;
         }
@@ -237,7 +237,7 @@ class BTree {
         while (!node.leaf) node = node.children[0];
         while (node) {
             for (let i = 0; i < node.keys.length; i++) {
-                if (node.keys[i] < max) result.push(...node.values[i]);
+                if (node.keys[i] < max) for (const __e of node.values[i]) result.push(__e);
                 else return result;
             }
             node = node.next;
@@ -251,7 +251,7 @@ class BTree {
         while (!node.leaf) node = node.children[0];
         while (node) {
             for (let i = 0; i < node.keys.length; i++) {
-                if (node.keys[i] <= max) result.push(...node.values[i]);
+                if (node.keys[i] <= max) for (const __e of node.values[i]) result.push(__e);
                 else return result;
             }
             node = node.next;
@@ -408,9 +408,9 @@ class BTree {
             left.keys.push(midKey);
             left.values.push(midVal);
         }
-        left.keys.push(...right.keys);
-        left.values.push(...right.values);
-        if (!left.leaf) left.children.push(...right.children);
+        for (const __e of right.keys) left.keys.push(__e);
+        for (const __e of right.values) left.values.push(__e);
+        if (!left.leaf) for (const __e of right.children) left.children.push(__e);
         if (left.leaf) left.next = right.next;
 
         parent.keys.splice(index, 1);

package/lib/cache.js

@@ -152,7 +152,7 @@ class Cache {
       throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
     }
     if (!list) { list = []; this._getData().set(k, list); }
-    list.push(...values.map(String));
+    for (const __e of values.map(String)) list.push(__e);
     this._dirty = true;
     return list.length;
   }

package/lib/database.js

@@ -566,7 +566,7 @@ class Database {
                         case 'insert': {
                             const t = op.table && this._tables[op.table];
                             if (!t || !Array.isArray(op.rows) || op.rows.length === 0) { failed++; break; }
-                            t._rows.push(...op.rows);
+                            for (const __e of op.rows) t._rows.push(__e);
                             touched.add(t);
                             replayed++;
                             break;

package/lib/jsql_format.js

@@ -510,7 +510,7 @@ class JSQLFormat {
     t.schema = schema;
 
     const { rows: oldRows } = this.readTable(name);
-    oldRows.push(...rows);
+    for (const __e of rows) oldRows.push(__e);
     this.writeTable(name, schema, oldRows, pkField);
   }
 }

package/lib/mongo_server.js

@@ -647,10 +647,14 @@ class MongoServer {
                         doc[k] = vals.reduce((a, b) => a + b, 0) / vals.length;
                       } else if (v.$min !== undefined) {
                         const vals = grow.map(r => r[field]).filter(v => v != null);
-                        doc[k] = vals.length ? Math.min(...vals) : null;
+                        let best = null;
+                        for (const x of vals) if (best === null || x < best) best = x;
+                        doc[k] = best;
                       } else if (v.$max !== undefined) {
                         const vals = grow.map(r => r[field]).filter(v => v != null);
-                        doc[k] = vals.length ? Math.max(...vals) : null;
+                        let best = null;
+                        for (const x of vals) if (best === null || x > best) best = x;
+                        doc[k] = best;
                       } else if (v.$first !== undefined) {
                         doc[k] = grow[0] ? grow[0][field] : null;
                       } else if (v.$last !== undefined) {

package/lib/native_client.js

@@ -851,7 +851,7 @@ class JSQL {
     }
     if (!(await this._runHooks('beforeUpdate', [table, pairs]))) return;
     if (!this._opBuffer.update[table]) this._opBuffer.update[table] = [];
-    this._opBuffer.update[table].push(...pairs);
+    for (const __e of pairs) this._opBuffer.update[table].push(__e);
     this._scheduleOpFlush();
   }
 

package/lib/nedb_compat.js

@@ -170,7 +170,7 @@ function applyModifier(doc, update) {
       for (const [k, v] of Object.entries(payload)) {
         const cur = getPath(doc, k);
         const arr = Array.isArray(cur) ? cur : [];
-        if (v && typeof v === 'object' && v.$each) arr.push(...v.$each);
+        if (v && typeof v === 'object' && v.$each) for (const __e of v.$each) arr.push(__e);
         else arr.push(v);
         setPath(doc, k, arr);
       }

package/lib/query.js

@@ -706,7 +706,7 @@ class Query {
             const result = [];
             for (const group of Object.values(groups)) {
                 this._applyWindowToGroup(group, fn, field, dir);
-                result.push(...group);
+                for (const __e of group) result.push(__e);
             }
             return result;
         }

package/lib/redis_server.js

@@ -335,7 +335,7 @@ class RedisServer {
         if (cmd === 'LPUSH') {
           for (const val of args.slice(1)) list.unshift(val);
         } else {
-          list.push(...args.slice(1));
+          for (const __e of args.slice(1)) list.push(__e);
         }
         this.db.set(args[0], { type: 'list', val: list, ttl: v ? v.ttl : null });
         this._scheduleSnapshot();

package/lib/sql.js

@@ -1079,6 +1079,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 +1599,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 +2228,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 +2939,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 +2979,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;
@@ -4114,13 +4210,25 @@ function applyScalarFunction(fnNode, row, ctx) {
       }
       function depth(obj) {
         if (typeof obj !== 'object' || obj === null) return 0;
-        if (Array.isArray(obj)) {
-          if (obj.length === 0) return 1;
-          return 1 + Math.max(...obj.map(depth));
+        let max = 0;
+        const stack = [{ o: obj, d: 1 }];
+        while (stack.length) {
+          const { o, d } = stack.pop();
+          if (typeof o !== 'object' || o === null) continue;
+          if (d > max) max = d;
+          if (Array.isArray(o)) {
+            for (const x of o) {
+              if (x && typeof x === 'object') stack.push({ o: x, d: d + 1 });
+            }
+          } else {
+            const ks = Object.keys(o);
+            for (const k of ks) {
+              const x = o[k];
+              if (x && typeof x === 'object') stack.push({ o: x, d: d + 1 });
+            }
+          }
         }
-        const keys = Object.keys(obj);
-        if (keys.length === 0) return 1;
-        return 1 + Math.max(...keys.map(k => depth(obj[k])));
+        return max;
       }
       return depth(data);
     }
@@ -4301,6 +4409,19 @@ 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);
+}
+
 function evaluateExpr(expr, row, ctx) {
   if (expr === null || expr === undefined) return false;
   switch (expr.type) {
@@ -4317,12 +4438,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 的行错误纳入结果。
@@ -4337,11 +4460,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);
@@ -4353,6 +4484,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 都不影响。
@@ -4360,9 +4493,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
@@ -5243,22 +5379,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();
@@ -5658,17 +5810,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 &&
@@ -5915,7 +6076,7 @@ class SQLExecutor {
   _rollupRow(groupReps) {
     const all = [];
     for (const rep of groupReps) {
-      if (rep._group) all.push(...rep._group);
+      if (rep._group) for (const __e of rep._group) all.push(__e);
       else all.push(rep);
     }
     const out = {};
@@ -5979,8 +6140,12 @@ class SQLExecutor {
       const numeric = (v) => typeof v === 'number' ||
         (typeof v === 'string' && String(v).trim() !== '' && Number.isFinite(Number(v)));
       if (vs.every(numeric)) {
-        const nums = vs.map(v => Number(v));
-        return fn === 'MIN' ? Math.min(...nums) : Math.max(...nums);
+        let best = Number(vs[0]);
+        for (let i = 1; i < vs.length; i++) {
+          const n = Number(vs[i]);
+          if (fn === 'MIN' ? n < best : n > best) best = n;
+        }
+        return best;
       }
       let best = vs[0];
       for (const v of vs.slice(1)) {
@@ -7192,24 +7357,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);
             },

package/lib/tui.js

@@ -72,7 +72,9 @@ function renderTable(headers, rows, maxWidth) {
   for (const w of widths) total += w + 3;
   if (total > maxCol && widths.length > 1) {
     let overshoot = total - maxCol;
-    let i = widths.indexOf(Math.max(...widths));
+    let maxW = widths[0];
+    for (const w of widths) if (w > maxW) maxW = w;
+    let i = widths.indexOf(maxW);
     while (overshoot > 0) {
       if (i === -1 || widths[i] <= 3) break;
       const cut = Math.min(widths[i] - 3, overshoot);

package/package.json

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