jsql-neo 4.0.2 → 4.1.0

package/bin/jsql

@@ -15,6 +15,8 @@ function printModules(list) {
 
 const manager = new ModuleManager();
 
+const RAW_ARGV = process.argv.slice(2);
+
 const cli = yaggs()
   .usage('jsql <command> [options]')
   .option('help', { alias: 'h', type: 'boolean', description: 'Show help' })
@@ -50,6 +52,10 @@ const cli = yaggs()
       switch (action) {
         case 'add': {
           if (!argv.address) return fail(new Error("'mod add' requires --address <path>"));
+          const ext = path.extname(argv.address).toLowerCase();
+          if (ext === '.js' || ext === '.cjs' || ext === '.mjs') {
+            console.warn("Warning: JS modules run without sandbox isolation (trust model). Use .json files for data-only plugins.");
+          }
           const entry = manager.add(argv.address);
           out(useJson ? entry : `Module '${entry.name}' added (${entry.path}). Use 'jsql mod enable ${entry.name}' to enable.`);
           break;
@@ -89,6 +95,69 @@ const cli = yaggs()
   })
   .command('version', 'Show version', null, () => {
     console.log(require('../package.json').version);
+  })
+  .command('server', 'Run the MySQL-compatible server in background', (sub) => {
+    sub.option('port', { alias: 'p', type: 'number', description: 'Listen port (default 3306)' });
+    sub.option('host', { type: 'string', description: 'Listen host (default 127.0.0.1)' });
+    sub.option('data-dir', { type: 'string', description: 'Directory to store databases (default in-memory)' });
+    sub.option('auth', { alias: 'a', type: 'string', description: 'User credential: user:password[:db1,db2] (repeatable)' });
+    sub.option('config', { type: 'string', description: 'Path to config file (JSON)' });
+    sub.option('no-auth', { type: 'boolean', description: 'Allow connections without authentication (local dev only)' });
+  }, (argv) => {
+    const { serverControl } = require('./jsql-server-control');
+    const action = argv._[0];
+    const fail = (err) => {
+      console.error(`Error: ${err.message}`);
+      process.exitCode = 1;
+    };
+    const options = {};
+    if (argv.config) options.config = argv.config;
+    if (argv.port != null) options.port = argv.port;
+    if (argv.host != null) options.host = argv.host;
+    if (argv['data-dir'] != null) options.dataDir = argv['data-dir'];
+    if (argv['no-auth'] === true) options.noAuth = true;
+    const authSpecs = [];
+    for (let i = 0; i < RAW_ARGV.length; i++) {
+      const a = RAW_ARGV[i];
+      if (a === '--auth' || a === '-a') {
+        if (RAW_ARGV[i + 1]) authSpecs.push(RAW_ARGV[++i]);
+      } else if (a.startsWith('--auth=')) {
+        authSpecs.push(a.slice(7));
+      }
+    }
+    if (authSpecs.length > 0) options.auth = authSpecs;
+
+    try {
+      switch (action) {
+        case 'start': {
+          serverControl.start(options).then(
+            (msg) => console.log(msg),
+            (err) => fail(err)
+          );
+          break;
+        }
+        case 'stop': {
+          serverControl.stop(options).then(
+            (msg) => console.log(msg),
+            (err) => fail(err)
+          );
+          break;
+        }
+        case 'status': {
+          serverControl.status(options).then(
+            (msg) => console.log(msg),
+            (err) => fail(err)
+          );
+          break;
+        }
+        case undefined:
+          return fail(new Error("Missing action. Usage: jsql server <start|stop|status>"));
+        default:
+          return fail(new Error(`Unknown server action: ${action}`));
+      }
+    } catch (e) {
+      fail(e);
+    }
   });
 
 cli.run(process.argv.slice(2)).catch(e => {

package/bin/jsql-server

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+// © Vexify 2026 All Rights Reserved.
+// jsql-neo 后台常驻服务入口 — 由 `jsql start` 以 detached 子进程方式拉起。
+// 用法: node bin/jsql-server --config <config.json>
+// 支持 SIGTERM/SIGINT 优雅关闭。
+
+const path = require('path');
+const fs = require('fs');
+const { createMysqlServer } = require('../lib/mysql_server');
+
+function parseArgs(argv) {
+  const args = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--config') { args.config = argv[++i]; }
+    else if (a.startsWith('--config=')) { args.config = a.slice(9); }
+    else args._.push(a);
+  }
+  return args;
+}
+
+function loadConfig(configPath) {
+  const cfg = { port: 3306, host: '127.0.0.1' };
+  if (configPath && fs.existsSync(configPath)) {
+    Object.assign(cfg, JSON.parse(fs.readFileSync(configPath, 'utf8')));
+  }
+  return cfg;
+}
+
+function buildAuth(cfg) {
+  if (cfg.auth) {
+    if (typeof cfg.auth !== 'object' || Array.isArray(cfg.auth)) {
+      throw new Error('config.auth must be an object map { user: "password" | { password, databases } }');
+    }
+    return cfg.auth;
+  }
+  if (cfg.user != null || cfg.password != null) {
+    const auth = {};
+    auth[cfg.user || 'root'] = cfg.password || '';
+    return auth;
+  }
+  return null;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const cfg = loadConfig(args.config);
+  const auth = buildAuth(cfg);
+  const options = {
+    port: cfg.port || 3306,
+    host: cfg.host || '127.0.0.1',
+    dataDir: cfg.dataDir || null,
+    maxConnections: cfg.maxConnections,
+    idleTimeout: cfg.idleTimeout,
+    handshakeTimeout: cfg.handshakeTimeout,
+    safety: cfg.safety !== false,
+    allowComments: cfg.allowComments === true,
+    noAuth: cfg.noAuth === true,
+  };
+  if (auth) options.auth = auth;
+  if (cfg.onSecurityEvent) options.onSecurityEvent = cfg.onSecurityEvent;
+
+  const server = createMysqlServer(options);
+
+  let closing = false;
+  const shutdown = (code) => {
+    if (closing) return;
+    closing = true;
+    server.close(() => process.exit(code));
+    setTimeout(() => process.exit(code), 2000).unref();
+  };
+  process.on('SIGTERM', () => shutdown(0));
+  process.on('SIGINT', () => shutdown(0));
+
+  server.listen(err => {
+    if (err) {
+      console.error(`[jsql-server] failed to start: ${err.message}`);
+      process.exit(1);
+      return;
+    }
+    const addr = server.address;
+    console.log(`[jsql-server] listening on ${options.host}:${addr ? addr.port : options.port} (dataDir: ${options.dataDir || 'in-memory'})`);
+    console.log(`[jsql-server] pid ${process.pid}`);
+  });
+}
+
+main().catch(e => {
+  console.error(`[jsql-server] ${e.message}`);
+  process.exit(1);
+});

package/bin/jsql-server-control.js

@@ -0,0 +1,177 @@
+// © Vexify 2026 All Rights Reserved.
+// jsql server start/stop/status — 后台常驻服务控制（对标 `net mysql80 start`）。
+// 状态文件放在 ~/.jsql/ 下：server.pid / server.log / server.json（保存启动配置）。
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const STATE_DIR = path.join(os.homedir(), '.jsql');
+const PID_FILE = path.join(STATE_DIR, 'server.pid');
+const LOG_FILE = path.join(STATE_DIR, 'server.log');
+const CONF_FILE = path.join(STATE_DIR, 'server.json');
+
+function ensureStateDir() {
+  fs.mkdirSync(STATE_DIR, { recursive: true, mode: 0o700 });
+}
+
+function readPid() {
+  try {
+    const pid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10);
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch (e) {
+    return null;
+  }
+}
+
+function isAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === 'EPERM';
+  }
+}
+
+function isPortOpen(port, host) {
+  return new Promise(resolve => {
+    const net = require('net');
+    const sock = net.connect({ port, host: host || '127.0.0.1' });
+    sock.once('connect', () => { sock.destroy(); resolve(true); });
+    sock.once('error', () => resolve(false));
+    setTimeout(() => { sock.destroy(); resolve(false); }, 800);
+  });
+}
+
+function parseAuthSpecs(list) {
+  const auth = {};
+  for (const spec of list) {
+    const idx = spec.indexOf(':');
+    if (idx <= 0) {
+      auth[spec] = '';
+      continue;
+    }
+    const user = spec.slice(0, idx);
+    const rest = spec.slice(idx + 1);
+    const idx2 = rest.indexOf(':');
+    const password = idx2 === -1 ? rest : rest.slice(0, idx2);
+    const dbPart = idx2 === -1 ? '' : rest.slice(idx2 + 1);
+    const dbs = dbPart
+      ? dbPart.split(',').map(s => s.trim()).filter(Boolean)
+      : null;
+    auth[user] = dbs ? { password, databases: dbs } : password;
+  }
+  return auth;
+}
+
+async function start(opts = {}) {
+  ensureStateDir();
+  const existing = readPid();
+  if (existing && isAlive(existing)) {
+    return `jsql server is already running (pid ${existing}).`;
+  }
+
+  const configPath = opts.config || CONF_FILE;
+  let cfg = { port: 3306, host: '127.0.0.1' };
+  if (fs.existsSync(configPath)) {
+    try { cfg = Object.assign(cfg, JSON.parse(fs.readFileSync(configPath, 'utf8'))); } catch (e) {}
+  }
+  if (opts.port != null) cfg.port = opts.port;
+  if (opts.host != null) cfg.host = opts.host;
+  if (opts.dataDir != null) cfg.dataDir = path.resolve(opts.dataDir);
+  if (opts.noAuth) {
+    cfg.noAuth = true;
+    delete cfg.auth;
+    delete cfg.user;
+    delete cfg.password;
+  } else {
+    cfg.noAuth = false;
+  }
+  if (opts.auth) cfg.auth = parseAuthSpecs(Array.isArray(opts.auth) ? opts.auth : [opts.auth]);
+  fs.writeFileSync(CONF_FILE, JSON.stringify(cfg, null, 2), 'utf8');
+
+  const entry = path.join(__dirname, 'jsql-server');
+  const logFd = fs.openSync(LOG_FILE, 'a');
+  const child = spawn(process.execPath, [entry, '--config', CONF_FILE], {
+    detached: true,
+    stdio: ['ignore', logFd, logFd],
+    env: Object.assign({}, process.env, { JSQL_SERVER_MAIN: '1' }),
+  });
+  child.once('error', err => {
+    fs.closeSync(logFd);
+    throw err;
+  });
+  child.unref();
+
+  fs.writeFileSync(PID_FILE, String(child.pid), 'utf8');
+
+  const ready = await waitReady(cfg.port, cfg.host, 5000);
+  if (!ready) {
+    if (isAlive(child.pid)) {
+      try { process.kill(child.pid, 'SIGTERM'); } catch (e) {}
+      fs.unlinkSync(PID_FILE);
+    }
+    throw new Error(`server failed to start (see ${LOG_FILE})`);
+  }
+  return `jsql server started (pid ${child.pid}, ${cfg.host}:${cfg.port}, dataDir: ${cfg.dataDir || 'in-memory'}). Log: ${LOG_FILE}`;
+}
+
+function waitReady(port, host, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  return new Promise(resolve => {
+    const tick = async () => {
+      if (await isPortOpen(port, host)) return resolve(true);
+      if (Date.now() > deadline) return resolve(false);
+      setTimeout(tick, 200);
+    };
+    tick();
+  });
+}
+
+async function stop(opts = {}) {
+  const pid = readPid();
+  if (!pid) return 'jsql server is not running.';
+  if (!isAlive(pid)) {
+    fs.unlinkSync(PID_FILE);
+    return 'jsql server is not running.';
+  }
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch (e) {
+    throw new Error(`failed to stop server (pid ${pid}): ${e.message}`);
+  }
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    if (!isAlive(pid)) break;
+    await new Promise(r => setTimeout(r, 150));
+  }
+  if (isAlive(pid)) {
+    try { process.kill(pid, 'SIGKILL'); } catch (e) {}
+  }
+  fs.unlinkSync(PID_FILE);
+  return `jsql server stopped (pid ${pid}).`;
+}
+
+async function status(opts = {}) {
+  const pid = readPid();
+  if (!pid || !isAlive(pid)) {
+    return 'jsql server is not running.';
+  }
+  let cfg = {};
+  try { cfg = JSON.parse(fs.readFileSync(CONF_FILE, 'utf8')); } catch (e) {}
+  const port = (opts.port != null ? opts.port : cfg.port) || 3306;
+  const host = (opts.host != null ? opts.host : cfg.host) || '127.0.0.1';
+  const up = await isPortOpen(port, host);
+  const lines = [
+    `jsql server is running (pid ${pid}).`,
+    `  ${host}:${port} ${up ? 'listening' : 'NOT responding'}`,
+    `  dataDir: ${cfg.dataDir || 'in-memory'}`,
+    `  log: ${LOG_FILE}`,
+  ];
+  if (cfg.auth) lines.push(`  users: ${Object.keys(cfg.auth).join(', ')}`);
+  return lines.join('\n');
+}
+
+module.exports = { serverControl: { start, stop, status }, STATE_DIR, PID_FILE, LOG_FILE, CONF_FILE };

package/lib/database.js

@@ -134,20 +134,53 @@ class Database {
         try {
             if (fs.existsSync(this._metaPath)) {
                 const parsed = JSON.parse(fs.readFileSync(this._metaPath, 'utf8'));
-                if (parsed && parsed.tables) this._meta = parsed;
+                if (parsed && parsed.tables) {
+                    this._meta = parsed;
+                    // 清洗 meta 中的 file 字段：拒绝绝对路径/.. 穿越，防恶意 meta.json 写任意位置
+                    for (const name of Object.keys(this._meta.tables)) {
+                        const meta = this._meta.tables[name];
+                        if (meta && meta.file !== undefined) {
+                            if (this._safeTableFile(meta.file) === null) {
+                                delete this._meta.tables[name];
+                            }
+                        }
+                    }
+                }
             }
         } catch (e) {
             this._meta = { version: 1, tables: {} };
         }
+        for (const name of Object.keys(this._meta.tables)) {
+            if (this[name] === undefined && !(name in this)) {
+                Object.defineProperty(this, name, {
+                    get: () => this._ensureTable(name) || this._tables[name],
+                    enumerable: true,
+                    configurable: true
+                });
+            }
+        }
         this._startMonitor();
     }
 
     _tableFile(name) {
         const meta = this._meta.tables[name];
-        if (meta && meta.file) return path.join(this._filePath, meta.file);
+        if (meta && meta.file) {
+            const safe = this._safeTableFile(meta.file);
+            if (safe) return path.join(this._filePath, safe);
+        }
         return path.join(this._filePath, encodeURIComponent(name) + '.jsql');
     }
 
+    _safeTableFile(file) {
+        if (typeof file !== 'string' || file.length === 0) return null;
+        if (path.isAbsolute(file)) return null;
+        if (file.includes('/') || file.includes('\\')) return null;
+        const base = path.basename(file);
+        if (base !== file || base === '.' || base === '..') return null;
+        if (file.includes('\0')) return null;
+        return file;
+    }
+
     _saveMeta() {
         if (!this._dirMode) return;
         try {
@@ -166,7 +199,7 @@ class Database {
         if (!this._dirMode) return null;
         const meta = this._meta.tables[name];
         if (!meta) return null;
-        const file = path.join(this._filePath, meta.file);
+        const file = this._tableFile(name);
         if (!fs.existsSync(file)) return null;
         try {
             const fmt = new JSQLFormat(file);
@@ -197,13 +230,13 @@ class Database {
         if (this._flushInterval <= 0) {
             this._flushTimer = setImmediate(() => {
                 this._flushTimer = null;
-                try { this._flushDirty(); } catch (e) {}
+                try { this._flushDirty(); } catch (e) { this._emit('error', e); }
             });
             return;
         }
         this._flushTimer = setTimeout(() => {
             this._flushTimer = null;
-            try { this._flushDirty(); } catch (e) {}
+            try { this._flushDirty(); } catch (e) { this._emit('error', e); }
         }, this._flushInterval);
         if (this._flushTimer.unref) this._flushTimer.unref();
     }
@@ -211,8 +244,15 @@ class Database {
     _flushDirty() {
         if (!this._dirMode || this._dirtyTables.size === 0) return;
         const names = [...this._dirtyTables];
-        this._dirtyTables.clear();
-        for (const name of names) this._flushTable(name);
+        for (const name of names) {
+            try {
+                this._flushTable(name);
+                this._dirtyTables.delete(name);
+            } catch (e) {
+                // 保留脏标记，下次 flush 重试；错误对外传播而非静默
+                this._emit('error', e);
+            }
+        }
         this._saveMeta();
     }
 
@@ -374,6 +414,9 @@ class Database {
     // ============================================================
 
     createTable(name, schema) {
+        if (!name || name.length > 64 || name === '.' || name === '..' || /[\x00-\x1f/\\]|\.\./.test(name)) {
+            throw createError('ER_BAD_TABLE_NAME', 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);
@@ -1287,7 +1330,7 @@ class Database {
                 }
             }
         } else if (targetVersion < current) {
-            for (const m of this._migrations.reverse()) {
+            for (const m of [...this._migrations].reverse()) {
                 if (m.version <= current && m.version > targetVersion) {
                     m.down(this);
                     this._setCurrentVersion(m.version - 1);
@@ -1448,7 +1491,14 @@ class Database {
             clearTimeout(this._autoSaveTimer);
             this._autoSaveTimer = null;
         }
-        if (this._dirty && !this._memoryMode) {
+        if (this._dirMode) {
+            try {
+                this._flushDirty();
+                this._saveMeta();
+            } catch (e) {
+                this._emit('error', e);
+            }
+        } else if (this._dirty && !this._memoryMode) {
             this.save();
         }
         if (this._jsqlFormat) this._jsqlFormat._close();
@@ -1475,6 +1525,45 @@ class Database {
         this._markDirtyLegacy();
     }
 
+    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._txId = (this._txId || 0) + 1;
+        return this._txId;
+    }
+
+    async commitTx() {
+        this._txSnapshot = null;
+        this._txId = undefined;
+        if (this._dirMode) {
+            try { this._flushDirty(); } catch (e) {}
+        } else if (!this._memoryMode) {
+            this.save();
+        }
+    }
+
+    async rollbackTx() {
+        const snap = this._txSnapshot;
+        this._txSnapshot = null;
+        this._txId = undefined;
+        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;
+    }
+
     // ============================================================
     // 加密（内部）
     // ============================================================

package/lib/errors.js

@@ -62,6 +62,12 @@ const ErrorCodes = {
     ER_TRIGGER_EXISTS:        { code: 1359,  msg: "Trigger '%s' already exists" },
     ER_TRIGGER_NOT_FOUND:     { code: 1360,  msg: "Trigger '%s' does not exist" },
     ER_PLUGIN_ERR:            { code: 1125,  msg: "Plugin error: %s" },
+    ER_PLUGIN_ABORT:          { code: 1125,  msg: "Operation aborted by plugin: %s" },
+    ER_TABLE_EXISTS_ERROR:    { code: 1050,  msg: "Table '%s' already exists" },
+    ER_BAD_TABLE_NAME:        { code: 1058,  msg: "Invalid table name '%s'" },
+    ER_BAD_REGEX:             { code: 1258,  msg: "Unsafe regular expression rejected: %s" },
+    ER_DBATTACH_EXISTS:       { code: 1007,  msg: "Database '%s' already attached" },
+    ER_DBATTACH_NOT_FOUND:    { code: 1049,  msg: "Attached database '%s' not found" },
 };
 
 /**

package/lib/jsql_format.js

@@ -305,19 +305,25 @@ class JSQLFormat {
   }
 
   _reset() {
-    fs.ftruncateSync(this.fd, SZ.SUPER);
-    const sb = Buffer.alloc(SZ.SUPER); sb.write('JSQL', 0, 'utf8');
-    fs.writeSync(this.fd, sb, 0, SZ.SUPER, 0);
     this.nBlocks = 1;
     this._nextTableId = 1;
     this.tables.clear();
     this.pkIdx.clear();
   }
 
+  _truncateToSuper() {
+    fs.ftruncateSync(this.fd, SZ.SUPER);
+    const sb = Buffer.alloc(SZ.SUPER); sb.write('JSQL', 0, 'utf8');
+    fs.writeSync(this.fd, sb, 0, SZ.SUPER, 0);
+    this.nBlocks = 1;
+  }
+
   saveAll(allTables) {
     this._open();
     this._reset();
 
+    const pending = [];
+
     for (const [name, info] of Object.entries(allTables)) {
       const { schema, rows, pkField } = info;
       if (!rows || rows.length === 0) continue;
@@ -338,8 +344,16 @@ class JSQLFormat {
       // Scratch buffer for row encoding (max row size fits in one block)
       const scratch = Buffer.allocUnsafe(SZ.DATA);
 
+      // Phase 1: encode every row into memory first. Any error thrown here
+      // (oversized row, bad value) aborts before the file is touched.
       for (const row of rows) {
         const end = encRowInPlace(row, encoders, scratch, 0);
+        if (end > SZ.DATA) {
+          throw new Error(
+            `row in table '${name}' is too large (${end} bytes > max row size ${SZ.DATA} bytes); ` +
+            'split the value or reduce field sizes before saving'
+          );
+        }
         if (bp + end > SZ.BLOCK) {
           const raw = Buffer.from(buf.subarray(SZ.HEADER, bp));
           rawBlocks.push(raw);
@@ -368,13 +382,19 @@ class JSQLFormat {
         buf.writeUInt32LE(bp - SZ.HEADER, 40);
       }
 
+      pkEntries.sort((a, b) => a.hash - b.hash);
+      pending.push({ name, tableId, rawBlocks, blockIds, pkEntries });
+    }
+
+    // Phase 2: all rows encoded successfully — now write to disk.
+    for (const p of pending) {
       // Compress and write blocks
-      for (let i = 0; i < rawBlocks.length; i++) {
-        const bid = blockIds[i];
-        const compBuf = zlib.gzipSync(rawBlocks[i], { level: 1 });
+      for (let i = 0; i < p.rawBlocks.length; i++) {
+        const bid = p.blockIds[i];
+        const compBuf = zlib.gzipSync(p.rawBlocks[i], { level: 1 });
         const block = Buffer.alloc(SZ.BLOCK);
-        mkHeader(BT.DATA, bid, tableId).copy(block);
-        block.writeUInt32LE(rawBlocks[i].length, 40);
+        mkHeader(BT.DATA, bid, p.tableId).copy(block);
+        block.writeUInt32LE(p.rawBlocks[i].length, 40);
         block[48] = 1;
         block.writeUInt32LE(compBuf.length, 44);
         compBuf.copy(block, SZ.HEADER);
@@ -382,13 +402,12 @@ class JSQLFormat {
         fs.writeSync(this.fd, block, 0, SZ.BLOCK, bid * SZ.BLOCK);
       }
 
-      const t = this.tables.get(name);
-      t.rowCount = rows.length;
-      t.dataBlock = blockIds.length > 0 ? blockIds[blockIds.length - 1] : 0;
+      const t = this.tables.get(p.name);
+      t.rowCount = p.pkEntries.length;
+      t.dataBlock = p.blockIds.length > 0 ? p.blockIds[p.blockIds.length - 1] : 0;
 
-      pkEntries.sort((a, b) => a.hash - b.hash);
-      this.pkIdx.set(name, pkEntries);
-      this._saveIdx(name);
+      this.pkIdx.set(p.name, p.pkEntries);
+      this._saveIdx(p.name);
     }
 
     this._saveSuper();