FlexSearch 持久化索引(Persistent Indexes)完整指南:从 IndexedDB 到六种存储引擎的挂载、提交与迁移实战

原创2026-09-21 22:50:531,976 阅读
文章标签:搜索引擎后端

FlexSearch 持久化索引(Persistent Indexes)完整指南:从 IndexedDB 到六种存储引擎的挂载、提交与迁移实战

FlexSearch 通过 Storage Adapter(存储适配器)机制,将索引数据从内存委托给 IndexedDB、Redis、SQLite、Postgres、MongoDB、Clickhouse 等持久化存储,从而在浏览器与 Node.js 场景下获得可跨节点共享、可重启恢复、面向大规模索引的全文检索能力。本文以 doc/persistent.md 为核心骨架,系统讲解持久化索引的挂载方式、自动提交语义、各引擎的连接配置与表结构、clear/destroy 生命周期管理,并结合仓库源码(src/db/interface.js、src/index.js 及各引擎适配器实现)说明其底层工作原理。读完本文,你将掌握"一条索引对应一个命名存储"的完整落地姿势,并能按需在六种数据库之间切换与迁移。

一、为什么需要持久化索引:Storage Adapter 的设计动机

FlexSearch 默认的索引是纯内存(In-Memory)结构,数据保存在进程内,进程退出即丢失,也无法在多节点集群间共享。为此 FlexSearch 引入了持久化索引(Persistent Indexes)能力:索引的增删改查全部委托给一个实现了 StorageInterface 的存储适配器(Storage Adapter),索引写入会被批量(batch)落地到所选数据库引擎,查询则直接打到数据库侧执行。

从源码看,这套能力的边界非常清晰:

持久化索引与内存索引在查询能力上完全等价,原文档明确列出的能力清单包括:

  • Context-Search(上下文/关联词搜索)
  • Suggestions(建议词)
  • Cursor-based Queries(Limit/Offset 游标式分页查询)
  • Scoring(评分,分辨率最高支持 32767 个槽位)
  • Document-Search(文档搜索)
  • Partial Search(部分匹配)
  • Multi-Tag-Search(多标签搜索)
  • Boost Fields(字段加权)
  • Custom Encoder(自定义编码器)
  • Resolver(结果解析器)
  • Tokenizer(分词器)
  • Document Store(文档存储,含 enrich 结果富化)
  • Worker Threads(并行 Worker 线程)
  • Auto-Balanced Cache(自动平衡缓存:热门查询 + 最近查询)

原文档特别强调:所有持久化变体都针对"大规模索引 + 高负载写入"做了优化,几乎每个任务都会被流水线化(streamlined)为批量/并行执行,从而榨干所选数据库引擎的性能。更关键的一点是:内存索引无法在集群的多个节点间共享数据,而所有持久化存储默认天然支持跨节点共享——这正是把 FlexSearch 从单机库升级为服务化搜索组件的关键一步。

二、核心编程模型:mount、commit 与 commit 选项

2.1 mount:建立索引与存储的绑定

无论哪种引擎,使用范式完全一致:

  1. 创建 Index(或 Document 索引);
  2. 创建对应引擎的 Database 实例(如 IndexedDB、Redis、Sqlite、Postgres 等);
  3. 调用 await index.mount(db) 完成挂载,必须 await,等待数据库响应后才能传输数据;
  4. 之后照常使用 index.add() / index.update() / index.remove() 与 index.search()。

对应实现位于 src/index.js:Index.prototype.mount 会先清理尚未触发的提交定时器,然后转发给 db.mount(this);Index.prototype.commit 同样清理定时器后调用 this.db.commit(this)。也就是说,mount 与 commit 的真正实现在各引擎的适配器类上,而存储适配器统一继承自 src/db/interface.js 定义的接口。

src/db/interface.js 定义了适配器必须实现的方法,是理解整个持久化架构的总纲:

  • 初始化类方法:mount(index)(将存储绑定到索引)、open()(打开连接)、close()(关闭连接)、destroy()(删除数据库/表);
  • 查询类方法:commit(index)(把索引的增量变更批量转移给数据库)、get(key, ctx, limit, offset, resolve, enrich)(按词元取结果,支持上下文、分页、解析与富化)、enrich(ids)(按 ID 批量取文档做结果富化)、has(id)(判断 ID 是否存在)、remove(ids)(删除一个或多个 ID)、clear()(清空数据,等价 TRUNCATE);
  • 可选方法:search(...)(在数据库侧执行查询交集,为 null 时由索引侧聚合)、info()(存储信息)。

以浏览器端 IndexedDB 为例,src/db/indexeddb/index.js 中 commit 的流程是:先从 flexsearch.commit_task 收集待删除 ID 并执行删除,然后分别对 map(词元映射)、ctx(上下文映射)、reg(ID 注册表)、tag(标签)等 object store 做事务性写入,全部完成后清空索引侧的增量缓存(flexsearch.map.clear() 等),从而把内存增量"滚动"落地。

2.2 自动提交(Auto-Commit)与手动 commit

原文档明确了提交语义:

Auto-Commit is enabled by default and will process changes asynchronously in batch. You can fully disable the auto-commit feature and perform them manually.

即:自动提交默认开启,变更会被异步地批量处理;当你需要确认任务真正完成时,可以显式 await index.commit();即使设置了 commit: true,也随时可以手动调用 commit 方法。

对应的构造函数逻辑在 src/index.js:this.commit_auto = options.commit !== false。而自动提交的触发机制在 autoCommit 函数(src/index.js):它通过 setTimeout(..., 1) 将同一批次内的多次 add/update/remove 合并为一次 db.commit(),这正是"批量异步提交"的来源——高频写操作会被合并成单个数据库事务,避免逐条写入的性能损耗。

手动提交模式示例(disable auto-commit):

const index = new Index({
    db: new Storage("my-store"),
    commit: false          // 关闭自动提交
});
// 更新索引(仅修改内存侧增量)
index.add(1, "content...");
index.update(2, "content...");
index.remove(3);

// 手动将所有变更一次性转移给数据库
await index.commit();

2.3 查询持久化存储

持久化索引的查询与内存索引一样,只是查询结果通过 Promise 返回:

const result = await index.search("gulliver");

以 Redis 适配器为例(src/db/redis/index.js),search 方法会将多词查询转化为 ZSet 的 zInterStore/zUnionStore 操作在数据库侧完成交集与排序,并以 zRange ... REV: true 反向取出按分值排序的结果——这就是"在数据库侧执行查询交集"的落地实现,配合 create_result 按 resolution - score 还原出 FlexSearch 的评分槽位结构。SQLite 适配器(src/db/sqlite/index.js)则用 GROUP BY id + count(*) 的 SQL 实现同样语义,并通过 LEFT JOIN main.reg 完成 enrich 富化。

三、Browser:IndexedDB 适配器实战

IndexedDB 是所有主流浏览器原生支持的持久化存储,无需任何额外依赖。直接使用打包产物中的 IndexedDB 类:

import { Index, IndexedDB } from "../dist/flexsearch.bundle.module.min.js";
// 创建索引
const index = new Index();
// 创建 db 实例,可传入可选的命名空间
const db = new IndexedDB("my-store");
// 挂载并 await,等待数据库就绪后再传输数据
await index.mount(db);

// 照常更新索引
index.add(1, "content...");
index.update(2, "content...");
index.remove(3);

// 变更默认自动提交;若需等待任务完成,可显式提交:
await index.commit();

也可以在建索引时直接通过 db 选项挂载:

const index = new Index({
    db: new IndexedDB("my-store")
});

// 首次访问前 await db 响应
await index.db;
// 然后照常增删改查...

从 src/db/indexeddb/index.js 的实现看,IndexedDB 适配器还有几个值得注意的细节:

  • 数据库标识为 "flexsearch:" + sanitize(name)(未传 name 时仅为 "flexsearch" 并输出提示),sanitize 会把名称转为小写并剔除非法字符(toLowerCase().replace(/[^a-z0-9_\-]/g, ""));
  • open() 时会调用 navigator.storage.persist() 请求持久化配额,降低浏览器回收存储的风险;
  • 打开时会按需创建 map、ctx、tag、reg、cfg 等 object store,reg 是全局的 ID 注册表,其余按字段命名。

IndexedDB 的表结构

原文档给出了清晰的 object store 布局。FlexSearch 会为每个索引名(如 "my-store")创建独立的 DATABASE 条目,因此多个索引可以在同一时刻使用不同 store 而互不冲突;Document Index 则会把字段名映射到 object store 名上:

DATABASE
   |__OBJECTSTORE map:field (FlexSearch Data)
   |__OBJECTSTORE ctx:field (FlexSearch Data)
   |__OBJECTSTORE tag:field (FlexSearch Data)
   |__OBJECTSTORE cfg:field (FlexSearch Data)
   |__OBJECTSTORE reg       (FlexSearch Data)

四、Node.js:五种服务端引擎适配器

Node.js 环境通过 flexsearch/db/<engine> 子路径引入对应适配器。所有引擎的挂载范式一致(以 Postgres 为例):

import { Index } from "flexsearch";
import Database from "flexsearch/db/postgres";
// 创建索引
const index = new Index();
// 创建 db 实例,可传入可选的命名空间
const db = new Database("my-store");
// 挂载并 await,等待数据库就绪后再传输数据
await index.mount(db);

// 照常更新索引
index.add(1, "content...");
index.update(2, "content...");
index.remove(3);

// 变更默认自动提交;若需等待任务完成,可显式提交:
await index.commit();

以下按引擎逐个展开连接配置与专属参数。

4.1 Redis:兼顾内存性能与持久化

Redis 兼具 InMemory 引擎的性能与数据持久化能力,代价是全部数据常驻内存。文档要求安装固定版本的 npm 包:

npm install redis@4.7.0

连接配置与挂载:

import { Index } from "flexsearch";
import Database from "flexsearch/db/redis";

// Redis 连接配置
const config = {
    host: "localhost",
    port: "6379",
    user: null,
    pass: null
};

const index = new Index();
const db = new Database("my-store", config);
await index.mount(db);

index.add(1, "content...");
index.update(2, "content...");
index.remove(3);
await index.commit();   // 显式等待提交完成

自定义 Redis 实例:可传入已经连接好的 redis client,适配器将直接复用而不自行建连(源码中 this.db = config.db || DB || null,src/db/redis/index.js):

import { createClient } from "redis";
import Database from "flexsearch/db/redis";
// 假设你已经创建了一个自定义 redis 实例...
const redis = await createClient("redis://localhost:6379").connect();
// 作为选项传入
const db = new Database("my-store", {
    db: redis
});

ID 类型(type):由于 Redis 一切皆字符串,必须显式定义 ID 类型,否则默认得到字符串化的 ID 结果;当数据内容包含数字字符串(如 "15712")时,定义类型会自动把 ID 转换为你选择的类型:

import Database from "flexsearch/db/redis";
// 强制整型
const db = new Database("my-store", {
    type: "integer"
});
// ...
index.add("15712", "content...");
// ID 会被转换为整型
let result = await index.search("content...");
// -> [15712]

Redis 表结构(前缀命名):FlexSearch 使用前缀风格避免与既有 key 冲突。未设置名称时前缀为 flexsearch|:

flexsearch|map:field
flexsearch|ctx:field
flexsearch|tag:field
flexsearch|cfg:field
flexsearch|reg
flexsearch|doc

设置名称(如 "my-store")后前缀替换为 my-store|:

my-store|map:field
my-store|ctx:field
my-store|tag:field
my-store|cfg:field
my-store|reg
my-store|doc

需要注意的是:每一个 DocumentIndex、WorkerIndex 或独立 Index 实例,都需要创建具有自己名称的 Database 实例。从源码看,Redis 适配器在挂载时会读取索引的 resolution / resolution_ctx(src/db/redis/index.js),并通过 Sorted Set 以 score = resolution - i 保存评分槽位,查询时再用 zRangeWithScores + REV 反向读取,实现最高 32767 槽位的评分精度。

4.2 SQLite:便携文件型数据库

SQLite 把数据存进文件系统上一个便携的 db 文件,紧凑且资源友好。需要安装:

npm install sqlite3@5.1.7

挂载范式同上(import Database from "flexsearch/db/sqlite"),此处不再重复。专属配置如下。

自定义文件路径:不传名称、直接通过 path 指定 db 文件位置:

const db = new Database({
    path: "./path-to-db/main.db"
});
// ...
await index.mount(db);

自定义 DB 实例:传入已创建的 sqlite3.Database:

import sqlite3 from "sqlite3";
import Database from "flexsearch/db/sqlite";

// 假设你已经创建了一个自定义数据库实例...
const database = new sqlite3.Database("./path-to-db/main.db");

const db = new Database("my-store", {
    db: database
});
// ...
await index.mount(db);

ID 类型:由于 SQLite 驱动不支持通过 ALTER TABLE 升级 key 字段类型,ID 默认类型为 text。显式定义数值类型可节省磁盘空间并提升性能:

// 整型
const db = new Database("my-store", {
    type: "integer"
});

BigInt 范围:

const db = new Database("my-store", {
    type: "bigint"
});

需要修改 ID 类型时,只能通过 index.db.destroy() 删除索引后重建(这一限制源自 SQLite 无法原地升级主键列类型)。

内存引擎:将 :memory: 作为名称传入,即可使用 SQLite 原生的内存存储:

const db = new Database(":memory:");

SQLite 表结构:FlexSearch 为每个索引名创建独立的 .sqlite 文件(文件名为 flexsearch-<name>.sqlite,可自定义 path 覆盖),Document Index 的字段名映射为表名后缀:

FILENAME
  |__ MAIN
        |__TABLES map:field (FlexSearch Data)
        |__TABLES ctx:field (FlexSearch Data)
        |__TABLES tag:field (FlexSearch Data)
        |__TABLES cfg:field (FlexSearch Data)
        |__TABLES reg       (FlexSearch Data)

从 src/db/sqlite/index.js 可以看到建表细节:map 表为 (key TEXT, res INTEGER, id <type>),ctx 表为 (ctx TEXT, key TEXT, res INTEGER, id <type>),均建有索引;reg 表以 id 为主键并带有 doc 列用于文档存储。写入时通过批量 INSERT 并控制单条语句参数不超过 MAXIMUM_QUERY_VARS = 16000,事务内 BEGIN/COMMIT 包裹,并设置了 PRAGMA busy_timeout = 5000 应对写锁。查询时用 ORDER BY res LIMIT/OFFSET 实现游标分页,get 支持通过子查询 id IN (SELECT id FROM main.tag_<tag> WHERE tag = ?) 做多标签交集过滤。

4.3 PostgreSQL:默认数据库与横向扩展

Postgres 是大数据量承载与扩展能力的默认选择。需要安装:

npm install pg-promise@11.10.2

连接配置与挂载:

import { Index } from "flexsearch";
import Database from "flexsearch/db/postgres";

// 数据库连接配置
const config = {
    user: "postgres",
    pass: "postgres",
    host: "localhost",
    port: "5432",
    // 数据库名:
    name: "postgres"
};

const index = new Index();
const db = new Database("my-store", config);
await index.mount(db);

index.add(1, "content...");
index.update(2, "content...");
index.remove(3);
await index.commit();

自定义 DB 实例:传入 pg-promise 创建的实例:

import pg_promise from "pg-promise";
import Database from "flexsearch/db/postgres";
const pgp = pg_promise();
// 假设你已经创建了一个自定义数据库实例...
const database = pgp(`postgres://${user}:${pass}@${host}:${port}/${name}`);
const db = new Database("my-store", {
    db: database
});

ID 类型与自动升级:Postgres 驱动支持通过 ALTER TABLE 升级类型,索引会从 integer 自动升级为 bigint 或 string。一旦升级过,想切回原类型需要重建索引。同样地,当数据内容包含数字字符串(如 ID "15712")时,定义 type 会自动完成类型转换:

import Database from "flexsearch/db/postgres";
// 强制整型
const db = new Database("my-store", {
    type: "integer"
});
// ...
// 字符串会被转换为整型
index.add("15712", "content...");

表结构(SCHEMA 隔离):FlexSearch 为每个索引名创建独立的 SCHEMA,避免多索引命名冲突:

DATABASE_NAME
  |__ SCHEMA
        |__TABLE map:field (FlexSearch Data)
        |__TABLE ctx:field (FlexSearch Data)
        |__TABLE tag:field (FlexSearch Data)
        |__TABLE cfg:field (FlexSearch Data)
        |__TABLE reg       (FlexSearch Data)

也可以不传名称、强制指定 SCHEMA:

const db = new Database({
    schema: "public"
});

与 Redis/SQLite 相同,每个 DocumentIndex、WorkerIndex 或独立 Index 实例都需要拥有自己 SCHEMA 的 Database 实例。

4.4 MongoDB:NoSQL 文档存储

MongoDB 作为 NoSQL 文档库提供完整的 FlexSearch 存储能力。需要安装:

npm install mongodb@6.13.0

挂载范式与 Redis/SQLite 相同(import Database from "flexsearch/db/mongodb")。专属配置为自定义连接:

import { MongoClient } from "mongodb";
import Database from "flexsearch/db/mongodb";
// 假设你已经创建了一个自定义数据库实例...
const database = new MongoClient("mongodb://localhost:27017/");
// 连接并 await
await database.connect();
const db = new Database("my-store", {
    db: database
});

MongoDB 表结构:FlexSearch 为每个索引名创建独立的 DATABASE 条目,Document Index 的字段名映射为 collection 名:

DATABASE
   |__COLLECTION map:field (FlexSearch Data)
   |__COLLECTION ctx:field (FlexSearch Data)
   |__COLLECTION tag:field (FlexSearch Data)
   |__COLLECTION cfg:field (FlexSearch Data)
   |__COLLECTION reg       (FlexSearch Data)

每个 DocumentIndex、WorkerIndex 或独立 Index 实例同样需要拥有自己名称的 Database 实例。

4.5 Clickhouse:面向高频写入的分析型引擎

Clickhouse 针对原始 I/O 与写入做了高度优化,当索引需要频繁更新时,可显著减少阻塞式写入。需要安装:

npm install clickhouse@2.6.0

连接配置与挂载:

import { Index } from "flexsearch";
import Database from "flexsearch/db/clickhouse";

// 数据库连接配置
const config = {
    host: "http://localhost",
    port: "8123",
    database: "default",
    basicAuth: null,
    debug: false
};

const index = new Index();
const db = new Database("my-store", config);
await index.mount(db);

index.add(1, "content...");
index.update(2, "content...");
index.remove(3);
await index.commit();

自定义 DB 实例:

import { ClickHouse } from "clickhouse";
import Database from "flexsearch/db/clickhouse";
// 假设你已经创建了一个自定义数据库实例...
const database = new ClickHouse({/* config */});
const db = new Database("my-store", {
    db: database
});

ID 类型:Clickhouse 驱动不支持通过 ALTER TABLE 升级 merge key,因此 ID 默认类型为 text;显式定义数值类型可节省磁盘并提升性能:

import Database from "flexsearch/db/clickhouse";
// 强制整型
const db = new Database("my-store", {
    type: "integer"
});
// ...
index.add("15712", "content...");
// ID 会被转换为整型
let result = await index.search("content...");
// -> [15712]

BigInt 支持:

const db = new Database("my-store", {
    type: "bigint"
});

与 SQLite 类似,之后要修改类型必须 db.destroy() 删除并 db.mount() 重建。

表结构与默认数据库:FlexSearch 为每个索引名创建独立的 DATABASE 条目:

DATABASE
   |__TABLE map:field (FlexSearch Data)
   |__TABLE ctx:field (FlexSearch Data)
   |__TABLE tag:field (FlexSearch Data)
   |__TABLE cfg:field (FlexSearch Data)
   |__TABLE reg       (FlexSearch Data)

Clickhouse 的默认数据库通常名为 default,首次连接创建新数据库时必须依赖它。也可通过选项强制指定默认数据库:

const db = new Database({
    database: "public"
});

五、命名隔离原则:为什么每个索引都要独立存储空间

六种引擎的适配器虽然底层形态各异(IndexedDB 的 DATABASE、Redis 的 key 前缀、SQLite 的独立文件、Postgres 的 SCHEMA、MongoDB/Clickhouse 的 DATABASE),但遵循同一条规则:FlexSearch 会为每个索引名创建独立、互不冲突的存储空间,Document Index 再把字段名映射为表/集合/前缀后缀名。因此:

  • 不同索引可以在同一时刻连接不同引擎、使用不同名称并行存在;
  • 同一个引擎实例内,通过"名称"这一维度天然隔离各索引的数据;
  • 每个 DocumentIndex、WorkerIndex 或独立 Index(standalone)都必须创建具有自己名称(或 schema/path) 的 Database 实例,禁止共享同一命名空间,否则会造成数据交叉污染。

这一设计在 src/db/redis/index.js(this.id = sanitize(name) + "|")、src/db/sqlite/index.js(this.id = config.path || "flexsearch-" + sanitize(name) + ".sqlite")、src/db/indexeddb/index.js(this.id = "flexsearch:" + sanitize(name))中都能直接看到:名称经过 sanitize(小写化 + 剔除非法字符)后,成为隔离标识的一部分。

六、Delete Store 与迁移(clear / destroy / 重建循环)

原文档明确指出:目前不存在迁移工具。未来版本更新或需要重建索引时,你可能需要自己完成某种迁移。因此理解 clear 与 destroy 的语义至关重要。

[!CAUTION] 请谨慎使用 index.destroy() 和 index.clear()。这两个方法会根据初始化时传入的 name,相应地删除(truncate / drop)数据库中的内容。命名不当可能误删数据。

6.1 clear:清空内容(等价 TRUNCATE)

只清空与索引关联的 store 中的所有内容,保留表/库结构:

// 初始化时务必传入唯一名称
const db = new Database("my-store", config);
await index.mount(db);
// 清空所有内容
await index.clear();

从实现看,各引擎的 clear 都是对自身表/存储执行 truncate 语义:IndexedDB 对 map/ctx/tag/reg/cfg 各 object store 执行 clear()(src/db/indexeddb/index.js),SQLite 对 map/ctx/tag/cfg/reg 各表执行 DELETE FROM ... WHERE 1(src/db/sqlite/index.js),Redis 则用 KEYS 匹配前缀后 UNLINK(src/db/redis/index.js)。

6.2 destroy:删除全部表与库结构

删除与索引关联的全部表(以及其 schema / 库结构):

const db = new Database("my-store", config);
await index.mount(db);
// 删除所有关联的表
await index.destroy();

对应实现:IndexedDB 是 IndexedDB.deleteDatabase(this.id),SQLite 是 DROP TABLE IF EXISTS main.map/ctx/tag/cfg/reg,Redis 的 destroy() 直接委托给 clear(true)(destroy 模式下通配匹配所有前缀 key 并 unlink)。

6.3 完整迁移循环

一次完整的迁移/重建可以组合为:销毁 → 重新挂载(触发建表)→ 继续使用:

// 初始化时务必传入唯一名称
const db = new Database("my-store", config);
await index.mount(db);
// 删除所有关联的表
await index.destroy();
// 销毁后需要重新挂载,以触发建表流程
await index.mount(db);
// 然后照常访问索引...

七、跑通一个真实示例:Node.js CommonJS 持久化入门

仓库在 example/nodejs-commonjs/basic-persistent 提供了一个最小可运行的完整示例(index.js),默认使用 SQLite,一行注释即可切换 Postgres/MongoDB/Redis/Clickhouse:

const { Index } = require("flexsearch");
const Sqlite = require("flexsearch/db/sqlite");
// const Postgres = require("flexsearch/db/postgres");
// const MongoDB = require("flexsearch/db/mongodb");
// const Redis = require("flexsearch/db/redis");
// const Clickhouse = require("flexsearch/db/clickhouse");

(async function(){

    // 创建带命名空间的 DB 实例
    const db = new Sqlite("my-store");

    // 创建一个可存 id-content 对的简单索引
    const index = new Index({
        tokenize: "forward"
    });

    // 把数据库挂载到索引
    await index.mount(db);
    // 如需重建:await index.destroy(); await index.mount(db);

    // 测试数据
    const data = [
        'cats abcd efgh ijkl mnop qrst uvwx cute',
        'cats abcd efgh ijkl mnop qrst cute',
        'cats abcd efgh ijkl mnop cute',
        'cats abcd efgh ijkl cute',
        'cats abcd efgh cute',
        'cats abcd cute',
        'cats cute'
    ];

    // 向索引添加数据
    data.forEach((item, id) => {
        index.add(id, item);
    });

    // 批量转移变更
    await index.commit();

    // 执行查询
    const result = await index.search({
        query: "cute cat"
    });

    // 展示结果
    result.forEach(i => {
        console.log(data[i]);
    });

}());

对应浏览器端示例见 example/browser-module/basic-persistent 与 example/browser-legacy/basic-persistent(IndexedDB),文档索引场景见 example/nodejs-commonjs/document-persistent 与 example/browser-module/document-persistent。各引擎的专项文档分别位于 doc/persistent-indexeddb.md、doc/persistent-redis.md、doc/persistent-sqlite.md、doc/persistent-postgres.md、doc/persistent-mongodb.md、doc/persistent-clickhouse.md。

八、附:各引擎 Benchmark 参考(terms per second)

原文档附有一份以 "terms per second" 为单位的基准测试表,测试针对单客户端执行,其中 Search 1 为单词查询,Search N 为多词查询(Context-Search)。该数据用于横向感受各引擎在不同操作上的吞吐量级差异:

Store Add Search 1 Search N Replace Remove Not Found Scaling
IndexedDB 123,298 83,823 62,370 57,410 171,053 425,744 No
Redis 1,566,091 201,534 859,463 117,013 129,595 875,526 Yes
Sqlite 269,812 29,627 129,735 174,445 1,406,553 122,566 No
Postgres 354,894 24,329 76,189 324,546 3,702,647 50,305 Yes
MongoDB 515,938 19,684 81,558 243,353 485,192 67,751 Yes
Clickhouse 1,436,992 11,507 22,196 931,026 3,276,847 16,644 Yes

几点解读供选型参考(均来自原文档标注与源码结构推断,不代表任何排名结论):

  • Redis 与 Clickhouse 在 Add(写入)吞吐上领先,这与文档所述"Clickhouse 高度优化原始 I/O 与写访问"一致;Redis 的 Search N 与 Not Found 也很突出,得益于 ZSet 集合运算的数据库侧聚合;
  • IndexedDB 无 Scaling(无法跨节点扩展),仅适用于浏览器单端场景;而 Redis、Postgres、MongoDB、Clickhouse 均标记为可扩展(Yes),支撑原文档"持久化存储天然支持集群多节点共享"的论断;
  • 由于内存索引的该行在文档中被注释掉(<!-- ... -->),本文不再展示内存侧数据,避免引入未经确认的数值。

需要再次强调:这些数值是原文档记录的特定环境测量结果,实际吞吐取决于硬件、数据规模、网络与数据库配置,仅作相对量级的参考。

九、小结

持久化索引是 FlexSearch 面向生产环境的进阶能力,其核心心智模型可以总结为三句话:

  1. 一个索引、一个命名存储:无论选择 IndexedDB(浏览器)还是 Redis/SQLite/Postgres/MongoDB/Clickhouse(Node.js),都通过 await index.mount(db) 建立绑定,且每个索引实例必须拥有独立命名的 Database;
  2. 增删改查照旧,提交可显式:add/update/remove/search API 与内存索引一致,自动提交默认开启并批量异步落地,需要确认完成时随时 await index.commit();
  3. 生命周期谨慎操作:clear() 是 TRUNCATE,destroy() 是 DROP,改名或换类型必须走"destroy → mount → 重建"循环,且当前仓库没有内置迁移工具,迁移需自行编排。

通过 src/db/interface.js 定义的统一接口与各引擎适配器(src/db/indexeddb/index.js、src/db/redis/index.js、src/db/sqlite/index.js 等),FlexSearch 把全文索引的"内存增量合并 + 批量落地 + 数据库侧聚合查询"完整流水线化,这也是它在集群场景下能够跨节点共享、支撑大规模索引的根本原因。

登录后查看全文
flexsearch