jsql-neo 6.4.0-beta.14 → 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.14** — 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.14 — 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);
@@ -3622,6 +3622,16 @@ function applyScalarFunction(fnNode, row, ctx) {
     });
     case 'DATABASE': case 'SCHEMA': return row && row.__db !== undefined ? row.__db : 'default';
     // ===== JSON 函数（B2 修复：此前未实现，静默返回 NULL）=====
+    // 辅助函数：获取 JSON 值的类型
+    function getJsonType(val) {
+      if (val === null) return 'null';
+      if (Array.isArray(val)) return 'array';
+      if (typeof val === 'object') return 'object';
+      if (typeof val === 'string') return 'string';
+      if (typeof val === 'number') return Number.isInteger(val) ? 'integer' : 'number';
+      if (typeof val === 'boolean') return 'boolean';
+      return 'unknown';
+    }
     case 'JSON_OBJECT': {
       // JSON_OBJECT(k1, v1, k2, v2, ...) → { k1: v1, k2: v2 }
       const obj = {};
@@ -3657,7 +3667,7 @@ function applyScalarFunction(fnNode, row, ctx) {
       if (firstKey === '') return data;
       let current = data;
       // 逐段解析路径
-      const segments = path.replace(/^\$/, '').split('.');
+      const segments = path.replace(/^\$\.?/, '').split('.');
       for (const seg of segments) {
         if (current == null) return null;
         // 处理数组索引: key[0] 或 [0]
@@ -3675,6 +3685,353 @@ function applyScalarFunction(fnNode, row, ctx) {
       }
       return current === undefined ? null : current;
     }
+    case 'JSON_KEYS': {
+      // JSON_KEYS(json) → [key1, key2, ...]
+      const json = args[0];
+      if (json == null) return null;
+      let data = json;
+      if (typeof json === 'string') {
+        try { data = JSON.parse(json); } catch (e) { return null; }
+      }
+      if (typeof data !== 'object' || data === null || Array.isArray(data)) return null;
+      return Object.keys(data);
+    }
+    case 'JSON_LENGTH': {
+      // JSON_LENGTH(json[, path]) → 元素数/长度
+      const json = args[0];
+      const path = args[1];
+      if (json == null) return null;
+      let data = json;
+      if (typeof json === 'string') {
+        try { data = JSON.parse(json); } catch (e) { return null; }
+      }
+      if (path != null) {
+        // 按路径提取后取长度
+        const p = String(path).replace(/^\$\.?/, '');
+        if (p === '') return Array.isArray(data) ? data.length : (typeof data === 'object' && data !== null ? Object.keys(data).length : 0);
+        let current = data;
+        for (const seg of p.split('.')) {
+          if (current == null) return null;
+          const arrMatch = seg.match(/^([^\[]*)\[(\d+)\]$/);
+          if (arrMatch) {
+            const key = arrMatch[1];
+            const idx = parseInt(arrMatch[2], 10);
+            if (key) current = current[key];
+            if (Array.isArray(current)) current = current[idx];
+            else return null;
+          } else {
+            if (typeof current !== 'object' || current === null) return null;
+            current = current[seg];
+          }
+        }
+        if (current == null) return null;
+        if (Array.isArray(current)) return current.length;
+        if (typeof current === 'object') return Object.keys(current).length;
+        if (typeof current === 'string') return current.length;
+        return 1;
+      }
+      if (Array.isArray(data)) return data.length;
+      if (typeof data === 'object' && data !== null) return Object.keys(data).length;
+      if (typeof data === 'string') return data.length;
+      return 1;
+    }
+    case 'JSON_MERGE': case 'JSON_MERGE_PRESERVE': {
+      // JSON_MERGE_PRESERVE(json1, json2, ...) → 合并后的 JSON
+      const items = args.filter(a => a != null);
+      if (!items.length) return null;
+      const parsed = items.map(item => {
+        if (typeof item === 'string') { try { return JSON.parse(item); } catch (e) { return null; } }
+        return item;
+      }).filter(a => a != null);
+      if (!parsed.length) return null;
+      // 递归合并
+      function mergePreserve(target, source) {
+        if (Array.isArray(target) && Array.isArray(source)) {
+          return [...target, ...source];
+        }
+        if (typeof target === 'object' && target !== null && typeof source === 'object' && source !== null && !Array.isArray(target) && !Array.isArray(source)) {
+          const result = { ...target };
+          for (const k of Object.keys(source)) {
+            if (k in result) result[k] = mergePreserve(result[k], source[k]);
+            else result[k] = source[k];
+          }
+          return result;
+        }
+        return source;
+      }
+      return parsed.reduce((acc, cur) => mergePreserve(acc, cur));
+    }
+    case 'JSON_MERGE_PATCH': {
+      // JSON_MERGE_PATCH(json1, json2, ...) → RFC 7396 合并
+      const items = args.filter(a => a != null);
+      if (!items.length) return null;
+      const parsed = items.map(item => {
+        if (typeof item === 'string') { try { return JSON.parse(item); } catch (e) { return null; } }
+        return item;
+      }).filter(a => a != null);
+      if (!parsed.length) return null;
+      function mergePatch(target, source) {
+        if (typeof source !== 'object' || source === null || Array.isArray(source)) return source;
+        if (typeof target !== 'object' || target === null || Array.isArray(target)) return { ...source };
+        const result = { ...target };
+        for (const k of Object.keys(source)) {
+          if (source[k] === null) delete result[k];
+          else result[k] = mergePatch(result[k], source[k]);
+        }
+        return result;
+      }
+      return parsed.reduce((acc, cur) => mergePatch(acc, cur));
+    }
+    case 'JSON_OBJECTAGG': {
+      // JSON_OBJECTAGG(key, value) → { key: value } (聚合函数)
+      // 在 JSQL 中作为普通函数调用，接收 key 和 value
+      const key = args[0];
+      const value = args[1];
+      if (key == null) return null;
+      const obj = {};
+      obj[String(key)] = value === undefined ? null : value;
+      return obj;
+    }
+    case 'JSON_ARRAYAGG': {
+      // JSON_ARRAYAGG(expr) → [expr] (聚合函数)
+      // 在 JSQL 中作为普通函数调用，接收单个值
+      const val = args[0];
+      return [val === undefined ? null : val];
+    }
+    case 'JSON_SET': {
+      // JSON_SET(json, path, val, ...) → 设置值（路径存在则更新，不存在则创建）
+      const json = args[0];
+      if (json == null) return null;
+      let data = json;
+      if (typeof json === 'string') {
+        try { data = JSON.parse(json); } catch (e) { return null; }
+      }
+      // 深拷贝
+      data = JSON.parse(JSON.stringify(data));
+      for (let i = 1; i + 1 < args.length; i += 2) {
+        const path = String(args[i]);
+        const val = args[i + 1];
+        const p = path.replace(/^\$\.?/, '');
+        if (p === '') continue;
+        const segments = p.split('.');
+        let current = data;
+        for (let j = 0; j < segments.length - 1; j++) {
+          const seg = segments[j];
+          const arrMatch = seg.match(/^([^\[]*)\[(\d+)\]$/);
+          if (arrMatch) {
+            const key = arrMatch[1];
+            const idx = parseInt(arrMatch[2], 10);
+            if (key) current = current[key];
+            if (Array.isArray(current)) current = current[idx];
+            else { current = null; break; }
+          } else {
+            if (typeof current !== 'object' || current === null) { current = null; break; }
+            if (!(seg in current)) current[seg] = {};
+            current = current[seg];
+          }
+        }
+        if (current == null) continue;
+        const last = segments[segments.length - 1];
+        const arrMatch = last.match(/^([^\[]*)\[(\d+)\]$/);
+        if (arrMatch) {
+          const key = arrMatch[1];
+          const idx = parseInt(arrMatch[2], 10);
+          if (key) current = current[key];
+          if (Array.isArray(current)) current[idx] = val;
+        } else {
+          current[last] = val;
+        }
+      }
+      return data;
+    }
+    case 'JSON_INSERT': {
+      // JSON_INSERT(json, path, val, ...) → 仅路径不存在时插入
+      const json = args[0];
+      if (json == null) return null;
+      let data = json;
+      if (typeof json === 'string') {
+        try { data = JSON.parse(json); } catch (e) { return null; }
+      }
+      data = JSON.parse(JSON.stringify(data));
+      for (let i = 1; i + 1 < args.length; i += 2) {
+        const path = String(args[i]);
+        const val = args[i + 1];
+        const p = path.replace(/^\$\.?/, '');
+        if (p === '') continue;
+        const segments = p.split('.');
+        let current = data;
+        let exists = true;
+        for (let j = 0; j < segments.length - 1; j++) {
+          const seg = segments[j];
+          const arrMatch = seg.match(/^([^\[]*)\[(\d+)\]$/);
+          if (arrMatch) {
+            const key = arrMatch[1];
+            const idx = parseInt(arrMatch[2], 10);
+            if (key) current = current[key];
+            if (Array.isArray(current)) current = current[idx];
+            else { exists = false; break; }
+          } else {
+            if (typeof current !== 'object' || current === null || !(seg in current)) { exists = false; break; }
+            current = current[seg];
+          }
+        }
+        if (!exists) continue;
+        const last = segments[segments.length - 1];
+        if (typeof current === 'object' && current !== null && !(last in current)) {
+          current[last] = val;
+        }
+      }
+      return data;
+    }
+    case 'JSON_REMOVE': {
+      // JSON_REMOVE(json, path, ...) → 删除路径
+      const json = args[0];
+      if (json == null) return null;
+      let data = json;
+      if (typeof json === 'string') {
+        try { data = JSON.parse(json); } catch (e) { return null; }
+      }
+      data = JSON.parse(JSON.stringify(data));
+      for (let i = 1; i < args.length; i++) {
+        const path = String(args[i]);
+        const p = path.replace(/^\$\.?/, '');
+        if (p === '') continue;
+        const segments = p.split('.');
+        let current = data;
+        for (let j = 0; j < segments.length - 1; j++) {
+          const seg = segments[j];
+          const arrMatch = seg.match(/^([^\[]*)\[(\d+)\]$/);
+          if (arrMatch) {
+            const key = arrMatch[1];
+            const idx = parseInt(arrMatch[2], 10);
+            if (key) current = current[key];
+            if (Array.isArray(current)) current = current[idx];
+            else { current = null; break; }
+          } else {
+            if (typeof current !== 'object' || current === null) { current = null; break; }
+            current = current[seg];
+          }
+        }
+        if (current == null) continue;
+        const last = segments[segments.length - 1];
+        const arrMatch = last.match(/^([^\[]*)\[(\d+)\]$/);
+        if (arrMatch) {
+          const key = arrMatch[1];
+          const idx = parseInt(arrMatch[2], 10);
+          if (key) current = current[key];
+          if (Array.isArray(current)) current.splice(idx, 1);
+        } else {
+          delete current[last];
+        }
+      }
+      return data;
+    }
+    case 'JSON_UNQUOTE': {
+      // JSON_UNQUOTE(json_val) → 去掉 JSON 字符串的引号
+      const val = args[0];
+      if (val == null) return null;
+      if (typeof val === 'string') {
+        // 如果是 JSON 字符串（带引号），解析它
+        const trimmed = val.trim();
+        if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+          try { return JSON.parse(trimmed); } catch (e) { return trimmed.slice(1, -1); }
+        }
+        return val;
+      }
+      return val;
+    }
+    case 'JSON_QUOTE': {
+      // JSON_QUOTE(str) → 给字符串加引号
+      const val = args[0];
+      if (val == null) return null;
+      return JSON.stringify(String(val));
+    }
+    case 'JSON_TYPE': {
+      // JSON_TYPE(json[, path]) → 返回类型
+      const json = args[0];
+      const path = args[1];
+      if (json == null) return null;
+      let data = json;
+      if (typeof json === 'string') {
+        try { data = JSON.parse(json); } catch (e) { return null; }
+      }
+      if (path != null) {
+        const p = String(path).replace(/^\$\.?/, '');
+        if (p === '') return getJsonType(data);
+        let current = data;
+        for (const seg of p.split('.')) {
+          if (current == null) return null;
+          const arrMatch = seg.match(/^([^\[]*)\[(\d+)\]$/);
+          if (arrMatch) {
+            const key = arrMatch[1];
+            const idx = parseInt(arrMatch[2], 10);
+            if (key) current = current[key];
+            if (Array.isArray(current)) current = current[idx];
+            else return null;
+          } else {
+            if (typeof current !== 'object' || current === null) return null;
+            current = current[seg];
+          }
+        }
+        return getJsonType(current);
+      }
+      return getJsonType(data);
+    }
+    case 'JSON_DEPTH': {
+      // JSON_DEPTH(json) → 返回深度
+      const json = args[0];
+      if (json == null) return null;
+      let data = json;
+      if (typeof json === 'string') {
+        try { data = JSON.parse(json); } catch (e) { return null; }
+      }
+      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));
+        }
+        const keys = Object.keys(obj);
+        if (keys.length === 0) return 1;
+        return 1 + Math.max(...keys.map(k => depth(obj[k])));
+      }
+      return depth(data);
+    }
+    case 'JSON_VALID': {
+      // JSON_VALID(json) → 1 if valid JSON, 0 otherwise
+      const val = args[0];
+      if (val == null) return 0;
+      if (typeof val !== 'string') return 1; // 非字符串视为有效
+      try { JSON.parse(val); return 1; } catch (e) { return 0; }
+    }
+    case 'JSON_SEARCH': {
+      // JSON_SEARCH(json, one_or_all, search_str) → 搜索路径
+      const json = args[0];
+      const mode = args[1];
+      const search = args[2];
+      if (json == null || search == null) return null;
+      let data = json;
+      if (typeof json === 'string') {
+        try { data = JSON.parse(json); } catch (e) { return null; }
+      }
+      const searchStr = String(search).toLowerCase();
+      const results = [];
+      function searchObj(obj, currentPath) {
+        if (typeof obj === 'string' && obj.toLowerCase().includes(searchStr)) {
+          results.push(currentPath);
+        } else if (Array.isArray(obj)) {
+          obj.forEach((item, i) => searchObj(item, currentPath + '[' + i + ']'));
+        } else if (typeof obj === 'object' && obj !== null) {
+          for (const k of Object.keys(obj)) {
+            searchObj(obj[k], currentPath ? currentPath + '.' + k : '$.' + k);
+          }
+        }
+      }
+      searchObj(data, '$');
+      if (results.length === 0) return null;
+      if (mode === 'one') return results[0];
+      return results;
+    }
     case 'JSON_CONTAINS': {
       // JSON_CONTAINS(json, value) → 1 or 0
       const json = args[0];
@@ -3866,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);
@@ -6394,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.14",
+  "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",
@@ -46,7 +46,7 @@
   ],
   "scripts": {
     "postinstall": "node postinstall.js",
-    "test": "node test/smoke.js && node test/sql-parser.test.js && node test/readme-audit.test.js && node test/query-opt.test.js && node test/wal-recovery.test.js && node test/mysql-compat-hijack.test.js && node test/dml-constraints.test.js",
+    "test": "node test/smoke.js && node test/json-functions.test.js && node test/sql-parser.test.js && node test/readme-audit.test.js && node test/query-opt.test.js && node test/wal-recovery.test.js && node test/mysql-compat-hijack.test.js && node test/dml-constraints.test.js",
     "test:parser": "node test/sql-parser.test.js",
     "test:btree": "node test/btree.test.js",
     "test:native": "node test/native.test.js",

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!');

package/test/json-functions.test.js

@@ -0,0 +1,172 @@
+/*
+ * JSON function tests for JSQL-neo
+ *   node test/json-functions.test.js
+ * Covers: JSON_EXTRACT path fix, JSON_KEYS, JSON_LENGTH, JSON_MERGE,
+ * JSON_MERGE_PATCH, JSON_MERGE_PRESERVE, JSON_OBJECTAGG, JSON_ARRAYAGG,
+ * JSON_SET, JSON_INSERT, JSON_REMOVE, JSON_UNQUOTE, JSON_QUOTE,
+ * JSON_TYPE, JSON_DEPTH, JSON_VALID, JSON_SEARCH
+ */
+const { executeSQL } = require('../lib/sql.js');
+
+let pass = 0, fail = 0;
+const ok = (name, cond, extra) => {
+  if (cond) { pass++; console.log('[OK]', name); }
+  else { fail++; console.log('[FAIL]', name, extra !== undefined ? '→ ' + JSON.stringify(extra) : ''); }
+};
+
+const engine = {
+  hasTable: () => true,
+  truncate: async () => {},
+  flush: async () => {},
+  find: async () => [],
+  getTableSchema: async () => ({}),
+};
+
+// Helper: execute SQL and return first row as object
+async function query(sql) {
+  const r = await executeSQL(engine, sql);
+  if (!r.rows || r.rows.length === 0) return null;
+  const row = {};
+  r.columns.forEach((col, i) => { row[col] = r.rows[0][i]; });
+  return row;
+}
+
+(async () => {
+  // ===== Bug 1: JSON_EXTRACT path parsing =====
+  {
+    const r1 = await query('SELECT JSON_EXTRACT(\'{"name":"test"}\', \'$.name\') AS val');
+    ok('JSON_EXTRACT $.name returns "test"', r1 && r1.val === 'test', r1 && r1.val);
+
+    const r2 = await query('SELECT JSON_EXTRACT(\'{"a":{"b":42}}\', \'$.a.b\') AS val');
+    ok('JSON_EXTRACT $.a.b returns 42', r2 && r2.val === 42, r2 && r2.val);
+
+    const r3 = await query('SELECT JSON_EXTRACT(\'{"items":[10,20,30]}\', \'$.items[1]\') AS val');
+    ok('JSON_EXTRACT $.items[1] returns 20', r3 && r3.val === 20, r3 && r3.val);
+
+    const r4 = await query('SELECT JSON_EXTRACT(\'{"name":"test"}\', \'$\') AS val');
+    ok('JSON_EXTRACT $ returns whole object', r4 && typeof r4.val === 'object' && r4.val.name === 'test', r4 && r4.val);
+
+    const r5 = await query('SELECT JSON_EXTRACT(\'{"name":"test"}\', \'$.nonexistent\') AS val');
+    ok('JSON_EXTRACT $.nonexistent returns null', r5 && (r5.val === null || r5.val === undefined), r5 && r5.val);
+  }
+
+  // ===== JSON_KEYS =====
+  {
+    const r = await query('SELECT JSON_KEYS(\'{"a":1,"b":2,"c":3}\') AS val');
+    ok('JSON_KEYS returns all keys', r && Array.isArray(r.val) && r.val.length === 3 && r.val.includes('a') && r.val.includes('b') && r.val.includes('c'), r && r.val);
+  }
+
+  // ===== JSON_LENGTH =====
+  {
+    const r1 = await query('SELECT JSON_LENGTH(\'{"a":1,"b":2,"c":3}\') AS val');
+    ok('JSON_LENGTH object returns 3', r1 && r1.val === 3, r1 && r1.val);
+
+    const r2 = await query('SELECT JSON_LENGTH(\'[1,2,3,4,5]\') AS val');
+    ok('JSON_LENGTH array returns 5', r2 && r2.val === 5, r2 && r2.val);
+
+    const r3 = await query('SELECT JSON_LENGTH(\'{"a":{"b":1,"c":2}}\', \'$.a\') AS val');
+    ok('JSON_LENGTH with path returns 2', r3 && r3.val === 2, r3 && r3.val);
+  }
+
+  // ===== JSON_MERGE_PRESERVE =====
+  {
+    const r = await query('SELECT JSON_MERGE_PRESERVE(\'{"a":1}\', \'{"b":2}\') AS val');
+    ok('JSON_MERGE_PRESERVE merges objects', r && typeof r.val === 'object' && r.val.a === 1 && r.val.b === 2, r && r.val);
+  }
+
+  // ===== JSON_MERGE_PATCH =====
+  {
+    const r = await query('SELECT JSON_MERGE_PATCH(\'{"a":1,"b":2}\', \'{"b":99,"c":3}\') AS val');
+    ok('JSON_MERGE_PATCH patches objects', r && typeof r.val === 'object' && r.val.a === 1 && r.val.b === 99 && r.val.c === 3, r && r.val);
+  }
+
+  // ===== JSON_OBJECTAGG =====
+  {
+    const r = await query('SELECT JSON_OBJECTAGG(\'key\', \'value\') AS val');
+    ok('JSON_OBJECTAGG creates object', r && typeof r.val === 'object' && r.val.key === 'value', r && r.val);
+  }
+
+  // ===== JSON_ARRAYAGG =====
+  {
+    const r = await query('SELECT JSON_ARRAYAGG(42) AS val');
+    ok('JSON_ARRAYAGG creates array', r && Array.isArray(r.val) && r.val.length === 1 && r.val[0] === 42, r && r.val);
+  }
+
+  // ===== JSON_SET =====
+  {
+    const r = await query('SELECT JSON_SET(\'{"a":1}\', \'$.b\', 2) AS val');
+    ok('JSON_SET adds new key', r && typeof r.val === 'object' && r.val.a === 1 && r.val.b === 2, r && r.val);
+
+    const r2 = await query('SELECT JSON_SET(\'{"a":1}\', \'$.a\', 99) AS val');
+    ok('JSON_SET updates existing key', r2 && typeof r2.val === 'object' && r2.val.a === 99, r2 && r2.val);
+  }
+
+  // ===== JSON_INSERT =====
+  {
+    const r = await query('SELECT JSON_INSERT(\'{"a":1}\', \'$.b\', 2) AS val');
+    ok('JSON_INSERT adds new key', r && typeof r.val === 'object' && r.val.a === 1 && r.val.b === 2, r && r.val);
+
+    const r2 = await query('SELECT JSON_INSERT(\'{"a":1}\', \'$.a\', 99) AS val');
+    ok('JSON_INSERT does not overwrite existing', r2 && typeof r2.val === 'object' && r2.val.a === 1, r2 && r2.val);
+  }
+
+  // ===== JSON_REMOVE =====
+  {
+    const r = await query('SELECT JSON_REMOVE(\'{"a":1,"b":2}\', \'$.b\') AS val');
+    ok('JSON_REMOVE deletes key', r && typeof r.val === 'object' && r.val.a === 1 && !('b' in r.val), r && r.val);
+  }
+
+  // ===== JSON_UNQUOTE =====
+  {
+    const r = await query('SELECT JSON_UNQUOTE(\'"hello"\') AS val');
+    ok('JSON_UNQUOTE removes quotes', r && r.val === 'hello', r && r.val);
+  }
+
+  // ===== JSON_QUOTE =====
+  {
+    const r = await query('SELECT JSON_QUOTE(\'hello\') AS val');
+    ok('JSON_QUOTE adds quotes', r && r.val === '"hello"', r && r.val);
+  }
+
+  // ===== JSON_TYPE =====
+  {
+    const r1 = await query('SELECT JSON_TYPE(\'{"a":1}\') AS val');
+    ok('JSON_TYPE object returns "object"', r1 && r1.val === 'object', r1 && r1.val);
+
+    const r2 = await query('SELECT JSON_TYPE(\'[1,2,3]\') AS val');
+    ok('JSON_TYPE array returns "array"', r2 && r2.val === 'array', r2 && r2.val);
+
+    const r3 = await query('SELECT JSON_TYPE(\'"hello"\') AS val');
+    ok('JSON_TYPE string returns "string"', r3 && r3.val === 'string', r3 && r3.val);
+
+    const r4 = await query('SELECT JSON_TYPE(\'42\') AS val');
+    ok('JSON_TYPE integer returns "integer"', r4 && r4.val === 'integer', r4 && r4.val);
+  }
+
+  // ===== JSON_DEPTH =====
+  {
+    const r1 = await query('SELECT JSON_DEPTH(\'{"a":1}\') AS val');
+    ok('JSON_DEPTH flat object returns 1', r1 && r1.val === 1, r1 && r1.val);
+
+    const r2 = await query('SELECT JSON_DEPTH(\'{"a":{"b":1}}\') AS val');
+    ok('JSON_DEPTH nested object returns 2', r2 && r2.val === 2, r2 && r2.val);
+  }
+
+  // ===== JSON_VALID =====
+  {
+    const r1 = await query('SELECT JSON_VALID(\'{"a":1}\') AS val');
+    ok('JSON_VALID valid JSON returns 1', r1 && r1.val === 1, r1 && r1.val);
+
+    const r2 = await query('SELECT JSON_VALID(\'not json\') AS val');
+    ok('JSON_VALID invalid JSON returns 0', r2 && r2.val === 0, r2 && r2.val);
+  }
+
+  // ===== JSON_SEARCH =====
+  {
+    const r = await query('SELECT JSON_SEARCH(\'{"name":"test","desc":"hello world"}\', \'all\', \'test\') AS val');
+    ok('JSON_SEARCH finds matching value', r && Array.isArray(r.val) && r.val.length > 0, r && r.val);
+  }
+
+  console.log(`\n${pass} passed, ${fail} failed`);
+  process.exit(fail > 0 ? 1 : 0);
+})();