PostgreSQL全文搜索：在数据库里实现高效检索

可视化演示

动态演示PostgreSQL全文搜索的核心机制，通过输入/处理/存储/输出四种模式展示关键概念与交互流程。

搜索原理：从翻书到查目录

老管理员找书，靠的不是把每本书翻一遍，而是大厅角落那排抽屉柜。柜子里插满卡片，每张卡片顶端写着一个关键词，下面密密麻麻排着书号。想找“数据库”相关的书，抽出“数据库”这张卡片，书号直接出现在眼前。这套机制的学名叫倒排索引——正常索引是“书 → 关键词”的正向关系，而倒排索引把方向反过来，建成“关键词 → 书籍列表”，正好匹配“按内容找书”的检索场景。

PostgreSQL 的全文搜索正是围绕倒排索引设计的。当你用 LIKE '%数据库%' 搜索时，数据库必须逐行扫描、逐行做字符串匹配，就像新手管理员翻书；而全文搜索先把每篇文档拆解成词条（这个过程叫词项归一化：转小写、去停用词、还原词根），再将这些词条连同文档编号一起存入倒排索引，查询时只需查找索引。

为了让结果更聪明，搜索引擎还引入了相关度打分：一篇文档里关键词出现得越多、这个词在全库越罕见，这篇文档就越“相关”。这就是 TF-IDF 的核心思想：

目录柜的想法很朴素，但正是这套“关键词 → 书号”的反向映射，让全文搜索比翻书快上几个数量级。接下来我们看 PostgreSQL 如何把一本书变成一张目录卡——这就是 tsvector。

tsvector 词向量：编目员写下的目录卡

老管理员从不整本抄书。他拿过一本书，翻一翻，提炼出几十个关键词，每个词后面标注它出现在第几页，再按重要程度贴上不同颜色的标签。PostgreSQL 里的 tsvector 就是这张目录卡：把一整篇文本压缩成“词素 + 位置 + 权重”的集合，体积小、检索快。

创建目录卡的工具是 to_tsvector 函数。它会先调用分词器把文本拆成词，再做归一化（英文转小写、去词尾变化），最后记录每个词在原文里的位置。看一个例子：

注意 jumps 变成了 jump，lazy 变成了 lazi，这就是词根还原。每个词后面的数字是位置编号，而权重（A/B/C/D）可以后续手动指定，比如标题里的词标为 A，正文里的词标为 D。数学上，tsvector 就是一组三元组的集合：

目录卡建好了，读者要怎样描述需求呢？这就轮到 tsquery 登场。

SELECT to_tsvector('english', 'The quick brown fox jumps over the lazy dog');-- 结果: 'fox':4  'jump':5  'lazi':8  'quick':2

tsquery 查询：读者填写的查询单

读者在查询单上写：“我要数据库 和 性能相关的书，但 不要 讲缓存的。”管理员一看就能明白：取“数据库”和“性能”两张卡片的交集，再排除“缓存”卡片上的书。tsquery 就是这张结构化查询单，它支持 &（同时满足，即 AND）、|（任一满足，即 OR）、!（排除，即 NOT）三种逻辑运算。

构造查询用 to_tsquery，它和 to_tsvector 使用同一个分词器，保证查询词和文档词用同一套规则归一化：

to_tsquery 还支持两种进阶写法：用 <-> 表示“两个词必须相邻出现”（短语匹配），如 高性能 <-> 数据库；用 :* 表示前缀匹配，如 数据:* 能命中“数据”“数据库”“数据结构”。查询的匹配条件本质上是一个布尔表达式：

有了查询单，图书馆里的目录柜得够快才行。GIN 索引就是这个“快”的关键。

SELECT to_tsquery('english', 'postgres & (performance | index)');-- 结果: 'postgres' & ( 'perform' | 'index' )

GIN 索引：装卡片的大柜子

目录卡片如果随意堆在桌上，找起来一样慢。PostgreSQL 用 GIN（Generalized Inverted Index） 索引来存放 tsvector 中的词条。它的内部结构是：每个词条对应一个倒排表，表中记录哪些文档包含这个词。查询时只需要两步：先找到词条，再取出这个文档列表。

GIN 基于 B-tree 组织词条，所以定位词条的复杂度是 O(log n)；随后取文档列表的耗时正比于命中文档数。于是整体查询代价是：

创建 GIN 索引很简单，但要注意：通常先把文本转成独立的 tsvector 列，再对该列建索引，避免每次查询都现场转换：

GIN 的代价是“写放大”：每插入一篇文章，要更新多个词条的倒排表，写入比普通 B-tree 索引更慢。查询快、写入慢，这就是目录柜的保养费。中文书籍进馆时还有一个特殊问题——中文没有空格，编目员怎么切词？

ALTER TABLE articles ADD COLUMN body_tsv tsvector;UPDATE articles SET body_tsv = to_tsvector('english', body);CREATE INDEX idx_gin_body ON articles USING GIN (body_tsv);

中文分词：给中文书籍编目

英文图书的词汇天然被空格分开，编目员照抄即可。但中文的一句“研究生命科学”可以切出“研究/生命/科学”，也可能被切出“研究生/命/科学”，含义天差地别。PostgreSQL 默认的分词器只认识空格和标点，面对连续汉字会不知所措，所以中文搜索必须引入专门的分词插件。

主流的两个方案是 zhparser（基于 SCWS 分词引擎）和 pg_jieba（结巴分词的 PG 移植）。它们的原理类似：在预置词典的基础上，用统计语言模型挑选概率最大的切分方式。给定句子 S，分词器在所有可能的切分中寻找累计概率最高的一种：

实际配置时，装好扩展后需要创建名为 zhparser 或 jieba 的全文搜索配置，并在每次建 tsvector 时指定它。整套配置只在会话内生效，重启数据库后仍需设置 search_path——这也是后面误区部分要提醒的重点。切好词、建好目录卡，最后一个问题浮出水面：命中的十本书里，哪本最值得读？

排序调优：按推荐度排书架

当“数据库 + 性能”命中三十本书时，管理员不能把这三十本一股脑堆给读者，他得按推荐度排个序：整本专讲数据库性能的书排最前，只在第一章提到一句的排最后。PostgreSQL 用 ts_rank 函数给每篇命中文档打分，分高者排在前面。

打分的依据有两个：一是词条在文档里的权重等级（A 比 D 贡献大），二是词条在文档中的出现频次。setweight 可以给已构造的 tsvector 批量赋权，比如标题字段设为 A、正文字段设为 D：

一个常见技巧是用 COALESCE 合并多个向量：setweight(to_tsvector(title),'A') || setweight(to_tsvector(body),'D')，这样标题命中的文档自然排在正文命中的前面。简化后的排序模型是：

排序规则明确后，全文搜索的整套工具链就齐了。但还有一个问题藏在幕后：这套方案到底适合什么规模？什么时候该把书搬进更大的图书馆？

SELECT title, ts_rank(body_tsv, query) AS rankFROM articles,     to_tsquery('english', 'database & performance') AS queryWHERE body_tsv @@ queryORDER BY rank DESC;

实践应用：何时换大设备

社区图书馆藏书一万本，配一个抽屉目录柜绰绰有余；可如果藏书千万册、高峰时段每分钟来一千个读者，手抄卡片柜就撑不住了——该上自动化检索系统了。PostgreSQL 全文搜索与 Elasticsearch 的分界线，本质上是数据量与并发量的分界线。

经验上，百万行以内的数据、峰值百 QPS 以内的查询，PG 全文搜索完全能胜任：它不需要引入额外服务，支持事务，数据一致性有保障。而 Elasticsearch 适合海量数据、高并发、需要复杂聚合分析、滚动搜索等场景。判断是否升级，可以套用一个粗略的决策式：

无论是否升级，PG 内部的优化都不可少：定期 VACUUM 控制 GIN 索引膨胀、把 tsvector 独立成列避免重复计算、用 EXPLAIN ANALYZE 确认索引真的被使用。理解了这些边界，你就能像那位老管理员一样——小图书馆用抽屉柜，大图书馆用自动化系统，心里始终有本明白账。

AI 应用场景

Python 演示

"""模拟 PostgreSQL 全文搜索：构建倒排索引并执行查询。"""import mathimport re STOPWORDS = {"de", "le", "et", "en", "un", "une"}  def tokenize(text):    """简易分词：英文按单词，中文按单字 + 相邻二元组。"""    text = text.lower()    latin = re.findall(r"[a-z0-9]+", text)    han = re.findall(r"[\u4e00-\u9fff]", text)    bigrams = [han[i] + han[i + 1] for i in range(len(han) - 1)]    words = [w for w in latin if w not in STOPWORDS] + han + bigrams    return words  def build_index(docs):    """返回倒排索引：term -> {doc_id: [positions]}。"""    index = {}    for doc_id, doc in enumerate(docs):        terms = tokenize(doc["content"])        for pos, term in enumerate(terms):            if term not in index:                index[term] = {}            if doc_id not in index[term]:                index[term][doc_id] = []            index[term][doc_id].append(pos)    return index  def search(query, docs, index, top_k=3):    """执行布尔查询，返回 (doc_id, score) 列表。"""    q_terms = set(tokenize(query))    scores = {}    for term in q_terms:        if term not in index:            continue        entries = index[term]        idf = math.log(len(docs) / (len(entries) + 1)) + 1        for doc_id, positions in entries.items():            scores[doc_id] = scores.get(doc_id, 0) + idf * len(positions)    ranked = sorted(scores.items(), key=lambda x: x[1], reverse=True)    return [(doc_id, round(score, 3)) for doc_id, score in ranked[:top_k]]  if __name__ == "__main__":    docs = [        {"title": "PostgreSQL 优化指南", "content": "数据库 索引 性能 优化 查询"},        {"title": "全文搜索原理", "content": "全文 检索 倒排 索引 数据库"},        {"title": "Redis 缓存实践", "content": "缓存 性能 数据库 并发"},        {"title": "搜索引擎设计", "content": "全文 搜索 索引 排序"},        {"title": "GIN 索引原理", "content": "索引 数据库 搜索 性能"},        {"title": "中文分词技术", "content": "分词 中文 全文 检索"},    ]    index = build_index(docs)    print("倒排索引片段:", {k: v for k, v in list(index.items())[:3]})    for doc_id, score in search("数据库 索引", docs, index):        print("命中:", docs[doc_id]["title"], "score =", score)

1. latin = re.findall(r"[a-z0-9]+", text)先抽出英文单词和数字，模拟英文分词。
2. bigrams = [han[i] + han[i + 1] for i in range(len(han) - 1)]中文按相邻两字组合成词，模拟简单二元分词。
3. index[term][doc_id].append(pos)这就是在搭建倒排表：每个词条记录它出现在哪些文档、哪些位置。
4. idf = math.log(len(docs) / (len(entries) + 1)) + 1计算逆文档频率，词条越罕见权重越高。
5. scores[doc_id] = scores.get(doc_id, 0) + idf * len(positions)累加每个词条的贡献，相当于本文的 ts_rank 简化版。
6. ranked = sorted(scores.items(), key=lambda x: x[1], reverse=True)按分数降序排列，返回最相关的 Top-K 篇文档。

常见误区

面试题