jsql-neo 6.5.9 → 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.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.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)

package/index.js

@@ -1,5 +1,5 @@
 /**
- * JSQL-NEO v6.5.9 — 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/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;
@@ -4313,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) {
@@ -4329,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 的行错误纳入结果。
@@ -4349,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);
@@ -4365,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 都不影响。
@@ -4372,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
@@ -5255,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();
@@ -5670,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 &&
@@ -7208,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/package.json

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