jsql-neo 3.5.2 → 4.0.0

package/lib/database.js

@@ -6,6 +6,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const crypto = require('crypto');
 const Table = require('./table');
 const { createError } = require('./errors');
@@ -13,11 +14,19 @@ const JSQLFormat = require('./jsql_format');
 
 class Database {
     /**
-     * @param {string} filePath - 数据库文件路径，传 null 或 ':memory:' 使用内存模式
+     * @param {string} filePath - 数据库文件/目录路径，传 null 或 ':memory:' 使用内存模式
      * @param {object} options
-     * @param {boolean} options.autoSave - 是否自动保存（默认 true）
-     * @param {number} options.autoSaveInterval - 自动保存间隔 ms（默认 0）
-     * @param {boolean} options.pretty - JSON 是否格式化（默认 true）
+     * @param {string} options.mode - 存储模式：
+     *   'memory'（默认）：纯内存，不落盘
+     *   'hybrid'（混合，Redis 式）：先写内存，后台异步慢慢刷盘；内存充足（默认预留 0.5GB 余量）
+     *     则数据常驻内存作为缓存；内存紧张时按 LRU 驱逐最冷表（已落盘），查询时自动从磁盘加载
+     *   'disk'（磁盘模式）：写入后尽快刷盘，内存只做读写缓存
+     * @param {number} options.memReserveMB - 内存余量 MB（默认 512，即预留 0.5GB）
+     * @param {number} options.flushInterval - 脏表后台刷盘间隔 ms（默认 hybrid 200 / disk 50，0 = 每次写后立即刷）
+     * @param {number} options.evictInterval - 内存压力检查间隔 ms（默认 1000）
+     * @param {boolean} options.autoSave - 是否自动保存（默认 true，仅旧文件模式）
+     * @param {number} options.autoSaveInterval - 自动保存间隔 ms（默认 0，仅旧文件模式）
+     * @param {boolean} options.pretty - JSON 是否格式化（默认 true，仅旧文件模式）
      * @param {string} options.encryptKey - 加密密钥（16/24/32 字节），启用 AES-256-CBC
      * @param {boolean} options.versioning - 是否启用版本历史（默认 false）
      * @param {boolean} options.wal - 是否启用 WAL 模式（默认 false，内存模式自动禁用）
@@ -33,6 +42,21 @@ class Database {
             autoSaveInterval: options.autoSaveInterval || 0,
             pretty: options.pretty !== false
         };
+
+        // 存储模式: 'memory' | 'hybrid' | 'disk' | null(旧文件模式: 全量 save)
+        this._mode = options.mode || (this._memoryMode ? 'memory' : null);
+        this._dirMode = this._mode === 'hybrid' || this._mode === 'disk';
+        this._memReserve = (options.memReserveMB !== undefined ? options.memReserveMB : 512) * 1024 * 1024;
+        this._flushInterval = options.flushInterval !== undefined
+            ? options.flushInterval
+            : (this._mode === 'disk' ? 50 : 200);
+        this._evictInterval = options.evictInterval !== undefined ? options.evictInterval : 1000;
+        this._dirtyTables = new Set();
+        this._flushTimer = null;
+        this._monitorTimer = null;
+        this._lastAccess = {};
+        this._meta = { version: 1, tables: {} };
+
         this._tables = {};
         this._dirty = false;
         this._autoSaveTimer = null;
@@ -43,6 +67,19 @@ class Database {
         this._versions = {};       // tableName -> [{ rows, timestamp }]
         this._maxVersions = options.maxVersions || 50;
         this._plugins = [];
+        this._hooks = {
+            beforeInsert: [], afterInsert: [],
+            beforeUpdate: [], afterUpdate: [],
+            beforeDelete: [], afterDelete: [],
+            beforeFind: [], afterFind: [],
+            beforeCreateTable: [], afterCreateTable: [],
+            beforeDropTable: [], afterDropTable: [],
+            beforeFlush: [], afterFlush: [],
+            beforeCount: [], afterCount: [],
+            onStart: [], onStop: []
+        };
+        this._eventListeners = [];
+        this._tableNames = new Set(Object.keys(this._tables));
         this._migrations = [];
         this._observers = [];      // 响应式观察者
         this._views = {};           // 视图 { name: { query, table } }
@@ -72,12 +109,158 @@ class Database {
         this._slowQueries = [];
 
         // 从文件加载
-        if (!this._memoryMode && fs.existsSync(this._filePath)) {
+        if (!this._memoryMode && !this._dirMode && fs.existsSync(this._filePath)) {
             this._loading = true;
             this._acquireLock();
             this._load();
             this._loading = false;
         }
+
+        // 磁盘/混合模式: 目录存储（每表独立 JSql 文件，增量刷盘）
+        if (this._dirMode) {
+            this._initDirStore();
+        }
+    }
+
+    // ============================================================
+    // 磁盘/混合存储（Redis 式: 内存缓存 + 异步刷盘 + LRU 驱逐）
+    // ============================================================
+
+    _initDirStore() {
+        if (!this._filePath) throw new Error('hybrid/disk mode requires a directory path');
+        fs.mkdirSync(this._filePath, { recursive: true });
+        this._metaPath = path.join(this._filePath, 'meta.json');
+        this._meta = { version: 1, tables: {} };
+        try {
+            if (fs.existsSync(this._metaPath)) {
+                const parsed = JSON.parse(fs.readFileSync(this._metaPath, 'utf8'));
+                if (parsed && parsed.tables) this._meta = parsed;
+            }
+        } catch (e) {
+            this._meta = { version: 1, tables: {} };
+        }
+        this._startMonitor();
+    }
+
+    _tableFile(name) {
+        const meta = this._meta.tables[name];
+        if (meta && meta.file) return path.join(this._filePath, meta.file);
+        return path.join(this._filePath, encodeURIComponent(name) + '.jsql');
+    }
+
+    _saveMeta() {
+        if (!this._dirMode) return;
+        try {
+            fs.writeFileSync(this._metaPath, JSON.stringify(this._meta, null, 2), 'utf8');
+        } catch (e) {
+            // 忽略 meta 写入失败
+        }
+    }
+
+    _touchTable(name) {
+        this._lastAccess[name] = Date.now();
+    }
+
+    _ensureTable(name) {
+        if (this._tables[name]) return this._tables[name];
+        if (!this._dirMode) return null;
+        const meta = this._meta.tables[name];
+        if (!meta) return null;
+        const file = path.join(this._filePath, meta.file);
+        if (!fs.existsSync(file)) return null;
+        try {
+            const fmt = new JSQLFormat(file);
+            const { rows } = fmt.readTableSync(name);
+            const table = new Table(name, meta.schema, this);
+            if (rows && rows.length > 0) table._loadRows(rows);
+            this._tables[name] = table;
+            if (this._versioning) this._versions[name] = [];
+            this._touchTable(name);
+            return table;
+        } catch (e) {
+            return null;
+        }
+    }
+
+    _markDirty(name) {
+        if (!this._dirMode) {
+            this._dirty = true;
+            return;
+        }
+        this._touchTable(name);
+        this._dirtyTables.add(name);
+        this._scheduleFlush();
+    }
+
+    _scheduleFlush() {
+        if (this._flushTimer) return;
+        if (this._flushInterval <= 0) {
+            this._flushTimer = setImmediate(() => {
+                this._flushTimer = null;
+                try { this._flushDirty(); } catch (e) {}
+            });
+            return;
+        }
+        this._flushTimer = setTimeout(() => {
+            this._flushTimer = null;
+            try { this._flushDirty(); } catch (e) {}
+        }, this._flushInterval);
+        if (this._flushTimer.unref) this._flushTimer.unref();
+    }
+
+    _flushDirty() {
+        if (!this._dirMode || this._dirtyTables.size === 0) return;
+        const names = [...this._dirtyTables];
+        this._dirtyTables.clear();
+        for (const name of names) this._flushTable(name);
+        this._saveMeta();
+    }
+
+    _flushTable(name) {
+        const table = this._tables[name];
+        if (!table) return;
+        const meta = this._meta.tables[name];
+        let file = meta && meta.file ? meta.file : encodeURIComponent(name) + '.jsql';
+        const fmt = new JSQLFormat(path.join(this._filePath, file));
+        try {
+            const pkField = Object.keys(table._schema).find(f => table._schema[f].primaryKey) || null;
+            fmt.writeTable(name, table._schema, table._rows, pkField);
+            this._meta.tables[name] = { file, schema: table._schema };
+        } finally {
+            fmt._close();
+        }
+    }
+
+    _startMonitor() {
+        if (this._monitorTimer) return;
+        this._monitorTimer = setInterval(() => {
+            try { this._checkMemory(); } catch (e) {}
+        }, this._evictInterval);
+        if (this._monitorTimer.unref) this._monitorTimer.unref();
+    }
+
+    _checkMemory() {
+        const total = os.totalmem();
+        if (!total) return;
+        const budget = total - this._memReserve;
+        if (budget <= 0) return;
+        const rss = process.memoryUsage().rss;
+        if (rss <= budget) return;
+        this._evictTables(budget);
+    }
+
+    _evictTables(budget) {
+        const candidates = Object.keys(this._tables)
+            .filter(n => n !== '__meta__' && !this._versioning && this._meta.tables[n]);
+        candidates.sort((a, b) => (this._lastAccess[a] || 0) - (this._lastAccess[b] || 0));
+        for (const name of candidates) {
+            if (budget !== undefined && process.memoryUsage().rss <= budget) break;
+            try { this._flushTable(name); } catch (e) { continue; }
+            delete this._tables[name];
+            delete this[name];
+            this._dirtyTables.delete(name);
+        }
+        this._saveMeta();
     }
 
     // ============================================================
@@ -191,14 +374,21 @@ class Database {
     // ============================================================
 
     createTable(name, schema) {
-        if (this._tables[name]) {
+        if (!this._runHooks('beforeCreateTable', [name, schema])) throw createError('ER_PLUGIN_ABORT', 'createTable aborted by plugin');
+        if (this._tables[name] || (this._dirMode && this._meta.tables[name])) {
             throw createError('ER_TABLE_EXISTS_ERROR', name);
         }
-        const table = new Table(name, schema, this);
+        const normalized = {};
+        for (const [field, def] of Object.entries(schema || {})) {
+            if (typeof def === 'string') normalized[field] = { type: def.toLowerCase() };
+            else normalized[field] = def;
+        }
+        const table = new Table(name, normalized, this);
         this._tables[name] = table;
+        this._tableNames.add(name);
 
         Object.defineProperty(this, name, {
-            get: () => this._tables[name],
+            get: () => this._ensureTable(name) || this._tables[name],
             enumerable: true,
             configurable: true
         });
@@ -206,27 +396,59 @@ class Database {
         if (this._versioning) {
             this._versions[name] = [];
         }
+        if (this._dirMode) {
+            this._meta.tables[name] = { file: encodeURIComponent(name) + '.jsql', schema: normalized };
+            this._saveMeta();
+        }
 
-        this._markDirty();
+        this._markDirty(name);
         this._walWrite({ op: 'createTable', table: name, schema });
+        this._emit('createTable', { name, schema });
+        this._runHooks('afterCreateTable', [name, schema]);
         return table;
     }
 
     dropTable(name) {
-        if (!this._tables[name]) throw createError('ER_NO_SUCH_TABLE', name);
-        delete this._tables[name];
+        if (!this._tables[name] && !(this._dirMode && this._meta.tables[name])) throw createError('ER_NO_SUCH_TABLE', name);
+        if (!this._runHooks('beforeDropTable', [name])) return;
+        if (this._tables[name]) {
+            delete this._tables[name];
+        }
         delete this[name];
         delete this._versions[name];
+        this._tableNames.delete(name);
+        if (this._dirMode) {
+            const meta = this._meta.tables[name];
+            if (meta && meta.file) {
+                try { fs.unlinkSync(path.join(this._filePath, meta.file)); } catch (e) {}
+            }
+            delete this._meta.tables[name];
+            this._dirtyTables.delete(name);
+            this._saveMeta();
+        }
         this._walWrite({ op: 'dropTable', table: name });
-        this._markDirty();
+        this._markDirty(name);
+        this._emit('dropTable', { name });
+        this._runHooks('afterDropTable', [name]);
     }
 
     hasTable(name) {
-        return !!this._tables[name];
+        return !!this._tables[name] || (this._dirMode && !!this._meta.tables[name]);
     }
 
     getTables() {
-        return Object.keys(this._tables);
+        const names = new Set(Object.keys(this._tables));
+        if (this._dirMode) {
+            for (const name of Object.keys(this._meta.tables)) names.add(name);
+        }
+        return [...names];
+    }
+
+    getTableSchema(name) {
+        const table = this._ensureTable(name);
+        if (table) return table._schema;
+        if (this._dirMode && this._meta.tables[name]) return this._meta.tables[name].schema;
+        return null;
     }
 
     // ============================================================
@@ -285,7 +507,7 @@ class Database {
      */
     createTrigger(name, options, callback) {
         if (this._triggers[name]) throw createError('ER_TRIGGER_EXISTS', name);
-        const table = this._tables[options.table];
+        const table = this._ensureTable(options.table);
         if (!table) throw createError('ER_NO_SUCH_TABLE', options.table);
 
         const hookName = options.timing + options.event.charAt(0).toUpperCase() + options.event.slice(1);
@@ -296,7 +518,7 @@ class Database {
     dropTrigger(name) {
         const trigger = this._triggers[name];
         if (!trigger) throw createError('ER_TRIGGER_NOT_FOUND', name);
-        const table = this._tables[trigger.table];
+        const table = this._ensureTable(trigger.table);
         if (table) table.off(trigger.hookName, trigger.callback);
         delete this._triggers[name];
     }
@@ -320,7 +542,7 @@ class Database {
      * @param {object} options - { delimiter: ',', hasHeader: true, skipRows: 0, mapping: { csvCol: schemaCol } }
      */
     importCSV(filePath, tableName, options = {}) {
-        const table = this._tables[tableName];
+        const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
 
         const delimiter = options.delimiter || ',';
@@ -375,7 +597,7 @@ class Database {
      * 导出表数据到 CSV 文件
      */
     exportCSV(filePath, tableName, query = {}, options = {}) {
-        const table = this._tables[tableName];
+        const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
 
         const delimiter = options.delimiter || ',';
@@ -627,7 +849,7 @@ class Database {
         this._walWrite({ op: 'commit', at: this._transaction.startedAt });
         this._transaction = null;
         this._checkpoint();
-        this._markDirty();
+        this._markDirtyLegacy();
     }
 
     rollback() {
@@ -708,7 +930,7 @@ class Database {
         if (!this._versioning) throw createError('ER_NOT_SUPPORTED', 'Versioning is not enabled');
         const versions = this._versions[tableName];
         if (!versions || versions.length < 2) throw createError('ER_NOT_SUPPORTED', 'No versions to undo');
-        const table = this._tables[tableName];
+        const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
 
         for (let i = 0; i < steps && versions.length > 1; i++) {
@@ -727,7 +949,7 @@ class Database {
             }
         }
         this._walWrite({ op: 'undo', table: tableName, steps });
-        this._markDirty();
+        this._markDirtyLegacy();
         return versions.length;
     }
 
@@ -793,14 +1015,243 @@ class Database {
 
     /**
      * 注册插件
-     * @param {object} plugin - { name, install(db) }
+     * @param {object|function} plugin - { name, install(db, ctx), hooks, onEvent } 或函数 (作为 install)
      */
     use(plugin) {
-        if (typeof plugin.install !== 'function') {
-            throw createError('ER_PLUGIN_INVALID', 'Plugin must have an install() method');
+        if (typeof plugin === 'function') {
+            plugin = { install: plugin };
+        }
+        if (plugin.hooks) {
+            for (const [event, fn] of Object.entries(plugin.hooks)) {
+                if (this._hooks[event]) {
+                    this._hooks[event].push(fn);
+                }
+            }
+        }
+        if (typeof plugin.install === 'function') {
+            plugin.install(this, this._buildCtx(plugin));
+        }
+        if (typeof plugin.onEvent === 'function') {
+            this._eventListeners.push(plugin.onEvent);
         }
         this._plugins.push(plugin);
-        plugin.install(this);
+        return this;
+    }
+
+    _buildCtx(plugin) {
+        const self = this;
+        return {
+            name: plugin.name || 'anonymous',
+            engine: this,
+            plugin,
+            on(hook, fn) { return self.on(hook, fn); },
+            onEvent(fn) { return self.onEvent(fn); },
+            emit(eventName, data) { self._emit(eventName, data); },
+            tables() { return Array.from(self._tableNames); },
+            hasTable(name) { return self._tableNames.has(name); },
+            getTableSchema(name) {
+                const t = self._tables[name];
+                return t ? t._schema : null;
+            },
+            table(name) { return self._tables[name] || null; }
+        };
+    }
+
+    on(event, fn) {
+        if (this._hooks[event]) {
+            this._hooks[event].push(fn);
+        }
+        return this;
+    }
+
+    onEvent(fn) {
+        this._eventListeners.push(fn);
+        return this;
+    }
+
+    _emit(eventName, data) {
+        for (const fn of this._eventListeners) {
+            try { fn(eventName, data); } catch (e) { /* ignore */ }
+        }
+    }
+
+    _runHooks(hookName, args) {
+        const hooks = this._hooks[hookName];
+        if (!hooks || hooks.length === 0) return true;
+        for (const fn of hooks) {
+            const r = fn(...args);
+            if (r === false) return false;
+            if (r !== undefined && args.length > 0) {
+                args[0] = r;
+            }
+        }
+        return true;
+    }
+
+    // ============================================================
+    // 统一高层 API（与 Native/WASM 引擎对齐）
+    // ============================================================
+
+    _pkOf(table) {
+        return table._primaryKey || table._autoIncrementField || null;
+    }
+
+    async start() {
+        this._runHooks('onStart', []);
+        this._emit('start', {});
+        return this;
+    }
+
+    insert(tableName, data) {
+        const table = this._ensureTable(tableName);
+        if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
+        const arr = Array.isArray(data) ? data : [data];
+        if (!this._runHooks('beforeInsert', [tableName, arr])) return [];
+        const pk = this._pkOf(table);
+        const ids = [];
+        for (const row of arr) {
+            const r = table.insert(row);
+            ids.push(pk ? r[pk] : (table._rows.indexOf(r) + 1));
+        }
+        this._emit('insert', { table: tableName, count: arr.length, ids });
+        this._runHooks('afterInsert', [tableName, arr, ids]);
+        this._markDirty(tableName);
+        return ids;
+    }
+
+    async flush() {
+        if (!this._runHooks('beforeFlush', [])) return;
+        if (this._dirMode) {
+            this._flushDirty();
+            this._saveMeta();
+        } else if (!this._memoryMode) {
+            this.save();
+        }
+        this._runHooks('afterFlush', []);
+        return this;
+    }
+
+    _resolveId(table, id) {
+        const pk = this._pkOf(table);
+        if (pk) return table._rows.find(r => r[pk] === id) || null;
+        return table._rows[id - 1] || null;
+    }
+
+    find(tableName, filter, opts = {}) {
+        const table = this._ensureTable(tableName);
+        if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
+        if (!this._runHooks('beforeFind', [tableName, { filter, opts }])) return [];
+        const { limit = 100, offset = 0 } = opts;
+        let rows = table._applyFilter(table._rows, filter || {});
+        rows = rows.slice(offset, offset + limit);
+        this._touchTable(tableName);
+        this._runHooks('afterFind', [tableName, { filter, opts }, rows]);
+        return rows;
+    }
+
+    findById(tableName, id) {
+        const table = this._ensureTable(tableName);
+        if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
+        if (!this._runHooks('beforeFind', [tableName, { id }])) return null;
+        const row = this._resolveId(table, id);
+        this._touchTable(tableName);
+        this._runHooks('afterFind', [tableName, { id }, row]);
+        return row;
+    }
+
+    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);
+        this._touchTable(tableName);
+        this._runHooks('afterFind', [tableName, { ids }, rows]);
+        return rows;
+    }
+
+    findByIdsRaw(tableName, ids) {
+        return this.findByIds(tableName, ids);
+    }
+
+    count(tableName) {
+        const table = this._ensureTable(tableName);
+        if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
+        this._runHooks('beforeCount', [tableName]);
+        const n = table._rows.length;
+        this._touchTable(tableName);
+        this._runHooks('afterCount', [tableName, n]);
+        return n;
+    }
+
+    updateById(tableName, id, data) {
+        const table = this._ensureTable(tableName);
+        if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
+        if (!this._runHooks('beforeUpdate', [tableName, id, data])) return;
+        const row = this._resolveId(table, id);
+        if (!row) return { ok: false, error: 'not found' };
+        Object.assign(row, data);
+        this._emit('update', { table: tableName, id, data });
+        this._runHooks('afterUpdate', [tableName, id, data, { ok: true }]);
+        this._markDirty(tableName);
+        return { ok: true };
+    }
+
+    updateByIds(tableName, entries) {
+        const table = this._ensureTable(tableName);
+        if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
+        const pairs = entries.map(([id, data]) => [id, data]);
+        if (!this._runHooks('beforeUpdate', [tableName, pairs])) return;
+        let count = 0;
+        for (const [id, data] of pairs) {
+            const row = this._resolveId(table, id);
+            if (row) { Object.assign(row, data); count++; }
+        }
+        this._emit('update', { table: tableName, entries: pairs, result: { ok: true, count } });
+        this._runHooks('afterUpdate', [tableName, pairs, { ok: true, count }]);
+        this._markDirty(tableName);
+        return { ok: true, count };
+    }
+
+    removeById(tableName, id) {
+        const table = this._ensureTable(tableName);
+        if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
+        if (!this._runHooks('beforeDelete', [tableName, id])) return;
+        const idx = table._rows.findIndex(r => r === this._resolveId(table, id));
+        if (idx === -1) return { ok: false, error: 'not found' };
+        table._rows.splice(idx, 1);
+        this._emit('delete', { table: tableName, id });
+        this._runHooks('afterDelete', [tableName, id, { ok: true }]);
+        this._markDirty(tableName);
+        return { ok: true };
+    }
+
+    removeByIds(tableName, ids) {
+        const table = this._ensureTable(tableName);
+        if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
+        if (!this._runHooks('beforeDelete', [tableName, ids])) return;
+        let removed = 0;
+        for (const id of ids) {
+            const idx = table._rows.findIndex(r => r === this._resolveId(table, id));
+            if (idx !== -1) {
+                table._rows.splice(idx, 1);
+                removed++;
+            }
+        }
+        this._emit('delete', { table: tableName, ids, result: { ok: true, count: removed } });
+        this._runHooks('afterDelete', [tableName, ids, { ok: true, count: removed }]);
+        this._markDirty(tableName);
+        return { ok: true, count: removed };
+    }
+
+    async stop() {
+        this._runHooks('onStop', []);
+        this._emit('stop', {});
+        if (this._dirMode) {
+            try {
+                this._flushDirty();
+                this._saveMeta();
+            } catch (e) {}
+        }
         return this;
     }
 
@@ -886,7 +1337,7 @@ class Database {
             }
         }
         this._walWrite({ op: 'restore', from: filePath });
-        this._markDirty();
+        this._markDirtyLegacy();
     }
 
     // ============================================================
@@ -902,6 +1353,11 @@ class Database {
         }
 
         if (this._memoryMode) return;
+        if (this._dirMode) {
+            this._flushDirty();
+            this._saveMeta();
+            return;
+        }
 
         if (this._jsqlMode) {
             const all = {};
@@ -972,7 +1428,7 @@ class Database {
         }
     }
 
-    _markDirty() {
+    _markDirtyLegacy() {
         this._dirty = true;
         if (this._loading) return;
         if (this._options.autoSave && !this._autoSaveTimer) {
@@ -1016,7 +1472,7 @@ class Database {
             }
         }
         this._walWrite({ op: 'import', tables: Object.keys(data) });
-        this._markDirty();
+        this._markDirtyLegacy();
     }
 
     // ============================================================