纲要
- ANN(Approximate Nearest Neighbor,近似最近邻)搜索
- 精确搜索 vs 近似搜索
- 召回率(Recall)的定义与意义
- pgvector 索引类型
- IVFFlat(Inverted File with Flat Compression)
- 聚类(K-Means)原理
lists参数probes参数- 适用场景与限制
- HNSW(Hierarchical Navigable Small World)
- 分层图结构原理
m参数ef_construction参数ef_search参数- 适用场景与限制
- IVFFlat(Inverted File with Flat Compression)
- IVFFlat 与 HNSW 对比
- pgvector 版本演进
- 距离度量与操作符类
- 索引创建与查询调优
精确搜索与近似搜索
在向量相似性搜索中,最直接的方法是精确最近邻搜索(Exact Nearest Neighbor Search):计算查询向量与表中每一行向量之间的距离,然后返回距离最小的行。这种方法能够保证 100% 的召回率,但计算成本随数据量线性增长。对于 10,000 行的表,精确搜索约需 36ms;而当数据量增长至 1,000,000 行时,查询耗时可能达到数秒级别。
近似最近邻搜索(Approximate Nearest Neighbor,ANN)以牺牲少量精度为代价换取数量级的性能提升。ANN 算法将向量组织为特定的数据结构,使查询时仅需检查部分向量。衡量 ANN 搜索质量的核心指标是召回率(Recall):近似搜索结果中真实最近邻所占的比例。例如,召回率 95% 意味着在 100 个真实的最近邻中,平均有 95 个被近似搜索返回。大多数 AI 应用在 95%-99% 的召回率下即可获得良好的实际效果。
pgvector 提供了两种 ANN 索引类型:IVFFlat 和 HNSW。
IVFFlat 索引
原理
IVFFlat(Inverted File with Flat Compression)的核心思想是向量聚类。在索引创建期间,pgvector 对已有向量执行 K-Means 聚类,将向量分组到指定数量的列表(Lists/聚类中心)中。每个聚类中心(质心)是该聚类中所有向量的平均位置。
查询时,pgvector 计算查询向量到每个聚类中心的距离,识别出最近的若干聚类(由 probes 参数控制),然后仅在这些聚类内部进行搜索。这种方式将距离计算次数从总行数减少到约 (rows / lists) * probes。
关键参数
lists(索引构建时指定)
lists 控制聚类数量。更多的列表意味着每个聚类包含的向量更少,查询速度更快;但如果聚类将语义相似的向量拆分到不同聚类中,则可能降低召回率。
推荐起始值:
- 行数 ≤ 1,000,000:
lists = rows / 1000 - 行数 > 1,000,000:
lists = sqrt(rows)
probes(查询时指定)
probes 控制查询时要搜索的聚类数量。增加 probes 的值可提高召回率,但会增加查询延迟。默认值为 1。
-- 设置当前会话的 probes 值
SET ivfflat.probes = 10;
-- 或在查询级别设置
SELECT * FROM items
ORDER BY embedding <=> '[0.1, 0.2, ...]'
LIMIT 10;
限制
IVFFlat 索引必须在表中已有代表性数据之后创建。这是因为索引构建时需要执行 K-Means 聚类,而聚类依赖于实际的数据分布。如果在空表上创建 IVFFlat 索引,召回率会显著降低。
此外,当新增数据量超过原始数据量的一倍以上时,原有的聚类结构可能不再适用,需要重建索引。
HNSW 索引
原理
HNSW(Hierarchical Navigable Small World,分层导航小世界)是一种基于分层图结构的 ANN 算法。它构建了多层的邻近图:越上层的图越稀疏(节点更少、连接更少),越下层的图越密集。查询时从顶层开始,逐层向下搜索,快速定位到目标区域。
HNSW 的核心思想源于“六度分隔理论”(Six Degrees of Separation)—— 任意两个节点之间通过很少的中间节点即可建立连接。NSW(Navigable Small World)是 HNSW 的前身,HNSW 在其基础上引入了分层结构以提升搜索效率。
关键参数
HNSW 有三个核心调优参数:
构建时参数
| 参数 | 默认值 | 说明 |
|---|---|---|
m | 16 | 每个节点的最大连接数。值越高,召回率越高,但内存占用也越大 |
ef_construction | 64 | 索引构建时的动态候选列表大小。值越高,构建的图质量越好,但构建时间越长 |
查询时参数
| 参数 | 默认值 | 说明 |
|---|---|---|
ef_search | 40 | 查询时的动态候选列表大小。值越高,召回率越高,但查询越慢 |
-- 创建 HNSW 索引
CREATE INDEX idx_items_embedding_hnsw ON items
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);
-- 设置查询时的 ef_search(会话级别)
SET hnsw.ef_search = 100;
-- 或在事务中设置
SET LOCAL hnsw.ef_search = 200;
优势与限制
HNSW 的优势:
- 查询速度更快,召回率更高
- 支持动态插入,无需在数据加载后重建索引
- 可在空表上创建索引
HNSW 的限制:
- 索引构建时间更长
- 内存占用更大(索引通常保存在内存中以获得最佳性能)
- 对于 1,000,000 行、1,536 维的向量,HNSW 索引约占用 6GB 磁盘空间,且需要相近的内存
IVFFlat 与 HNSW 对比
| 对比维度 | IVFFlat | HNSW |
|---|---|---|
| 查询速度 | 较慢 | 更快(可达 17 倍) |
| 召回率 | 较低,依赖 lists/probes 调优 | 更高(0.95-0.99) |
| 索引构建速度 | 更快(仅需一次聚类) | 更慢(需构建多层图) |
| 内存占用 | 更少 | 更大 |
| 增量数据支持 | 敏感,需定期重建 | 友好,支持动态插入 |
| 索引创建时机 | 需在数据加载后创建 | 可在空表上创建 |
| 适用场景 | 高写入频率、需频繁重建索引的场景 | 大多数生产工作负载(推荐) |
距离度量与操作符类
pgvector 支持多种距离度量方式:
| 距离类型 | 操作符 | 操作符类 | 说明 |
|---|---|---|---|
| 余弦距离 | <=> | vector_cosine_ops | 大多数现代嵌入模型的默认选择 |
| 欧氏距离(L2) | <-> | vector_l2_ops | 通用选择 |
| 内积 | <#> | vector_ip_ops | 向量已归一化时计算最快 |
| L1 距离 | <+> | - | 较少使用 |
创建索引时,操作符类必须与查询中使用的距离操作符匹配。
-- 余弦距离索引
CREATE INDEX idx_cosine ON items USING ivfflat (embedding vector_cosine_ops);
-- 欧氏距离索引
CREATE INDEX idx_l2 ON items USING ivfflat (embedding vector_l2_ops);
pgvector 版本演进
pgvector 自发布以来持续增强 ANN 能力:
- 0.4.x:基础性能优化,查询性能提升
- 0.5.0:正式引入 HNSW 索引支持,同时支持 IVFFlat 并行构建
- 0.6.0:HNSW 并行构建支持
- 0.7.0:引入半精度(half-precision)和二进制量化(binary quantization)支持,进一步压缩索引体积
这些演进使 pgvector 在保持 PostgreSQL 生态兼容性的同时,逐渐追平专业向量数据库的能力。
API 速览
本节列出 pgvector 中与索引管理和向量查询相关的核心 SQL API。
启用扩展
CREATE EXTENSION IF NOT EXISTS vector;
向量类型与表创建
向量类型为 vector(n),其中 n 表示维度。
CREATE TABLE items (
id bigserial PRIMARY KEY,
embedding vector(1536), -- 例如 OpenAI 嵌入维度
metadata jsonb
);
插入向量数据
INSERT INTO items (embedding, metadata)
VALUES ('[0.1, 0.2, ...]', '{"name": "sample"}');
创建 IVFFlat 索引
CREATE INDEX idx_items_ivfflat ON items
USING ivfflat (embedding vector_cosine_ops)
WITH (lists = 1000);
创建 HNSW 索引
CREATE INDEX idx_items_hnsw ON items
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);
执行向量相似性查询
-- 使用余弦距离,返回最相似的 10 个结果
SELECT id, metadata
FROM items
ORDER BY embedding <=> '[0.1, 0.2, ...]'
LIMIT 10;
-- 同时返回距离值
SELECT id, metadata, embedding <=> '[0.1, 0.2, ...]' AS distance
FROM items
ORDER BY distance
LIMIT 10;
调整运行时参数
IVFFlat 的 probes:
SET ivfflat.probes = 10;
HNSW 的 ef_search:
SET hnsw.ef_search = 100;
Demo 简单示例
以下是一个完整的 Node.js 示例,使用 pg 驱动连接 PostgreSQL(已安装 pgvector 扩展),演示创建表、插入数据、建立索引和执行向量检索。
运行说明
- 确保 PostgreSQL 已安装 pgvector 扩展(参考 pgvector 安装指南)。
- 创建数据库并启用扩展:
CREATE EXTENSION vector; - 安装 Node.js 依赖:
npm install pg - 运行脚本:
node demo.js
代码示例 (demo.js)
const { Client } = require('pg');
// 数据库连接配置
const client = new Client({
host: 'localhost',
port: 5432,
user: 'postgres',
password: 'your_password',
database: 'testdb',
});
(async () => {
await client.connect();
// 1. 创建表(使用 vector 类型,维度为 3 仅作演示)
await client.query(`
DROP TABLE IF EXISTS items;
CREATE TABLE items (
id SERIAL PRIMARY KEY,
embedding vector(3)
);
`);
// 2. 插入示例向量
const vectors = [
[1, 1, 1],
[1, 2, 1],
[5, 5, 5],
[6, 6, 6],
[10, 10, 10],
];
for (const v of vectors) {
await client.query(
'INSERT INTO items (embedding) VALUES ($1)',
[`[${v.join(',')}]`]
);
}
console.log('Inserted 5 vectors.');
// 3. 创建 IVFFlat 索引(注意:必须存在数据后创建)
await client.query(`
CREATE INDEX idx_items_ivfflat ON items
USING ivfflat (embedding vector_l2_ops)
WITH (lists = 2);
`);
console.log('IVFFlat index created.');
// 4. 设置 probes 参数(可选)
await client.query('SET ivfflat.probes = 2;');
// 5. 执行近似最近邻查询(L2 距离)
const queryVec = [1, 1, 1];
const res = await client.query(
`SELECT id, embedding, embedding <-> $1 AS distance
FROM items
ORDER BY distance
LIMIT 3;`,
[`[${queryVec.join(',')}]`]
);
console.log('Query results:');
res.rows.forEach(row => {
console.log(`ID: ${row.id}, Distance: ${row.distance.toFixed(4)}`);
});
await client.end();
})();
对应的 PostgreSQL 原生 SQL 注释
上述操作等效于以下 SQL 命令(可直接在 psql 中执行):
-- 创建扩展(若未安装)
CREATE EXTENSION vector;
-- 建表
CREATE TABLE items (id SERIAL PRIMARY KEY, embedding vector(3));
-- 插入数据
INSERT INTO items (embedding) VALUES
('[1,1,1]'), ('[1,2,1]'), ('[5,5,5]'), ('[6,6,6]'), ('[10,10,10]');
-- 创建 IVFFlat 索引(需要数据已存在)
CREATE INDEX idx_items_ivfflat ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 2);
-- 设置 probes(可选)
SET ivfflat.probes = 2;
-- 查询(使用 <-> L2 距离)
SELECT id, embedding, embedding <-> '[1,1,1]' AS distance
FROM items
ORDER BY distance
LIMIT 3;
技术点总结
- 演示了 pgvector 扩展启用、向量表创建和向量数据插入。
- 使用 IVFFlat 索引并指定
lists参数,强调了数据加载后才能创建索引的限制。 - 设置
probes参数以调节查询召回率与性能的权衡。 - 使用 L2 欧氏距离操作符
<->执行相似性检索,并获取距离值。 - 通过 Node.js 展示了完整的数据库操作流程,便于集成到应用后端。
多语言示例
Go 示例
以下是一个完整的 Go 示例,使用 pgx 驱动连接 PostgreSQL(已安装 pgvector 扩展),演示创建表、插入数据、建立索引和执行向量检索。
运行说明
- 确保 PostgreSQL 已安装 pgvector 扩展。
- 创建数据库并启用扩展:
CREATE EXTENSION vector; - 安装 Go 依赖:
go get github.com/jackc/pgx/v5 - 运行脚本:
go run demo.go
代码示例 (demo.go)
package main
import (
"context"
"fmt"
"log"
"strings"
"github.com/jackc/pgx/v5"
)
func main() {
ctx := context.Background()
// 1. 连接数据库
conn, err := pgx.Connect(ctx, "postgres://postgres:your_password@localhost:5432/testdb")
if err != nil {
log.Fatal(err)
}
defer conn.Close(ctx)
// 2. 创建表(vector 维度为 3)
_, err = conn.Exec(ctx, `
DROP TABLE IF EXISTS items;
CREATE TABLE items (
id SERIAL PRIMARY KEY,
embedding vector(3)
);
`)
if err != nil {
log.Fatal(err)
}
// 3. 插入示例向量
vectors := [][]float32{
{1, 1, 1},
{1, 2, 1},
{5, 5, 5},
{6, 6, 6},
{10, 10, 10},
}
for _, v := range vectors {
str := fmt.Sprintf("[%v,%v,%v]", v[0], v[1], v[2])
_, err = conn.Exec(ctx, "INSERT INTO items (embedding) VALUES ($1)", str)
if err != nil {
log.Fatal(err)
}
}
fmt.Println("Inserted 5 vectors.")
// 4. 创建 IVFFlat 索引(需在数据存在后创建)
_, err = conn.Exec(ctx, `
CREATE INDEX idx_items_ivfflat ON items
USING ivfflat (embedding vector_l2_ops)
WITH (lists = 2);
`)
if err != nil {
log.Fatal(err)
}
fmt.Println("IVFFlat index created.")
// 5. 设置 probes(可选)
_, err = conn.Exec(ctx, "SET ivfflat.probes = 2")
if err != nil {
log.Fatal(err)
}
// 6. 执行近似最近邻查询(L2 距离)
queryVec := []float32{1, 1, 1}
queryStr := fmt.Sprintf("[%v,%v,%v]", queryVec[0], queryVec[1], queryVec[2])
rows, err := conn.Query(ctx, `
SELECT id, embedding, embedding <-> $1 AS distance
FROM items
ORDER BY distance
LIMIT 3;
`, queryStr)
if err != nil {
log.Fatal(err)
}
defer rows.Close()
fmt.Println("Query results:")
for rows.Next() {
var id int
var embedding string
var distance float64
if err := rows.Scan(&id, &embedding, &distance); err != nil {
log.Fatal(err)
}
fmt.Printf("ID: %d, Distance: %.4f\n", id, distance)
}
if err := rows.Err(); err != nil {
log.Fatal(err)
}
}
代码说明
- 使用
pgx驱动(github.com/jackc/pgx/v5)连接 PostgreSQL,支持上下文取消和连接池。 - 向量数据通过字符串数组格式
"[1,2,3]"传递给 SQL 查询,pgx 自动适配vector类型。 - 索引创建使用
USING ivfflat,指定vector_l2_ops操作符类,与查询中的<->距离操作符匹配。 - 设置
ivfflat.probes会话参数以调整召回率。
技术点总结
- 使用 Go 标准库风格完成数据库操作,错误处理显式。
- 向量查询利用 PostgreSQL 的
ORDER BY distance LIMIT n语法,无需额外计算。 - 通过
pgx的Query方法获取结果集并扫描到变量,类型安全。
Python 示例
以下是一个完整的 Python 示例,使用 psycopg2 驱动连接 PostgreSQL(已安装 pgvector 扩展),演示创建表、插入数据、建立索引和执行向量检索。
运行说明
- 确保 PostgreSQL 已安装 pgvector 扩展。
- 创建数据库并启用扩展:
CREATE EXTENSION vector; - 安装 Python 依赖:
pip install psycopg2-binary - 运行脚本:
python demo.py
代码示例 (demo.py)
import psycopg2
def main():
# 1. 连接数据库
conn = psycopg2.connect(
host="localhost",
port=5432,
user="postgres",
password="your_password",
database="testdb"
)
conn.autocommit = True
cur = conn.cursor()
# 2. 创建表(vector 维度为 3)
cur.execute("""
DROP TABLE IF EXISTS items;
CREATE TABLE items (
id SERIAL PRIMARY KEY,
embedding vector(3)
);
""")
# 3. 插入示例向量
vectors = [
[1, 1, 1],
[1, 2, 1],
[5, 5, 5],
[6, 6, 6],
[10, 10, 10],
]
for v in vectors:
cur.execute(
"INSERT INTO items (embedding) VALUES (%s)",
(f"[{','.join(map(str, v))}]",)
)
print("Inserted 5 vectors.")
# 4. 创建 IVFFlat 索引(需在数据存在后创建)
cur.execute("""
CREATE INDEX idx_items_ivfflat ON items
USING ivfflat (embedding vector_l2_ops)
WITH (lists = 2);
""")
print("IVFFlat index created.")
# 5. 设置 probes(可选)
cur.execute("SET ivfflat.probes = 2")
# 6. 执行近似最近邻查询(L2 距离)
query_vec = [1, 1, 1]
query_str = f"[{','.join(map(str, query_vec))}]"
cur.execute("""
SELECT id, embedding, embedding <-> %s AS distance
FROM items
ORDER BY distance
LIMIT 3;
""", (query_str,))
print("Query results:")
for row in cur.fetchall():
print(f"ID: {row[0]}, Distance: {row[2]:.4f}")
cur.close()
conn.close()
if __name__ == "__main__":
main()
代码说明
- 使用
psycopg2驱动,通过字符串插值构造向量文本,参数化查询防止注入。 - 设置
autocommit=True简化事务管理,实际生产可改用显式提交。 - 索引创建与查询语法与 SQL 原生一致,Python 仅作参数传递。
技术点总结
- Python 脚本简洁,适合数据科学和快速原型。
- 向量格式化使用列表推导和
join生成 PostgreSQL 可识别的数组字符串。 - 查询结果通过
fetchall一次性获取,适合小数据集演示。
Java 示例
以下是一个完整的 Java 示例,使用 JDBC 驱动连接 PostgreSQL(已安装 pgvector 扩展),演示创建表、插入数据、建立索引和执行向量检索。
运行说明
- 确保 PostgreSQL 已安装 pgvector 扩展。
- 创建数据库并启用扩展:
CREATE EXTENSION vector; - 添加 Maven 依赖(见
pom.xml)或下载 PostgreSQL JDBC 驱动。 - 编译并运行:
javac Demo.java && java Demo
Maven 依赖 (pom.xml)
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<version>42.7.2</version>
</dependency>
代码示例 (Demo.java)
import java.sql.*;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Demo {
public static void main(String[] args) throws Exception {
String url = "jdbc:postgresql://localhost:5432/testdb";
String user = "postgres";
String password = "your_password";
// 1. 连接数据库
try (Connection conn = DriverManager.getConnection(url, user, password);
Statement stmt = conn.createStatement()) {
// 2. 创建表(vector 维度为 3)
stmt.execute("DROP TABLE IF EXISTS items");
stmt.execute("CREATE TABLE items (id SERIAL PRIMARY KEY, embedding vector(3))");
// 3. 插入示例向量
List<List<Double>> vectors = Arrays.asList(
Arrays.asList(1.0, 1.0, 1.0),
Arrays.asList(1.0, 2.0, 1.0),
Arrays.asList(5.0, 5.0, 5.0),
Arrays.asList(6.0, 6.0, 6.0),
Arrays.asList(10.0, 10.0, 10.0)
);
for (List<Double> v : vectors) {
String vecStr = v.stream()
.map(String::valueOf)
.collect(Collectors.joining(",", "[", "]"));
try (PreparedStatement pstmt = conn.prepareStatement(
"INSERT INTO items (embedding) VALUES (?)")) {
pstmt.setString(1, vecStr);
pstmt.executeUpdate();
}
}
System.out.println("Inserted 5 vectors.");
// 4. 创建 IVFFlat 索引(需在数据存在后创建)
stmt.execute("CREATE INDEX idx_items_ivfflat ON items " +
"USING ivfflat (embedding vector_l2_ops) WITH (lists = 2)");
System.out.println("IVFFlat index created.");
// 5. 设置 probes(可选)
stmt.execute("SET ivfflat.probes = 2");
// 6. 执行近似最近邻查询(L2 距离)
List<Double> queryVec = Arrays.asList(1.0, 1.0, 1.0);
String queryStr = queryVec.stream()
.map(String::valueOf)
.collect(Collectors.joining(",", "[", "]"));
try (PreparedStatement pstmt = conn.prepareStatement(
"SELECT id, embedding, embedding <-> ? AS distance " +
"FROM items ORDER BY distance LIMIT 3")) {
pstmt.setString(1, queryStr);
try (ResultSet rs = pstmt.executeQuery()) {
System.out.println("Query results:");
while (rs.next()) {
int id = rs.getInt("id");
double distance = rs.getDouble("distance");
System.out.printf("ID: %d, Distance: %.4f%n", id, distance);
}
}
}
}
}
}
代码说明
- 使用 JDBC 原生 API,
DriverManager获取连接,Statement执行 DDL,PreparedStatement执行参数化查询。 - 向量文本通过 Java Stream API 拼接,确保格式正确。
- 资源使用 try-with-resources 自动关闭,保证健壮性。
- 索引创建和 probes 设置与 SQL 标准一致。
技术点总结
- Java JDBC 方式通用,适用于 Spring 等框架集成。
- 参数化查询可防止 SQL 注入,同时 PostgreSQL 驱动自动识别
vector类型。 - 结果集通过列名或索引提取,类型转换明确。
多语言示例对比表
| 维度 | Node.js | Go | Python | Java |
|---|---|---|---|---|
| 驱动/库 | pg | pgx/v5 | psycopg2 | JDBC (postgresql) |
| 连接方式 | 客户端对象 | pgx.Connect | psycopg2.connect | DriverManager.getConnection |
| 参数占位符 | $1, $2 | $1, $2 | %s (psycopg2 使用 %s 或 %(name)s) | ? 或 $1 (取决于驱动版本,PostgreSQL JDBC 支持 ?) |
| 向量字符串构造 | 模板字符串 | fmt.Sprintf | f-string / join | Stream API / String.join |
| 事务管理 | 默认自动提交,可控制 | 默认自动提交 | autocommit 属性 | 默认自动提交,可 setAutoCommit(false) |
| 异步支持 | 原生 async/await | 支持 (pgx 原生异步) | 需额外库 (asyncpg) | 同步,可通过 CompletableFuture 异步 |
| 错误处理 | 回调/promise | 显式返回 error | 异常捕获 | SQLException 捕获 |
| 资源管理 | 需手动释放连接池 | defer conn.Close | with 语句或手动关闭 | try-with-resources |
| 适用场景 | 全栈 JavaScript 生态 | 高性能并发服务 | 数据分析/快速原型 | 企业级应用 |
| 索引创建语法 | 完全一致 | 完全一致 | 完全一致 | 完全一致 |
| 查询参数化 | 支持 | 支持 | 支持 | 支持 |
所有示例均遵循相同的 PostgreSQL 原生 SQL 逻辑,核心区别仅在于各语言驱动 API 和字符串处理方式。开发者可根据团队技术栈选择对应实现。
项目难点与解决方案
核心难点
在向量搜索场景中,需要在极低延迟下处理百万级向量,同时保证召回率不低于 95%。纯精确搜索无法满足性能要求,而简单的 ANN 索引又可能因参数不当导致召回率严重下降。
解决方案
采用分层策略:新上线阶段使用 IVFFlat 索引并配合定期重建,待数据稳定后迁移至 HNSW 索引。同时,通过 A/B 测试逐步调优 probes 和 ef_search 参数,在延迟和召回率之间找到平衡点。
广度
涉及数据库索引设计、向量数据存储、查询优化、参数调优以及应用层集成等多个技术层面。
深度
深入理解 K-Means 聚类原理、分层图搜索机制,以及不同距离度量对索引选择的影响,要求团队具备一定程度的向量检索理论基础。
复杂度
索引参数组合众多(如 lists 与 probes 的配合、m 与 ef_construction 的权衡),且不同数据分布下最佳配置差异较大,需要结合真实业务数据进行反复测试与监控。
官方文档
参考链接
总结
pgvector 为 PostgreSQL 提供了工业级的向量检索能力,通过 IVFFlat 和 HNSW 两种 ANN 索引覆盖了从轻量级到高性能的不同场景。IVFFlat 基于聚类,构建快、内存小,适合数据频繁更新且需定期重建的环境;HNSW 基于分层图,查询快、召回高,支持动态插入,是大多数生产工作负载的首选。
索引调优需要结合数据规模、维度和业务容忍度进行细致测试,lists/probes 与 m/ef_construction 等参数直接影响性能表现。随着 pgvector 版本的迭代,其功能已逐步接近专业向量数据库,是 PostgreSQL 生态中不可或缺的扩展组件。
225



被折叠的 条评论
为什么被折叠?



