jsql-neo 6.4.0-beta.15 → 6.4.0-beta.16

package/README.md

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

package/index.js

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

package/lib/btree.js

@@ -171,9 +171,10 @@ class BTree {
             for (let i = 0; i < node.keys.length; i++) {
                 const k = node.keys[i];
                 const s = k === undefined || k === null ? '' : String(k);
-                if (s < p) continue;
-                if (!s.startsWith(p)) return result;
-                result.push(...node.values[i]);
+                // 不能假设键按字典序排序（数字键按数值序），必须检查所有键
+                if (s.startsWith(p)) {
+                    result.push(...node.values[i]);
+                }
             }
             node = node.next;
         }
@@ -326,13 +327,14 @@ class BTree {
         const left = parent.children[i - 1];
         const right = parent.children[i];
         if (right.leaf) {
-            // 叶子节点：分隔键是叶子的副本，用被移动的键而非旧分隔键，避免重复
+            // 叶子节点：移动左叶最大键到右叶最小位置
             const k = left.keys.pop();
             const v = left.values.pop();
             right.keys.unshift(k);
             right.values.unshift(v);
-            parent.keys[i - 1] = k;
-            parent.values[i - 1] = v;
+            // 父节点分隔键应为左叶新的最大值（pop 后的最后一个键）
+            parent.keys[i - 1] = left.keys[left.keys.length - 1];
+            parent.values[i - 1] = left.values[left.values.length - 1];
         } else {
             right.keys.unshift(parent.keys[i - 1]);
             right.values.unshift(parent.values[i - 1]);

package/lib/query.js

@@ -675,6 +675,12 @@ class Query {
             for (const { field, dir } of this._orderBy) {
                 const va = a[field];
                 const vb = b[field];
+                // MySQL 语义：NULL 在 ASC 时排在最前，DESC 时排在最后
+                const aNull = va === null || va === undefined;
+                const bNull = vb === null || vb === undefined;
+                if (aNull && bNull) continue;
+                if (aNull) return dir === 'asc' ? -1 : 1;
+                if (bNull) return dir === 'asc' ? 1 : -1;
                 if (va < vb) return dir === 'asc' ? -1 : 1;
                 if (va > vb) return dir === 'asc' ? 1 : -1;
             }

package/lib/sql.js

@@ -2908,7 +2908,7 @@ function resolveOperand(operand, row, ctx) {
     }
     // P1-19: ON DUPLICATE KEY UPDATE 表达式赋值，如 count = count + 1
     case 'binary': {
-      return evaluateExpr({ type: 'arith', op: operand.op, left: operand.left, right: operand.right }, row, ctx);
+      return evaluateExpr(operand, row, ctx);
     }
     case 'func':
       return applyScalarFunction(operand, row, ctx);
@@ -4223,10 +4223,14 @@ function evaluateExpr(expr, row, ctx) {
     }
     case 'in': {
       const v = resolveOperand(expr.operand, 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 false;
+      if (!expr.list) return expr.not ? true : false;
+      // 列表中出现 NULL 时：三值逻辑 → NULL IN (1,2,NULL) 为 NULL（UNKNOWN）
+      const hasNull = expr.list.some(x => x === null || x === undefined);
+      if (hasNull) return null;
       const r = expr.list.some(x => x === v || String(x) === String(v));
-      return expr.not ? !r : r;   // NOT IN：此前漏了取反，导致 NOT IN 与 IN 结果相同
+      return expr.not ? !r : r;
     }
     case 'like': {
       const v = resolveOperand(expr.operand, row, ctx);
@@ -6751,9 +6755,25 @@ class SQLExecutor {
 
     // 分组聚合
     if (statement.groupBy) {
+      // MySQL 支持 GROUP BY alias，而 alias 指向 SELECT 列表的输出列名。
+      // 解析时 groupBy[] 存的是原始字符串（如 "b"），必须先在 SELECT 别名里查找：
+      //  - 找到 → 取输出行里的 alias 值（因为 alias 已求出值了）
+      //  - 找不到 → 当列名取输入行里对应列的值（标准 SQL 行为）
+      // 此前全用 resolveOperand({type:'column', name:g}) 按列名取，导致 GROUP BY b
+      // 取 row['b']，而原始行里没有 b 列（b 是别名），全返回 undefined 并成一组。
+      const aliases = {};
+      if (statement.columns) {
+        for (const c of statement.columns) {
+          if (c.alias) aliases[c.alias.toLowerCase()] = true;
+        }
+      }
       const groups = new Map();
       for (const row of rows) {
-        const key = JSON.stringify(statement.groupBy.map(g => resolveOperand({ type: 'column', name: g }, row, this.ctx)));
+        const key = JSON.stringify(statement.groupBy.map(g => {
+          const key = String(g).toLowerCase();
+          if (aliases[key] && row[key] !== undefined) return row[key];
+          return resolveOperand({ type: 'column', name: g }, row, this.ctx);
+        }));
         if (!groups.has(key)) groups.set(key, []);
         groups.get(key).push(row);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsql-neo",
-  "version": "6.4.0-beta.15",
+  "version": "6.4.0-beta.16",
   "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
   "main": "index.js",
   "types": "index.d.ts",

package/test/bug-hunt.test.js

@@ -0,0 +1,344 @@
+// © Vexify 2026 All Rights Reserved.
+/**
+ * Bug Hunt Tests — v6.4.0-beta.16
+ * Tests for bugs found during code review:
+ *   1. BTree _borrowFromLeft wrong parent key (leaf nodes)
+ *   2. Query _applyOrderBy missing NULL handling
+ *   3. BTree prefix incorrect early return for numeric keys
+ *
+ *   node test/bug-hunt.test.js
+ */
+const BTree = require('../lib/btree');
+const Query = require('../lib/query');
+
+let passed = 0, failed = 0;
+function ok(name, cond, extra) {
+    if (cond) { passed++; }
+    else { failed++; console.log('[FAIL]', name, extra !== undefined ? '-> ' + JSON.stringify(extra) : ''); }
+}
+
+// ============================================================
+// Helper: Mock Table for Query tests
+// ============================================================
+function createMockTable(name, rows, schema = {}) {
+    const table = {
+        _name: name,
+        _rows: rows,
+        _schema: schema,
+        _btrees: {},
+        _indexes: {},
+        _applyFilterOptimized(rows, query) {
+            return rows.filter(row => {
+                for (const [field, condition] of Object.entries(query)) {
+                    const value = row[field];
+                    if (condition !== null && typeof condition === 'object' && !Array.isArray(condition)) {
+                        for (const [op, target] of Object.entries(condition)) {
+                            if (op === '$gt' && !(value > target)) return false;
+                            if (op === '$gte' && !(value >= target)) return false;
+                            if (op === '$lt' && !(value < target)) return false;
+                            if (op === '$lte' && !(value <= target)) return false;
+                            if (op === '$eq' && value !== target) return false;
+                            if (op === '$ne' && value === target) return false;
+                            if (op === '$in' && !target.includes(value)) return false;
+                        }
+                    } else {
+                        if (value !== condition) return false;
+                    }
+                }
+                return true;
+            });
+        },
+        _applyFilter(rows, query) { return this._applyFilterOptimized(rows, query); },
+        _matchRow(row, query) {
+            for (const [field, condition] of Object.entries(query)) {
+                const value = row[field];
+                if (condition !== null && typeof condition === 'object' && !Array.isArray(condition)) {
+                    for (const [op, target] of Object.entries(condition)) {
+                        if (op === '$gt' && !(value > target)) return false;
+                        if (op === '$gte' && !(value >= target)) return false;
+                        if (op === '$lt' && !(value < target)) return false;
+                        if (op === '$lte' && !(value <= target)) return false;
+                        if (op === '$eq' && value !== target) return false;
+                        if (op === '$ne' && value === target) return false;
+                        if (op === '$in' && !target.includes(value)) return false;
+                    }
+                } else {
+                    if (value !== condition) return false;
+                }
+            }
+            return true;
+        },
+        _getVisibleRows() { return this._rows; },
+        _db: {
+            _logSlowQuery() {},
+            _tables: {},
+        },
+    };
+    return table;
+}
+
+// ============================================================
+// Bug 1: BTree _borrowFromLeft wrong parent key
+// ============================================================
+console.log('\n=== Bug 1: BTree _borrowFromLeft parent key ===');
+
+{
+    const tree = new BTree(4, false);
+    for (let i = 0; i < 20; i++) tree.insert(i, i);
+
+    // Delete from the right side to trigger left borrows
+    for (let i = 19; i >= 10; i--) tree.remove(i, i);
+
+    // After deletions, search for remaining keys should work
+    let allFound = true;
+    for (let i = 0; i < 10; i++) {
+        const result = tree.search(i);
+        if (result.length === 0 || !result.includes(i)) { allFound = false; break; }
+    }
+    ok('Bug1: search after left borrows', allFound);
+
+    // Range query should return correct results
+    const rangeResult = tree.range(0, 9);
+    ok('Bug1: range [0,9] returns 10 items', rangeResult.length === 10, { len: rangeResult.length });
+}
+
+{
+    const tree = new BTree(4, false);
+    for (let i = 0; i < 50; i++) tree.insert(i, i);
+
+    // Delete every other key to force rebalancing
+    for (let i = 1; i < 50; i += 2) tree.remove(i, i);
+
+    // Verify all remaining keys are searchable
+    let allEvenFound = true;
+    for (let i = 0; i < 50; i += 2) {
+        const result = tree.search(i);
+        if (result.length === 0 || !result.includes(i)) { allEvenFound = false; break; }
+    }
+    ok('Bug1: even keys after heavy deletions', allEvenFound);
+
+    // Verify deleted keys are gone
+    let allOddGone = true;
+    for (let i = 1; i < 50; i += 2) {
+        const result = tree.search(i);
+        if (result.length !== 0) { allOddGone = false; break; }
+    }
+    ok('Bug1: odd keys deleted', allOddGone);
+
+    // Greater than query
+    const gtResult = tree.greaterThan(25);
+    ok('Bug1: greaterThan(25) finds keys', gtResult.length > 0);
+
+    // Less than query
+    const ltResult = tree.lessThan(25);
+    ok('Bug1: lessThan(25) finds keys', ltResult.length > 0);
+}
+
+{
+    const tree = new BTree(4, true);
+    for (let i = 0; i < 30; i++) tree.insert(i * 10, i);
+
+    // Delete from the right half to trigger left borrows
+    for (let i = 29; i >= 15; i--) tree.remove(i * 10, i);
+
+    // Verify remaining keys
+    let allFound = true;
+    for (let i = 0; i < 15; i++) {
+        const result = tree.search(i * 10);
+        if (result.length !== 1 || result[0] !== i) { allFound = false; break; }
+    }
+    ok('Bug1: unique index with left borrows', allFound);
+}
+
+// ============================================================
+// Bug 2: Query _applyOrderBy missing NULL handling
+// ============================================================
+console.log('\n=== Bug 2: Query _applyOrderBy NULL handling ===');
+
+{
+    const rows = [
+        { id: 1, name: 'Alice', age: 30 },
+        { id: 2, name: 'Bob', age: null },
+        { id: 3, name: 'Charlie', age: 25 },
+        { id: 4, name: 'Dave', age: null },
+    ];
+    const table = createMockTable('users', rows);
+    const query = new Query(table);
+    query.orderBy('age', 'asc');
+    const result = query.get();
+
+    ok('Bug2: ASC nulls first (1st)', result[0].age === null);
+    ok('Bug2: ASC nulls first (2nd)', result[1].age === null);
+    ok('Bug2: ASC 25 before 30', result[2].age === 25);
+    ok('Bug2: ASC 30 last', result[3].age === 30);
+}
+
+{
+    const rows = [
+        { id: 1, name: 'Alice', age: 30 },
+        { id: 2, name: 'Bob', age: null },
+        { id: 3, name: 'Charlie', age: 25 },
+        { id: 4, name: 'Dave', age: null },
+    ];
+    const table = createMockTable('users', rows);
+    const query = new Query(table);
+    query.orderBy('age', 'desc');
+    const result = query.get();
+
+    ok('Bug2: DESC nulls last (1st=30)', result[0].age === 30);
+    ok('Bug2: DESC nulls last (2nd=25)', result[1].age === 25);
+    ok('Bug2: DESC nulls last (3rd=null)', result[2].age === null);
+    ok('Bug2: DESC nulls last (4th=null)', result[3].age === null);
+}
+
+{
+    const rows = [
+        { id: 1, name: 'Alice', age: null },
+        { id: 2, name: 'Bob', age: null },
+        { id: 3, name: 'Charlie', age: null },
+    ];
+    const table = createMockTable('users', rows);
+    const query = new Query(table);
+    query.orderBy('age', 'asc');
+    const result = query.get();
+
+    ok('Bug2: all nulls ASC', result.length === 3 && result.every(r => r.age === null));
+}
+
+{
+    const rows = [
+        { id: 1, name: 'Alice', score: 85 },
+        { id: 2, name: 'Bob' }, // score is undefined
+        { id: 3, name: 'Charlie', score: null },
+        { id: 4, name: 'Dave', score: 90 },
+    ];
+    const table = createMockTable('users', rows);
+    const query = new Query(table);
+    query.orderBy('score', 'asc');
+    const result = query.get();
+
+    // Both null and undefined sort as null; stable sort preserves original order
+    // Bob (undefined) was at index 1, Charlie (null) at index 2
+    ok('Bug2: mixed null/undefined ASC (1st=null/undefined)', result[0].score == null);
+    ok('Bug2: mixed null/undefined ASC (2nd=null/undefined)', result[1].score == null);
+    ok('Bug2: mixed null/undefined ASC (3rd=85)', result[2].score === 85);
+    ok('Bug2: mixed null/undefined ASC (4th=90)', result[3].score === 90);
+}
+
+{
+    const rows = [
+        { id: 1, department: 'Engineering', salary: 5000 },
+        { id: 2, department: 'Engineering', salary: null },
+        { id: 3, department: 'Sales', salary: 4000 },
+        { id: 4, department: 'Sales', salary: null },
+        { id: 5, department: 'Engineering', salary: 6000 },
+    ];
+    const table = createMockTable('employees', rows);
+    const query = new Query(table);
+    query.orderBy('department', 'asc').orderBy('salary', 'asc');
+    const result = query.get();
+
+    ok('Bug2: multi-field orderBy', result.length === 5);
+    ok('Bug2: Eng null salary first', result[0].department === 'Engineering' && result[0].salary === null);
+    ok('Bug2: Eng 5000 second', result[1].department === 'Engineering' && result[1].salary === 5000);
+    ok('Bug2: Eng 6000 third', result[2].department === 'Engineering' && result[2].salary === 6000);
+    ok('Bug2: Sales null salary fourth', result[3].department === 'Sales' && result[3].salary === null);
+    ok('Bug2: Sales 4000 fifth', result[4].department === 'Sales' && result[4].salary === 4000);
+}
+
+// ============================================================
+// Bug 3: BTree prefix incorrect early return for numeric keys
+// ============================================================
+console.log('\n=== Bug 3: BTree prefix with numeric keys ===');
+
+{
+    const tree = new BTree(64, false);
+    const keys = [1, 2, 10, 20, 100, 200, 1000, 2000];
+    for (const key of keys) tree.insert(key, key);
+
+    const result = tree.prefix('1');
+    ok('Bug3: prefix "1" finds 1', result.includes(1));
+    ok('Bug3: prefix "1" finds 10', result.includes(10));
+    ok('Bug3: prefix "1" finds 100', result.includes(100));
+    ok('Bug3: prefix "1" finds 1000', result.includes(1000));
+    ok('Bug3: prefix "1" excludes 2', !result.includes(2));
+    ok('Bug3: prefix "1" excludes 20', !result.includes(20));
+    ok('Bug3: prefix "1" excludes 200', !result.includes(200));
+    ok('Bug3: prefix "1" excludes 2000', !result.includes(2000));
+}
+
+{
+    const tree = new BTree(64, false);
+    const keys = [2, 20, 200, 2000, 3, 30, 300];
+    for (const key of keys) tree.insert(key, key);
+
+    const result = tree.prefix('2');
+    ok('Bug3: prefix "2" finds 2', result.includes(2));
+    ok('Bug3: prefix "2" finds 20', result.includes(20));
+    ok('Bug3: prefix "2" finds 200', result.includes(200));
+    ok('Bug3: prefix "2" finds 2000', result.includes(2000));
+    ok('Bug3: prefix "2" excludes 3', !result.includes(3));
+}
+
+{
+    const tree = new BTree(64, false);
+    const keys = ['apple', 'application', 'apply', 'banana', 'cherry'];
+    for (const key of keys) tree.insert(key, key);
+
+    const result = tree.prefix('app');
+    ok('Bug3: string prefix finds apple', result.includes('apple'));
+    ok('Bug3: string prefix finds application', result.includes('application'));
+    ok('Bug3: string prefix finds apply', result.includes('apply'));
+    ok('Bug3: string prefix excludes banana', !result.includes('banana'));
+}
+
+{
+    const tree = new BTree(4, false);
+    for (let i = 1; i <= 100; i++) tree.insert(i, i);
+
+    // Prefix '1' should match: 1, 10-19, 100
+    const result = tree.prefix('1');
+    ok('Bug3: multi-leaf prefix "1" finds 1', result.includes(1));
+    ok('Bug3: multi-leaf prefix "1" finds 10', result.includes(10));
+    ok('Bug3: multi-leaf prefix "1" finds 11', result.includes(11));
+    ok('Bug3: multi-leaf prefix "1" finds 19', result.includes(19));
+    ok('Bug3: multi-leaf prefix "1" finds 100', result.includes(100));
+
+    // Prefix '9' should match: 9, 90-99
+    const result9 = tree.prefix('9');
+    ok('Bug3: multi-leaf prefix "9" finds 9', result9.includes(9));
+    ok('Bug3: multi-leaf prefix "9" finds 90', result9.includes(90));
+    ok('Bug3: multi-leaf prefix "9" finds 99', result9.includes(99));
+}
+
+{
+    const tree = new BTree(64, false);
+    tree.insert(1, 1);
+    tree.insert(2, 2);
+    tree.insert(3, 3);
+
+    const result = tree.prefix('9');
+    ok('Bug3: non-matching prefix returns empty', result.length === 0);
+}
+
+{
+    const tree = new BTree(64, false);
+    tree.insert('a.b', 1);
+    tree.insert('a*b', 2);
+    tree.insert('a+b', 3);
+    tree.insert('abc', 4);
+
+    const result = tree.prefix('a');
+    ok('Bug3: special chars prefix finds a.b', result.includes(1));
+    ok('Bug3: special chars prefix finds a*b', result.includes(2));
+    ok('Bug3: special chars prefix finds a+b', result.includes(3));
+    ok('Bug3: special chars prefix finds abc', result.includes(4));
+}
+
+// ============================================================
+// Summary
+// ============================================================
+console.log('\n========================================');
+console.log(`Results: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);
+else console.log('All tests passed!');