jsql-neo 6.3.6 → 6.3.10

package/lib/database.js

@@ -9,7 +9,23 @@ const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
 const Table = require('./table');
-const { createError } = require('./errors');
+const { createError, JSQL_Error, ErrorCodes } = require('./errors');
+
+/**
+ * 构造带补充说明的错误。
+ *
+ * 为什么不能直接用 createError：它的消息来自错误码目录的模板，
+ * 只把 %s 换成参数 —— ER_NO_TRANSACTION 的模板里没有 %s，
+ * 自定义说明会被整段丢弃，用户只能看到一句 "No transaction in progress"，
+ * 不知道该怎么做。这里沿用同一个 MySQL 错误码（保证兼容），
+ * 但在标准消息后面补上有用的提示。
+ */
+function errorWithHint(codeKey, hint) {
+    const t = ErrorCodes[codeKey];
+    if (!t) return new JSQL_Error('UNKNOWN', hint);
+    const msg = hint ? `${t.msg}: ${hint}` : t.msg;
+    return new JSQL_Error(t.code, msg, { codeKey });
+}
 const JSQLFormat = require('./jsql_format');
 const {
   createHookRegistry, applyPlugin, buildPluginContext, registerHook,
@@ -341,22 +357,27 @@ class Database {
     _acquireLock() {
         if (!this._fileLockEnabled) return;
         try {
-            // 检查锁文件是否存在
-            if (fs.existsSync(this._lockPath)) {
-                const lockTime = fs.statSync(this._lockPath).mtimeMs;
-                // 锁超过 30 秒视为过期
-                if (Date.now() - lockTime > 30000) {
-                    fs.unlinkSync(this._lockPath);
-                } else {
-                    throw createError('ER_LOCK_WAIT_TIMEOUT', 'Database is locked by another process');
-                }
-            }
-            fs.writeFileSync(this._lockPath, String(process.pid), 'utf8');
-            this._lockFd = true;
+            // 原子创建锁文件：'wx' 模式在文件存在时立即抛错，无需 TOCTOU 两步检查
+            this._lockFd = fs.openSync(this._lockPath, 'wx');
+            fs.writeSync(this._lockFd, String(process.pid), null, 'utf8');
+            fs.fsyncSync(this._lockFd);
         } catch (e) {
-            if (e.code === 'ER_LOCK_WAIT_TIMEOUT') throw e;
+            if (e.code === 'EEXIST') {
+                try {
+                    const lockTime = fs.statSync(this._lockPath).mtimeMs;
+                    if (Date.now() - lockTime > 30000) {
+                        fs.unlinkSync(this._lockPath);
+                        this._lockFd = fs.openSync(this._lockPath, 'wx');
+                        fs.writeSync(this._lockFd, String(process.pid), null, 'utf8');
+                        fs.fsyncSync(this._lockFd);
+                        return;
+                    }
+                } catch (_) { /* ignore */ }
+                throw createError('ER_LOCK_WAIT_TIMEOUT', 'Database is locked by another process');
+            }
             // 权限不足等，降级为无锁模式
             this._fileLockEnabled = false;
+            this._lockFd = null;
         }
     }
 
@@ -606,6 +627,14 @@ class Database {
                 }
                 return true;
 
+            case 'renameTable':
+                // 重命名也要能回放：否则崩溃恢复后表名会退回去，
+                // 而后续的 insert/update 记录全都打在新名字上，全部丢失。
+                if (op.from && op.to && this._tables[op.from] && !this._tables[op.to]) {
+                    this.renameTable(op.from, op.to);
+                }
+                return true;
+
             case 'insert':
             case 'update':
             case 'remove':
@@ -705,6 +734,89 @@ class Database {
         this._runHooks('afterDropTable', [name]);
     }
 
+    /**
+     * 重命名表。
+     *
+     * 单独写成引擎方法而不是在 SQL 层拼：表名不只存在 _tables 里 ——
+     * _tableNames、db.<表名> 这个取值属性、_versions、_meta.tables（目录模式）
+     * 各自都存了一份。漏掉任何一个都会留下一张「半改名」的表：
+     * 查得到数据却列不出来，或者反过来。
+     */
+    renameTable(oldName, newName, { ifExists = false } = {}) {
+        if (oldName === newName) {
+            if (!this._tables[oldName]) {
+                if (ifExists) return false;
+                throw createError('ER_NO_SUCH_TABLE', oldName);
+            }
+            return true;   // 改成同名 = 无事发生，不算错
+        }
+        if (!this._tables[oldName]) {
+            if (ifExists) return false;
+            throw createError('ER_NO_SUCH_TABLE', oldName);
+        }
+        if (this._tables[newName] || (this._dirMode && this._meta.tables[newName])) {
+            throw createError('ER_TABLE_EXISTS_ERROR', newName);
+        }
+        if (!newName || newName.length > 64 || newName === '.' || newName === '..' ||
+            /[\x00-\x1f/\\]|\.\./.test(newName)) {
+            throw createError('ER_BAD_TABLE_NAME', newName);
+        }
+        if (!this._runHooks('beforeRenameTable', [oldName, newName])) return false;
+
+        const table = this._tables[oldName];
+
+        // 目录模式：先把物理文件挪过去。放在改动内存状态之前 ——
+        // 文件挪失败就整体放弃，不会留下内存与磁盘不一致的状态。
+        if (this._dirMode && this._meta.tables[oldName]) {
+            const meta = this._meta.tables[oldName];
+            const oldFile = meta.file;
+            const newFile = encodeURIComponent(newName) + '.jsql';
+            if (oldFile && oldFile !== newFile) {
+                const from = path.join(this._filePath, oldFile);
+                const to = path.join(this._filePath, newFile);
+                if (fs.existsSync(from)) {
+                    try { fs.renameSync(from, to); }
+                    catch (e) { throw createError('ER_FILE_NOT_FOUND', `${oldFile} → ${newFile}: ${e.message}`); }
+                }
+                meta.file = newFile;
+            }
+        }
+
+        delete this._tables[oldName];
+        table._name = newName;
+        this._tables[newName] = table;
+
+        this._tableNames.delete(oldName);
+        this._tableNames.add(newName);
+
+        delete this[oldName];
+        Object.defineProperty(this, newName, {
+            get: () => this._ensureTable(newName) || this._tables[newName],
+            enumerable: true,
+            configurable: true
+        });
+
+        if (this._versioning && this._versions[oldName]) {
+            this._versions[newName] = this._versions[oldName];
+            delete this._versions[oldName];
+        }
+        if (this._dirMode && this._meta.tables[oldName]) {
+            const meta = this._meta.tables[oldName];
+            delete this._meta.tables[oldName];
+            this._meta.tables[newName] = meta;
+            this._dirtyTables.delete(oldName);
+            this._dirtyTables.add(newName);
+            this._saveMeta();
+        }
+
+        this._dirtyTables.delete(oldName);
+        this._markDirty(newName);
+        this._walWrite({ op: 'renameTable', from: oldName, to: newName });
+        this._emit('renameTable', { from: oldName, to: newName });
+        this._runHooks('afterRenameTable', [oldName, newName]);
+        return true;
+    }
+
     hasTable(name) {
         return !!this._tables[name] || (this._dirMode && !!this._meta.tables[name]);
     }
@@ -1085,6 +1197,83 @@ class Database {
     // 事务（支持隔离级别）
     // ============================================================
 
+    // ============================================================
+    // 事务（支持隔离级别）与保存点
+    // ============================================================
+
+    /**
+     * 抓一份「所有表」的快照。
+     *
+     * 形状与 beginTx 的 _txSnapshot 一致（表名 → {rows, schema}），
+     * 让「事务开始」「保存点」「两种回滚」共用同一套还原逻辑。
+     *
+     * 必须是深拷贝：行里可能含嵌套对象/数组，浅拷贝的话回滚之后
+     * 调用方手里的引用仍指向已被改动的数据。
+     */
+    _captureTxSnapshot() {
+        const snap = {};
+        for (const [name, table] of Object.entries(this._tables)) {
+            snap[name] = {
+                rows: JSON.parse(JSON.stringify(table.toJSON())),
+                schema: table._schema,
+                // 自增计数器也要存：否则回滚掉刚插入的行之后，
+                // 下一次插入会跳过已用过的号（用户看到 id 从 2 开始会困惑）。
+                // 原有 rollback() 一直是这么做的，保存点保持一致。
+                autoIncrement: table._autoIncrement
+            };
+        }
+        return snap;
+    }
+
+    /**
+     * 把数据还原到某个快照。
+     *
+     * 还原时**再深拷贝一次**是关键：同一个保存点可以被 ROLLBACK TO 多次，
+     * 若把快照里的数组直接交给表，后续写入会改坏快照本身，
+     * 第二次回滚拿到的就不是最初的状态了。
+     *
+     * 快照里没有的表要删掉 —— 否则「保存点之后才建的表」会残留，
+     * 回滚完却多出一张当时并不存在的表。
+     */
+    _restoreTxSnapshot(snap) {
+        if (!snap) return;
+        for (const name of Object.keys(this._tables)) {
+            if (!snap[name]) delete this._tables[name];
+        }
+        for (const [name, entry] of Object.entries(snap)) {
+            const rows = JSON.parse(JSON.stringify(entry.rows));
+            let table = this._tables[name];
+            if (!table) {
+                table = new Table(name, entry.schema, this);
+                this._tables[name] = table;
+            }
+            table._loadRows(rows);
+            // _loadRows 只会把计数器往上抬（取现有行的最大值），
+            // 所以「回滚掉刚插入的行」之后还得显式退回去。
+            if (entry.autoIncrement !== undefined) {
+                table._autoIncrement = entry.autoIncrement;
+            }
+        }
+        this._dirty = true;
+    }
+
+    /**
+     * 是否有进行中的事务。
+     *
+     * 引擎里有两条事务实现路径：begin/commit/rollback 与
+     * beginTx/commitTx/rollbackTx。SQL 层走后者（因为 Database.beginTx 存在），
+     * 直接调 API 走前者 —— 保存点必须对两条都有效，所以这里两条都算。
+     */
+    hasActiveTx() {
+        return (this._txId !== undefined && !!this._txSnapshot) || !!this._transaction;
+    }
+
+    /** 保存点栈（懒建），随事务结束清空 */
+    _savepointStackRef() {
+        if (!this._savepointStack) this._savepointStack = [];
+        return this._savepointStack;
+    }
+
     /**
      * 开始事务
      * @param {string} isolationLevel - 覆盖默认隔离级别（可选）
@@ -1095,7 +1284,7 @@ class Database {
         const level = isolationLevel || this._isolationLevel;
 
         this._transaction = {
-            rows: {},
+            snapshot: null,
             autoIncrements: {},
             level,
             startedAt: Date.now()
@@ -1103,10 +1292,7 @@ class Database {
 
         if (level === 'REPEATABLE_READ') {
             // 快照：保存当前所有数据（深拷贝，保证嵌套对象可回滚）
-            for (const [name, table] of Object.entries(this._tables)) {
-                this._transaction.rows[name] = JSON.parse(JSON.stringify(table._rows));
-                this._transaction.autoIncrements[name] = table._autoIncrement;
-            }
+            this._transaction.snapshot = this._captureTxSnapshot();
         } else {
             // READ_COMMITTED：只保存 autoIncrement
             for (const [name, table] of Object.entries(this._tables)) {
@@ -1114,35 +1300,120 @@ class Database {
             }
         }
 
+        this._savepointStack = [];
         this._walWrite({ op: 'begin', level });
     }
 
     commit() {
         if (!this._transaction) throw createError('ER_NO_TRANSACTION');
         this._walWrite({ op: 'commit', at: this._transaction.startedAt });
+        // 提交即释放全部保存点 —— 它们随事务一起结束
         this._transaction = null;
-        this._checkpoint();
+        this._savepointStack = [];
+        // 不在此处调用 _checkpoint()：_checkpoint() 清空 WAL，但数据可能还未保存。
+        // save() 内部会在保存完成后自动调用 _checkpoint()。
         this._markDirtyLegacy();
     }
 
     rollback() {
         if (!this._transaction) throw createError('ER_NO_TRANSACTION');
 
-        for (const [name, table] of Object.entries(this._tables)) {
-            if (this._transaction.rows[name]) {
-                table._rows = this._transaction.rows[name];
-                table._autoIncrement = this._transaction.autoIncrements[name];
-                table._rebuildAllBTrees();
-                for (const field of Object.keys(table._indexes)) {
-                    table.createIndex(field);
-                }
-            } else if (this._transaction.autoIncrements[name] !== undefined) {
-                table._autoIncrement = this._transaction.autoIncrements[name];
+        if (this._transaction.snapshot) {
+            this._restoreTxSnapshot(this._transaction.snapshot);
+        } else {
+            // READ_COMMITTED：没有行快照，只能退回自增值
+            for (const [name, table] of Object.entries(this._tables)) {
+                const v = this._transaction.autoIncrements[name];
+                if (v !== undefined) table._autoIncrement = v;
             }
         }
 
         this._walWrite({ op: 'rollback', at: this._transaction.startedAt });
         this._transaction = null;
+        this._savepointStack = [];
+        this._markDirtyLegacy();
+    }
+
+    // ============================================================
+    // 保存点（SAVEPOINT / ROLLBACK TO / RELEASE）
+    // ============================================================
+
+    /**
+     * 建立一个保存点。
+     *
+     * 语义遵循 SQL 标准：
+     *   - 只在事务内有效，COMMIT / ROLLBACK 时全部释放
+     *   - 同名保存点覆盖旧的（Postgres 行为），它之后的保存点一并作废
+     *   - ROLLBACK TO 之后该保存点**仍然存在**，可以再回滚一次
+     *
+     * 保存点一律做全量行快照，不看隔离级别 —— 保存点的全部意义就是精确还原，
+     * READ_COMMITTED 下若只记自增值，「回滚成功」就是假的。
+     */
+    savepoint(name) {
+        if (!this.hasActiveTx()) {
+            throw errorWithHint('ER_NO_TRANSACTION',
+                `SAVEPOINT '${name}' requires an active transaction (run BEGIN first)`);
+        }
+        const sp = String(name == null ? '' : name).trim();
+        if (!sp) throw errorWithHint('ER_PARSE_ERROR', 'Savepoint name cannot be empty');
+
+        const list = this._savepointStackRef();
+        // 同名覆盖：丢掉它以及它之后的所有保存点
+        const dup = list.findIndex(s => s.name.toLowerCase() === sp.toLowerCase());
+        if (dup >= 0) list.length = dup;
+
+        list.push({ name: sp, snap: this._captureTxSnapshot(), at: Date.now() });
+        return list.length;
+    }
+
+    /**
+     * 回滚到某个保存点，事务本身继续有效。
+     * 该保存点保留（可再次回滚到它），它之后建立的保存点全部丢弃。
+     */
+    rollbackTo(name) {
+        const list = this._requireSavepoints(name, 'ROLLBACK TO SAVEPOINT');
+        const idx = this._findSavepoint(list, name);
+        this._restoreTxSnapshot(list[idx].snap);
+        list.length = idx + 1;
+        this._walWrite({ op: 'rollbackTo', name });
+        this._markDirtyLegacy();
+        return list.length;
+    }
+
+    /** 释放保存点：它和它之后的都作废，但不还原数据 */
+    releaseSavepoint(name) {
+        const list = this._requireSavepoints(name, 'RELEASE SAVEPOINT');
+        const idx = this._findSavepoint(list, name);
+        list.length = idx;
+        return list.length;
+    }
+
+    /** 当前事务里的保存点名（由外到内） */
+    listSavepoints() {
+        if (!this.hasActiveTx()) return [];
+        return this._savepointStackRef().map(s => s.name);
+    }
+
+    _requireSavepoints(name, op) {
+        if (!this.hasActiveTx()) {
+            throw errorWithHint('ER_NO_TRANSACTION',
+                `${op} '${name}' requires an active transaction (run BEGIN first)`);
+        }
+        return this._savepointStackRef();
+    }
+
+    _findSavepoint(list, name) {
+        const sp = String(name == null ? '' : name).toLowerCase();
+        const idx = list.findIndex(s => s.name.toLowerCase() === sp);
+        if (idx < 0) {
+            const known = list.map(s => s.name).join(', ') || '(none)';
+            // 用 MySQL 的错误码 1305（SAVEPOINT xxx does not exist），
+            // 后面补上已定义的保存点，省得用户回头翻代码
+            const base = ErrorCodes.ER_SP_DOES_NOT_EXIST.msg.replace('%s', String(name));
+            throw new JSQL_Error(ErrorCodes.ER_SP_DOES_NOT_EXIST.code,
+                `${base} (defined savepoints: ${known})`, { codeKey: 'ER_SP_DOES_NOT_EXIST' });
+        }
+        return idx;
     }
 
     inTransaction() {
@@ -1385,6 +1656,13 @@ class Database {
         if (Database._signalDBs) Database._signalDBs.delete(db);
     }
 
+    /** 公开别名 */
+    static removeSignalHandler(db) {
+        if (Database._signalDBs) {
+            Database._signalDBs.delete(db);
+        }
+    }
+
     insert(tableName, data) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
@@ -1435,6 +1713,8 @@ class Database {
         let rows = table._applyFilterOptimized(table._rows, filter || {});
         if (limit > 0) rows = rows.slice(offset, offset + limit);
         else if (offset > 0) rows = rows.slice(offset);
+        // P1-11: 返回浅拷贝，防止调用方修改影响内部数据
+        rows = rows.map(r => ({ ...r }));
         this._touchTable(tableName);
         this._runHooks('afterFind', [tableName, { filter, opts }, rows]);
         return rows;
@@ -1464,16 +1744,19 @@ 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-11: 返回浅拷贝，防止调用方修改影响内部数据
+        const result = row ? { ...row } : null;
         this._touchTable(tableName);
-        this._runHooks('afterFind', [tableName, { id }, row]);
-        return row;
+        this._runHooks('afterFind', [tableName, { id }, result]);
+        return result;
     }
 
     findByIds(tableName, ids) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
         if (!this._runHooks('beforeFind', [tableName, { ids }])) return null;
-        const rows = ids.map(id => this._resolveId(table, id)).filter(r => r !== null);
+        // P1-11: 返回浅拷贝
+        const rows = ids.map(id => this._resolveId(table, id)).filter(r => r !== null).map(r => ({ ...r }));
         this._touchTable(tableName);
         this._runHooks('afterFind', [tableName, { ids }, rows]);
         return rows;
@@ -1497,6 +1780,8 @@ class Database {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
         if (!this._runHooks('beforeUpdate', [tableName, id, data])) return;
+        // P1-9: updateById 绕过类型校验——先校验再更新
+        const validated = table._validateDataTypes({ ...data }, true);
         const row = this._resolveId(table, id);
         if (!row) return { ok: false, error: 'not found' };
         // 改主键/唯一列时要先确认新值不与其它行冲突。
@@ -1509,16 +1794,16 @@ class Database {
         const pk = this._pkOf(table);
         const uniq = (table._cachedUniqueFields || []).filter(f => f !== pk);
         for (const field of [pk, ...uniq]) {
-            if (!field || !Object.prototype.hasOwnProperty.call(data, field)) continue;
-            const nv = data[field];
+            if (!field || !Object.prototype.hasOwnProperty.call(validated, field)) continue;
+            const nv = validated[field];
             if (nv === row[field]) continue;          // 值没变，不算冲突
             const clash = table._rows.find(r => r !== row && r[field] === nv);
             if (clash) throw createError('ER_DUP_ENTRY', `Duplicate entry '${nv}' for key '${field}'`);
         }
-        Object.assign(row, data);
-        if (pk) this._walWrite({ op: 'update', table: tableName, pk, id, row: { ...data } });
-        this._emit('update', { table: tableName, id, data });
-        this._runHooks('afterUpdate', [tableName, id, data, { ok: true }]);
+        Object.assign(row, validated);
+        if (pk) this._walWrite({ op: 'update', table: tableName, pk, id, row: { ...validated } });
+        this._emit('update', { table: tableName, id, data: validated });
+        this._runHooks('afterUpdate', [tableName, id, validated, { ok: true }]);
         this._markDirty(tableName);
         return { ok: true };
     }
@@ -1627,6 +1912,10 @@ class Database {
         const arr = Array.isArray(items) ? items : [items];
         if (!this._runHooks('beforeInsert', [tableName, arr])) return [];
         const inserted = table.insertMany(arr);
+        // P1-6: insertMany 不写 WAL——崩溃恢复时丢失这些操作
+        if (table._primaryKey && inserted.length > 0) {
+            this._walWrite({ op: 'insert', table: tableName, rows: inserted });
+        }
         this._emit('insert', { table: tableName, count: arr.length });
         this._runHooks('afterInsert', [tableName, arr, inserted]);
         this._markDirty(tableName);
@@ -1638,6 +1927,14 @@ class Database {
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
         if (!this._runHooks('beforeUpdate', [tableName, query, updates])) return 0;
         const count = table.update(query, updates);
+        // P1-6: update 不写 WAL——崩溃恢复时丢失这些操作
+        if (table._primaryKey && count > 0) {
+          const updatedRows = table.find(query);
+          for (const row of updatedRows) {
+            const id = row[table._primaryKey];
+            if (id !== undefined) this._walWrite({ op: 'update', table: tableName, pk: table._primaryKey, id, row: { ...row } });
+          }
+        }
         this._emit('update', { table: tableName, query, count });
         this._runHooks('afterUpdate', [tableName, query, updates, count]);
         this._markDirty(tableName);
@@ -1648,6 +1945,14 @@ class Database {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
         if (!this._runHooks('beforeDelete', [tableName, query])) return 0;
+        // P1-6: delete 不写 WAL——崩溃恢复时丢失这些操作
+        if (table._primaryKey) {
+          const toDelete = table.find(query);
+          for (const row of toDelete) {
+            const id = row[table._primaryKey];
+            if (id !== undefined) this._walWrite({ op: 'remove', table: tableName, pk: table._primaryKey, id });
+          }
+        }
         const count = table.remove(query);
         this._emit('delete', { table: tableName, query, count });
         this._runHooks('afterDelete', [tableName, query, count]);
@@ -1658,6 +1963,14 @@ class Database {
     truncate(tableName) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
+        // P1-6: truncate 不写 WAL——崩溃恢复时丢失这些操作
+        if (table._primaryKey) {
+          const toDelete = table.find({});
+          for (const row of toDelete) {
+            const id = row[table._primaryKey];
+            if (id !== undefined) this._walWrite({ op: 'remove', table: tableName, pk: table._primaryKey, id });
+          }
+        }
         const count = table.truncate();
         this._emit('delete', { table: tableName, count });
         this._markDirty(tableName);
@@ -1834,6 +2147,12 @@ class Database {
             return;
         }
 
+            // P1-10: WAL-only 恢复 —— 主库文件不存在时跳过读取，直接恢复 WAL
+            if (!fs.existsSync(this._filePath)) {
+                this._recoverFromWAL();
+                return;
+            }
+
             const json = this._readFile(this._filePath);
             const data = JSON.parse(json);
 
@@ -1892,6 +2211,11 @@ class Database {
         }
         if (this._jsqlFormat) this._jsqlFormat._close();
         this._releaseLock();
+        // Bug 3: 清理静态信号处理器，防止关闭后还在响应信号
+        if (this._sigInstalled) {
+            this._sigInstalled = false;
+            Database.removeSignalHandler(this);
+        }
         this._tables = {};
     }
 
@@ -1915,10 +2239,10 @@ class Database {
     }
 
     async beginTx() {
-        this._txSnapshot = {};
-        for (const [name, table] of Object.entries(this._tables)) {
-            this._txSnapshot[name] = { rows: JSON.parse(JSON.stringify(table.toJSON())), schema: table._schema };
-        }
+        this._savepointStack = [];
+        // 与保存点共用同一套快照函数，两边形状必须一致，
+        // 否则 rollbackTx 还原不了保存点存下来的快照（反之亦然）。
+        this._txSnapshot = this._captureTxSnapshot();
         this._txId = (this._txId || 0) + 1;
         return this._txId;
     }
@@ -1926,6 +2250,7 @@ class Database {
     async commitTx() {
         this._txSnapshot = null;
         this._txId = undefined;
+        this._savepointStack = [];   // 提交即释放全部保存点
         if (this._dirMode) {
             try { this._flushDirty(); } catch (e) {}
         } else if (!this._memoryMode) {
@@ -1937,20 +2262,9 @@ class Database {
         const snap = this._txSnapshot;
         this._txSnapshot = null;
         this._txId = undefined;
+        this._savepointStack = [];
         if (!snap) return;
-        for (const name of Object.keys(this._tables)) {
-            if (!snap[name]) delete this._tables[name];
-        }
-        for (const [name, entry] of Object.entries(snap)) {
-            if (this._tables[name]) {
-                this._tables[name]._loadRows(entry.rows);
-            } else {
-                const table = new Table(name, entry.schema, this);
-                table._loadRows(entry.rows);
-                this._tables[name] = table;
-            }
-        }
-        this._dirty = true;
+        this._restoreTxSnapshot(snap);
     }
 
     // ============================================================