jsql-neo 6.0.0-beta2 → 6.0.2

package/lib/table.js

@@ -347,8 +347,17 @@ class Table {
     }
 
     findOne(query = {}) {
-        const rows = this.find(query);
-        return rows.length > 0 ? rows[0] : null;
+        let rows = this._getVisibleRows();
+        if (Object.keys(query).length > 0) {
+            rows = this._applyFilterOptimized(rows, query);
+        }
+        return rows.length > 0 ? { ...rows[0] } : null;
+    }
+
+    exists(query = {}) {
+        if (Object.keys(query).length === 0) return this._getVisibleRows().length > 0;
+        const rows = this._applyFilterOptimized(this._getVisibleRows(), query);
+        return rows.length > 0;
     }
 
     findById(id) {
@@ -853,39 +862,77 @@ class Table {
     // 内部: 过滤器（B-Tree 加速）
     // ============================================================
 
+    _rowsFromIndices(indices) {
+        const subset = [];
+        for (let i = 0; i < indices.length; i++) {
+            const row = this._rows[indices[i]];
+            if (row) subset.push(row);
+        }
+        return subset;
+    }
+
+    _likePrefix(pattern) {
+        if (typeof pattern !== 'string' || pattern.length === 0) return null;
+        if (pattern[0] === '%' || pattern[0] === '_') return null;
+        let end = pattern.length;
+        for (let i = 0; i < pattern.length; i++) {
+            const c = pattern[i];
+            if (c === '%' || c === '_') { end = i; break; }
+        }
+        return end > 0 ? pattern.slice(0, end) : null;
+    }
+
     _applyFilterOptimized(rows, query) {
         this._ensureBTrees();
-        // 尝试用 B-Tree 加速
         for (const [field, condition] of Object.entries(query)) {
             if (field === '$or' || field === '$and' || field === '$not') continue;
-            // 等值查询用 B-Tree
             if (typeof condition !== 'object' || condition === null || Array.isArray(condition) || condition instanceof RegExp) {
                 if (this._btrees[field]) {
                     const indices = this._btrees[field].search(condition);
-                    if (indices.length > 0) {
-                        const subset = indices.map(i => this._rows[i]).filter(r => r);
-                        return this._applyFilter(subset, query);
-                    }
-                    return [];
+                    if (indices.length === 0) return [];
+                    return this._applyFilter(this._rowsFromIndices(indices), query);
                 }
                 if (this._indexes[field] && this._indexes[field].has(condition)) {
-                    const indices = this._indexes[field].get(condition);
-                    const subset = indices.map(i => this._rows[i]).filter(r => r);
-                    return this._applyFilter(subset, query);
+                    return this._applyFilter(this._rowsFromIndices(this._indexes[field].get(condition)), query);
                 }
                 if (this._indexes[field]) return [];
             }
-            // 范围查询用 B-Tree
             if (condition && typeof condition === 'object') {
-                if (condition.$gt !== undefined && condition.$lt !== undefined && this._btrees[field]) {
-                    const indices = this._btrees[field].range(condition.$gt, condition.$lt);
-                    const subset = indices.map(i => this._rows[i]).filter(r => r);
-                    return this._applyFilter(subset, query);
+                if (this._btrees[field] && Array.isArray(condition.$in) && condition.$in.length > 0) {
+                    const indices = this._btrees[field].searchMany(condition.$in);
+                    if (indices.length === 0) return [];
+                    return this._applyFilter(this._rowsFromIndices(indices), query);
+                }
+                if (this._btrees[field] && typeof condition.$like === 'string') {
+                    const prefix = this._likePrefix(condition.$like);
+                    if (prefix) {
+                        const indices = this._btrees[field].prefix(prefix);
+                        if (indices.length === 0) return [];
+                        return this._applyFilter(this._rowsFromIndices(indices), query);
+                    }
                 }
-                if (condition.$gte !== undefined && condition.$lte !== undefined && this._btrees[field]) {
-                    const indices = this._btrees[field].range(condition.$gte, condition.$lte);
-                    const subset = indices.map(i => this._rows[i]).filter(r => r);
-                    return this._applyFilter(subset, query);
+                if (this._btrees[field] && (condition.$gt !== undefined || condition.$gte !== undefined ||
+                    condition.$lt !== undefined || condition.$lte !== undefined || condition.$between)) {
+                    let min, max, exclusiveMin = false, exclusiveMax = false;
+                    if (condition.$between && Array.isArray(condition.$between) && condition.$between.length === 2) {
+                        min = condition.$between[0];
+                        max = condition.$between[1];
+                    } else {
+                        if (condition.$gte !== undefined) min = condition.$gte;
+                        else if (condition.$gt !== undefined) { min = condition.$gt; exclusiveMin = true; }
+                        if (condition.$lte !== undefined) max = condition.$lte;
+                        else if (condition.$lt !== undefined) { max = condition.$lt; exclusiveMax = true; }
+                    }
+                    if (min === undefined && max === undefined) continue;
+                    let indices;
+                    if (min !== undefined && max !== undefined) {
+                        indices = this._btrees[field].range(min, max);
+                    } else if (min !== undefined) {
+                        indices = exclusiveMin ? this._btrees[field].greaterThan(min) : this._btrees[field].greaterThanEqual(min);
+                    } else {
+                        indices = exclusiveMax ? this._btrees[field].lessThan(max) : this._btrees[field].lessThanEqual(max);
+                    }
+                    return this._applyFilter(this._rowsFromIndices(indices), query);
                 }
             }
         }

package/lib/wasm_client.js

@@ -10,6 +10,32 @@ function safeJsonParse(str) {
   try { return JSON.parse(str); } catch { return str; }
 }
 
+/**
+ * 序列化并给出可读错误。直接 JSON.stringify 遇到循环引用会抛
+ * "Converting circular structure to JSON"，指向不到具体列，这里补上表/列信息。
+ */
+function safeStringify(value, table, column) {
+  try {
+    return JSON.stringify(value);
+  } catch (e) {
+    const msg = (e && e.message) ? e.message : String(e);
+    throw new Error(`Cannot serialize column '${column}' of table '${table}': ${msg}`);
+  }
+}
+
+/** 插入行必须是普通对象；null/undefined/数组/基本类型在这里就被拦下 */
+function assertRowObject(row, index, isBatch) {
+  const ok = row !== null && row !== undefined && typeof row === 'object' &&
+    !Array.isArray(row) && !(row instanceof Date);
+  if (ok) return;
+  const got = row === null ? 'null'
+    : Array.isArray(row) ? 'array'
+      : row instanceof Date ? 'Date'
+        : typeof row;
+  const where = isBatch ? ` at index ${index}` : '';
+  throw new TypeError(`insert(): expected a row object${where}, got ${got}`);
+}
+
 const NATIVE_TYPE_MAP = {
   text: 'string',
   varchar: 'string',
@@ -422,7 +448,7 @@ class JSQL {
           if (typeof def === 'string') t = def.toLowerCase();
           else if (def && typeof def === 'object' && def.type) t = String(def.type).toLowerCase();
           if (v !== null && v !== undefined && ['json', 'array', 'object'].includes(t) && typeof v !== 'string') {
-            out[k] = JSON.stringify(v);
+            out[k] = safeStringify(v, table, k);
           } else if (v instanceof Date) {
             out[k] = v.toISOString();
           } else {
@@ -432,7 +458,7 @@ class JSQL {
         return out;
       });
     }
-    const r = safeJsonParse(wasmBindings.jsql_insert_json(table, JSON.stringify(rows)));
+    const r = safeJsonParse(wasmBindings.jsql_insert_json(table, safeStringify(rows, table, '<rows>')));
     if (r && r.error) throw new Error(r.error);
     if (r && Array.isArray(r) && !this._pkAutoIncrement(table)) {
       const pk = this._pkOf(table);
@@ -448,24 +474,48 @@ class JSQL {
 
   async _flush() {
     if (!this._runHooks('beforeFlush', [])) return null;
-    const flushed = {};
-    for (const [table, rows] of Object.entries(this._buffer)) {
-      if (rows.length === 0) continue;
-      const r = await this._insertBatch(table, rows);
-      flushed[table] = r;
-    }
+    // 先把整个 buffer 原子取出再写入。
+    // 旧写法是遍历 this._buffer 然后在 await 之后才清空 —— 这期间其他协程会继续
+    // 往同一个数组 push，导致同一批行被多个 flush 重复写（并发 insert 行数暴涨）。
+    const pending = this._buffer;
     this._buffer = {};
     this._bufferSize = 0;
+    const flushed = {};
+    try {
+      for (const [table, rows] of Object.entries(pending)) {
+        if (rows.length === 0) continue;
+        flushed[table] = await this._insertBatch(table, rows);
+      }
+    } catch (e) {
+      // 坏行绝不回写 buffer：否则 stop() 二次 flush 会再抛同一个错，进程 exit 1。
+      // 但也不能静默丢数据 —— 记到 _flushErrors 供排查（见 lastFlushErrors()）。
+      if (!this._flushErrors) this._flushErrors = [];
+      this._flushErrors.push({
+        at: Date.now(),
+        message: (e && e.message) ? e.message : String(e),
+        tables: Object.keys(pending),
+        rowCounts: Object.fromEntries(Object.entries(pending).map(([t, r]) => [t, r.length])),
+      });
+      throw e;
+    }
     this._runHooks('afterFlush', []);
     return flushed;
   }
 
+  /** 返回历次 flush 失败的记录（坏行不会回写 buffer，只能从这里查） */
+  lastFlushErrors() {
+    return (this._flushErrors || []).slice();
+  }
+
   async flush() {
     await this._flush();
   }
 
   async insert(table, data) {
+    // 入参校验：null / undefined / 非对象会在下游 Object.entries() 处炸成
+    // 难以定位的 "Cannot convert undefined or null to object"，这里直接给明确 TypeError
     const arr = Array.isArray(data) ? data : [data];
+    arr.forEach((row, i) => assertRowObject(row, i, arr.length > 1 || Array.isArray(data)));
     if (!this._runHooks('beforeInsert', [table, arr])) return [];
     if (arr.length > 1) {
       await this._flush();
@@ -484,7 +534,10 @@ class JSQL {
     this._buffer[table].push(arr[0]);
     this._bufferSize++;
     const flushed = await this._flush();
-    return flushed && flushed[table] ? flushed[table] : null;
+    const result = flushed && flushed[table] ? flushed[table] : null;
+    this._emit('insert', { table, count: arr.length, ids: result });
+    this._runHooks('afterInsert', [table, arr, result]);
+    return result;
   }
 
   async insertMany(table, data) {
@@ -493,6 +546,7 @@ class JSQL {
 
   async createTable(name, schema) {
     await this._flush();
+    if (typeof schema === 'string') schema = parseSchemaString(schema);
     if (!this._runHooks('beforeCreateTable', [name, schema])) return null;
     const r = safeJsonParse(wasmBindings.jsql_create_table(name, JSON.stringify(mapNativeSchema(schema))));
     if (r && r.ok === false) throw new Error(r.error || 'create table failed');
@@ -692,6 +746,15 @@ class JSQL {
     return result;
   }
 
+  async exists(table, filter = {}) {
+    const rows = await this.find(table, filter, { limit: 1 });
+    return Array.isArray(rows) && rows.length > 0;
+  }
+
+  prepare(sql) {
+    return require('./prepared').createPrepared(this, sql);
+  }
+
   async stop() {
     await this._flush();
     this._runHooks('onStop', []);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsql-neo",
-  "version": "6.0.0-beta2",
+  "version": "6.0.2",
   "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
   "main": "index.js",
   "types": "index.d.ts",
@@ -21,6 +21,7 @@
     },
     "./wasm/browser.d.ts": "./wasm/browser.d.ts",
     "./wasm/*": "./wasm/*",
+    "./lib/plugins": "./lib/plugins/index.js",
     "./lib/*.js": "./lib/*.js",
     "./lib/*": "./lib/*.js",
     "./package.json": "./package.json",
@@ -45,12 +46,12 @@
   ],
   "scripts": {
     "postinstall": "node postinstall.js",
-    "test": "node test/smoke.js && node test/sql-parser.test.js",
+    "test": "node test/smoke.js && node test/sql-parser.test.js && node test/readme-audit.test.js && node test/query-opt.test.js",
     "test:parser": "node test/sql-parser.test.js",
     "test:btree": "node test/btree.test.js",
     "test:native": "node test/native.test.js",
     "test:regress": "node test/regress-5.1.0.js",
-    "test:all": "node test/smoke.js && node test/sql-parser.test.js && node test/native.test.js && node test/wasm.test.js && node test/coverage.js && node test/regress-5.1.0.js && node test/join.test.js && node test/btree.test.js",
+    "test:all": "node test/smoke.js && node test/sql-parser.test.js && node test/readme-audit.test.js && node test/native.test.js && node test/wasm.test.js && node test/coverage.js && node test/regress-5.1.0.js && node test/join.test.js && node test/btree.test.js",
     "test:coverage": "c8 --all --include='lib/**' --exclude='lib/mysql_server.js' --exclude='lib/native_client.js' --exclude='lib/wasm_client.js' --exclude='lib/mysql_compat.js' --exclude='lib/nedb_compat.js' --exclude='lib/plugin.js' --reporter=text --reporter=lcov node test/coverage.js",
     "test:orms": "node examples/orms/run-all.js"
   },

package/test/btree.test.js

@@ -58,6 +58,22 @@ function validate(bt) {
   ok('non-unique remove value keeps key until last', n.search('a').length === 0 && n.size === 1);
 }
 
+/* ---- 二分查找 / IN / 前缀 ---- */
+{
+  const bt = new BTree(16);
+  for (let i = 0; i < 200; i++) bt.insert(i, i);
+  ok('binary search mid', JSON.stringify(bt.search(123)) === '[123]');
+  ok('searchMany unique', JSON.stringify(bt.searchMany([0, 199, 50, 50]).sort((a, b) => a - b)) === '[0,50,199]');
+  ok('greaterThanEqual last two', JSON.stringify(bt.greaterThanEqual(198).sort((a, b) => a - b)) === '[198,199]');
+  ok('lessThanEqual first two', JSON.stringify(bt.lessThanEqual(1).sort((a, b) => a - b)) === '[0,1]');
+}
+
+{
+  const bt = new BTree(8);
+  ['alpha', 'alpine', 'beta', 'alpine'].forEach((k, i) => bt.insert(k, i));
+  ok('prefix alp', JSON.stringify(bt.prefix('alp').sort((a, b) => a - b)) === '[0,1,3]');
+}
+
 /* ---- 多值键删除只影响目标 rowIndex（size 对照 distinct keys） ---- */
 {
   const bt = new BTree(8);

package/test/query-opt.test.js

@@ -0,0 +1,109 @@
+/*
+ * Query / B-Tree / exists / prepare 回归
+ *   node test/query-opt.test.js
+ */
+const Database = require('../lib/database');
+const BTree = require('../lib/btree');
+
+let passed = 0, failed = 0;
+function ok(name, cond, extra) {
+  if (cond) { passed++; }
+  else { failed++; console.log('[FAIL]', name, extra !== undefined ? '-> ' + JSON.stringify(extra) : ''); }
+}
+
+{
+  const bt = new BTree(8);
+  for (let i = 0; i < 80; i++) bt.insert(i, i);
+  ok('search hit', JSON.stringify(bt.search(42)) === '[42]');
+  ok('search miss', bt.search(999).length === 0);
+  ok('searchMany', JSON.stringify(bt.searchMany([1, 5, 999, 5]).sort((a, b) => a - b)) === '[1,5]');
+  ok('prefix numeric-as-string', bt.prefix('7').length > 0);
+  ok('gte/gt', bt.greaterThanEqual(78).length === 2 && bt.greaterThan(78).length === 1);
+  ok('lte/lt', bt.lessThanEqual(1).length === 2 && bt.lessThan(1).length === 1);
+}
+
+{
+  const bt = new BTree(8);
+  ['alice', 'albert', 'bob', 'carol', 'art'].forEach((n, i) => bt.insert(n, i));
+  const hits = bt.prefix('al').sort((a, b) => a - b);
+  ok('string prefix al', JSON.stringify(hits) === '[0,1]');
+  ok('string prefix z', bt.prefix('z').length === 0);
+}
+
+{
+  const db = new Database(':memory:');
+  db.createTable('users', {
+    id: { type: 'integer', primaryKey: true, autoIncrement: true },
+    name: { type: 'string', unique: true },
+    age: { type: 'integer' }
+  });
+  db.users.insertMany([
+    { name: 'alice', age: 20 },
+    { name: 'albert', age: 30 },
+    { name: 'bob', age: 40 },
+    { name: 'carol', age: 50 }
+  ]);
+
+  ok('table.exists true', db.users.exists({ name: 'bob' }) === true);
+  ok('table.exists false', db.users.exists({ name: 'zack' }) === false);
+  ok('db.exists true', db.exists('users', { age: { $gte: 50 } }) === true);
+  ok('db.exists false', db.exists('users', { age: { $gt: 90 } }) === false);
+  ok('query.exists', db.users.where({ age: { $lt: 25 } }).exists() === true);
+
+  const inRows = db.users.find({ name: { $in: ['alice', 'carol', 'nope'] } });
+  ok('$in via btree', inRows.length === 2 && inRows.every(r => r.name === 'alice' || r.name === 'carol'));
+
+  const likeRows = db.users.find({ name: { $like: 'al%' } });
+  ok('$like prefix via btree', likeRows.length === 2 && likeRows.every(r => r.name.startsWith('al')));
+
+  const rangeRows = db.users.find({ age: { $gte: 30, $lte: 40 } });
+  ok('range via btree', rangeRows.length === 2);
+
+  const one = db.users.findOne({ name: 'bob' });
+  ok('findOne no full clone', one && one.name === 'bob' && one.age === 40);
+}
+
+(async () => {
+  const db = new Database(':memory:');
+  db.createTable('users', {
+    id: { type: 'integer', primaryKey: true, autoIncrement: true },
+    name: { type: 'string' },
+    age: { type: 'integer' }
+  });
+  db.users.insertMany([
+    { name: 'alice', age: 20 },
+    { name: 'bob', age: 40 }
+  ]);
+
+  const stmt = db.prepare('SELECT name, age FROM users WHERE age > ? ORDER BY age ASC');
+  const r = await stmt.all([25]);
+  ok('prepare.all columns', r && Array.isArray(r.columns) && r.columns.includes('name'));
+  ok('prepare.all rows', r && r.rows && r.rows.length === 1 && (r.rows[0][0] === 'bob' || r.rows[0].name === 'bob'), r && r.rows);
+
+  const first = await stmt.get(10);
+  ok('prepare.get', first && (first.name === 'alice' || first[0] === 'alice'), first);
+
+  const empty = await db.prepare('SELECT name FROM users WHERE name = ?').get('nope');
+  ok('prepare.get empty', empty === null);
+
+  {
+    const pdb = new Database(':memory:');
+    pdb.use('timestamps', { createdField: 'created_at', updatedField: 'updated_at' });
+    pdb.createTable('notes', { id: { type: 'integer', primaryKey: true, autoIncrement: true }, title: { type: 'string' } });
+    const schema = pdb.getTableSchema('notes');
+    ok('use opts timestamps fields', !!(schema && schema.created_at && schema.updated_at), schema);
+    pdb.insert('notes', { title: 'hello' });
+    const row = pdb.notes.findOne({ title: 'hello' });
+    ok('timestamps stamped', !!(row && row.created_at && row.updated_at), row);
+
+    let afterInsertHits = 0;
+    pdb.on('afterInsert', () => { afterInsertHits++; });
+    pdb.insert('notes', { title: 'one' });
+    ok('single-row afterInsert', afterInsertHits === 1, afterInsertHits);
+    pdb.insert('notes', [{ title: 'a' }, { title: 'b' }]);
+    ok('batch afterInsert', afterInsertHits === 2, afterInsertHits);
+  }
+
+  console.log(failed === 0 ? `\nALL ${passed} QUERY-OPT TESTS PASSED` : `\n${failed} FAILURES (${passed} passed)`);
+  process.exit(failed === 0 ? 0 : 1);
+})().catch(e => { console.error('FATAL', e); process.exit(1); });