jsql-neo 6.3.10 → 6.4.0-beta.1

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.3.10** — 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.1** — 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)
@@ -112,6 +112,27 @@ const db = new Database(':memory:');
 // same API as Node.js
 ```
 
+### 🦀 NativeJSQL
+
+Pure Rust native bindings — the highest-performance way to run JSQL-NEO:
+
+- **Zero abstraction overhead** — direct calls into the Rust core
+- **Batch operations** — up to **1.54M rows/sec** peak throughput
+- **Automatic memory management** with smart caching
+
+**Install:**
+
+```bash
+npm install jsql-neo
+```
+
+**Usage:**
+
+```javascript
+import { Database } from 'jsql-neo';
+const db = new Database('mydb.jsql');
+```
+
 ### Storage modes
 
 | Mode | Usage | Use Case |

package/bin/jsql

@@ -247,6 +247,96 @@ const cli = yaggs({ pkg: require('../package.json') })
     console.log(`jsql-neo Redis server on ${argv.host || '127.0.0.1'}:${argv.port != null ? argv.port : 6379}${argv['data-dir'] ? ' (data: ' + argv['data-dir'] + ')' : ''}`);
     setInterval(() => {}, 1 << 30);
   })
+  .command('plugin', 'Plugin registry management (list, search, install, uninstall, info)', (sub) => {
+    sub.option('json', { type: 'boolean', description: 'Output as JSON' });
+    sub.option('category', { type: 'string', description: 'Filter by category' });
+    sub.option('limit', { type: 'number', description: 'Max results per page' });
+  }, async (argv) => {
+    const pluginMgr = require('../src/cli/plugin');
+    const action = argv._[0];
+    const arg = argv._[1];
+    const useJson = !!argv.json;
+
+    const fail = (e) => { console.error(`Error: ${e.message}`); process.exitCode = 1; };
+    const out = (obj) => {
+      if (obj === undefined) return;
+      if (useJson) console.log(JSON.stringify(obj, null, 2));
+      else console.log(obj);
+    };
+
+    try {
+      switch (action) {
+        case 'list':
+        case 'ls': {
+          const opts = {};
+          if (argv.category) opts.category = argv.category;
+          if (argv.limit) opts.limit = argv.limit;
+          const plugins = await pluginMgr.listPlugins(opts);
+          out(useJson ? plugins : pluginMgr.formatPluginList(plugins));
+          break;
+        }
+        case 'search': {
+          if (!arg) throw new Error('Usage: jsql plugin search <query>');
+          const opts = {};
+          if (argv.category) opts.category = argv.category;
+          const data = await pluginMgr.searchPlugins(arg, opts);
+          // search 返回 { results: [...], query, total } 或 [...]
+          const plugins = Array.isArray(data) ? data : (data.results || []);
+          if (useJson) {
+            out(data);
+          } else {
+            if (!plugins.length) {
+              console.log(`No plugins found for '${arg}'.`);
+            } else {
+              console.log(`Found ${plugins.length} plugin(s) for '${arg}':`);
+              console.log(pluginMgr.formatPluginList(plugins.map(p => p.plugin || p)));
+            }
+          }
+          break;
+        }
+        case 'install': {
+          if (!arg) throw new Error('Usage: jsql plugin install <name>');
+          const manifest = await pluginMgr.installPlugin(arg);
+          out(useJson ? manifest : `Installed plugin '${manifest.name}' (${manifest.version})`);
+          break;
+        }
+        case 'uninstall':
+        case 'remove': {
+          if (!arg) throw new Error('Usage: jsql plugin uninstall <name>');
+          const r = pluginMgr.uninstallPlugin(arg);
+          out(useJson ? r : `Uninstalled plugin '${r.name}'.`);
+          break;
+        }
+        case 'info': {
+          if (!arg) throw new Error('Usage: jsql plugin info <name>');
+          const p = await pluginMgr.getPluginInfo(arg);
+          out(useJson ? p : pluginMgr.formatPluginInfo(p));
+          break;
+        }
+        case undefined:
+          // 无子命令 → 显示已安装插件
+          const installed = pluginMgr.listInstalled();
+          if (useJson) {
+            out(installed);
+          } else {
+            if (!installed.length) {
+              console.log('No plugins installed.');
+              console.log(`Plugin directory: ${pluginMgr.PLUGIN_DIR}`);
+            } else {
+              console.log(`Installed plugins (${installed.length}):`);
+              installed.forEach(p => {
+                console.log(`  ${p.name.padEnd(24)} ${p.version || '?'}`);
+              });
+            }
+          }
+          break;
+        default:
+          throw new Error(`Unknown plugin action: ${action}`);
+      }
+    } catch (e) {
+      fail(e);
+    }
+  })
   .command('version', 'Show version', null, () => {
     console.log(require('../package.json').version);
   })

package/index.js

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

package/lib/cache.js

@@ -50,7 +50,7 @@ class Cache {
     if (typeof val === 'string') return 'string';
     if (val instanceof Set) return 'set';
     if (Array.isArray(val)) return val._type === 'hash' ? 'hash' : 'list';
-    if (typeof val === 'object' && val._type === 'hash') return 'hash';
+    if (val !== null && typeof val === 'object' && val._type === 'hash') return 'hash';
     return 'string';
   }
   expire(key, seconds) {
@@ -85,7 +85,10 @@ class Cache {
   hset(key, field, value) {
     const k = String(key);
     let hash = this._getData().get(k);
-    if (!hash || hash._type !== 'hash') { hash = { _type: 'hash' }; this._getData().set(k, hash); }
+    if (hash !== undefined && (typeof hash !== 'object' || hash._type !== 'hash')) {
+      throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
+    }
+    if (!hash) { hash = { _type: 'hash' }; this._getData().set(k, hash); }
     const existed = hash[field] !== undefined;
     hash[field] = String(value);
     this._dirty = true;
@@ -134,7 +137,10 @@ class Cache {
   lpush(key, ...values) {
     const k = String(key);
     let list = this._getData().get(k);
-    if (!list || !Array.isArray(list) || list._type === 'hash') { list = []; this._getData().set(k, list); }
+    if (list !== undefined && (!Array.isArray(list) || list._type === 'hash')) {
+      throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
+    }
+    if (!list) { list = []; this._getData().set(k, list); }
     list.unshift(...values.map(String).reverse());
     this._dirty = true;
     return list.length;
@@ -142,7 +148,10 @@ class Cache {
   rpush(key, ...values) {
     const k = String(key);
     let list = this._getData().get(k);
-    if (!list || !Array.isArray(list) || list._type === 'hash') { list = []; this._getData().set(k, list); }
+    if (list !== undefined && (!Array.isArray(list) || list._type === 'hash')) {
+      throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
+    }
+    if (!list) { list = []; this._getData().set(k, list); }
     list.push(...values.map(String));
     this._dirty = true;
     return list.length;
@@ -185,7 +194,10 @@ class Cache {
   sadd(key, ...members) {
     const k = String(key);
     let set = this._getData().get(k);
-    if (!set || !(set instanceof Set)) { set = new Set(); this._getData().set(k, set); }
+    if (set !== undefined && !(set instanceof Set)) {
+      throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
+    }
+    if (!set) { set = new Set(); this._getData().set(k, set); }
     let count = 0;
     for (const m of members) { if (!set.has(String(m))) { set.add(String(m)); count++; } }
     if (count > 0) this._dirty = true;
@@ -223,10 +235,11 @@ class Cache {
   }
 
   flushall() {
+    const currentDb = this._db;
     for (let i = 0; i < this._dbs.length; i++) { if (this._dbs[i]) this._dbs[i].clear(); if (this._dbsExpires[i]) this._dbsExpires[i].clear(); }
-    this._data = this._dbs[0] = new Map();
-    this._expires = this._dbsExpires[0] = new Map();
-    this._db = 0;
+    this._data = this._dbs[currentDb] = new Map();
+    this._expires = this._dbsExpires[currentDb] = new Map();
+    this._db = currentDb;
     this._dirty = true;
     return 'OK';
   }

package/lib/database.js

@@ -1710,7 +1710,8 @@ class Database {
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
         if (!this._runHooks('beforeFind', [tableName, { filter, opts }])) return [];
         const { limit, offset = 0 } = opts;
-        let rows = table._applyFilterOptimized(table._rows, filter || {});
+        // P1-4: 软删除模式下不得泄露已删除行——只看可见行
+        let rows = table._applyFilterOptimized(table._getVisibleRows(), filter || {});
         if (limit > 0) rows = rows.slice(offset, offset + limit);
         else if (offset > 0) rows = rows.slice(offset);
         // P1-11: 返回浅拷贝，防止调用方修改影响内部数据
@@ -1744,6 +1745,8 @@ class Database {
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
         if (!this._runHooks('beforeFind', [tableName, { id }])) return null;
         const row = this._resolveId(table, id);
+        // P1-4: 软删除行对普通读取不可见
+        if (row && row._deleted) return null;
         // P1-11: 返回浅拷贝，防止调用方修改影响内部数据
         const result = row ? { ...row } : null;
         this._touchTable(tableName);
@@ -1755,8 +1758,8 @@ class Database {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
         if (!this._runHooks('beforeFind', [tableName, { ids }])) return null;
-        // P1-11: 返回浅拷贝
-        const rows = ids.map(id => this._resolveId(table, id)).filter(r => r !== null).map(r => ({ ...r }));
+        // P1-4: 过滤掉软删除行；P1-11: 返回浅拷贝
+        const rows = ids.map(id => this._resolveId(table, id)).filter(r => r !== null && !r._deleted).map(r => ({ ...r }));
         this._touchTable(tableName);
         this._runHooks('afterFind', [tableName, { ids }, rows]);
         return rows;
@@ -1770,7 +1773,8 @@ class Database {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
         this._runHooks('beforeCount', [tableName]);
-        const n = table._rows.length;
+        // P1-4: 软删除模式下只统计可见行
+        const n = table._softDelete ? table._getVisibleRows().length : table._rows.length;
         this._touchTable(tableName);
         this._runHooks('afterCount', [tableName, n]);
         return n;
@@ -1783,7 +1787,8 @@ class Database {
         // P1-9: updateById 绕过类型校验——先校验再更新
         const validated = table._validateDataTypes({ ...data }, true);
         const row = this._resolveId(table, id);
-        if (!row) return { ok: false, error: 'not found' };
+        // P1-4: 软删除行不可更新
+        if (!row || row._deleted) return { ok: false, error: 'not found' };
         // 改主键/唯一列时要先确认新值不与其它行冲突。
         // 此前直接 Object.assign，导致
         //   UPDATE t SET id = 1 WHERE id = 2   （t 已有 id=1）
@@ -1893,7 +1898,8 @@ class Database {
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
         if (!this._runHooks('beforeDelete', [tableName, [filter]])) return { ok: true, count: 0 };
         const before = table._rows.length;
-        const matched = table._applyFilter(table._rows, filter || {});
+        // P1-4: 只匹配可见行（软删除行已“不存在”，不应被硬删操作波及）
+        const matched = table._applyFilter(table._getVisibleRows(), filter || {});
         const matchSet = new Set(matched);
         table._rows = table._rows.filter(r => !matchSet.has(r));
         const removed = before - table._rows.length;

package/lib/date-types.js

@@ -199,9 +199,12 @@ function validateTime(value, fieldName) {
                 return value;
             }
         }
-        // 负时间: -HH:MM:SS
+        // 负时间: -HH:MM:SS（同样校验范围）
         const neg = value.match(/^-(\d{2}):(\d{2}):(\d{2})$/);
-        if (neg) return value;
+        if (neg) {
+            const h = parseInt(neg[1]), min = parseInt(neg[2]), sec = parseInt(neg[3]);
+            if (h >= 0 && h < 24 && min >= 0 && min < 60 && sec >= 0 && sec < 60) return value;
+        }
     }
     throw createError('ER_INVALID_DATE', fieldName, String(value));
 }

package/lib/jsql_format.js

@@ -12,12 +12,19 @@ const SZ = {
 
 const BT = { FREE: 0, DATA: 1, IDX: 2 };
 
-const TYPE = { NUL:0, BOL:1, I32:2, F64:3, STR:4, BUF:5, ARR:6, OBJ:7 };
+const TYPE = { NUL:0, BOL:1, I32:2, F64:3, STR:4, BUF:5, ARR:6, OBJ:7, I64:8 };
 
 function tag(v) {
   if (v===null||v===undefined) return TYPE.NUL;
   if (typeof v==='boolean') return TYPE.BOL;
-  if (typeof v==='number') return Number.isInteger(v)?TYPE.I32:TYPE.F64;
+  if (typeof v==='number') {
+    if (Number.isInteger(v)) {
+      // P2-29-fix: 超出 int32 范围的整数用 I64 存储
+      if (v >= -0x80000000 && v <= 0x7FFFFFFF) return TYPE.I32;
+      return TYPE.I64;
+    }
+    return TYPE.F64;
+  }
   if (typeof v==='string') return TYPE.STR;
   if (v instanceof Buffer) return TYPE.BUF;
   return Array.isArray(v)?TYPE.ARR:TYPE.OBJ;
@@ -29,6 +36,7 @@ function enc(v) {
     case TYPE.NUL: return Buffer.from([t]);
     case TYPE.BOL: return Buffer.from([t, v?1:0]);
     case TYPE.I32: { const b=Buffer.alloc(5); b[0]=t; b.writeInt32LE(v,1); return b; }
+    case TYPE.I64: { const b=Buffer.alloc(9); b[0]=t; b.writeBigInt64LE(BigInt(v),1); return b; }
     case TYPE.F64: { const b=Buffer.alloc(9); b[0]=t; b.writeDoubleLE(v,1); return b; }
     case TYPE.STR: { const s=Buffer.from(v,'utf8'); const b=Buffer.alloc(5+s.length); b[0]=t; b.writeUInt32LE(s.length,1); s.copy(b,5); return b; }
     case TYPE.BUF: { const b=Buffer.alloc(5+v.length); b[0]=t; b.writeUInt32LE(v.length,1); v.copy(b,5); return b; }
@@ -43,6 +51,7 @@ function dec(buf, off) {
     case TYPE.NUL: return {v:null,off};
     case TYPE.BOL: return {v:buf[off]!==0,off:off+1};
     case TYPE.I32: return {v:buf.readInt32LE(off),off:off+4};
+    case TYPE.I64: return {v:Number(buf.readBigInt64LE(off)),off:off+8};
     case TYPE.F64: return {v:buf.readDoubleLE(off),off:off+8};
     case TYPE.STR: { const l=buf.readUInt32LE(off);off+=4; return {v:buf.toString('utf8',off,off+l),off:off+l}; }
     case TYPE.BUF: { const l=buf.readUInt32LE(off);off+=4; return {v:Buffer.from(buf.subarray(off,off+l)),off:off+l}; }
@@ -62,7 +71,11 @@ function writeEnc(buf, off, v) {
   if (v === null || v === undefined) { buf[off] = 0; return off + 1; }
   if (typeof v === 'boolean') { buf[off] = 1; buf[off+1] = v ? 1 : 0; return off + 2; }
   if (typeof v === 'number') {
-    if (Number.isInteger(v)) { buf[off] = 2; buf.writeInt32LE(v, off+1); return off + 5; }
+    if (Number.isInteger(v)) {
+      // P2-29-fix: 超出 int32 范围的整数用 I64 存储
+      if (v >= -0x80000000 && v <= 0x7FFFFFFF) { buf[off] = 2; buf.writeInt32LE(v, off+1); return off + 5; }
+      buf[off] = 8; buf.writeBigInt64LE(BigInt(v), off+1); return off + 9;
+    }
     buf[off] = 3; buf.writeDoubleLE(v, off+1); return off + 9;
   }
   if (typeof v === 'string') {
@@ -414,8 +427,7 @@ class JSQLFormat {
       }
       if (buf[36] !== BT.DATA || buf[37] !== t.tableId) continue;
       if (!verifyHash(buf)) {
-        console.warn(`[JSQLFormat] Table '${name}': data block ${bid} failed integrity check, skipping`);
-        continue;
+        throw new Error(`[JSQLFormat] Table '${name}': data block ${bid} failed integrity check`);
       }
 
       const compFlag = buf[48];

package/lib/mongo_server.js

@@ -154,6 +154,7 @@ class MongoServer {
     this._engine = null;
     this._server = null;
     this._sockets = new Set();
+    this._dbCollections = new Map(); // db name → Set of collection names
   }
 
   async _getEngine() {
@@ -166,11 +167,15 @@ class MongoServer {
     return this._engine;
   }
 
-  async _ensureCollection(name) {
+  async _ensureCollection(name, db = null) {
     const engine = await this._getEngine();
     if (!engine.getTableSchema(name)) {
       engine.createTable(name, {});
     }
+    if (db) {
+      if (!this._dbCollections.has(db)) this._dbCollections.set(db, new Set());
+      this._dbCollections.get(db).add(name);
+    }
     return engine;
   }
 
@@ -339,7 +344,7 @@ class MongoServer {
         return { ok: 1, cursor: { id: { $long: 0 }, ns: `${this._dbOf(doc)}.$cmd.listCollections`, firstBatch } };
       }
       case 'create': {
-        const engine = await this._ensureCollection(String(doc.create));
+        const engine = await this._ensureCollection(String(doc.create), this._dbOf(doc));
         return { ok: 1, ns: engine ? `${this._dbOf(doc)}.${doc.create}` : '' };
       }
       case 'drop': {
@@ -353,7 +358,7 @@ class MongoServer {
       }
       case 'insert': {
         const coll = String(doc.insert);
-        const engine = await this._ensureCollection(coll);
+        const engine = await this._ensureCollection(coll, this._dbOf(doc));
         const docs = doc.documents || [];
         const ids = [];
         for (const d of docs) {
@@ -369,7 +374,7 @@ class MongoServer {
       }
       case 'findAndModify': {
         const coll = String(doc.findAndModify);
-        const engine = await this._ensureCollection(coll);
+        const engine = await this._ensureCollection(coll, this._dbOf(doc));
         const q = doc.query || {};
         const rows = this._matching(engine, coll, q);
         const found = rows[0] || null;
@@ -393,7 +398,7 @@ class MongoServer {
       }
       case 'distinct': {
         const coll = String(doc.distinct);
-        const engine = await this._ensureCollection(coll);
+        const engine = await this._ensureCollection(coll, this._dbOf(doc));
         const key = String(doc.key || '');
         const rows = this._matching(engine, coll, doc.query);
         const seen = new Set();
@@ -404,11 +409,21 @@ class MongoServer {
         }
         return { ok: 1, values };
       }
-      case 'dropDatabase':
-        return { ok: 1, dropped: String(doc.dropDatabase || this._dbOf(doc)) };
+      case 'dropDatabase': {
+        const dbName = String(doc.$db || 'test');
+        const engine = await this._getEngine();
+        const colls = this._dbCollections.get(dbName);
+        if (colls) {
+          for (const c of colls) {
+            try { engine.dropTable(c); } catch (_) {}
+          }
+          this._dbCollections.delete(dbName);
+        }
+        return { ok: 1, dropped: dbName };
+      }
       case 'find': {
         const coll = String(doc.find);
-        const engine = await this._ensureCollection(coll);
+        const engine = await this._ensureCollection(coll, this._dbOf(doc));
         let rows = this._matching(engine, coll, doc.filter);
         const skip = typeof doc.skip === 'number' ? doc.skip : 0;
         if (skip > 0) rows = rows.slice(skip);
@@ -420,7 +435,7 @@ class MongoServer {
         return { ok: 1, cursor: { id: { $long: 0 }, ns: String(doc.collection || ''), nextBatch: [] } };
       case 'update': {
         const coll = String(doc.update);
-        const engine = await this._ensureCollection(coll);
+        const engine = await this._ensureCollection(coll, this._dbOf(doc));
         let n = 0;
         const updates = doc.updates || [];
         for (const u of updates) {
@@ -453,24 +468,26 @@ class MongoServer {
       }
       case 'delete': {
         const coll = String(doc.delete);
-        const engine = await this._ensureCollection(coll);
+        const engine = await this._ensureCollection(coll, this._dbOf(doc));
         let n = 0;
         for (const d of (doc.deletes || [])) {
           const rows = this._matching(engine, coll, d.q || {});
-          if (rows.length > 0) this._removeRows(engine, coll, rows);
-          n += rows.length;
+          // MongoDB delete: limit=1 means delete only one, limit=0 means delete all
+          const toDelete = d.limit === 1 ? rows.slice(0, 1) : rows;
+          if (toDelete.length > 0) this._removeRows(engine, coll, toDelete);
+          n += toDelete.length;
         }
         return { ok: 1, n };
       }
       case 'count': {
         const coll = String(doc.count);
-        const engine = await this._ensureCollection(coll);
+        const engine = await this._ensureCollection(coll, this._dbOf(doc));
         const rows = this._matching(engine, coll, doc.query);
         return { ok: 1, n: Number(doc.limit) > 0 ? Math.min(rows.length, doc.limit) : rows.length };
       }
       case 'aggregate': {
         const coll = String(doc.aggregate);
-        const engine = await this._ensureCollection(coll);
+        const engine = await this._ensureCollection(coll, this._dbOf(doc));
         const pipeline = doc.pipeline || [];
         let rows = engine.find(coll, {});
         for (const stage of pipeline) {

package/lib/mysql_compat.js

@@ -19,7 +19,7 @@ function toResultPacket(r, table, rowsAsArray) {
     // P3-9: fields 类型全 253——根据实际类型设置
     const fields = columns.map(name => {
       let type = 253; // VAR_STRING
-      const val = values[0] ? values[0][name] : null;
+      const val = rawRows[0] ? rawRows[0][columns.indexOf(name)] : null;
       if (typeof val === 'number') type = 8; // LONGLONG
       else if (typeof val === 'boolean') type = 1; // TINY
       else if (val instanceof Date) type = 12; // DATETIME
@@ -73,6 +73,7 @@ class Connection extends EventEmitter {
     this.filename = options.filename || null;
     this.engine = null;
     this._ownEngine = false;
+    this._connectEmitted = false;
     this.state = 'disconnected';
     this.stream = {
       destroyed: false,

package/lib/mysql_server.js

@@ -131,6 +131,12 @@ function parseLenenc(buf, offset) {
   if (first === 0xfb) return { value: null, size: 1 };
   if (first === 0xfc) return { value: buf.readUInt16LE(offset + 1), size: 3 };
   if (first === 0xfd) return { value: buf.readUIntLE(offset + 1, 3), size: 4 };
+  // 0xfe: 8-byte int64
+  if (first === 0xfe) {
+    const low = buf.readUInt32LE(offset + 1);
+    const high = buf.readUInt32LE(offset + 5);
+    return { value: low + high * 4294967296, size: 9 };
+  }
   return { value: buf.readUInt32LE(offset + 1), size: 5 };
 }
 

package/lib/nedb_compat.js

@@ -53,7 +53,7 @@ function arraysEqual(a, b) {
 function looseEqual(a, b) {
   if (a === b) return true;
   if (a === null || b === null || a === undefined || b === undefined) return false;
-  if (typeof a === 'number' || typeof b === 'number') {
+  if (typeof a === 'number' && typeof b === 'number') {
     const na = Number(a), nb = Number(b);
     if (!Number.isNaN(na) && !Number.isNaN(nb)) return na === nb;
   }
@@ -63,17 +63,17 @@ function looseEqual(a, b) {
     if (ka.length !== kb.length) return false;
     return ka.every(k => looseEqual(a[k], b[k]));
   }
-  return String(a) === String(b);
+  return false;
 }
 
 function matchOperator(value, op, expected) {
   switch (op) {
     case '$eq': return looseEqual(value, expected);
     case '$ne': return !looseEqual(value, expected);
-    case '$lt': return value !== undefined && (value === null ? expected !== null && expected !== undefined && 0 < expected : value < expected);
-    case '$lte': return value !== undefined && (value === null ? expected !== null && expected !== undefined && 0 <= expected : value <= expected);
-    case '$gt': return value !== undefined && (value === null ? expected !== null && expected !== undefined && 0 > expected : value > expected);
-    case '$gte': return value !== undefined && (value === null ? expected !== null && expected !== undefined && 0 >= expected : value >= expected);
+    case '$lt': return value !== undefined && (value === null ? 0 < expected : value < expected);
+    case '$lte': return value !== undefined && (value === null ? 0 <= expected : value <= expected);
+    case '$gt': return value !== undefined && (value === null ? 0 > expected : value > expected);
+    case '$gte': return value !== undefined && (value === null ? 0 >= expected : value >= expected);
     case '$in': return Array.isArray(expected) && expected.some(e => looseEqual(value, e));
     case '$nin': return Array.isArray(expected) && !expected.some(e => looseEqual(value, e));
     case '$exists': return expected ? value !== undefined : value === undefined;

package/lib/query.js

@@ -232,7 +232,8 @@ class Query {
             return this._cache.result;
         }
 
-        let rows = this._table._applyFilterOptimized(this._table._rows, this._conditions);
+        // P1-4: 软删除模式下 QueryBuilder 也不得泄露已删除行
+        let rows = this._table._applyFilterOptimized(this._table._getVisibleRows(), this._conditions);
 
         // JOIN
         for (const join of this._joins) {

package/lib/redis_server.js

@@ -26,7 +26,7 @@ const TYPE_SIGNATURES = {
   INCR: 1, DECR: 1, INCRBY: 2, DECRBY: 2, APPEND: 2, STRLEN: 1,
   MSET: -2, MGET: -1,
   HSET: -3, HGET: 2, HGETALL: 1, HDEL: -2, HEXISTS: 2, HLEN: 1, HKEYS: 1, HVALS: 1,
-  LPUSH: -2, RPUSH: -2, LPOP: 1, RPOP: 1, LLEN: 1, LRANGE: 3, LINDEX: 2, LREM: 3,
+  LPUSH: -2, RPUSH: -2, LPOP: -1, RPOP: -1, LLEN: 1, LRANGE: 3, LINDEX: 2, LREM: 3,
   SADD: -2, SREM: -2, SMEMBERS: 1, SISMEMBER: 2, SCARD: 1,
   ZADD: -3, ZRANGE: 3, ZREVRANGE: 3, ZSCORE: 2, ZCARD: 1, ZREM: -2, ZINCRBY: 3,
   DBSIZE: 0, FLUSHALL: 0, FLUSHDB: 0, SELECT: 1, INFO: 0, AUTH: 1, QUIT: 0,
@@ -167,17 +167,22 @@ class RedisServer {
         return v.val;
       }
       case 'APPEND': {
+        const argCount = args.length;
+        if (argCount > 2) throw new Error(`ERR wrong number of arguments for 'append' command`);
         const v = this._get(args[0]);
-        const prev = v && v.type === 'string' ? v.val : '';
+        // N2-fix: 对非 string 类型的 key（list/hash/set/zset）必须报 WRONGTYPE，
+        // 此前静默把整值覆盖成 string，丢数据且与真 Redis 行为不符。
+        if (v && v.type !== 'string') throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
+        const prev = v ? v.val : '';
         this.db.set(args[0], { type: 'string', val: prev + args[1], ttl: v ? v.ttl : null });
         this._scheduleSnapshot();
-        return this.db.get(args[0]).val.length;
+        return Buffer.byteLength(this.db.get(args[0]).val, 'utf8');
       }
       case 'STRLEN': {
         const v = this._get(args[0]);
         if (!v) return 0;
         if (v.type !== 'string') throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
-        return v.val.length;
+        return Buffer.byteLength(v.val, 'utf8');
       }
       case 'INCR': case 'DECR': case 'INCRBY': case 'DECRBY': {
         const by = cmd === 'INCRBY' || cmd === 'DECRBY' ? parseInt(args[1], 10) : 1;
@@ -241,7 +246,8 @@ class RedisServer {
       case 'HSET': {
         if (args.length % 2 !== 1) throw new Error(`ERR wrong number of arguments for 'hset' command`);
         const v = this._get(args[0]);
-        const h = (v && v.type === 'hash') ? { ...v.val } : {};
+        if (v && v.type !== 'hash') throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
+        const h = v ? { ...v.val } : {};
         let n = 0;
         for (let i = 1; i < args.length; i += 2) {
           if (!(args[i] in h)) n++;
@@ -290,7 +296,8 @@ class RedisServer {
       }
       case 'LPUSH': case 'RPUSH': {
         const v = this._get(args[0]);
-        const list = (v && v.type === 'list') ? [...v.val] : [];
+        if (v && v.type !== 'list') throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
+        const list = v ? [...v.val] : [];
         if (cmd === 'LPUSH') {
           for (const val of args.slice(1)) list.unshift(val);
         } else {
@@ -301,16 +308,32 @@ class RedisServer {
         return list.length;
       }
       case 'LPOP': case 'RPOP': {
+        // N3-fix: 支持可选 count 参数（Redis 6.2+）。旧实现忽略 count，LPOP key 2 只弹 1 个。
+        // 无 count：弹 1 个，key 不存在时返回 nil（bulk null）。
+        // 有 count：返回数组（最多 count 个元素），key 不存在时返回空数组；count<0 报错。
+        const hasCount = args.length >= 2;
+        let count = 1;
+        if (hasCount) {
+          count = parseInt(args[1], 10);
+          if (isNaN(count) || count < 0) throw new Error('ERR value is out of range, must be positive');
+        }
         const v = this._get(args[0]);
-        if (!v) return null;
+        if (!v) return hasCount ? [] : null;
         if (v.type !== 'list') throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
-        const el = cmd === 'LPOP' ? v.val.shift() : v.val.pop();
+        const popped = [];
+        for (let i = 0; i < count && v.val.length > 0; i++) {
+          popped.push(cmd === 'LPOP' ? v.val.shift() : v.val.pop());
+        }
+        if (v.val.length === 0) this.db.delete(args[0]);
         this._scheduleSnapshot();
-        return el === undefined ? null : el;
+        if (hasCount) return popped;
+        return popped.length ? popped[0] : null;
       }
       case 'LLEN': {
         const v = this._get(args[0]);
-        return v && v.type === 'list' ? v.val.length : 0;
+        if (!v) return 0;
+        if (v.type !== 'list') throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
+        return v.val.length;
       }
       case 'LRANGE': {
         const v = this._get(args[0]);
@@ -366,7 +389,8 @@ class RedisServer {
       }
       case 'SADD': case 'SREM': {
         const v = this._get(args[0]);
-        const set = (v && v.type === 'set') ? new Set(v.val) : new Set();
+        if (v && v.type !== 'set') throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
+        const set = v ? new Set(v.val) : new Set();
         let n = 0;
         for (const m of args.slice(1)) {
           if (cmd === 'SADD') { if (!set.has(m)) { set.add(m); n++; } }
@@ -495,8 +519,9 @@ class RedisServer {
       case 'DBSIZE': {
         let count = 0;
         const now = Date.now();
-        for (const v of this.db.values()) {
-          if (!v.ttl || v.ttl > now) count++;
+        for (const [k, v] of this.db) {
+          if (v.ttl && v.ttl <= now) { this.db.delete(k); continue; }
+          count++;
         }
         return count;
       }

package/lib/sql.js

@@ -1,3 +1,6 @@
+// N1-fix: createError 此前未导入，UPDATE 无主键表时抛 ReferenceError（而非预期的 SQL 错误）
+const { createError } = require('./errors');
+
 const DANGEROUS_SQL = [
   { re: /^INTO$/, next: /^(OUTFILE|DUMPFILE)$/, name: 'INTO OUTFILE/DUMPFILE' },
   { re: /^LOAD$/, next: /^(FILE|DATA)$/, name: 'LOAD_FILE/LOAD DATA' },
@@ -616,7 +619,9 @@ class Parser {
           const nextTok = this.peek(1);
           if (nextTok && (nextTok.type === 'ident' || nextTok.type === 'keyword') &&
               ['TEXT', 'INT', 'INTEGER', 'VARCHAR', 'CHAR', 'DATE', 'DATETIME', 'TIMESTAMP', 'BOOLEAN', 'BOOL', 'FLOAT', 'DOUBLE', 'DECIMAL', 'BLOB', 'JSON'].includes(String(nextTok.value).toUpperCase())) {
-            const col = this.parseTableName();
+            // P1-24: KEY/INDEX 是保留字，不能直接用 parseTableName()，改用 nameOfToken + next()
+            const col = nameOfToken(t);
+            this.next(); // 消费 KEY/INDEX token
             const def = this.parseColumnDef();
             schema[col] = def;
             if (def.primaryKey) hasPk = true;
@@ -983,6 +988,24 @@ class Parser {
   }
 
   parseValue() {
+    const atom = this.parseValueAtom();
+    return this.parseBinaryFromAtom(atom);
+  }
+
+  /** P2-3 helper: parse binary expression starting from an already-parsed left atom. */
+  parseBinaryFromAtom(left) {
+    const ops = ['+', '-', '*', '/', '%', '<<', '>>', '&', '|', '^'];
+    for (;;) {
+      const opTok = this.peek();
+      if (opTok.type !== 'op' || !ops.includes(opTok.value)) break;
+      this.next();
+      const right = this.parseValueAtom();
+      left = { type: 'binary', op: opTok.value, left, right };
+    }
+    return left;
+  }
+
+  parseValueAtom() {
     const t = this.next();
     if (t.type === 'number' || t.type === 'string') return t.value;
     // MySQL: ON DUPLICATE KEY UPDATE col = VALUES(col) —— 引用"本次本应插入的值"
@@ -1007,17 +1030,15 @@ class Parser {
       if (num.type !== 'number') throw new Error('Expected number after +');
       return num.value;
     }
-    // P1-19/P2-3: parseValue 不支持表达式 RHS，如 col = col + 1
-    // 支持简单的二元表达式：left op right
     if (t.type === 'ident') {
-      const left = this.parseColumnRef();
-      const opTok = this.peek();
-      if (opTok.type === 'op' && ['+', '-', '*', '/', '%', '<<', '>>', '&', '|', '^'].includes(opTok.value)) {
+      // Handle dotted column refs (a.b) without double-consuming the token
+      if (this.peek().type === 'op' && this.peek().value === '.') {
         this.next();
-        const right = this.parseValue();
-        return { type: 'binary', op: opTok.value, left, right };
+        const col = this.next();
+        if (!isUsableNameToken(col)) throw new Error(`Expected column name after '.', got '${col.value}'`);
+        return nameOfToken(t) + '.' + nameOfToken(col);
       }
-      return left;
+      return nameOfToken(t);
     }
     throw new Error(`Expected value, got '${t.value}'`);
   }
@@ -2355,9 +2376,11 @@ class Parser {
         return { type: 'value', value: t.value === '-' ? -num.value : num.value };
       }
       // 负号/正号后面是列名或表达式：解析为 unary 运算符
-      if (num.type === 'column' || num.type === 'value') {
-        const operand = num.type === 'column' ? { type: 'column', name: num.value } : { type: 'value', value: num.value };
-        return { type: 'negate', operand };
+      if (num.type === 'ident') {
+        return { type: 'negate', operand: { type: 'column', name: nameOfToken(num) }, positive: t.value === '+' };
+      }
+      if (num.type === 'string') {
+        return { type: 'negate', operand: { type: 'value', value: num.value }, positive: t.value === '+' };
       }
       throw new Error('Expected number or column after sign');
     }
@@ -2825,7 +2848,9 @@ function resolveOperand(operand, row, ctx) {
     case 'negate': {
       const v = resolveOperand(operand.operand, row, ctx);
       if (v === null || v === undefined) return null;
-      return -Number(v);
+      const n = Number(v);
+      if (isNaN(n)) return null;
+      return operand.positive ? n : -n;
     }
     // P1-19: ON DUPLICATE KEY UPDATE 表达式赋值，如 count = count + 1
     case 'binary': {
@@ -3990,8 +4015,14 @@ class SQLExecutor {
               break;
             }
             case 'dropPrimary': {
-              for (const def of Object.values(table._schema)) { if (def && typeof def === 'object') { def.primaryKey = false; } }
-              // P1-23: 清除主键缓存，否则后续插入仍会检查主键冲突
+              for (const [colName, def] of Object.entries(table._schema)) {
+                if (def && typeof def === 'object' && def.primaryKey) {
+                  def.primaryKey = false;
+                  // P1-23: 同时清除 unique 标记，否则后续 INSERT 仍会拒绝重复值
+                  def.unique = false;
+                }
+              }
+              // 清除主键缓存
               table._primaryKey = null;
               table._pkIndex = null;
               break;
@@ -6409,24 +6440,24 @@ class SQLExecutor {
     const tableName = statement.from ? (statement.from.tables[0].table || null) : null;
     if (statement.columns.length === 1 && statement.columns[0].expr === '*') {
       const schemaKeys = schema ? Object.keys(schema) : [];
-      const pkCols = schemaKeys.filter(k => schema && schema[k] && schema[k].primaryKey);
-      const pk = pkCols.length > 0 ? pkCols[0] : (schemaKeys[0] || 'id');
       let cols;
       // 有 JOIN 时，SELECT * 应展开所有表的列（合并后的行包含所有前缀列）
       const hasJoins = statement.from && statement.from.joins && statement.from.joins.length > 0;
       if (schema && !hasJoins) {
-        cols = [pk, ...schemaKeys.filter(k => k !== pk)];
+        // P1-17: SELECT * 按列声明顺序输出，不得把主键强制排到首位（MySQL 语义）
+        cols = schemaKeys.filter(k => k !== '_softDelete');
       } else if (rowsAll && rowsAll.columns) {
         cols = rowsAll.columns;
       } else {
-        // JOIN 时：只使用带前缀的键，避免同一列重复
+        // JOIN 时：只使用带前缀的键，避免同一列重复。
+        // 不能按裸名去重——右表同名列（如 b.id）会被丢弃，导致右表列全部丢失。
         if (hasJoins) {
           const seen = new Set();
           cols = [];
           for (const r of rows) {
             for (const k of Object.keys(r)) {
-              const bare = k.includes('.') ? k.slice(k.indexOf('.') + 1) : k;
-              if (!seen.has(bare)) { seen.add(bare); cols.push(k); }
+              if (!k.includes('.')) continue; // 只取带前缀的键
+              if (!seen.has(k)) { seen.add(k); cols.push(k); }
             }
           }
         } else {
@@ -6453,15 +6484,56 @@ class SQLExecutor {
       return { ok: true, type: 'select', table: tableName, columns: cols, rows: rows.map(r => cols.map(c => (r[c] !== undefined ? r[c] : r[String(c).slice(String(c).indexOf('.') + 1)]))), raw: rows };
     }
 
+    // P1-18: SELECT *, col —— 星号必须展开为全部列，列名与值对齐。
+    // 此前把 '*' 当成单列输出嵌套数组，导致每行值错位重复/输出 null。
+    if (statement.columns.some(c => c.expr === '*')) {
+      const hasJoins2 = statement.from && statement.from.joins && statement.from.joins.length > 0;
+      let starKeys = [];
+      if (schema && !hasJoins2) {
+        starKeys = Object.keys(schema).filter(k => k !== '_softDelete');
+      } else if (hasJoins2) {
+        // JOIN 时：保留所有带前缀的键，不按裸名去重（否则右表同名列丢失）
+        const seenK = new Set();
+        for (const r of rows) {
+          for (const k of Object.keys(r)) {
+            if (!k.includes('.')) continue;
+            if (!seenK.has(k)) { seenK.add(k); starKeys.push(k); }
+          }
+        }
+      } else {
+        const seenK = new Set();
+        for (const r of rows) {
+          for (const k of Object.keys(r)) {
+            const bare = k.includes('.') ? k.slice(k.indexOf('.') + 1) : k;
+            if (!seenK.has(bare)) { seenK.add(bare); starKeys.push(k); }
+          }
+        }
+      }
+      const cols = [];
+      for (const c of statement.columns) {
+        if (c.expr === '*') { for (const k of starKeys) cols.push(k.includes('.') ? k.slice(k.indexOf('.') + 1) : k); }
+        else cols.push(scalarColumnName(c));
+      }
+      const mapped = await this._projectRows(statement, rows, (r) => {
+        const out = [];
+        for (const c of statement.columns) {
+          if (c.expr === '*') {
+            for (const k of starKeys) out.push(r[k] !== undefined ? r[k] : r[String(k).slice(String(k).indexOf('.') + 1)]);
+          } else if (c.over || (c.scalar && c.scalar.over)) out.push(windowColumnValue(c, r));
+          else if (c.scalar) out.push(projectScalar(resolveOperand(c.scalar, r, this.ctx)));
+          else if (c.literal !== undefined) out.push(c.literal);
+          else if (c.caseExpr) out.push(projectScalar(evaluateCaseVal(c.caseExpr, r)));
+          else out.push(projectScalar(resolveOperand({ type: 'column', name: c.expr }, r, this.ctx)));
+        }
+        return out;
+      });
+      return { ok: true, type: 'select', table: tableName, columns: cols, rows: mapped, raw: rows };
+    }
+
     const cols = statement.columns.map(c => scalarColumnName(c));
     const mapped = await this._projectRows(statement, rows, (r) => statement.columns.map(c => {
       if (c.over || (c.scalar && c.scalar.over)) return windowColumnValue(c, r);
       if (c.scalar) return projectScalar(resolveOperand(c.scalar, r, this.ctx));
-      // P1-18: SELECT *, col 星号列输出 null——应展开为所有列
-      if (c.expr === '*') {
-        // 展开星号：返回行的所有值
-        return Object.keys(r).map(k => r[k]);
-      }
       if (c.literal !== undefined) return c.literal;
       if (c.caseExpr) return projectScalar(evaluateCaseVal(c.caseExpr, r));
       return projectScalar(resolveOperand({ type: 'column', name: c.expr }, r, this.ctx));
@@ -6604,7 +6676,10 @@ function escapeValue(value) {
     }
     return value.map(escapeValue).join(', ');
   }
-  if (typeof value === 'object') return "'" + JSON.stringify(value).replace(/'/g, "\\'") + "'";
+  // P1-25: 对象参数先 JSON 序列化，再走与字符串完全相同的转义通道。
+  // 此前只对单引号做替换，反斜杠原样拼进 SQL 文本，解析时丢失/翻倍，
+  // 导致 C:\temp\x 这类值存成两个反斜杠或直接 JSON 解析失败。
+  if (typeof value === 'object') return escapeValue(JSON.stringify(value));
   const str = String(value)
     .replace(/\\/g, '\\\\')
     .replace(/\0/g, '\\0')

package/lib/table.js

@@ -175,6 +175,18 @@ class Table {
         this._autoCreateBTrees();
     }
 
+    // P1-2: DDL 后统一刷新 schema 缓存。
+    // dropColumn/renameColumn 过去只改 _cachedSchemaFields，unique/required/numeric/
+    // date/computed 缓存残留旧列 → insertMany 等路径拿到陈旧 schema 直接崩溃或漏校验。
+    _refreshSchemaCache() {
+        this._cachedSchemaFields = Object.keys(this._schema).filter(f => f !== '_softDelete');
+        this._cachedDateFields = Object.keys(this._dateFields);
+        this._cachedUniqueFields = this._cachedSchemaFields.filter(f => this._schema[f] && this._schema[f].unique);
+        this._cachedRequiredFields = this._cachedSchemaFields.filter(f => this._schema[f] && this._schema[f].required);
+        this._cachedNumericFields = this._cachedSchemaFields.filter(f => ['integer', 'int', 'float', 'number', 'decimal'].includes(this._schema[f] && this._schema[f].type));
+        this._cachedComputedFields = this._cachedSchemaFields.filter(f => this._computedFields[f]);
+    }
+
     _autoCreateBTrees() {
         for (const [field, def] of Object.entries(this._schema)) {
             if (field === '_softDelete') continue;
@@ -463,6 +475,10 @@ class Table {
         if (rowIndex === undefined) return 0;
         const row = this._rows[rowIndex];
         if (row && row._deleted) return 0;
+        // P1-3：主键被更新时传播到外键引用（CASCADE / SET NULL / RESTRICT）
+        if (updates[this._primaryKey] !== undefined && updates[this._primaryKey] !== id) {
+            this._propagatePKUpdate(id, updates[this._primaryKey]);
+        }
         const oldData = { ...row };
         const merged = { ...row, ...updates };
         this._validateConstraints(merged, rowIndex);
@@ -708,6 +724,7 @@ class Table {
                 if (val !== undefined && val !== null) this._pkIndex.set(val, i);
             }
         }
+        this._refreshSchemaCache();
         this._dirty = true;
         this._db._markDirty(this._name);
         return this;
@@ -732,6 +749,7 @@ class Table {
             if (this._pkIndex) this._pkIndex.clear();
         }
         if (this._autoIncrementField === field) this._autoIncrementField = null;
+        this._refreshSchemaCache();
         this._dirty = true;
         this._db._markDirty(this._name);
         return this;
@@ -759,8 +777,27 @@ class Table {
             row[newName] = row[oldName];
             delete row[oldName];
         }
+        if (this._indexes[oldName]) {
+            this._indexes[newName] = this._indexes[oldName];
+            delete this._indexes[oldName];
+        }
+        this._foreignKeys = this._foreignKeys.filter(fk => true);
+        for (const fk of this._foreignKeys) {
+            if (fk.field === oldName) fk.field = newName;
+        }
+        this._checkConstraints = this._checkConstraints.map(c =>
+            c.field === oldName ? { ...c, field: newName } : c);
+        if (this._computedFields[oldName]) {
+            this._computedFields[newName] = this._computedFields[oldName];
+            delete this._computedFields[oldName];
+        }
+        if (this._dateFields[oldName]) {
+            this._dateFields[newName] = this._dateFields[oldName];
+            delete this._dateFields[oldName];
+        }
         if (this._primaryKey === oldName) this._primaryKey = newName;
         if (this._autoIncrementField === oldName) this._autoIncrementField = newName;
+        this._refreshSchemaCache();
         this._dirty = true;
         this._db._markDirty(this._name);
         return this;
@@ -780,6 +817,12 @@ class Table {
                 delete this._btrees[field];
             }
         }
+        if (definition.type && ['date', 'datetime', 'timestamp', 'time'].includes(definition.type)) {
+            this._dateFields[field] = definition.type;
+        } else if (definition.type) {
+            delete this._dateFields[field];
+        }
+        this._refreshSchemaCache();
         this._dirty = true;
         this._db._markDirty(this._name);
         return this;
@@ -1212,20 +1255,55 @@ class Table {
 
     /**
      * 级联外键操作：当删除当前表的行时，查找所有引用此表的子表
-     * 并执行 CASCADE 或 SET NULL
+     * 并执行 CASCADE / SET NULL / RESTRICT（P1-3：RESTRICT 之前静默放行）
      */
-    _cascadeForeignKeys(row) {
+    _cascadeForeignKeys(row, opts = {}) {
         for (const [, table] of Object.entries(this._db._tables)) {
             if (table._name === this._name) continue;
             for (const fk of table._foreignKeys) {
                 const refTable = table._resolveTable(fk.table);
                 if (!refTable || refTable._name !== this._name) continue;
 
-                // 检查子表行是否引用当前行
+                // 被引用列值为 NULL 时不构成引用（SQL 语义），不参与约束
+                const refVal = row[fk.refField];
+                if (refVal === undefined || refVal === null) continue;
+
+                // 检查子表行是否引用当前行（软删除模式下行已不可见则不阻断）
+                const refs = table._applyFilterOptimized(table._getVisibleRows(), { [fk.field]: refVal });
+                if (refs.length === 0) continue;
+
                 if (fk.onDelete === 'cascade') {
                     table.remove({ [fk.field]: row[fk.refField] });
                 } else if (fk.onDelete === 'set null') {
                     table.update({ [fk.field]: row[fk.refField] }, { [fk.field]: null });
+                } else {
+                    // RESTRICT / NO ACTION / 未指定：默认拒绝删除（ER_ROW_IS_REFERENCED）
+                    if (opts.skipRestrict) continue;
+                    throw createError('ER_ROW_IS_REFERENCED');
+                }
+            }
+        }
+    }
+
+    /**
+     * P1-3：父表主键被更新时，传播到引用它的子表。
+     * CASCADE → 同步新值；SET NULL → 置空；RESTRICT → 拒绝更新。
+     */
+    _propagatePKUpdate(oldVal, newVal) {
+        for (const [, table] of Object.entries(this._db._tables)) {
+            if (table._name === this._name) continue;
+            for (const fk of table._foreignKeys) {
+                const refTable = table._resolveTable(fk.table);
+                if (!refTable || refTable._name !== this._name) continue;
+                const refs = table._applyFilterOptimized(table._getVisibleRows(), { [fk.field]: oldVal });
+                if (refs.length === 0) continue;
+                const action = (fk.onUpdate || 'restrict').toLowerCase();
+                if (action === 'cascade') {
+                    table.update({ [fk.field]: oldVal }, { [fk.field]: newVal });
+                } else if (action === 'set null') {
+                    table.update({ [fk.field]: oldVal }, { [fk.field]: null });
+                } else {
+                    throw createError('ER_ROW_IS_REFERENCED');
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsql-neo",
-  "version": "6.3.10",
+  "version": "6.4.0-beta.1",
   "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
   "main": "index.js",
   "types": "index.d.ts",
@@ -88,7 +88,7 @@
     "node": ">=14.0.0"
   },
   "dependencies": {
-    "@vexify-org/yaggs": "^8.1.0"
+    "@vexify-org/yaggs": "^8.1.1"
   },
   "devDependencies": {
     "c8": "^10.1.2"

package/test/readme-audit.test.js

@@ -533,22 +533,23 @@ async function main() {
     const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
     const raw = fs.readFileSync(path.join(__dirname, '..', 'README.md'), 'utf8');
     const v = pkg.version;
-    ok('package.json 版本号格式合法', /^\d+\.\d+\.\d+$/.test(v), v);
+    // 支持 prerelease 版本如 6.4.0-beta.1
+    ok('package.json 版本号格式合法', /^\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?$/.test(v), v);
 
-    // README 头部横幅必须与 package.json 一致
-    const banner = raw.match(/^> \*\*v(\d+\.\d+\.\d+)\*\*/m);
+    // README 头部横幅必须与 package.json 一致（支持 prerelease）
+    const banner = raw.match(/^> \*\*v(\d+\.\d+\.\d+(?:-[a-zA-Z0-9.]+)?)\*\*/m);
     ok('README 顶部版本横幅与 package.json 一致', banner && banner[1] === v,
       banner ? `README=${banner[1]} package=${v}` : '未找到顶部横幅');
 
-    // 所有 "jsql-neo vX.Y.Z" / "文档版本：vX.Y.Z" 形式的版本声明都必须等于当前版本
-    const claims = [...raw.matchAll(/(?:jsql-neo v|文档版本：v|ver=)(\d+\.\d+\.\d+)/g)]
+    // 所有 "jsql-neo vX.Y.Z" / "文档版本：vX.Y.Z" 形式的版本声明都必须等于当前版本（支持 prerelease）
+    const claims = [...raw.matchAll(/(?:jsql-neo v|文档版本：v|ver=)(\d+\.\d+\.\d+(?:-[a-zA-Z0-9.]+)?)/g)]
       .map(m => m[1]);
     const stale = [...new Set(claims.filter(c => c !== v))];
     ok('README 无陈旧版本号声明', stale.length === 0, stale);
 
-    // index.js 头部注释也必须同步
+    // index.js 头部注释也必须同步（支持 prerelease）
     const idx = fs.readFileSync(path.join(__dirname, '..', 'index.js'), 'utf8');
-    const hdr = idx.match(/JSQL-NEO v(\d+\.\d+\.\d+)/);
+    const hdr = idx.match(/JSQL-NEO v(\d+\.\d+\.\d+(?:-[a-zA-Z0-9.]+)?)/);
     ok('index.js 头部版本注释与 package.json 一致', hdr && hdr[1] === v,
       hdr ? `index.js=${hdr[1]} package=${v}` : '未找到版本注释');
   }