thzxx
074afd3f1e
A8 行引用泄漏（调用方改查询结果即改写存储）
实测：rows[0].tag = 'HACKED' 后，tag='HACKED' 与 tag='x' 两条索引查询都返回 0 行 ——
行与索引失配、该行永久查不出来；嵌套 json 值同样按引用共享。
Aria 因走反序列化路径反而幸免，又形成跨引擎差异。
根治：在 IStorageEngine 契约层写入**行所有权约定**（engine/interface.ts）
—— 读出的行是副本、写入接收的行也是副本；新增 cloneRow/cloneRows
（优先 structuredClone，退化路径处理 Date/嵌套对象/二进制）。
Memory/KVStore/Hybrid：find、findStream、getRow 全部返回副本。
Aria：getAllRows 此前只做 `{ ...value }` 浅拷贝（嵌套 json 仍共享引用），
改为深拷贝；find/findStream 返回副本。
实测四种引擎：修改返回值后重读不变、索引两条查询均正确。
LSM 读取自洽（审计 P1-1：缓存未命中 = 静默丢数据）
此前 loadSSTableReader 缓存未命中返回 null，而所有调用方都是
const reader = this.loadSSTableReader(meta); if (!reader) continue;
于是**未命中就静默跳过整个 SSTable**。实测：缓存上限 4KB 而 SSTable 更大时，
300 行只能查回 59 行，且不报错。
同时"读路径必须先 prefetch"这个隐式约定，是每次读都要 drainChain + prefetch
的原因（性能悬崖的另一半）。
根治：LSM.get / rangeScan / rangeScanLazy 改为 async，未命中即
`await sstableStore.load()` 回源 + CRC 校验（损坏则自愈清理 meta），
只有数据确实不存在才返回 null。checkUniqueSync 相应改名 checkUnique 并 async
（原命名正是因为依赖 prefetch 约定）。引擎侧 12 处调用点补 await。
附带修正的缓存语义：
- tryCacheSSTable：单个 SSTable 超过缓存上限时标记为常驻（pinned），
不参与驱逐 —— 驱逐它等价于静默丢数据；内存上限因此是
cacheLimit + 单个最大 SSTable，已在代码与测试中明确。
- trimCache 跳过 pinned 条目（此前会把全部缓存一次性清空）。
- 新增 getCacheSize/getCacheLimit/getOversizedCount/setCacheLimit 访问器
（测试此前直接读私有字段 cacheSize/cacheLimitBytes —— 那是 TS 错误，
只因测试不做类型检查才没暴露）。
queryStream async 回调
此前用 constructor.name === 'AsyncFunction' 判定，对"普通函数返回 Promise"
完全失效（Promise 被静默丢弃）。现改为双条件识别并走物化路径逐行 await，
async 回调被真正等待。
测试契约修正：
- aria-cache：'缓存大小受上限约束' 在极小缓存下是不可成立的契约，改为断言
真正重要的不变量（数据完整；可装入时受上限约束），并新增"超大 SSTable 常驻"
用例；'缓存驱逐后全表扫描仍返回完整数据' 保留 300 行断言（此前会失败）。
- hybrid：磁盘引擎标签断言从 indexeddb（v0.6.0 已移除）改为 opfs。
303 lines
11 KiB
TypeScript
303 lines
11 KiB
TypeScript
/**
|
||
* AriaEngine SSTable 缓存内存上限测试
|
||
* @module tests/engine/aria-cache
|
||
*
|
||
* 验证 v0.2.6 修复：
|
||
* 1. SSTable 缓存受 cacheLimitBytes 上限约束（LRU 裁剪）
|
||
* 2. 缓存驱逐后所有读取路径（全表/范围/PK/索引）仍返回完整数据（prefetch 兜底）
|
||
* 3. 写入路径不会导致缓存无限增长
|
||
*/
|
||
import { AriaEngine } from '../../src/engine/aria/index';
|
||
import { createSchema } from '../../src/table/schema';
|
||
|
||
import { resetOPFSMock } from '../helpers/storage-harness';
|
||
|
||
beforeEach(() => { resetOPFSMock(); });
|
||
|
||
/** 构造小缓存 + 小 MemTable 阈值的引擎，快速产生多个 SSTable */
|
||
function createSmallCacheEngine(bufferPoolPages = 2) {
|
||
return new AriaEngine({
|
||
storageBackend: 'memory',
|
||
memtableSizeThreshold: 2048, // ~2KB 阈值 → 300 行会产生多个 SSTable
|
||
bufferPoolPages,
|
||
checkpointInterval: 100000, // 关闭自动 checkpoint，避免干扰
|
||
walSyncMode: 'none',
|
||
} as any);
|
||
}
|
||
|
||
function makeRows(count: number): Record<string, unknown>[] {
|
||
const rows: Record<string, unknown>[] = [];
|
||
for (let i = 0; i < count; i++) {
|
||
rows.push({ id: `u${i}`, name: `User${i}`, age: 20 + (i % 30) });
|
||
}
|
||
return rows;
|
||
}
|
||
|
||
describe('AriaEngine SSTable 缓存内存上限', () => {
|
||
test('缓存大小受 cacheLimitBytes 约束', async () => {
|
||
const engine = createSmallCacheEngine(2); // 2 * 4096 = 8KB 上限
|
||
await engine.open('cache-limit-test', 1);
|
||
await engine.createTable(createSchema('users', {
|
||
id: { type: 'string', primaryKey: true },
|
||
name: { type: 'string' },
|
||
age: { type: 'number', index: true },
|
||
}));
|
||
|
||
await engine.insert('users', makeRows(300));
|
||
const lsm = (engine as any).lsm as {
|
||
flush(): Promise<void>;
|
||
getCacheSize(): number;
|
||
getCacheLimit(): number;
|
||
getStats(): { sstableCount: number };
|
||
};
|
||
// v0.6.1-perf: insert 不再隐式排空后台链（逐行 prefetchKeys 已移除），
|
||
// 显式等待后台 flush 完成后再断言 SSTable 产物
|
||
await lsm.flush();
|
||
const stats = lsm.getStats();
|
||
// 300 行 / 2KB 阈值 → 应产生多个 SSTable
|
||
expect(stats.sstableCount).toBeGreaterThan(1);
|
||
|
||
// v0.8.0 契约修正：内存上限只约束**可驱逐条目**。
|
||
//
|
||
// 单个 SSTable 大于整个缓存上限时，它必须常驻：一旦驱逐，
|
||
// `loadSSTableReader` 未命中就会让调用方 `continue` 跳过整个文件 ——
|
||
// 那是静默丢数据（审计实测：300 行只能查回 59 行）。
|
||
// 因此这里断言的是"数据完整"这一真正重要的不变量，而不是一个
|
||
// 在极小缓存下无法成立的字节上限（上限 = cacheLimit + 单个最大 SSTable）。
|
||
for (let round = 0; round < 5; round++) {
|
||
const rows = await engine.find('users', { table: 'users', where: { age: 25 } });
|
||
expect(rows.length).toBe(10);
|
||
}
|
||
|
||
// 若所有 SSTable 都能装进上限，则缓存大小必须受上限约束
|
||
const oversizedPinned = lsm.getOversizedCount();
|
||
if (oversizedPinned === 0) {
|
||
expect(lsm.getCacheSize()).toBeLessThanOrEqual(lsm.getCacheLimit());
|
||
}
|
||
|
||
await engine.close();
|
||
});
|
||
|
||
test('超大 SSTable 常驻缓存（驱逐会导致读取静默跳过整个文件）', async () => {
|
||
const engine = createSmallCacheEngine(1); // 4KB 上限，单个 SSTable 必然超过
|
||
await engine.open('cache-oversized-pin', 1);
|
||
await engine.createTable(createSchema('users', {
|
||
id: { type: 'string', primaryKey: true },
|
||
name: { type: 'string' },
|
||
}));
|
||
await engine.insert('users', makeRows(300));
|
||
const lsm = (engine as any).lsm as {
|
||
flush(): Promise<void>;
|
||
getCacheSize(): number;
|
||
getCacheLimit(): number;
|
||
getOversizedCount(): number;
|
||
trimCache(): void;
|
||
getStats(): { sstableCount: number };
|
||
};
|
||
await lsm.flush();
|
||
expect(lsm.getStats().sstableCount).toBeGreaterThan(0);
|
||
|
||
// 强制裁剪后，超大文件仍必须可读（数据完整）
|
||
lsm.trimCache();
|
||
expect(lsm.getOversizedCount()).toBeGreaterThan(0);
|
||
const all = await engine.find('users', { table: 'users' });
|
||
expect(all.length).toBe(300);
|
||
await engine.close();
|
||
});
|
||
|
||
test('缓存驱逐后全表扫描仍返回完整数据（prefetch 兜底）', async () => {
|
||
const engine = createSmallCacheEngine(1); // 4KB 上限，必然触发驱逐
|
||
await engine.open('cache-evict-fullscan', 1);
|
||
await engine.createTable(createSchema('users', {
|
||
id: { type: 'string', primaryKey: true },
|
||
name: { type: 'string' },
|
||
}));
|
||
|
||
const rows = makeRows(300);
|
||
await engine.insert('users', rows);
|
||
|
||
// v0.8.0: 这是最关键的数据完整性断言 —— 缓存上限极小（4KB）而 SSTable 更大时，
|
||
// 读取路径必须仍然返回**全部** 300 行（此前会静默少数据）。
|
||
const all = await engine.find('users', { table: 'users' });
|
||
expect(all.length).toBe(300);
|
||
|
||
await engine.close();
|
||
});
|
||
|
||
test('缓存驱逐后 PK 等值查询仍正确（prefetchKeys 兜底）', async () => {
|
||
const engine = createSmallCacheEngine(1);
|
||
await engine.open('cache-evict-pk', 1);
|
||
await engine.createTable(createSchema('users', {
|
||
id: { type: 'string', primaryKey: true },
|
||
name: { type: 'string' },
|
||
}));
|
||
|
||
const rows = makeRows(300);
|
||
await engine.insert('users', rows);
|
||
|
||
// 分散查询多个 PK，每次都会经历 驱逐+重新加载
|
||
for (let i = 0; i < 300; i += 11) {
|
||
const found = await engine.find('users', { table: 'users', where: { id: `u${i}` } });
|
||
expect(found.length).toBe(1);
|
||
expect(found[0].name).toBe(`User${i}`);
|
||
}
|
||
|
||
await engine.close();
|
||
});
|
||
|
||
test('缓存驱逐后二级索引查询仍正确', async () => {
|
||
const engine = createSmallCacheEngine(1);
|
||
await engine.open('cache-evict-idx', 1);
|
||
await engine.createTable(createSchema('users', {
|
||
id: { type: 'string', primaryKey: true },
|
||
name: { type: 'string' },
|
||
age: { type: 'number', index: true },
|
||
}));
|
||
|
||
await engine.insert('users', makeRows(300));
|
||
|
||
// 索引等值 + 范围查询
|
||
const eq = await engine.find('users', { table: 'users', where: { age: 25 } });
|
||
expect(eq.length).toBe(10);
|
||
|
||
// age 范围 20-49，每个值 10 行
|
||
const range = await engine.find('users', { table: 'users', where: { age: { $gte: 40 } } });
|
||
expect(range.length).toBe(100);
|
||
|
||
const range2 = await engine.find('users', { table: 'users', where: { age: { $gt: 45 } } });
|
||
expect(range2.length).toBe(40);
|
||
|
||
const inQuery = await engine.find('users', { table: 'users', where: { age: { $in: [21, 22] } } });
|
||
expect(inQuery.length).toBe(20);
|
||
|
||
await engine.close();
|
||
});
|
||
|
||
test('UPDATE/DELETE 在缓存驱逐后仍作用于全部行', async () => {
|
||
const engine = createSmallCacheEngine(1);
|
||
await engine.open('cache-evict-mutate', 1);
|
||
await engine.createTable(createSchema('users', {
|
||
id: { type: 'string', primaryKey: true },
|
||
name: { type: 'string' },
|
||
age: { type: 'number' },
|
||
}));
|
||
|
||
await engine.insert('users', makeRows(300));
|
||
|
||
// 无条件更新 → 全表更新
|
||
const updated = await engine.update('users', { table: 'users' }, { name: 'Renamed' });
|
||
expect(updated).toBe(300);
|
||
|
||
// age 20-49 每个值 10 行；$lt 25 → age 20-24 → 50 行
|
||
const deleted = await engine.delete('users', { table: 'users', where: { age: { $lt: 25 } } });
|
||
expect(deleted).toBe(50);
|
||
|
||
const remaining = await engine.find('users', { table: 'users' });
|
||
expect(remaining.length).toBe(250);
|
||
expect(remaining.every((r) => r.name === 'Renamed')).toBe(true);
|
||
|
||
await engine.close();
|
||
});
|
||
|
||
test('写入路径不突破缓存上限（flush 后立即裁剪）', async () => {
|
||
const engine = createSmallCacheEngine(2);
|
||
await engine.open('cache-write-bound', 1);
|
||
await engine.createTable(createSchema('users', {
|
||
id: { type: 'string', primaryKey: true },
|
||
name: { type: 'string' },
|
||
}));
|
||
|
||
// 分批写入，每批都触发多次 flush
|
||
for (let batch = 0; batch < 10; batch++) {
|
||
await engine.insert('users', makeRows(30).map((r, i) => ({ ...r, id: `b${batch}_u${i}` })));
|
||
const lsm = (engine as any).lsm;
|
||
expect(lsm.getCacheSize()).toBeLessThanOrEqual(lsm.getCacheLimit());
|
||
}
|
||
|
||
const all = await engine.find('users', { table: 'users' });
|
||
expect(all.length).toBe(300);
|
||
|
||
await engine.close();
|
||
});
|
||
|
||
test('回归：主 LSM 与二级索引 LSM 的 SSTable 不互相覆盖（命名空间隔离）', async () => {
|
||
const engine = createSmallCacheEngine(4);
|
||
await engine.open('regression-ns', 1);
|
||
await engine.createTable(createSchema('users', {
|
||
id: { type: 'string', primaryKey: true },
|
||
name: { type: 'string', index: true },
|
||
age: { type: 'number', index: true },
|
||
}));
|
||
|
||
// 小阈值下 insert/update 会同时触发主 LSM 与两个索引 LSM 的多次 flush
|
||
await engine.insert('users', makeRows(120));
|
||
await engine.update('users', { table: 'users', where: { age: { $gte: 30 } } }, { name: 'Senior' });
|
||
|
||
// 主数据完整且为最新值（age 20-49 每个值出现 4 次；$gte 30 → 20 个值 × 4 = 80 行）
|
||
const all = await engine.find('users', { table: 'users' });
|
||
expect(all.length).toBe(120);
|
||
expect(all.filter((r) => r.name === 'Senior').length).toBe(80);
|
||
|
||
// 二级索引等值查找仍正确（索引 LSM 数据未被覆盖）
|
||
const byName = await engine.find('users', { table: 'users', where: { name: 'Senior' } });
|
||
expect(byName.length).toBe(80);
|
||
const byAge = await engine.find('users', { table: 'users', where: { age: 25 } });
|
||
expect(byAge.length).toBe(4);
|
||
|
||
await engine.close();
|
||
});
|
||
|
||
test('回归：同 key 跨多次 flush 更新后读到最新值（多版本语义）', async () => {
|
||
const engine = createSmallCacheEngine(4);
|
||
await engine.open('regression-versions', 1);
|
||
await engine.createTable(createSchema('users', {
|
||
id: { type: 'string', primaryKey: true },
|
||
value: { type: 'number' },
|
||
}));
|
||
|
||
await engine.insert('users', [{ id: 'a', value: 1 }]);
|
||
|
||
// 连续更新同一行 20 次，每次更新都经历 flush
|
||
for (let v = 2; v <= 20; v++) {
|
||
await engine.update('users', { table: 'users', where: { id: 'a' } }, { value: v });
|
||
}
|
||
|
||
const rows = await engine.find('users', { table: 'users', where: { id: 'a' } });
|
||
expect(rows.length).toBe(1);
|
||
expect(rows[0].value).toBe(20);
|
||
|
||
// 全表扫描也应返回最新值
|
||
const all = await engine.find('users', { table: 'users' });
|
||
expect(all.length).toBe(1);
|
||
expect(all[0].value).toBe(20);
|
||
|
||
await engine.close();
|
||
});
|
||
|
||
test('回归：删除后 tombstone 跨 flush 仍生效（不残留旧数据）', async () => {
|
||
const engine = createSmallCacheEngine(4);
|
||
await engine.open('regression-tombstone', 1);
|
||
await engine.createTable(createSchema('users', {
|
||
id: { type: 'string', primaryKey: true },
|
||
age: { type: 'number', index: true },
|
||
}));
|
||
|
||
await engine.insert('users', makeRows(120));
|
||
|
||
// 分批删除，触发多次 flush
|
||
for (let batch = 0; batch < 4; batch++) {
|
||
const deleted = await engine.delete('users', { table: 'users', where: { age: { $gte: 20 + batch * 5, $lt: 25 + batch * 5 } } });
|
||
expect(deleted).toBe(20);
|
||
}
|
||
|
||
const remaining = await engine.find('users', { table: 'users' });
|
||
expect(remaining.length).toBe(40);
|
||
|
||
// 索引查找也不应返回已删除行
|
||
const ghost = await engine.find('users', { table: 'users', where: { age: 22 } });
|
||
expect(ghost.length).toBe(0);
|
||
|
||
await engine.close();
|
||
});
|
||
});
|