pure-js-db 2.54.0 → 2.55.1

package/README.md

@@ -3,11 +3,11 @@
 > **零依赖嵌入式数据库引擎 —— 单文件部署，同时支持向量搜索、MVCC 并发写入、CDC 变更捕获。**
 > 如果你的 Node.js 应用需要 PostgreSQL + Milvus + Debezium 的能力但不想要三个独立服务，这里一个文件就够。
 
-> 📌 **当前状态**：v2.54.0，成熟度 **Beta+（工程验证成熟）**。历史版本公告（E26 查询缓存/时间旅行、F1-F10 接线、安全审计加固等）详见 [CHANGELOG.md](CHANGELOG.md) 与 [docs/internal/audit/](docs/internal/audit/) 审计档案。安全模块默认 fail-closed，生产部署必须显式配置认证/RBAC/加密（见 [SECURITY.md](SECURITY.md) §2.2）。
+> 📌 **当前状态**：v2.55.1，成熟度 **Beta+（工程验证成熟）**。历史版本公告（E26 查询缓存/时间旅行、F1-F10 接线、安全审计加固等）详见 [CHANGELOG.md](CHANGELOG.md) 与 [docs/internal/audit/](docs/internal/audit/) 审计档案。安全模块默认 fail-closed，生产部署必须显式配置认证/RBAC/加密（见 [SECURITY.md](SECURITY.md) §2.2）。
 
 ![Node.js](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen)
 ![License](https://img.shields.io/badge/license-MIT-blue)
-![Version](https://img.shields.io/badge/version-2.54.0-blue)
+![Version](https://img.shields.io/badge/version-2.55.1-blue)
 ![Tests](https://img.shields.io/badge/tests-826%20files-brightgreen)
 ![LOC](https://img.shields.io/badge/loc-~225k-blue)
 ![Maturity](https://img.shields.io/badge/maturity-Beta%2B%20engineering%20validated-orange)
@@ -48,6 +48,34 @@ console.log(result.rows);
 
 ---
 
+## 🤖 给 AI Agent 一个本地记忆库（3 步）
+
+零依赖纯 JS + 内置 MCP Server + 数据 100% 留在本地磁盘——这是 AI Agent 本地存储的最短路径（无需编译链、无需云服务、无需 Docker）。
+
+**① 安装**：`npm i pure-js-db`
+
+**② 配置 Claude Desktop / Cursor**（MCP stdio 直连）：
+
+```json
+{
+  "mcpServers": {
+    "pure-js-db": {
+      "command": "node",
+      "args": [
+        "<项目路径>/node_modules/pure-js-db/scripts/mcp-server.mjs",
+        "--db-path", "./mcpdata", "--allow-write"
+      ]
+    }
+  }
+}
+```
+
+**③ 对 AI 说**："建一张 memories 表，把我的偏好存进去，下次会话能查到。" —— 完成。数据落盘 `./mcpdata`，跨会话持久，26 个 MCP 工具（SQL/事务/向量检索/图查询/备份/CDC）全部可用。
+
+📘 完整教程（含探针脚本与 FAQ）：[《用 Pure-JS-DB 给 Claude 一个本地记忆库》](docs/tutorials/ai-agent-local-memory.md) · MCP 详情见下文 [MCP Server 章节](#mcp-server600-行)。
+
+---
+
 ## 按场景快速入门
 
 ### 场景 1：Web 服务需要并发写入
@@ -173,6 +201,27 @@ await db.save();
 
 参见 [src/storage/persisted-db.js](src/storage/persisted-db.js) — `STABLE`
 
+### 场景 5b：持久化到磁盘（文件系统 + 跨进程重启恢复）
+
+> 用 `FileKVAdapter` 把数据真正落到磁盘目录，进程重启 / 换新实例后 `load()` 完整恢复数据 + 模式 + 索引。
+
+```javascript
+import { PersistedDatabase, FileKVAdapter } from 'pure-js-db';
+
+// 建库，数据写到 ./mydb 目录（数据页 / 索引 / 元数据 / manifest）
+const db = new PersistedDatabase('app', new FileKVAdapter('./mydb'));
+await db.load();
+// ... 写入 / 建索引 ...
+await db.save();
+await db.close();
+
+// 模拟进程重启：指向同一目录即可完整恢复
+const db2 = new PersistedDatabase('app', new FileKVAdapter('./mydb'));
+await db2.load();
+```
+
+可复现演示（建库 → 写 → 关 → 新实例 load 恢复）：`node scripts/demo-persist-roundtrip.mjs`（`npm run demo:persist`）
+
 ### 场景 6：用 ActiveRecord 风格 ORM 操作数据库（v1.29.0+）
 
 > ✅ **v2.50.0 已接线**：ORM 模块已从主入口导出 `defineModel` / `Schema` / `QueryBuilder` / `transaction` 等 API（F5 接线 2026-08-17），以下示例可直接运行。npm 子路径导入请使用 `pure-js-db/src/orm/index.js`。
@@ -661,7 +710,7 @@ Pure-JS-DB 提供 **双引擎模式**，根据运行环境自动选择最优执
 | 引擎 | 适用环境 | 性能特点 | 加速方式 |
 |------|---------|---------|---------|
 | **纯 JS 引擎** | 浏览器/小程序/边缘函数 | 零依赖，v2.27.0 优化后 DELETE 0.56ms/1K行 | 批量触发器合并 + WHERE 条件下推 |
-| **Rust NAPI 加速** | Node.js + Rust 模块 | SIMD 加速，聚合计算旧基准宣称最高 **45x**（2026-10-27 独立性能评测发现加速层多数路径未在生产接线，实际收益有限；评测暴露的 AVX2 正确性 bug 已于 2026-10-28 修复；见 `docs/评估/Pure-JS-DB-独立第三方综合评测报告-2026-10-27.md`） | AVX2/AVX-512 指令集 |
+| **Rust NAPI 加速** | Node.js + Rust 模块 | SIMD 加速。**2026-11-06 更新：2026-10-27 评测指出的全部未接线项已闭环**——TopN（性能门禁 12.2x，1M 行 top-10 完整路径 16x）、向量化过滤（列存 BitmapFilter 接线，低选择率 2.1x）、F32 批量聚合（sum/min/max Rust 实现补齐 + countGtI32 绑定名失配修复）、单组聚合（sumF64/minF64/maxF64）。旧基准"最高 45x"口径已废弃，以门禁与实测为准（`node scripts/perf-baseline-gate.cjs` 可复现） | AVX2 指令集 |
 
 ### 自动引擎选择
 
@@ -699,7 +748,7 @@ const backend = getAccelerationBackend();
 
 ### Rust NAPI 加速引擎性能 (SIMD)
 
-> ⚠️ **2026-10-27 独立评测修正（2026-10-28 部分已修复）**：下表数据来自 v1.32 时代的旧基准。独立评测实测发现：Rust 加速层多数路径未在生产代码接线（4/5 性能声称失效）；评测同时暴露三处 AVX2 正确性 bug（utf8 批量编码、Float64 min/max 全 NaN、null bitmap ≥0x80），该三处已在 2026-10-28 修复并重建 `native/index.node`、相关 Native 路径已恢复。下表加速比仅供参考，不构成当前版本（v2.54.0）的性能承诺。
+> ⚠️ **2026-10-27 独立评测修正（2026-10-28 部分已修复）**：下表数据来自 v1.32 时代的旧基准。独立评测实测发现：Rust 加速层多数路径未在生产代码接线（4/5 性能声称失效）；评测同时暴露三处 AVX2 正确性 bug（utf8 批量编码、Float64 min/max 全 NaN、null bitmap ≥0x80），该三处已在 2026-10-28 修复并重建 `native/index.node`、相关 Native 路径已恢复。下表加速比仅供参考，不构成当前版本（v2.55.1）的性能承诺。
 >
 > 详见 [SIMD 优化报告](docs/simd/simd-final-optimization-report.md)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pure-js-db",
-  "version": "2.54.0",
+  "version": "2.55.1",
   "description": "Pure JavaScript 关系型数据库引擎 - 面向小程序/受限运行时环境。零 C/C++/WASM 依赖，支持 SQL 解析、B+树索引、查询优化、物化视图、数据分片、分布式事务、Worker Pool 并行、SharedArrayBuffer 共享内存、HTAP 混合存储、多语言客户端 SDK。可选 Rust NAPI 原生加速层（编译后性能提升 2-5x）。",
   "type": "module",
   "main": "src/index.js",
@@ -15,6 +15,7 @@
     "./internal": {
       "default": "./src/internal/public-api.js"
     },
+    "./version": "./src/version.js",
     "./v3": "./src/index-v3.js"
   },
   "sideEffects": false,
@@ -53,6 +54,7 @@
     "start:prod": "node --max-old-space-size=4096 --max-semi-space-size=64 --expose-gc scripts/start-server.js",
     "cli": "node --max-old-space-size=4096 --max-semi-space-size=64 src/cli.js",
     "demo": "node src/cli.js --init",
+    "demo:persist": "node scripts/demo-persist-roundtrip.mjs",
     "load-test": "node test/benchmark/load-test.mjs --init --warmup",
     "bench:storage": "node test/bench_binary_storage.js",
     "bench:random-read": "node test/bench-random-read-compare.js",

package/src/engine/public-api.js

@@ -208,3 +208,7 @@ export { LineageStore, extractSourceTables, extractSourceTablesFromSQL, extractC
 // 部署配置与启动 (生产环境)
 export { config as productionConfig } from '../../config/production.config.js';
 export { setupSoADaemon } from '../daemon/soa-daemon-integration.js';
+
+// v2.55.1: 批量聚合器（Rust/JS 自动选择）——batchSumF32 系列此前不在任何公开导出面，
+// exports 收紧后成为死导出；经 engine 子入口对用户可达。
+export { createBatchAggregator } from '../native/native-acceleration.js';

package/src/executor/executor.js

@@ -507,6 +507,8 @@ export class Executor {
     /** @type {string[]} v2.12 E16 M2-T2: 当前事务已创建的 SAVEPOINT 名栈（新库 join 时补录） */
     this._txSavepoints = [];
     this.optimizer = null;  // 延迟初始化成本优化器
+    /** @type {Object|null} TPC-H 慢查询专项：JOIN 哈希表跨查询缓存（懒创建，见 _getJoinHashTableCache） */
+    this._joinHashTableCache = null;
     /** @type {ViewManager|null} */
     this.viewManager = new ViewManager(this.db, this);
     /** @type {LineageStore} v2.47.0 P7-M1: 数据血缘存储（表级血缘自动记录） */
@@ -2659,6 +2661,26 @@ export class Executor {
           return this.execSelectParallel(stmt, options);
         }
 
+        // TPC-H 慢查询专项：JOIN 复合行列裁剪——仅顶层 SELECT 分发注入
+        // _requiredColumns；INSERT...SELECT / 子查询等内部 execSelect 调用不携带
+        // 该标记 → 自动维持全列行为（安全边界见 _computeRequiredColumns 注释）。
+        if (!options._requiredColumns) {
+          const requiredColumns = this._computeRequiredColumns(stmt);
+          if (requiredColumns) {
+            options = { ...options, _requiredColumns: requiredColumns };
+            // 无限定列引用 ⇒ __table__ 命名空间零消费 → 跳过赋值（复合行再降 ~40% 宽度）；
+            // 含子查询时保守保留 __table__（相关子查询提升/物化链路的隐式依赖，Q20 回归）
+            if (!requiredColumns.hasQualified && !requiredColumns.hasSubquery) {
+              options._skipTableNamespaces = true;
+            }
+          }
+        }
+        // TPC-H 慢查询专项：JOIN 哈希表跨查询缓存——v1.43.0 的 _hashTableCache
+        // 机制一直无生产者，同一查询重复执行每次重建右表哈希表（SF=1 lineitem
+        // 60K 行 ≈ 5-10ms/次）。失效以表对象 + Table._dataVersion（DML 必递增）为键。
+        if (!options._hashTableCache && typeof this._getJoinHashTableCache === 'function') {
+          options._hashTableCache = this._getJoinHashTableCache();
+        }
         result = this.execSelect(stmt, options);
       } else if (stmt instanceof InsertStatement) {
         result = this.execInsert(stmt, options);
@@ -3023,6 +3045,153 @@ export class Executor {
    * @param {Object} [db] - 数据库实例（用于查目标表触发器）
    * @returns {boolean}
    */
+  /**
+   * JOIN 复合行列裁剪（TPC-H 慢查询专项，2026-11-06）
+   *
+   * 计算整个 SELECT 语句引用的列名集合（全 AST 递归：SELECT/WHERE/GROUP BY/
+   * HAVING/ORDER BY/JOIN ON/子查询/窗口），供 JoinEngine._hashJoin 在构建
+   * 复合行时按需拷贝右表新键——复合行宽度从"全部表列"降到"查询实际引用列"，
+   * 展开成本随行宽线性下降（Q5 实测 JOIN 步耗时 -60%+）。
+   *
+   * 保守禁用（返回 null → 不裁剪，维持全列拷贝）：
+   *   - 投影含 Star（SELECT * / 任何层 SELECT 的 columns 含 Star，含 COUNT(*) 场景按
+   *     投影 Star 判定）——消费方可能按位置/全列使用；
+   *   - 集合操作（UNION/EXCEPT/INTERSECT，setOps）——列按位置对应，裁剪有错位风险；
+   *   - 无任何列引用（SELECT 1 等）——无收益。
+   *
+   * 适用边界：仅 execute() 的顶层 SELECT 分发注入 _requiredColumns；INSERT...SELECT、
+   * 标量/EXISTS 子查询等内部 execSelect 调用不携带该标记 → 自动维持全列行为。
+   *
+   * @param {Object} stmt - SELECT 语句 AST
+   * @returns {Set<string>|null} 需要的列名集合；null = 不裁剪
+   */
+  _computeRequiredColumns(stmt) {
+    const required = new Set();
+    let hasStar = false;
+    let hasSetOp = false;
+    let hasQualified = false;
+    let hasSubquery = false;
+    const walk = (node, depth) => {
+      if (!node || typeof node !== 'object' || depth > 64) return;
+      if (Array.isArray(node)) {
+        for (const item of node) walk(item, depth + 1);
+        return;
+      }
+      const cname = node.constructor && node.constructor.name;
+      if (cname === 'ColumnRef') {
+        required.add(node.columnName);
+        if (node.tableName) hasQualified = true;
+        return;
+      }
+      // 子查询节点（InSubquery/ScalarSubquery/ExistsSubquery 等）：含子查询的语句
+      // 禁用 _skipTableNamespaces——相关子查询的提升/物化链路（flattener temp 表、
+      // _replaceColumnRefs 外层绑定）对复合行结构有隐式依赖（Q20 回归实测），
+      // 保守保留 __table__ 命名空间。
+      if (cname && cname.includes('Subquery')) hasSubquery = true;
+      // 集合操作节点（UNION/EXCEPT/INTERSECT 解析为 {left, operation, right}）→ 禁裁剪
+      if (typeof node.operation === 'string' && node.left && node.right) {
+        hasSetOp = true;
+      }
+      // 投影 Star 检测：任何层 SELECT 的 columns 数组（元素为 SelectItem{expression} 或 Star）；
+      // COUNT(*) 的 args Star 不产生输出列，忽略
+      if (Array.isArray(node.columns)) {
+        for (const c of node.columns) {
+          const expr = c && c.expression ? c.expression : c;
+          if (expr && expr.constructor && expr.constructor.name === 'Star') hasStar = true;
+        }
+      }
+      for (const key of Object.keys(node)) {
+        if (key === 'loc' || key === '_parent' || key === '_optimized' || key === '__rowId') continue;
+        const v = node[key];
+        if (v && typeof v === 'object') walk(v, depth + 1);
+      }
+    };
+    walk(stmt, 0);
+    if (hasStar || hasSetOp || required.size === 0) return null;
+    // hasQualified/hasSubquery 挂在返回 Set 上：无限定列时 execute() 额外注入
+    // _skipTableNamespaces（_hashJoin 跳过 __table__ 命名空间赋值，复合行再降
+    // ~40% 宽度）。无限定列 ⇒ __table__ 的全部消费点（限定列解析/_getTableRow/
+    // graph-table）均不被触发。**含子查询时仅禁 ns 跳过、保留列裁剪**（相关子查询
+    // 的提升/物化链路对复合行结构有隐式依赖，Q20 回归实测）。
+    required.hasQualified = hasQualified;
+    required.hasSubquery = hasSubquery;
+    return required;
+  }
+
+  /**
+   * JOIN 哈希表跨查询缓存（TPC-H 慢查询专项，2026-11-07）
+   *
+   * 背景：JoinEngine._hashJoin/_buildHashTable 的 `_hashTableCache` 机制（v1.43.0）
+   * 一直只有消费者没有生产者——SELECT 链路从未注入，导致同一查询重复执行时每次
+   * 重建右表哈希表（SF=1 下 lineitem 60K 行 build ≈ 5-10ms/次）。
+   *
+   * 失效正确性（本实现与旧"行数版"的关键差异）：
+   *   旧接口用 rightRows.length 做版本号——UPDATE/DELETE 不改行数时返回脏哈希表
+   *   （错误结果）。本缓存以【表对象（WeakMap）+ Table._dataVersion（DML 必递增）+
+   *   键列名】为键：任何 DML 递增版本 → 自动失效；DROP 后 getTable 为空 → 不命中；
+   *   CREATE 同名新表为新对象（WeakMap 无旧缓存）→ 不命中。
+   *
+   * 缓存范围：仅键表达式为单列 ColumnRef（columnName 可提取）的等值 JOIN——复杂
+   * 键表达式不缓存（保守）。上限 64 条，超限整段清空。
+   *
+   * @returns {Object} { get(tableName, rowLen, keyExpr), set(tableName, rowLen, keyExpr, ht, bloom) }
+   */
+  _getJoinHashTableCache() {
+    if (this._joinHashTableCache) {
+      return this._joinHashTableCache;
+    }
+    const db = this.db;
+    const MAX_ENTRIES = 64;
+    const store = new Map(); // WeakMap<tableObj, Map<"version|colKey", {ht, bloom}>>
+
+    function keyOf(tableName, keyExpr, rowLen) {
+      if (!keyExpr || keyExpr.constructor?.name !== 'ColumnRef' || !keyExpr.columnName) {
+        return null; // 复杂键表达式不缓存
+      }
+      // 别名右表（FROM supplier s2）的 tableName 是别名而非基表名——getTable 对
+      // 不存在的表抛错 → 缓存键解析失败必须保守返回 null（不缓存，走原路径）
+      let table = null;
+      try {
+        table = db && typeof db.getTable === 'function' ? db.getTable(tableName) : null;
+      } catch {
+        return null;
+      }
+      if (!table || typeof table._dataVersion !== 'number') {
+        return null; // 表不存在（DROP）/别名/版本不可用 → 不缓存
+      }
+      // 仅缓存全表扫描行集：下推/过滤后的部分行集（rightRows ⊂ 表行）其内容取决于
+      // 具体 WHERE，仅按表+版本+键列做键会跨查询脏撞（不同 WHERE 同行数）→ 保守
+      // 只在 build 行数 === 表行数 时缓存。
+      if (rowLen !== table.rows.length) {
+        return null;
+      }
+      return { table, version: table._dataVersion, colKey: keyExpr.columnName };
+    }
+
+    function lookup(tableName, rowLen, keyExpr) {
+      const k = keyOf(tableName, keyExpr, rowLen);
+      if (!k) return null;
+      const byVersion = store.get(k.table);
+      if (!byVersion) return null;
+      return byVersion.get(`${k.version}|${k.colKey}`) || null;
+    }
+
+    function put(tableName, rowLen, keyExpr, ht, bloom) {
+      const k = keyOf(tableName, keyExpr, rowLen);
+      if (!k) return;
+      let byVersion = store.get(k.table);
+      if (!byVersion) {
+        byVersion = new Map();
+        store.set(k.table, byVersion);
+      }
+      if (byVersion.size >= MAX_ENTRIES) byVersion.clear();
+      byVersion.set(`${k.version}|${k.colKey}`, { ht, bloom });
+    }
+
+    this._joinHashTableCache = { get: lookup, set: put };
+    return this._joinHashTableCache;
+  }
+
   _isImmutableCacheableInsert(ast, db) {
     const stmts = ast && ast.statements;
     if (!stmts || stmts.length !== 1) {
@@ -3481,10 +3650,11 @@ export class Executor {
     // 从 table.rows 取对应行（保持行存格式，确保兼容性）
     const rows = indices.map(i => table.rows[i]);
 
-    // 构造投影后的行
+    // 构造投影后的行（{} 原型，与行存路径 _rowPool 的 {} 原型行一致——
+    // 原 Object.create(null) 与行存输出原型不同，deepStrictEqual 可区分）
     const projectedRows = [];
     for (const row of rows) {
-      const projRow = Object.create(null);
+      const projRow = {};
       let hasStar = false;
       for (const item of selectItems) {
         if (item.expression instanceof Star) {
@@ -3496,13 +3666,24 @@ export class Executor {
         projRow[outputName] = row[colName];
       }
       if (hasStar) {
-        // SELECT * — 直接复制整行（去掉 __rowId）
-        projectedRows.push({ ...row });
+        // SELECT * — 与行存 Star 语义一致：仅输出表声明列（排除 __rowId 等
+        // 系统键；原 {...row} 整行拷贝泄漏 __rowId，行存路径不携带）
+        const starRow = {};
+        for (const col of table.columns) {
+          if (col.name in row) {
+            starRow[col.name] = row[col.name];
+          }
+        }
+        projectedRows.push(starRow);
       } else {
         projectedRows.push(projRow);
       }
     }
 
+    // 投影类型格式化（JSON/JSONB/ARRAY/GEOMETRY/TIMESTAMPTZ）——与行存路径一致；
+    // 修复前返回列存原始值（ARRAY/JSON 为数组/对象、TIMESTAMPTZ 无会话时区）
+    const formattedRows = this._formatTypedColumns(projectedRows, table);
+
     // 构造输出列元信息
     const outputColumns = [];
     for (const item of selectItems) {
@@ -3522,9 +3703,9 @@ export class Executor {
 
     return {
       type: 'SELECT',
-      rows: projectedRows,
+      rows: formattedRows,
       columns: outputColumns,
-      rowCount: projectedRows.length,
+      rowCount: formattedRows.length,
       _columnarAccelerated: true,
     };
   }
@@ -5332,63 +5513,82 @@ export class Executor {
     });
 
     // JSON/JSONB/ARRAY/GEOMETRY/TIMESTAMPTZ 类型输出：自动序列化
-    if (table && table.columns) {
-      const jsonColumns = new Set(table.columns.filter(c => c.type === 'JSON' || c.type === 'JSONB').map(c => c.name));
-      if (jsonColumns.size > 0) {
-        resultRows = resultRows.map(row => {
-          const formatted = { ...row };
-          for (const colName of jsonColumns) {
-            if (colName in formatted && typeof formatted[colName] === 'object' && formatted[colName] !== null) {
-              formatted[colName] = formatJSON(formatted[colName]);
-            }
+    // （2026-11-07 抽取为 _formatTypedColumns 共享方法，供列存模式 B 复用）
+    return this._formatTypedColumns(resultRows, table);
+  }
+
+  /**
+   * 投影类型格式化（JSON/JSONB/ARRAY/GEOMETRY/TIMESTAMPTZ 输出形态）
+   *
+   * 2026-11-07 从 _applyProjection/_projectRowsCore 的两份内联块抽取为共享方法，
+   * 并接线列存加速模式 B（_tryColumnarFilterProject）——此前模式 B 返回列存原始值
+   * （ARRAY/JSON 为数组/对象、TIMESTAMPTZ 无会话时区格式化），与行存路径输出类型
+   * 不一致（同一列不同查询形状返回类型不同）。
+   * 语义与原内联块逐行一致：按表声明列收集类型列，逐行浅拷贝后格式化；
+   * 表无类型列时原样返回（零开销）。行键为输出列名（别名替换后与表列名不同的
+   * 列不参与格式化——与原两处内联块行为一致，未收窄）。
+   * @param {Object[]} resultRows 投影后的行
+   * @param {Object|null} table
+   * @returns {Object[]} 格式化后的行
+   */
+  _formatTypedColumns(resultRows, table) {
+    if (!table || !table.columns) {
+      return resultRows;
+    }
+    const jsonColumns = new Set(table.columns.filter(c => c.type === 'JSON' || c.type === 'JSONB').map(c => c.name));
+    if (jsonColumns.size > 0) {
+      resultRows = resultRows.map(row => {
+        const formatted = { ...row };
+        for (const colName of jsonColumns) {
+          if (colName in formatted && typeof formatted[colName] === 'object' && formatted[colName] !== null) {
+            formatted[colName] = formatJSON(formatted[colName]);
           }
-          return formatted;
-        });
-      }
-      const arrayColumns = new Set(table.columns.filter(c => c.type === 'ARRAY').map(c => c.name));
-      if (arrayColumns.size > 0) {
-        resultRows = resultRows.map(row => {
-          const formatted = { ...row };
-          for (const colName of arrayColumns) {
-            if (colName in formatted && Array.isArray(formatted[colName])) {
-              formatted[colName] = JSON.stringify(formatted[colName]);
-            }
+        }
+        return formatted;
+      });
+    }
+    const arrayColumns = new Set(table.columns.filter(c => c.type === 'ARRAY').map(c => c.name));
+    if (arrayColumns.size > 0) {
+      resultRows = resultRows.map(row => {
+        const formatted = { ...row };
+        for (const colName of arrayColumns) {
+          if (colName in formatted && Array.isArray(formatted[colName])) {
+            formatted[colName] = JSON.stringify(formatted[colName]);
           }
-          return formatted;
-        });
-      }
-      const geomColumns = new Set(table.columns.filter(c => c.type === 'GEOMETRY').map(c => c.name));
-      if (geomColumns.size > 0) {
-        resultRows = resultRows.map(row => {
-          const formatted = { ...row };
-          for (const colName of geomColumns) {
-            if (colName in formatted && formatted[colName] && typeof formatted[colName].toWKT === 'function') {
-              formatted[colName] = formatted[colName].toWKT();
-            }
+        }
+        return formatted;
+      });
+    }
+    const geomColumns = new Set(table.columns.filter(c => c.type === 'GEOMETRY').map(c => c.name));
+    if (geomColumns.size > 0) {
+      resultRows = resultRows.map(row => {
+        const formatted = { ...row };
+        for (const colName of geomColumns) {
+          if (colName in formatted && formatted[colName] && typeof formatted[colName].toWKT === 'function') {
+            formatted[colName] = formatted[colName].toWKT();
           }
-          return formatted;
-        });
-      }
-      const tstzColumns = new Set(table.columns.filter(c => c.type === 'TIMESTAMPTZ').map(c => c.name));
-      if (tstzColumns.size > 0) {
-        const tz = (this.db && typeof this.db._sessionTimeZoneOffset === 'number')
-          ? this.db._sessionTimeZoneOffset : 0;
-        resultRows = resultRows.map(row => {
-          const formatted = { ...row };
-          for (const colName of tstzColumns) {
-            if (colName in formatted && typeof formatted[colName] === 'string') {
-              const p = parseTimestampTZ(formatted[colName]);
-              const base = p ? p.date : parseWallTimeUTC(formatted[colName]);
-              if (base && !isNaN(base.getTime())) {
-                formatted[colName] = formatTimestampTZ(base, tz);
-              }
+        }
+        return formatted;
+      });
+    }
+    const tstzColumns = new Set(table.columns.filter(c => c.type === 'TIMESTAMPTZ').map(c => c.name));
+    if (tstzColumns.size > 0) {
+      const tz = (this.db && typeof this.db._sessionTimeZoneOffset === 'number')
+        ? this.db._sessionTimeZoneOffset : 0;
+      resultRows = resultRows.map(row => {
+        const formatted = { ...row };
+        for (const colName of tstzColumns) {
+          if (colName in formatted && typeof formatted[colName] === 'string') {
+            const p = parseTimestampTZ(formatted[colName]);
+            const base = p ? p.date : parseWallTimeUTC(formatted[colName]);
+            if (base && !isNaN(base.getTime())) {
+              formatted[colName] = formatTimestampTZ(base, tz);
             }
           }
-          return formatted;
-        });
-      }
+        }
+        return formatted;
+      });
     }
-
     return resultRows;
   }
 
@@ -5537,68 +5737,9 @@ export class Executor {
       return clean;
     });
 
-    // JSON/JSONB/ARRAY 类型输出：自动序列化
-    if (table && table.columns) {
-      const jsonColumns = new Set(table.columns.filter(c => c.type === 'JSON' || c.type === 'JSONB').map(c => c.name));
-      if (jsonColumns.size > 0) {
-        resultRows = resultRows.map(row => {
-          const formatted = { ...row };
-          for (const colName of jsonColumns) {
-            if (colName in formatted && typeof formatted[colName] === 'object' && formatted[colName] !== null) {
-              formatted[colName] = formatJSON(formatted[colName]);
-            }
-          }
-          return formatted;
-        });
-      }
-      const arrayColumns = new Set(table.columns.filter(c => c.type === 'ARRAY').map(c => c.name));
-      if (arrayColumns.size > 0) {
-        resultRows = resultRows.map(row => {
-          const formatted = { ...row };
-          for (const colName of arrayColumns) {
-            if (colName in formatted && Array.isArray(formatted[colName])) {
-              formatted[colName] = JSON.stringify(formatted[colName]);
-            }
-          }
-          return formatted;
-        });
-      }
-
-      // GEOMETRY 类型输出：自动序列化为 WKT
-      const geomColumns = new Set(table.columns.filter(c => c.type === 'GEOMETRY').map(c => c.name));
-      if (geomColumns.size > 0) {
-        resultRows = resultRows.map(row => {
-          const formatted = { ...row };
-          for (const colName of geomColumns) {
-            if (colName in formatted && formatted[colName] && typeof formatted[colName].toWKT === 'function') {
-              formatted[colName] = formatted[colName].toWKT();
-            }
-          }
-          return formatted;
-        });
-      }
-
-      // v2.0-12 G12: TIMESTAMPTZ 类型输出 — 内部以 UTC 存储（无后缀字符串），
-      // 展示时按会话时区偏移转换为 'YYYY-MM-DD HH:MM:SS±HH:MM'
-      const tstzColumns = new Set(table.columns.filter(c => c.type === 'TIMESTAMPTZ').map(c => c.name));
-      if (tstzColumns.size > 0) {
-        const tz = (this.db && typeof this.db._sessionTimeZoneOffset === 'number')
-          ? this.db._sessionTimeZoneOffset : 0;
-        resultRows = resultRows.map(row => {
-          const formatted = { ...row };
-          for (const colName of tstzColumns) {
-            if (colName in formatted && typeof formatted[colName] === 'string') {
-              const p = parseTimestampTZ(formatted[colName]);
-              const base = p ? p.date : parseWallTimeUTC(formatted[colName]);
-              if (base && !isNaN(base.getTime())) {
-                formatted[colName] = formatTimestampTZ(base, tz);
-              }
-            }
-          }
-          return formatted;
-        });
-      }
-    }
+    // JSON/JSONB/ARRAY/GEOMETRY/TIMESTAMPTZ 类型输出：自动序列化
+    // （2026-11-07 抽取为 _formatTypedColumns 共享方法，与 _projectRowsCore 共用）
+    resultRows = this._formatTypedColumns(resultRows, table);
 
     // 清理子查询展开创建的临时表（已缓存的保留，供后续查询复用）
     for (const alias of _flattenTempTables) {

package/src/executor/join-executor.js

@@ -368,7 +368,7 @@ export class JoinExecutor {
    */
   _pushJoinPredicates(leftRows, rightRows, leftAlias, rightAlias, stmt, options, joinType = null) {
     const conditions = this._flattenAND(stmt.where);
-    if (conditions.length <= 1) {
+    if (conditions.length === 0) {
       return { leftRows, rightRows };
     }
 
@@ -397,6 +397,47 @@ export class JoinExecutor {
           continue;
         }
       }
+      // TPC-H 慢查询专项（2026-11-06）：未限定列名的单表条件下推
+      // Q3/Q5 的 WHERE 全部使用未限定列名（r_name/o_orderdate/l_shipdate），上方
+      // `refs.every(r => r.tableName)` 全不满足 → 下推完全失效 → JOIN 中间行数翻倍
+      // （实测 Q5 第 1 步 orders 未过滤 100→50、region 未过滤 5→1）。
+      // 归属判定：未限定列按「列名在右表行 / 左行中的存在性」解析——
+      //   全部列仅在右表行 → 下推右表（OUTER 由 canPushRight 保护）；
+      //   全部列仅在左行 → 下推左行（INNER 语义安全，OUTER 由 canPushLeft 保护）；
+      //   歧义（左右都有）/空行 → 保持原位（保守，不改变语义）。
+      if (refs.length > 0 && refs.every(r => !r.tableName)) {
+        // TPC-H 慢查询专项边界：条件中含子查询（Subquery/SubqueryExpr 等节点）时，
+        // evaluate 需要 context._subqueryExecutor（_pushJoinPredicates 的 options
+        // 不保证携带），且子查询引用外层列时按存在性归属判定也可能误判 → 保守保持
+        // 原位（由 JOIN 后的 WHERE 阶段正常求值，语义不变）。
+        let hasSubquery = false;
+        this._walkExpr(cond, (n) => {
+          const cn = n.constructor && n.constructor.name;
+          // InSubquery/ExistsSubquery 等子查询类节点：evaluate 需要
+          // context._subqueryExecutor（本方法 options 不保证携带）→ 保守保持原位
+          if (cn && (cn.includes('Subquery') || cn === 'ExistsExpr')) {
+            hasSubquery = true;
+          }
+        });
+        if (!hasSubquery) {
+          const cols = refs.map(r => r.columnName);
+          const l0 = leftRows[0];
+          const r0 = rightRows[0];
+          if (l0 && r0) {
+            const inRight = cols.every(c => c !== '__rowId' && Object.prototype.hasOwnProperty.call(r0, c));
+            const inLeft = cols.every(c => c !== '__rowId' && Object.prototype.hasOwnProperty.call(l0, c));
+            if (inRight !== inLeft) {
+              if (inRight && canPushRight) {
+                rRows = rRows.filter(r => evaluate(cond, r, { params }) === true);
+                continue;
+              } else if (inLeft && canPushLeft) {
+                lRows = lRows.filter(r => evaluate(cond, r, { params }) === true);
+                continue;
+              }
+            }
+          }
+        }
+      }
       remaining.push(cond);
     }
 

package/src/executor/select-executor.js

@@ -326,6 +326,12 @@ export class SelectExecutor {
       const joinOpts = {
         params,
         _subqueryExecutor: options._subqueryExecutor,
+        // TPC-H 慢查询专项：透传列裁剪/命名空间跳过/哈希表缓存标记——此前白名单式
+        // 重建 joinOpts 丢弃这三个标记，导致 _computeRequiredColumns 的列裁剪、
+        // _skipTableNamespaces 与 _hashTableCache 三项优化在 JOIN 主路径从未生效。
+        _requiredColumns: options._requiredColumns,
+        _skipTableNamespaces: options._skipTableNamespaces,
+        _hashTableCache: options._hashTableCache,
         ...(useParallelJoin
           ? {
             parallel: true,

package/src/executor/vectorized-columnar-engine.js

@@ -36,7 +36,7 @@
 // 2026-10-27 性能评审修复：Rust 端仅实现 F64 聚合原语（sumF64/minF64/maxF64），
 // 此前绑定层检查的 sumF32Batch 等导出在 Rust 中不存在，导致 F32 路径恒走 JS。
 // 切换为 F64 原语使 Rust SIMD 聚合真正生效（2.5-5x），同时消除 Float32 累加精度风险。
-import { sumF64, minF64, maxF64 } from '../native/native-acceleration.js';
+import { sumF64, minF64, maxF64, filterI32Eq, filterI32Lt, filterI32Gt, filterI32Le, filterI32Ge, filterF64Eq, filterF64Lt, filterF64Gt, filterF64Le, filterF64Ge } from '../native/native-acceleration.js';
 
 // === 常量定义 ============================================================
 
@@ -232,12 +232,41 @@ export class BitmapFilter {
 
   /**
    * 单列数值快速谓词（生成位图）
+   * v2.55.0: TypedArray 输入优先走 Rust 向量化过滤（filterI32 系 / filterF64 系原语，
+   * 2026-10-27 评测指出的"native 2.67x~7.55x 但零生产调用方"由此接线），返回索引
+   * 后转位图；Rust 不可用或非 TypedArray 回退纯 JS 循环。'!=' 无 Rust 导出，恒走 JS。
    * @param {Float64Array|Int32Array|Array} column 列数据
    * @param {string} op 操作符 '>', '<', '>=', '<=', '=', '!='
    * @param {number} value 阈值
    * @returns {Uint8Array} 位图
    */
   static numeric(column, op, value) {
+    const isI32 = column instanceof Int32Array;
+    const isF64 = column instanceof Float64Array;
+    if (isI32 || isF64) {
+      const rustFn = isI32
+        ? { '>': filterI32Gt, '<': filterI32Lt, '>=': filterI32Ge, '<=': filterI32Le, '=': filterI32Eq }[op]
+        : { '>': filterF64Gt, '<': filterF64Lt, '>=': filterF64Ge, '<=': filterF64Le, '=': filterF64Eq }[op];
+      if (rustFn) {
+        try {
+          const indices = rustFn(column, value);
+          const n = column.length;
+          // 选择率门槛（2026-11-06 实测）：索引→位图是稀疏随机写（每 cache line 仅 1/64 有效），
+          // matches ≤ n/8 时全链（Rust 扫描 + 转换）约 3.6x 快于 JS 扫描；
+          // 高选择率时转换成本反超（50% 时合计 5.5ms vs JS 4.4ms），退回 JS 单次扫描。
+          if (indices.length <= n / 8) {
+            const bitmap = new Uint8Array(n);
+            for (let i = 0; i < indices.length; i++) {
+              bitmap[indices[i]] = 1;
+            }
+            return bitmap;
+          }
+          // matches 过多 → 落到下方 JS 扫描（已付出的 Rust 扫描最多 ~2.9ms/1M，可接受）
+        } catch {
+          // native 调用异常 → 回退 JS
+        }
+      }
+    }
     const n = column.length;
     const bitmap = new Uint8Array(n);
     switch (op) {

package/src/native/native-acceleration.js

@@ -1473,8 +1473,10 @@ export function batchMaxF32(data) {
 export function batchCountGtI32(data, threshold) {
   const arr = data instanceof Int32Array ? data : new Int32Array(data);
   const mod = getNativeModule();
-  if (mod && typeof mod.countGtI32Batch === 'function') {
-    return mod.countGtI32Batch(arr, threshold);
+  // v2.55.0 修复：Rust 导出名为 countGtI32（vec_agg.rs count_gt_i32），
+  // 此前检查的 countGtI32Batch 不存在 → 永远走 JS 回退（2026-10-27 评测"绑定名失配"的最后一处）。
+  if (mod && typeof mod.countGtI32 === 'function') {
+    return mod.countGtI32(arr, threshold);
   }
   return jsCountGtI32(arr, threshold);
 }

package/src/sdk/java/pom.xml

@@ -7,7 +7,7 @@
 
   <groupId>com.purejsdb</groupId>
   <artifactId>pure-client</artifactId>
-  <version>2.54.0</version>
+  <version>2.55.1</version>
   <packaging>jar</packaging>
 
   <name>pure-js-db Java SDK</name>

package/src/sdk/java/pureclient/PureClient.java

@@ -62,7 +62,7 @@ import java.util.NoSuchElementException;
 public class PureClient {
 
     /** SDK 版本号。 */
-    public static final String SDK_VERSION = "2.54.0";
+    public static final String SDK_VERSION = "2.55.1";
 
     /** 默认请求超时（秒）。 */
     public static final long DEFAULT_TIMEOUT_SECONDS = 30;

package/src/sdk/java/pureclient/PureClientTest.java

@@ -114,7 +114,7 @@ class PureClientTest {
     @Order(1)
     @DisplayName("J1: SDK 版本号应为 1.10.0")
     void testSdkVersion() {
-        assertEquals("2.54.0", PureClient.SDK_VERSION,
+        assertEquals("2.55.1", PureClient.SDK_VERSION,
                 "SDK 版本应为 1.10.0");
     }
 

package/src/sdk/php/composer.json

@@ -2,7 +2,7 @@
     "name": "pure-js-db/php-sdk",
     "description": "PHP SDK for pure-js-db — pure JavaScript database engine, via HTTP RESTful API.",
     "type": "library",
-    "version": "2.54.0",
+    "version": "2.55.1",
     "keywords": ["database", "sdk", "pure-js-db", "rest", "curl"],
     "license": "MIT",
     "require": {

package/src/sdk/php/src/PureClient.php

@@ -34,7 +34,7 @@ namespace PureJSDB\Sdk;
 class PureClient
 {
     /** @var string SDK 版本号 */
-    public const SDK_VERSION = '2.54.0';
+    public const SDK_VERSION = '2.55.1';
 
     /** @var float 默认请求超时（秒） */
     private const DEFAULT_TIMEOUT = 30.0;

package/src/sdk/python/pure_client.py

@@ -35,7 +35,7 @@ import urllib.parse
 from typing import Any, Dict, Iterator, List, Optional, Union
 
 
-__version__ = "2.54.0"
+__version__ = "2.55.1"
 
 
 class PureError(Exception):

package/src/sdk/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pure-js-db"
-version = "2.54.0"
+version = "2.55.1"
 edition = "2021"
 rust-version = "1.75"
 description = "Rust SDK for pure-js-db — HTTP RESTful API 客户端 + HNSWPQ 向量索引管理"

package/src/sdk/rust/RELEASE-CHECKLIST.md

@@ -29,8 +29,8 @@ grep -E 'SDK 版本：\*\*[0-9]+\.[0-9]+\.[0-9]+\*\*' README.md  # 期望: SDK
 
 | 文件 | 当前值 |
 |------|--------|
-| `pure-js-db/package.json` | `2.54.0` |
-| `pure-js-db/src/index.js` `VERSION` | `'2.54.0'` |
+| `pure-js-db/package.json` | `2.55.1` |
+| `pure-js-db/src/index.js` `VERSION` | `'2.55.1'` |
 
 ---
 

package/src/sdk/rust/src/lib.rs

@@ -57,7 +57,7 @@ pub use models::{
 pub use transaction::Transaction;
 
 /// SDK 版本号
-pub const SDK_VERSION: &str = "2.54.0";
+pub const SDK_VERSION: &str = "2.55.1";
 
 /// 默认 API 前缀
 pub const DEFAULT_API_PREFIX: &str = "/api/v1";

package/src/sdk/wechat/stubs/empty.js

@@ -58,6 +58,20 @@ export const batchMaxF64 = noop;
 export const sumF64 = noop;
 export const minF64 = noop;
 export const maxF64 = noop;
+// Rust 向量化过滤原语（v2.55.0 列存 BitmapFilter 接线，微信 stub 同步提供 noop）
+export const filterI32Eq = noop;
+export const filterI32Lt = noop;
+export const filterI32Gt = noop;
+export const filterI32Le = noop;
+export const filterI32Ge = noop;
+export const filterF64Eq = noop;
+export const filterF64Lt = noop;
+export const filterF64Gt = noop;
+export const filterF64Le = noop;
+export const filterF64Ge = noop;
+// Rust TopN 堆选择原语（v2.54.0 ORDER BY+LIMIT 快速路径，微信 stub 同步提供 noop）
+export const topnF64Asc = noop;
+export const topnF64Desc = noop;
 
 // 常见的常量导出
 export const PARALLEL_THRESHOLD = 0;

package/src/utils/join-engine.js

@@ -449,6 +449,13 @@ export class JoinEngine {
     if (leftKeyExtractor) {
       // 快速路径：预编译 extractor
       const maxRows = options.maxRows;
+      // TPC-H 慢查询专项：复合行列裁剪——按 options._requiredColumns（全 AST 列集合，
+      // 由 Executor.execute 顶层 SELECT 注入）按需拷贝右表新键，复合行宽度从"全部表列"
+      // 降到"查询实际引用列"，展开成本随行宽线性下降。null = 未启用（全列拷贝）。
+      const required = options._requiredColumns || null;
+      // 无限定列查询（_skipTableNamespaces）跳过 __table__ 赋值：该命名空间的全部
+      // 消费点（限定列解析/_getTableRow/graph-table）在此查询形状下均不被触发。
+      const skipNs = options._skipTableNamespaces === true;
       for (const leftRow of leftRows) {
         const key = leftKeyExtractor(leftRow);
         if (key === null || key === undefined) {
@@ -459,14 +466,26 @@ export class JoinEngine {
         if (matches) {
           for (const rightRow of matches) {
             const combined = { ...leftRow };
-            // v2.11 性能: for...in 替代 Object.entries（免每次 entries 数组分配）
-            for (const k in rightRow) {
-              if (k !== '__rowId' && !(k in leftRow)) {
-                combined[k] = rightRow[k];
+            if (required) {
+              // 列裁剪路径：仅拷贝 required 列（flat）；__table__ 引用随 spread 完整保留，
+              // 限定列访问（t.col）不受影响；未在 required 的列不进入复合行。
+              for (const k in rightRow) {
+                if (k !== '__rowId' && !(k in leftRow) && required.has(k)) {
+                  combined[k] = rightRow[k];
+                }
+              }
+            } else {
+              // v2.11 性能: for...in 替代 Object.entries（免每次 entries 数组分配）
+              for (const k in rightRow) {
+                if (k !== '__rowId' && !(k in leftRow)) {
+                  combined[k] = rightRow[k];
+                }
               }
             }
-            combined[rightTableKey] = rightRow;
-            combined[leftTableKey] = leftRow;
+            if (!skipNs) {
+              combined[rightTableKey] = rightRow;
+              combined[leftTableKey] = leftRow;
+            }
             joined.push(combined);
             // LIMIT 短路（2026-10-27 #4）：仅当查询形状安全（无 ORDER BY/GROUP BY 等，
             // 由 select-executor 判定后传入 maxRows）时提前终止，避免物化全部匹配对。

package/src/version.js

@@ -14,6 +14,6 @@
  * 并校验所有 JS 文件不再硬编码版本号。
  */
 
-export const VERSION = '2.54.0';
+export const VERSION = '2.55.1';
 
 export const PHASE = 'v2.53.2 可靠性验证与发版演练：Raft 3 节点容器集群实测通过（Leader 选举 + 日志复制 + 宕机重选三项 PASS，raft-node-entry.js 新增 POST /raft/propose 提案端点 + raft-extended-verify.mjs 两阶段扩展验证 + run-raft-extended.sh 一键编排）；可靠性周期重跑（2026-11-03）五项全 PASS（3 节点 2PC 30/30 TPS 95.85、网络分区注入 PARTITION_TEST_PASS、MVCC 同行冲突 SAME_ROW_CONFLICT_PASS、7 分钟 soak 7 cycle 0 abort 资金守恒、崩溃重启 6/6、断电模拟 8/8）；npm 周下载 486 破零记录；' + 'v2.53.0 性能服务化（P0-5/P0-6 请求级查询取消与超时）：执行器新增 options 级取消检查 _abortCheck（直接读 options.signal，避免共享 Executor 并发异步查询互相覆盖实例级取消状态），接线到全部分片让出检查点（分片过滤/分片 GROUP BY/_finishSelectAfterRows 阶段边界/JOIN 派发前/parallelHashJoinWithWorker 键计算让出点）；executeSQLAsync 与 parallelHashJoinWithWorker 对取消错误（QUERY_ABORTED）上抛而非静默回退同步；routeSQL(sql, params, res) 为每个请求创建 AbortController——客户端断开（res 提前 close）即中止 + this._timeout 超时中止，取消在让出检查点真实生效（P0-6）；query handler 主查询与 SELECT 端点传递 res；新增 query-cancel.test.js 6 项（预中止/JOIN 路径/运行中/routeSQL 断开/超时/正常回归）已注册 run-all；' + 'v2.52.0 性能服务化（P0-1 Worker 并行 JOIN + P0-3 HTTP WorkerPool）：JoinEngine.parallelHashJoinWithWorker 把 Hash Join 探测（JOIN_PROBE）真实分发到 Worker 线程（主线程预计算键 + 浅拷贝行附加 __joinKey + execAll 分发 + 合并 + LEFT 补行 + 失败回退同步 _parallelHashJoin）；Executor._performJoinAsync 委托 JoinExecutor 供异步路径使用；execSelectShardedAsync 支持单普通表等值 INNER/LEFT JOIN 的 Worker 并行（_canShardAsyncSelect 扩展 + WHERE 不得引用右表列的安全限制）；DBServer 启动时初始化 WorkerPool（lazy，默认 CPU-1，可 enableWorkerPool=false 关闭）并在 stop 时终止，使 HTTP 服务中 JOIN/SORT/FILTER/GROUP_BY 并行算子真实可用；新增 worker-join.test.js 5 项（INNER/LEFT/无池回退/右表列回退/任务分发断言）已注册 run-all；' + 'v2.51.0 缺陷修复（物化视图注册为可查询关系 + WAL 大批次分块）：物化视图作为只读关系注册到 Database（materializedViews 注册表 + hasTable/getTable 识别 + 只读表外观 + 命名冲突双向拒绝 + INFORMATION_SCHEMA.TABLES/COLUMNS 与 pg_class 可见 + CLI/.tables 与 HTTP 表列表纳入 + 持久化重建后重新注册 + SELECT/JOIN/EXPLAIN/跨库可解析），修复 CREATE MATERIALIZED VIEW 通过 SQL 调用时校验错误变为未处理 Promise 拒绝的问题（createMaterializedView 同步抛出 + execCreateMaterializedView 透传异步刷新）；事务 WAL 按 maxEntriesPerBatch 分块，消除同步突发写入 >65535 条时 serializeBatch 的 RangeError 崩溃路径（守卫保留供防御测试）；物化视图测试 +4 项（注册/冲突/只读/持久化），wal-count-bound 7/7 全绿；' + 'v2.50.0 T-05/T-06 架构清理：优化器 barrel 补齐 5 个生产可达类导出（ExplainVisualizer/JoinOrderOptimizer/QueryPlanCache/Histogram·HistogramBucket/TimestampQueryRewriter，经 engine/public-api.js 接主入口）+ StorageEngine 统一存储引擎接口（STORAGE_ENGINE_METHODS 契约 + isStorageEngine/assertStorageEngine 校验 + STORAGE_BACKENDS 四后端工厂 memory/file/binary/buffered + StorageEngine.switchBackend 运行时切换 + createStorageEngine）+ T-06 lockfree-worker.js 占位桩整体移除（lockfree-manager 移除 _startWorkers/useWorkers，单线程 COW 模式收敛）；storage-engine.test 16 项（含绕过）+ optimizer-exports.test 4 项（含主入口接线）已注册 run-all，全量 806/806 全绿、幻影审计 A 类 0/B 类 0、dist 22/22 含新符号；' + 'v2.49.0 E34 数据血缘收尾（UPDATE 源追踪 + CREATE VIEW 事前环拒绝 + Mermaid 导出）：extractUpdateColumnLineage（UPDATE SET 列级血缘，直接列/表达式/函数，常量不产生依赖，多表 UPDATE...FROM 无前缀 unresolved）+ recordStatement UpdateStatement 分支；wouldCreateCycle + DDLExecutor._assertNoLineageCycle（CREATE VIEW/CREATE MATERIALIZED VIEW 事前环拒绝，仅目标视图已存在时预检，保留 v2.11 E15 M2 T3 前向引用后补行为）；toMermaid/getLineageMermaid（Mermaid flowchart 导出）；生产入口导出 + lineage-e34 19 项 + 生产接线 4 项，run-all 804/804 全绿；' + 'v2.48.0 数据血缘全链路落地（P7 M1-M4 + P8 深化 + P9 版本历史）：表级/列级血缘自动记录（CREATE VIEW/MATERIALIZED VIEW/INSERT...SELECT）、LINEAGE SQL 语句（LINEAGE TABLE/COLUMN + lineage-executor + MCP 工具）、任务级登记（CopyStream/Migrator）、持久化（meta v5 随 PersistedDatabase 落盘）、环检测 detectCycles、CTE 列级推导（collectCtes）、HTML 可视化 toHTML、版本历史（getLineageHistory/getLineageAtTime/getLineageEvolution）、变更影响分析（analyzeImpact），生产入口全导出 + 常驻测试 70 项；run-all 全量通过 + vitest 123/123 + c8 Lines 91.99%/Branches 88.43%；' + 'v2.45.2 双缺陷修复（多轮门禁盘点发现）：① REGEXP (?g)/(?y) 全局/粘性标志剥离——编译产物跨行 LRU 缓存复用而 g/y 的 lastIndex 状态使求值行依赖（(?g)a 四行 [1,0,1,0]），REGEXP 逐行独立求值语义下 g/y 无意义且有害，编译期剥离（i/m/s/u 保持）；② WASM min/max 对齐区 NaN 传播——f32x4.min/max 按 IEEE 语义传播 NaN 与"NaN 被忽略"文档语义相悖（v2.45.1 激活 SIMD 路径后成为实际行为），NaN 结果 ⟺ 对齐区有 NaN lane，JS 重扫跳过 NaN 与降级路径对齐；绕过测试 v2450 +2（29 项）、wasm-simd-engine E3 守卫（23 项）；' + 'v2.45.1 WASM SIMD 常量错位修复 + 覆盖率债务清零：f32x4_max 误写 0xEA（实为 f32x4.pmin）致 init 运行时验证恒败、引擎自引入即静默降级（SIMD 路径从未激活，全部流量走 TypedArray fallback）——修正 0xE9 并经验解码验证（0xE7=div/0xE8=min/0xE9=max/0xEA=pmin/0xEB=pmax），修复后 READY/WASM_SIMD 五算子精确正确；wasm-simd-engine 移出 c8 exclude 并补全路径测试（初始化/SIMD 数值/降级/扩容/单例 + 修复守卫）；lockfree-worker.js 人工评估归档（确认占位桩：主路径不经 Worker，保持 exclude 豁免）；' + 'v2.45.0 安满分诊 P1/P2 治理落地（eslint-security 58 errors 分诊第四节立项 ①②③④ 全部修复）：REGEXP 用户正则防护（security/regex-guard.js compileUserRegex：模式长度上限 1024 + 嵌套量词灾难回溯编译期筛查，bitmap-filter _getRegex 接线）+ LIKE/GLOB/KEYS→regex 转换入口统一模式长度上限 1024（bitmap-filter _likeToRegex/_buildEscapeRegex、btree/offheap 部分索引 LikeExpr、cache-adapter KEYS、sqlite-kv-adapter LIKE、expression.js GLOB 共 7 处）+ oracle-adapter DECODE 线性解析重写（消除指数回溯，修复多分支 CASE 语义 + 括号/引号感知 + 嵌套 DECODE 递归转换）+ 输入长度上限（sql-injection-detector 256KB fail-closed、schema-versioning DDL 256KB + 顶层逗号线性切分）；绕过测试 v2450-p0-bypass-boundary 通过；v2.0 长期路线图收官：v2.0-1..6 全部落地（JSONB 二进制 JSON / Lambda 表达式 x->x+1 / UNNEST 多列并行 / DEFERRABLE 约束 / EXCLUDE 排他约束 / LISTEN-NOTIFY 异步通知，DoD 5/5 各 27-39 用例）；v2.0-7 WAL flush 慢 seq 初始化 flaky 修复 + wal-crash-validation 测试加固（10/10 稳定 + 绕过测试有效性验证）+ flush-timeout-simulation FT2/FT4 libuv 时钟边界修复；全量回归 run-all 459/459 全绿（历史首次）；v2.0-8 SQL:2016 阶段1 聚合补全（PERCENTILE_CONT/DISC + STRING_AGG/ARRAY_AGG + MODE + BOOL_AND/OR/EVERY + WIDTH_BUCKET + REGR_*，DoD 5/5 37/37）；v2.0-9 SQL:2016 阶段2 MATCH_RECOGNIZE 行模式识别（Part 2 §21.6 新执行器，DoD 5/5 30/30）；v2.0-10 SQL:2016 阶段3 多态表函数 PTF（Part 2 §10.9：ANY TABLE/COLUMN/MAX(n) + RETURNS TABLE + 函数体 AST 重写 + 物化临时表 + JOIN 内调用 + 幂等性/零副作用，DoD 5/5 25/25，run-all 461/462 + audit-log A8 时间竞态 flaky 修复）；v2.0-11 SQL:2016 阶段4 RATIO_TO_REPORT 分析函数（Part 2 §9.6 G9：分区求和比例 + NULL/除零语义 + 参数校验，DoD 5/5 14/14）+ 窗口函数源表零副作用 P0 修复（window-functions.js 浅拷贝行，156 项窗口回归全绿）；v2.0-12 SQL:2016 阶段5 类型系统深化（Part 2 §4.4 G11 INTERVAL 完整类型：YEAR/MONTH/DAY/HOUR/MINUTE/SECOND 字段子句 + 单位内嵌 + 纯时间/天数自动判断 + DAY TO MINUTE HH:MM + DAY TO HOUR/MINUTE/SECOND 时间部分列宽 + date/timestamp±interval 日历月 clamp + 算术/比较/CAST/一元运算；G12 TIMESTAMP WITH TIME ZONE：带偏移解析→UTC 内部存储 + 会话时区显示 + SET TIME ZONE/SHOW TIME ZONE + INSERT/UPDATE 归一化 + 混合比较，DoD 5/5 62/62）；v1.42.x 基础：STRUCT 类型 / LIST-ARRAY 完整操作 / WITHOUT ROWID 表 / VACUUM-REINDEX / user_version-application_id 持久化 + v1.42.1 全量回归闭环（16 个预存失败清零 + 2 个源码回归修复：query-isolation 原型链 / select-executor ORDER BY 聚合别名）；v1.41.x 基础：ASOF JOIN / ATTACH DATABASE / COMMENT ON / PIVOT 多聚合 / WITH CHECK OPTION；v1.40.4 基础：PRAGMA 完整集（25+ SQLite 标准）+ 版本号多 SDK 单一来源同步；v1.40.3 基础：3 个 P0 安全修复真实现 + SECURITY DEFINER 真实现 + 循环依赖 0；v2.11（E15）遗留清零：WAL 恢复数据版本一致性 + 视图 lossy 根治 + 多视图 CASCADED 链 + SECURITY DEFINER 真实现 + RedisCacheAdapter 真实现 + Arrow 有限宽度 guard + WAL count 上界 + executor 拆分（sql-reconstructor）；v2.12（E16）稳定性与分布式闭环：flaky 三件套根治（2pc-perf/index-build/soak-test + vector-executor 门槛统一）+ 跨库 DDL/事务 + WAL hot-standby 探针 + 分布式真实网络验证（raft/3PC/2PC + PK fastpath WAL 缺陷修复 + 2PC rejection 修复）+ executor PRAGMA 族拆离（pragma-executor，-550 行）+ 全量回归 612/612 + DL-D3 时序 flaky 修复；v2.13（E17）收尾治理与 SQL/XML：版本号全量对齐 + SQL:2016 阶段6 G10（XMLSERIALIZE/XMLAGG/XMLTABLE）+ 全量 c8 复验 + 跨库 TPC-H 数据刷新 + SQL:2023 roadmap 收敛；v2.14（E18）列存文件格式 M1+M2：PJDC 二进制列文件格式（表签名三层校验：schemaHash + rowCount + columnCount）+ save/load 持久化加速缓存 + 列存 roundtrip 持久化验证（22+8 用例全绿）；v2.15（E19）列存文件格式 M3：WAL _invalidateTableIndexes 修复（checkpoint 后索引失效重建）+ run-all 618/618 全绿；v2.15（E20）工程化基线清零：parquet.js 3 处 setUint32 guard 补零 + 超限绕过测试 + 版本号同步 2.13.0→2.15.0 + c8 覆盖率实测 + 审计章节归档；';

package/bindings/java/src/test/java/TestClient.java

@@ -1,68 +0,0 @@
-import purejsdb.PureJsDBClient;
-import purejsdb.TransactionClient;
-
-public class TestClient {
-    public static void main(String[] args) throws Exception {
-        testBasic();
-        System.out.println();
-        testTransaction();
-    }
-
-    static void testBasic() throws Exception {
-        PureJsDBClient client = new PureJsDBClient();
-        System.out.println("[Java SDK Test]");
-
-        String result = client.query("SELECT 1 AS test");
-        assert result != null && result.contains("data") : "query should return data";
-        System.out.println("  ✅ query: SELECT 1");
-
-        String tables = client.getTables();
-        assert tables != null : "getTables should return data";
-        System.out.println("  ✅ getTables");
-
-        String status = client.getStatus();
-        assert status != null : "getStatus should return data";
-        System.out.println("  ✅ getStatus");
-
-        System.out.println("\nAll Java SDK tests passed!");
-    }
-
-    static void testTransaction() throws Exception {
-        TransactionClient client = new TransactionClient();
-        System.out.println("[Java Transaction SDK Test]");
-
-        String txResult = client.begin();
-        assert txResult != null : "begin should return data";
-        System.out.println("  ✅ begin");
-
-        // Extract transaction id from response (simplified)
-        String txId = extractTxId(txResult);
-
-        String execResult = client.executeInTx("SELECT 1 AS tx_test", txId);
-        assert execResult != null : "executeInTx should return data";
-        System.out.println("  ✅ executeInTx");
-
-        String commitResult = client.commit(txId);
-        assert commitResult != null : "commit should return data";
-        System.out.println("  ✅ commit");
-
-        System.out.println("\nAll Java Transaction SDK tests passed!");
-    }
-
-    private static String extractTxId(String response) {
-        // Simple extraction - looks for "sessionId" or "transactionId" in JSON
-        if (response.contains("\"sessionId\"")) {
-            int start = response.indexOf("\"sessionId\"") + 12;
-            start = response.indexOf('"', start) + 1;
-            int end = response.indexOf('"', start);
-            return response.substring(start, end);
-        }
-        if (response.contains("\"transactionId\"")) {
-            int start = response.indexOf("\"transactionId\"") + 16;
-            start = response.indexOf('"', start) + 1;
-            int end = response.indexOf('"', start);
-            return response.substring(start, end);
-        }
-        return "unknown";
-    }
-}

package/bindings/python/test_client.py

@@ -1,63 +0,0 @@
-"""Python SDK 测试"""
-from purejsdb.client import PureJsDBClient, TransactionClient
-import sys
-
-
-def test_basic():
-    client = PureJsDBClient()
-    print('[Python SDK Test]')
-
-    # 测试 get_status
-    status = client.get_status()
-    assert status is not None, 'get_status should return data'
-    print(f'  ✅ get_status: {status.get("status", "OK")}')
-
-    # 测试 get_tables
-    tables = client.get_tables()
-    assert tables is not None, 'get_tables should return data'
-    print(f'  ✅ get_tables')
-
-    # 测试 query
-    result = client.query('SELECT 1 AS test')
-    assert result is not None, 'query should return data'
-    print(f'  ✅ query: SELECT 1')
-
-    # 测试 health
-    health = client.health()
-    assert health is not None, 'health should return data'
-    print(f'  ✅ health')
-
-    print('\nAll Python SDK tests passed!')
-
-
-def test_transaction():
-    """测试事务客户端（需要服务器支持事务）"""
-    client = TransactionClient()
-    print('[Python Transaction SDK Test]')
-
-    # 开始事务
-    tx = client.begin()
-    assert tx is not None, 'begin should return data'
-    tx_id = tx.get('sessionId') or tx.get('transactionId')
-    print(f'  ✅ begin: {tx_id}')
-
-    # 在事务中执行
-    result = client.execute_in_tx('SELECT 1 AS tx_test', tx_id)
-    assert result is not None, 'execute_in_tx should return data'
-    print(f'  ✅ execute_in_tx')
-
-    # 提交事务
-    result = client.commit(tx_id)
-    assert result is not None, 'commit should return data'
-    print(f'  ✅ commit')
-
-    print('\nAll Python Transaction SDK tests passed!')
-
-
-if __name__ == '__main__':
-    test_basic()
-    print()
-    try:
-        test_transaction()
-    except Exception as e:
-        print(f'  ⚠️ Transaction test skipped (server may not support transactions): {e}')