jsql-neo 6.5.4 → 6.5.6

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.4** — stable release · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo) · [jsql.vexify.top](https://jsql.vexify.top)
+> **v6.5.6** — 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)
@@ -41,7 +41,7 @@ npm install jsql-neo
 - **Four wire protocols on one port** — `jsql serve` accepts MySQL, PostgreSQL, MongoDB and Redis clients; `mysql2`, `pg`, `mongodb` and `ioredis` connect directly
 - **Zero dependencies** — no native libs to compile, no system deps to install
 - **Three engines, same API** — `native` (Rust N-API), `wasm` (same Rust core), `js` (pure JS)
-- **~2× faster than better-sqlite3** on indexed point lookups
+- **O(1) primary-key lookups and updates** — hash index, no full-table scan; unindexed filters run in Rust
 
 > **Wire protocols** — MySQL, PostgreSQL, MongoDB and Redis share a single listener
 > (`jsql serve`, default port 3306). The server sniffs the first packet of each
@@ -61,7 +61,7 @@ JSQL-NEO: MySQL + PostgreSQL + MongoDB + Redis + SQL
 
 | Feature | Detail |
 |---|---|
-| **Rust Core** | N-API native addon, ~2× faster than better-sqlite3 |
+| **Rust Core** | N-API native addon — O(1) primary-key point lookups, binary bulk inserts, Rust-side row filtering |
 | **WASM Build** | Same engine runs in Node.js and any browser |
 | **MySQL** | `mysql2`, Sequelize, Knex, TypeORM — just work |
 | **PostgreSQL** | `pg`, `psql`, pgAdmin — SCRAM-SHA-256, JSONB, ILIKE |

package/index.js

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

package/lib/native_client.js

@@ -32,6 +32,27 @@ function _loadNativeOrStub() {
 }
 
 const native = _loadNativeOrStub();
+
+// updateById / removeById 走 opBuffer + 定时批量 flush。进程直接退出（没调 stop()）
+// 时定时器来不及跑，写操作会丢。这里用一个进程级 exit 钩子，在退出前同步 flush
+// 所有仍然存活的实例；flush 本身是同步原生调用，可以安全地在 exit 事件里执行。
+const _liveInstances = new Set();
+let _exitFlushInstalled = false;
+function _trackInstance(inst) {
+  _liveInstances.add(inst);
+  if (_exitFlushInstalled) return;
+  _exitFlushInstalled = true;
+  process.once('exit', () => {
+    for (const db of _liveInstances) {
+      try {
+        db._flushOpsNow();
+        // disk/hybrid 模式还有一层「脏表落盘」，同样在退出前同步补一次。
+        if (db._mode !== 'memory' && db._handle !== null) db._n('jsqlFlushDirty');
+      } catch (e) { /* 进程已在退出，尽力而为 */ }
+    }
+  });
+}
+
 const INT64_TAG = 1;
 const FLOAT_TAG = 2;
 const STR_TAG = 3;
@@ -258,6 +279,30 @@ function encodeField(buf, off, v) {
   return off + 5 + sl;
 }
 
+/**
+ * 二进制批量格式只写一份字段名列表，因此要求所有行列集合完全一致，
+ * 且没有 undefined 值（undefined 在 JSON 中表示「不提供该列」，会触发默认值）。
+ */
+function _canEncodeBatch(rows) {
+  if (!rows.length) return false;
+  const keys = Object.keys(rows[0]);
+  for (const row of rows) {
+    if (!row || typeof row !== 'object') return false;
+    const rk = Object.keys(row);
+    if (rk.length !== keys.length) return false;
+    for (const k of keys) {
+      if (!Object.prototype.hasOwnProperty.call(row, k)) return false;
+      if (row[k] === undefined) return false;
+      // JSON.stringify 会把 NaN/Infinity 变成 null，二进制会原样写入浮点值。
+      if (typeof row[k] === 'number' && !Number.isFinite(row[k])) return false;
+      // 对象/数组走 JSON 路径由 Rust 侧按原语义处理；JSON 列在 _insertBatch
+      // 的前置映射里已经转成字符串，不会落到这里。
+      if (row[k] !== null && typeof row[k] === 'object') return false;
+    }
+  }
+  return true;
+}
+
 function encodeBatch(rows) {
   if (rows.length === 0) return new Uint8Array(0);
   const fieldNames = Object.keys(rows[0]);
@@ -334,6 +379,7 @@ class JSQL {
       const { ModuleManager } = require('./mod');
       new ModuleManager().applyTo(this);
     }
+    _trackInstance(this);
   }
 
   /**
@@ -477,9 +523,29 @@ class JSQL {
     return id;
   }
 
+  /**
+   * 自增整型主键时，内部行 id 与主键值一致，可直接走 O(1) 的 jsqlFindById；
+   * 非自增主键（如字符串主键）才退化为 filter 查询。
+   */
+  _isAutoIntPk(table) {
+    if (!this._pkAutoIncrement(table)) return false;
+    const def = this._schemas[table][this._pkOf(table)];
+    const t = typeof def === 'string' ? def.toLowerCase()
+      : (def && def.type ? String(def.type).toLowerCase() : '');
+    return ['integer', 'int', 'bigint'].includes(t);
+  }
+
   _findRawById(table, id) {
     const pk = this._pkOf(table);
     if (pk) {
+      if (this._isAutoIntPk(table)) {
+        const n = Number(id);
+        if (Number.isFinite(n)) {
+          const r = safeParse(this._n('jsqlFindById', table, n));
+          if (r && r.error) return r;
+          return r || null;
+        }
+      }
       const filter = {};
       filter[pk] = this._coercePkId(table, id);
       const r = safeParse(this._n('jsqlFind', table, JSON.stringify(filter), 1, 0));
@@ -492,6 +558,14 @@ class JSQL {
   _seqIdByPk(table, id) {
     const pk = this._pkOf(table);
     if (pk) {
+      if (this._isAutoIntPk(table)) {
+        const n = Number(id);
+        if (Number.isFinite(n)) {
+          const r = safeParse(this._n('jsqlFindById', table, n));
+          if (r && !r.error && r.id !== undefined) return r.id;
+        }
+        return null;
+      }
       const filter = {};
       filter[pk] = this._coercePkId(table, id);
       const r = safeParse(this._n('jsqlFind', table, JSON.stringify(filter), 1, 0));
@@ -539,16 +613,18 @@ class JSQL {
         return out;
       });
     }
-    const rawJson = JSON.stringify(rows);
-    // 优先用 jsqlInsertRaw（Rust 直接 JSON 解析，消除二进制序列化）
-    // 旧环境未编译 jsqlInsertRaw 时 fallback 到 jsqlInsertBuf
+    // 批量插入优先走二进制格式：整批只在 JS 侧 encode 一次，Rust 直接按
+    // tag 解析成 FieldValue，省掉「JS JSON.stringify → Rust serde 解析 →
+    // HashMap 再转 FieldValue」这一整条链路。20 万行实测约 2× 于 JSON 路径。
+    // 只有「所有行列集合一致且无 undefined」时才可用（二进制头只带一份字段名，
+    // 且 undefined 在 JSON 里是省略键、在二进制里是 null，语义不同）。
     let r;
-    if (typeof native.jsqlInsertRaw === 'function') {
-      r = safeParse(this._n('jsqlInsertRaw', table, rawJson));
+    if (typeof native.jsqlInsertBuf === 'function' && _canEncodeBatch(rows)) {
+      r = safeParse(this._n('jsqlInsertBuf', table, encodeBatch(rows)));
+    } else if (typeof native.jsqlInsertRaw === 'function') {
+      r = safeParse(this._n('jsqlInsertRaw', table, JSON.stringify(rows)));
     } else {
-      // fallback: 用 encodeBatch 二进制格式（向后兼容）
-      const bin = encodeBatch(rows);
-      r = safeParse(this._n('jsqlInsertBuf', table, bin));
+      r = safeParse(this._n('jsqlInsertBuf', table, encodeBatch(rows)));
     }
     if (r && r.error) throw new Error(r.error);
     if (r && Array.isArray(r) && !this._pkAutoIncrement(table)) {
@@ -724,7 +800,10 @@ class JSQL {
     this._flushOpsNow();
     if (!(await this._runHooks('beforeFind', [table, { ids }]))) return null;
     let r;
-    if (this._pkOf(table)) {
+    if (this._isAutoIntPk(table) && ids.every(id => Number.isFinite(Number(id)))) {
+      // 自增主键：内部 id 即主键值，一次批量调用即可，避免 N 次往返。
+      r = safeParse(this._n('jsqlFindByIds', table, JSON.stringify(ids.map(Number))));
+    } else if (this._pkOf(table)) {
       r = ids.map(id => this._findRawById(table, id)).filter(x => x !== null && !(x && x.error));
     } else {
       r = safeParse(this._n('jsqlFindByIds', table, JSON.stringify(ids)));
@@ -810,19 +889,21 @@ class JSQL {
     // 比读整张表还贵，而它本来只需要定位一行。
     const touched = fields.filter(f => Object.prototype.hasOwnProperty.call(data, f));
     if (!touched.length) return;
-    const raw = this._n('jsqlFind', table, '{}', 1000000, 0);
-    const all = safeParse(raw);
-    if (!Array.isArray(all)) return;
+    // 只取回被更新的这一行（自增主键下 O(1)），逐字段与现值比较；
+    // 不再把整张表导出成 JSON 到 JS 里做全量比对。
+    const self = this._findRawById(table, id);
+    if (!self || self.error) return;
     const pk = this._pkOf(table) || 'id';
-    // jsqlFind 返回的行结构是 { id, fields:{...} } —— 值在 fields 里，不在顶层。
     const valOf = (r, f) => (r && r.fields && typeof r.fields === 'object' ? r.fields[f] : r ? r[f] : undefined);
     const idOf = (r) => (r && r.fields ? valOf(r, pk) : r ? r[pk] : undefined);
-    for (const f of fields) {
-      if (!Object.prototype.hasOwnProperty.call(data, f)) continue;
+    for (const f of touched) {
       const nv = data[f];
-      const self = all.find(r => String(idOf(r)) === String(id));
-      if (self && valOf(self, f) === nv) continue;                   // 值没变
-      if (all.some(r => r !== self && valOf(r, f) === nv)) {
+      if (valOf(self, f) === nv) continue;                            // 值没变
+      // 只需知道「是否还存在另一行占用了这个键值」：limit 2 让原生层命中即停，
+      // 输出量恒定，不随表规模增长。
+      const probe = safeParse(this._n('jsqlFind', table, JSON.stringify({ [f]: nv }), 2, 0));
+      if (!Array.isArray(probe)) continue;
+      if (probe.some(r => String(idOf(r)) !== String(id))) {
         const e = new Error(`Duplicate entry '${nv}' for key '${f}'`);
         e.code = 'ER_DUP_ENTRY';
         e.errno = 1062;
@@ -893,6 +974,7 @@ class JSQL {
       } catch (e) { /* ignore */ }
       this._handle = null;
     }
+    _liveInstances.delete(this);
     await this._runHooks('onStop', []);
     this._emit('stop', {});
   }

package/lib/wasm_client.js

@@ -725,24 +725,59 @@ class JSQL {
   /**
    * 校验 UPDATE 后的主键 / UNIQUE 值不与其它行冲突。
    * 逐行比对（未建索引也正确）；值未变化时跳过。
+   *
+   * 6.5.5 性能修复（对齐 native_client.js 的 6.4.8 修复，那次漏了 wasm 侧）：
+   *   旧写法无条件 `this.find(table, {}, {limit: 1e9})` 把整张表导出成 JSON，
+   *   再逐字段 find/some。updateById 于是在 10 万行的表上要 ~590ms/次 ——
+   *   比读整张表还贵，而它本来只需要定位一行。
+   *     UPDATE t SET age = 30 WHERE id = 1   ← age 不是键，不可能冲突，却付了全表钱
+   *
+   * 新逻辑（性能从 O(表行数) 降回 O(1)）：
+   *   1. 只筛出 pk + unique 列，且**确实出现在 updateData 里**的（touched）；
+   *      一个都没碰 → 直接 return，整张表一个字都不读；
+   *   2. 先用主键把**自己那一行**取回来（一条走 pk 的 find，limit 1，O(1)）。
+   *      所有 touched 列的新值都和现值相同 → 值没变，同样直接 return
+   *      （幂等更新不误报，也不再触发全表扫描）；
+   *   3. 真的动了键，才退化成整表扫描逐字段比对（正确性优先）。
    */
   async _assertNoKeyConflict(table, id, data, selfSeq) {
     const schema = this._schemas[table];
     if (!schema) return;
     const fields = Object.keys(schema).filter(f => schema[f] && (schema[f].primaryKey || schema[f].unique));
     if (!fields.length) return;
+    // 只在**确实要改主键 / UNIQUE 列**时才做冲突检查。
+    const touched = fields.filter(f => Object.prototype.hasOwnProperty.call(data, f));
+    if (!touched.length) return;
+
+    // 自己那一行：走主键的 find(limit 1)，不整表导出。
+    let self = null;
+    try {
+      const pk = this._pkOf(table);
+      if (pk) {
+        const one = await this.find(table, { [pk]: this._coercePkId(table, id) }, { limit: 1, offset: 0 });
+        self = Array.isArray(one) ? (one[0] || null) : null;
+      }
+    } catch (_) {
+      self = null;   // 取不到就走下面的全量比对
+    }
+    // 所有 touched 列的值都没变 → 幂等更新，不可能产生新冲突，无需扫表。
+    if (self && touched.every(f => self[f] === data[f])) return;
+
     let rows;
     try {
       rows = await this.find(table, {}, { limit: 1e9, offset: 0 });
     } catch (_) {
       return;   // 读不到就不拦，交给底层报错
     }
+    if (!Array.isArray(rows)) return;
+    // 把自己那一行找出来并从比对中排除。注意：self 来自上一次 find，
+    // 与 rows 里的对象不是同一个引用，所以必须按 id 重新定位，不能直接 r !== self。
+    const selfRow = self || rows.find(r => r && String(r.id) === String(id)) || null;
     for (const f of fields) {
       if (!Object.prototype.hasOwnProperty.call(data, f)) continue;
       const nv = data[f];
-      const self = rows.find(r => r && String(r.id) === String(id));
-      if (self && self[f] === nv) continue;             // 值没变
-      if (rows.some(r => r && r !== self && r[f] === nv)) {
+      if (selfRow && selfRow[f] === nv) continue;       // 值没变
+      if (rows.some(r => r && r !== selfRow && r[f] === nv)) {
         const e = new Error(`Duplicate entry '${nv}' for key '${f}'`);
         e.code = 'ER_DUP_ENTRY';
         e.errno = 1062;

package/nativesrc/jsql-neo-core/src/engine/memory.rs

@@ -132,11 +132,16 @@ impl Engine for MemoryEngine {
         let t = self.tables.get_mut(table).ok_or_else(|| format!("table '{}' not found", table))?;
         let ids: Vec<u64> = match filter {
             Some(f) => {
-                let conds = t.parse_filter(f);
-                t.rows.iter()
-                    .filter(|r| matches_filter(t.get_row_values(r), &conds))
-                    .map(|r| r.id)
-                    .collect()
+                // 主键等值过滤：直接命中索引，不再逐行比较。
+                if let Some(id) = t.pk_eq_id(f) {
+                    if t.pk_index.contains_key(&id) { vec![id] } else { Vec::new() }
+                } else {
+                    let conds = t.parse_filter(f);
+                    t.rows.iter()
+                        .filter(|r| matches_filter(t.get_row_values(r), &conds))
+                        .map(|r| r.id)
+                        .collect()
+                }
             }
             None => t.rows.iter().map(|r| r.id).collect(),
         };
@@ -158,6 +163,10 @@ impl Engine for MemoryEngine {
             }
             Some(f) => f,
         };
+        // 主键等值删除：直接命索引，O(1)。
+        if let Some(id) = t.pk_eq_id(f) {
+            return Ok(if t.remove_row(id) { 1 } else { 0 });
+        }
         let conds = t.parse_filter(f);
         let to_remove: Vec<usize> = t.rows.iter().enumerate()
             .filter(|(_, r)| matches_filter(t.get_row_values(r), &conds))

package/nativesrc/jsql-neo-core/src/engine/table.rs

@@ -102,6 +102,9 @@ pub struct Table {
     pub next_id: u64,
     pub pk_field: Option<String>,
     pub pk_index: FxHashMap<u64, usize>,
+    /// 主键是否为自增整型：只有这时内部行 id 才等于主键值，
+    /// `pk_index` 才能直接用于 O(1) 主键点查。
+    pub pk_auto: bool,
 }
 
 pub fn default_value(ft: &FieldType) -> FieldValue {
@@ -192,6 +195,10 @@ impl Table {
         let pk_field = schema.iter()
             .find(|(_, f)| f.primary_key)
             .map(|(name, _)| name.clone());
+        let pk_auto = schema.iter()
+            .find(|(_, f)| f.primary_key)
+            .map(|(_, f)| f.auto_increment)
+            .unwrap_or(false);
 
         let field_order: Vec<String> = schema.iter().map(|(n, _)| n.clone()).collect();
         let field_index: HashMap<String, usize> = field_order.iter()
@@ -202,8 +209,22 @@ impl Table {
         Self {
             name, schema, field_order, field_index,
             rows: Vec::new(), values: Vec::new(), next_id: 1, pk_field,
-            pk_index: FxHashMap::default(),
+            pk_index: FxHashMap::default(), pk_auto,
+        }
+    }
+
+    /// 若过滤条件恰好是「自增主键 = 整数」则返回该主键值。
+    /// 这种查询可以直接走 `pk_index`，把 O(n) 全表扫描降到 O(1)。
+    pub(crate) fn pk_eq_id(&self, filter: &HashMap<String, serde_json::Value>) -> Option<u64> {
+        if !self.pk_auto || filter.len() != 1 {
+            return None;
+        }
+        let pk = self.pk_field.as_ref()?;
+        let id = filter.get(pk)?.as_i64()?;
+        if id <= 0 {
+            return None;
         }
+        Some(id as u64)
     }
 
     pub fn to_row_map(&self, values: &[FieldValue]) -> HashMap<String, serde_json::Value> {
@@ -743,6 +764,23 @@ impl Table {
                           order_by: &Option<String>, order: &Option<String>) -> (String, bool) {
         let o = offset.unwrap_or(0);
         let cap = limit.unwrap_or(usize::MAX);
+
+        // 主键点查直通：一次哈希查找定位到行，不再逐行 parse_filter/matches_filter。
+        if let Some(id) = filter.as_ref().and_then(|f| self.pk_eq_id(f)) {
+            let mut out = String::with_capacity(160);
+            out.push('[');
+            if o == 0 && cap > 0 {
+                if let Some(&idx) = self.pk_index.get(&id) {
+                    if let Some(rs) = self.rows.get(idx) {
+                        let mut tc = TimeCache::new();
+                        self.write_row_json_into(rs, &mut out, &mut tc);
+                    }
+                }
+            }
+            out.push(']');
+            return (out, false);
+        }
+
         let conds = filter.as_ref().map(|f| self.parse_filter(f)).unwrap_or_default();
 
         let mut out = String::with_capacity(128);
@@ -797,6 +835,19 @@ impl Table {
                      order_by: &Option<String>, order: &Option<String>) -> Vec<Row> {
         let o = offset.unwrap_or(0);
         let l = limit.unwrap_or(usize::MAX);
+
+        // 主键点查直通（与 find_rows_json 一致）。
+        if let Some(id) = filter.as_ref().and_then(|f| self.pk_eq_id(f)) {
+            if o == 0 && l > 0 {
+                if let Some(&idx) = self.pk_index.get(&id) {
+                    if let Some(rs) = self.rows.get(idx) {
+                        return vec![self.to_row(rs)];
+                    }
+                }
+            }
+            return Vec::new();
+        }
+
         let conds = filter.as_ref().map(|f| self.parse_filter(f)).unwrap_or_default();
 
         if let Some(field) = order_by.as_ref().filter(|f| self.field_index.contains_key(*f)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jsql-neo",
-  "version": "6.5.4",
-  "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
+  "version": "6.5.6",
+  "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",
   "exports": {
@@ -97,4 +97,4 @@
   "devDependencies": {
     "c8": "^10.1.2"
   }
-}
+}