PostgreSQL笔记44:pgvector向量操作与查询实践

PostgreSQL pgvector:如何利用向量数据库提升搜索效率和精度 随着基础模型的兴起,向量数据库的受欢迎程度也飙升。事实上,在大型语言模型环境中,向量数据库也很有用。在机器学习领域,我们经常处理的是向量嵌入。向量嵌入是通过特定的机器学习模型运行对象的特征,将对象的上下文信息投射到潜在空间中来创建的。为了在使用向量嵌入时能够表现得特别好,创建向量数据库是必要的。这方面的工作包括存储、更新和检索向量。当我们谈论检索时,通常是指检索与查询最相似的向量,这些向量与嵌入到同一潜在空间并传递到向量数据库中。这个检索过程被称为近似最近邻。 阅读详情

纲要

  • PostgreSQL原生向量相关数据类型及其局限性
    • array 类型
      • 支持任意元素类型(int4、int8、float4、float8 等)
      • 维度不受限(受TOAST物理限制)
      • 无内置距离函数
      • 无原生向量索引支持
    • cube 扩展
      • float8 双精度向量
      • 维度上限100
      • 内置距离度量函数
      • 支持精确KNN(<->、<#>、<=> 操作符)
      • GiST索引支持
  • pgvector 扩展
    • vector 数据类型(单精度浮点,4字节/维)
    • 索引类型:HNSW 与 IVFFlat
    • 距离度量:L2(欧几里得)、余弦相似度、内积、L1(曼哈顿)、汉明距离
    • 版本演进:0.4.0(IVFFlat)→ 0.5.0(HNSW)→ 0.7.0(L1距离、量化)→ 0.8.0(迭代索引扫描)
  • Pre-filter 与 Post-filter
    • Pre-filter:先应用过滤条件,再做相似度检索
    • Post-filter:先做相似度检索,再应用过滤条件
  • Iterative Index Scan(pgvector 0.8.0+)
    • strict_order 模式
    • relaxed_order 模式
    • 配置参数:hnsw.iterative_scan、ivfflat.iterative_scan、hnsw.max_scan_tuples、ivfflat.max_probes

PostgreSQL原生向量相关类型及其局限

在 pgvector 出现之前,PostgreSQL生态中已有若干可用于向量存储与检索的方案,但各自存在明显的功能短板。

array类型

PostgreSQL原生的 array 类型支持存储多维数组,元素类型可以是 int4、int8、float4、float8 等。其优势在于维度不受限制(仅受限于PostgreSQL的行大小与TOAST物理限制),但缺陷同样显著:

  • 无内置距离函数:无法直接计算向量间的欧几里得距离、余弦相似度等
  • 无原生向量索引:无法对数组类型的向量字段建立专用索引以加速相似度检索
  • 无向量距离运算符:虽然 array 类型支持 &&(重叠)、@>(包含)等操作符,但这些是集合意义上的操作,而非语义相似度

在实际应用中,若需使用 array 类型进行相似度排序,只能通过全表扫描逐一计算距离,数据规模扩大后性能急剧下降。

-- array类型示例
CREATE TABLE items_array (
    id SERIAL PRIMARY KEY,
    embedding float4[]
);

-- 插入数据
INSERT INTO items_array (embedding) VALUES (ARRAY[0.1, 0.2, 0.3]);

-- 问题:无法直接ORDER BY距离,需要自定义函数全表扫描

cube扩展

cube 是PostgreSQL的一个contrib扩展,提供了多维立方体(点或超矩形)的数据类型。其特点包括:

  • float8 双精度存储:每个维度占8字节
  • 维度上限100:无法满足现代AI模型(如768维、1536维)的嵌入向量需求
  • 内置距离度量:支持欧几里得距离(<->)、曼哈顿距离(<#>)、切比雪夫距离(<=>)
  • GiST索引支持:可加速精确KNN查询
-- 启用cube扩展
CREATE EXTENSION IF NOT EXISTS cube;

-- cube类型示例(3维点)
SELECT cube(ARRAY[1.0, 2.5, 3.0]) AS point_from_array;
-- 结果: (1,2.5,3)

-- 使用cube进行KNN查询(欧几里得距离)
SELECT id, cube_distance(embedding, '(1,2,3)'::cube) AS distance
FROM items_cube
ORDER BY embedding <-> '(1,2,3)'::cube
LIMIT 10;

cube 的致命限制在于维度上限仅为100,对于768维或1536维的嵌入向量完全不适用。尽管它支持精确KNN索引,但仅适合维度较低、数据规模较小的场景。

pgvector:为AI向量场景设计的专用扩展

pgvector 是PostgreSQL的专用向量扩展,由开源社区维护,旨在弥补原生类型的不足。它提供了 vector 数据类型、多种距离度量函数以及高性能索引算法,专为AI应用中的嵌入向量存储与检索设计。

vector数据类型

vector 类型以单精度浮点数(4字节/维)存储向量,无内置维度上限(受TOAST机制约束,与 array 类似)。但 pgvector 引入了专用的运算符和索引支持,使其能够高效地进行相似度检索。

-- 启用pgvector扩展(需预先安装)
CREATE EXTENSION IF NOT EXISTS vector;

-- 创建包含vector列的表
CREATE TABLE items (
    id SERIAL PRIMARY KEY,
    name TEXT,
    embedding vector(3)  -- 指定维度为3
);

-- 插入向量数据
INSERT INTO items (name, embedding) VALUES
    ('apple', '[1.0, 2.0, 3.0]'),
    ('banana', '[4.0, 5.0, 6.0]'),
    ('cherry', '[7.0, 8.0, 9.0]');

距离度量运算符

pgvector 提供了六种距离运算符,用于计算向量间的相似度或距离。常用度量包括:

运算符度量方式说明适用版本
<->L2(欧几里得)距离值越小越相似所有版本
<=>余弦距离值越小越相似(1 - 余弦相似度)所有版本
<#>内积(点积)值越大越相似(需与负值配合排序)所有版本
+L1(曼哈顿)距离值越小越相似≥0.7.0
<>汉明距离值越小越相似(仅适用于二进制向量)≥0.7.0
<=负内积(用于索引)内部使用≥0.7.0

以下示例演示如何使用余弦距离进行KNN查询:

-- 查询与给定向量最相似的5条记录(使用余弦距离)
SELECT id, name
FROM items
ORDER BY embedding <=> '[3.0, 4.0, 5.0]'::vector
LIMIT 5;

索引类型

pgvector 支持两种索引类型,用于加速向量相似度检索:

  • IVFFlat(0.4.0+):基于倒排文件索引,需在插入数据后构建,适合中等规模数据集
  • HNSW(0.5.0+):基于分层可导航小世界图,支持增量构建,查询延迟更低,适合大规模数据集

创建索引时需指定距离度量函数:

-- 创建IVFFlat索引(使用余弦距离)
CREATE INDEX idx_items_embedding_ivfflat ON items
    USING ivfflat (embedding vector_cosine_ops)
    WITH (lists = 100);

-- 创建HNSW索引(使用余弦距离)
CREATE INDEX idx_items_embedding_hnsw ON items
    USING hnsw (embedding vector_cosine_ops)
    WITH (m = 16, ef_construction = 200);

Pre-filter与Post-filter问题

在向量检索中,若查询同时包含结构化过滤条件(如 WHERE category = 'fruit')和向量相似度排序,索引的使用顺序会显著影响结果集的准确性与查询性能。

Pre-filter(预过滤)

先应用结构化过滤条件,缩小数据集,再对过滤后的子集进行向量相似度排序。这种方式总能返回满足过滤条件的Top-K结果,但缺点在于:

  • 若过滤条件选择性差(如命中大量数据),则仍需全表扫描,无法利用向量索引加速
  • 扩展性差,尤其在大数据量下

Post-filter(后过滤)

先利用向量索引进行近似检索,返回候选集(如Top-N),再应用结构化过滤条件。这种方式能充分利用向量索引,但可能因过滤条件过于严格,导致最终结果集为空或不足K条。

问题示例

假设表中有100万条记录,其中仅有2条属于 category = 'bus'。若使用Post-filter(先向量检索再过滤),向量索引可能只返回了与查询向量最相似的若干条(但恰好不包含那2条),最终结果为空。而Pre-filter虽能保证结果,但需先扫描全表过滤出2条,再计算距离,效率低下。

应用WHERE条件

向量索引检索

原始数据集

Pre-filter

过滤后子集

向量相似度排序

返回Top-K

Post-filter

候选集

应用WHERE条件

可能为空或不足K

Iterative Index Scan(迭代索引扫描)

为解决Pre-filter与Post-filter的矛盾,pgvector 在0.8.0版本引入了 迭代索引扫描(Iterative Index Scan)。其核心思想是:

  1. 从向量索引中逐步取回候选向量(分批)
  2. 对每一批候选应用结构化过滤条件
  3. 若过滤后的结果数量不足 LIMIT N,则继续从索引中取下一批,重复直至满足要求或索引扫描完毕

这种机制结合了两者的优点:既能利用向量索引加速,又能确保最终结果满足过滤条件且数量足够。

配置参数

迭代扫描的行为可通过以下会话级参数调整:

参数适用索引说明默认值
hnsw.iterative_scanHNSW启用/禁用迭代扫描strict_order
ivfflat.iterative_scanIVFFlat启用/禁用迭代扫描strict_order
hnsw.max_scan_tuplesHNSW每次迭代最大扫描元组数无限制
ivfflat.max_probesIVFFlat每次迭代探测的列表数1

模式值:

  • strict_order:严格模式,保证最终结果按距离排序且数量准确(较慢)
  • relaxed_order:宽松模式,可能返回未完全排序的结果(较快)
  • off:禁用迭代扫描,退化为普通索引扫描
-- 启用迭代扫描(strict模式)
SET hnsw.iterative_scan = 'strict_order';
SET ivfflat.iterative_scan = 'strict_order';

-- 执行查询,系统将自动使用迭代扫描
SELECT id, name
FROM items
WHERE category = 'fruit'
ORDER BY embedding <=> '[0.5, 0.6, 0.7]'::vector
LIMIT 10;

API速览

本节梳理 pgvector 涉及的数据库端API(SQL级)及Node.js驱动中的对应使用方式。

数据库端API

函数/运算符签名说明适用版本
vectorvector(text) → vector从字符串构造向量所有版本
vector_dims(vector) → integer返回向量维度所有版本
vector_norm(vector) → float8返回L2范数所有版本
l2_distance(vector, vector) → float8欧几里得距离(同 <->)所有版本
cosine_distance(vector, vector) → float8余弦距离(同 <=>)所有版本
inner_product(vector, vector) → float8内积(同 <#>)所有版本
l1_distance(vector, vector) → float8曼哈顿距离(同 +)≥0.7.0
hamming_distance(vector, vector) → float8汉明距离(同 <>)≥0.7.0
avg(vector) → vector向量均值聚合所有版本
sum(vector) → vector向量求和聚合所有版本

Node.js(node-postgres)使用示例

import { Client } from 'pg';

const client = new Client({
    host: 'localhost',
    port: 5432,
    database: 'test',
    user: 'postgres',
    password: 'postgres',
});

await client.connect();

// 插入向量
const insertQuery = `
    INSERT INTO items (name, embedding)
    VALUES ($1, $2::vector)
`;
await client.query(insertQuery, ['apple', '[1.0, 2.0, 3.0]']);

// KNN查询(余弦距离)
const queryVector = '[3.0, 4.0, 5.0]';
const selectQuery = `
    SELECT id, name, embedding
    FROM items
    ORDER BY embedding <=> $1::vector
    LIMIT 5
`;
const res = await client.query(selectQuery, [queryVector]);
console.log(res.rows);

// 迭代扫描配置
await client.query("SET hnsw.iterative_scan = 'strict_order'");
await client.query("SET ivfflat.iterative_scan = 'strict_order'");

await client.end();

Demo简单示例

本节提供一个基于Node.js的完整示例,演示 pgvector 的基本使用,包括建表、索引创建、数据插入、KNN查询及迭代扫描。

运行说明

  1. 确保PostgreSQL(≥12)已安装并运行
  2. 安装 pgvector 扩展(参考官方文档)
  3. 创建数据库并启用扩展
  4. 安装依赖:npm install pg
  5. 执行脚本

代码说明

import { Client } from 'pg';

const client = new Client({
    host: 'localhost',
    port: 5432,
    database: 'vectordb',
    user: 'postgres',
    password: 'postgres',
});

async function run() {
    await client.connect();

    // 1. 启用扩展
    await client.query('CREATE EXTENSION IF NOT EXISTS vector');

    // 2. 创建表(向量维度设为3)
    await client.query(`
        DROP TABLE IF EXISTS items;
        CREATE TABLE items (
            id SERIAL PRIMARY KEY,
            name TEXT,
            category TEXT,
            embedding vector(3)
        );
    `);

    // 3. 插入示例数据
    const items = [
        ['apple', 'fruit', '[1.0, 2.0, 3.0]'],
        ['banana', 'fruit', '[4.0, 5.0, 6.0]'],
        ['cherry', 'fruit', '[7.0, 8.0, 9.0]'],
        ['car', 'vehicle', '[2.0, 3.0, 4.0]'],
        ['bus', 'vehicle', '[5.0, 6.0, 7.0]'],
        ['train', 'vehicle', '[8.0, 9.0, 10.0]'],
    ];
    for (const [name, category, emb] of items) {
        await client.query(
            'INSERT INTO items (name, category, embedding) VALUES ($1, $2, $3::vector)',
            [name, category, emb]
        );
    }

    // 4. 创建HNSW索引(余弦距离)
    await client.query(`
        CREATE INDEX IF NOT EXISTS idx_items_embedding_hnsw
        ON items
        USING hnsw (embedding vector_cosine_ops)
        WITH (m = 16, ef_construction = 200);
    `);

    // 5. 执行KNN查询(不带过滤)
    const queryVec = '[3.0, 4.0, 5.0]';
    const knnRes = await client.query(
        `SELECT id, name, category
         FROM items
         ORDER BY embedding <=> $1::vector
         LIMIT 3`,
        [queryVec]
    );
    console.log('KNN results (cosine distance):');
    console.log(knnRes.rows);

    // 6. 带过滤条件的查询(展示Post-filter问题)
    // 先关闭迭代扫描,模拟传统Post-filter
    await client.query("SET hnsw.iterative_scan = 'off'");
    const postFilterRes = await client.query(
        `SELECT id, name, category
         FROM items
         WHERE category = 'vehicle'
         ORDER BY embedding <=> $1::vector
         LIMIT 3`,
        [queryVec]
    );
    console.log('Post-filter results (iterative off):');
    console.log(postFilterRes.rows);

    // 7. 启用迭代扫描(strict模式)
    await client.query("SET hnsw.iterative_scan = 'strict_order'");
    const iterativeRes = await client.query(
        `SELECT id, name, category
         FROM items
         WHERE category = 'vehicle'
         ORDER BY embedding <=> $1::vector
         LIMIT 3`,
        [queryVec]
    );
    console.log('Iterative scan results (strict):');
    console.log(iterativeRes.rows);

    await client.end();
}

run().catch(console.error);

技术点总结

  • pgvector 的 vector 数据类型与运算符使用
  • HNSW索引创建及参数配置(m, ef_construction)
  • KNN查询(ORDER BY embedding <=> ... LIMIT)
  • Post-filter与迭代扫描的对比
  • Node.js中通过 SET 命令动态调整索引扫描行为

多语言示例

基于前文的Node.js示例,本节提供Go、Python和Java三种语言的完整实现,并附多语言对比表格。所有示例均使用相同的数据库表结构、数据、索引及查询逻辑,确保行为一致。

Go语言示例(使用pgx)

Go语言推荐使用 pgx 驱动(支持原生 pgvector 类型),也可使用 lib/pq 配合字符串构造。

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/jackc/pgx/v5"
)

func main() {
    ctx := context.Background()
    connStr := "postgres://postgres:postgres@localhost:5432/vectordb"
    conn, err := pgx.Connect(ctx, connStr)
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close(ctx)

    // 1. 启用扩展
    _, err = conn.Exec(ctx, "CREATE EXTENSION IF NOT EXISTS vector")
    if err != nil {
        log.Fatal(err)
    }

    // 2. 建表
    _, err = conn.Exec(ctx, `
        DROP TABLE IF EXISTS items;
        CREATE TABLE items (
            id SERIAL PRIMARY KEY,
            name TEXT,
            category TEXT,
            embedding vector(3)
        );
    `)
    if err != nil {
        log.Fatal(err)
    }

    // 3. 插入数据
    items := [][3]string{
        {"apple", "fruit", "[1.0, 2.0, 3.0]"},
        {"banana", "fruit", "[4.0, 5.0, 6.0]"},
        {"cherry", "fruit", "[7.0, 8.0, 9.0]"},
        {"car", "vehicle", "[2.0, 3.0, 4.0]"},
        {"bus", "vehicle", "[5.0, 6.0, 7.0]"},
        {"train", "vehicle", "[8.0, 9.0, 10.0]"},
    }
    for _, item := range items {
        _, err = conn.Exec(ctx,
            "INSERT INTO items (name, category, embedding) VALUES ($1, $2, $3::vector)",
            item[0], item[1], item[2],
        )
        if err != nil {
            log.Fatal(err)
        }
    }

    // 4. 创建HNSW索引(余弦距离)
    _, err = conn.Exec(ctx, `
        CREATE INDEX IF NOT EXISTS idx_items_embedding_hnsw
        ON items
        USING hnsw (embedding vector_cosine_ops)
        WITH (m = 16, ef_construction = 200);
    `)
    if err != nil {
        log.Fatal(err)
    }

    queryVec := "[3.0, 4.0, 5.0]"

    // 5. KNN查询(不带过滤)
    rows, err := conn.Query(ctx,
        "SELECT id, name, category FROM items ORDER BY embedding <=> $1::vector LIMIT 3",
        queryVec,
    )
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("KNN results (cosine distance):")
    for rows.Next() {
        var id int
        var name, category string
        rows.Scan(&id, &name, &category)
        fmt.Printf("  id=%d, name=%s, category=%s\n", id, name, category)
    }
    rows.Close()

    // 6. Post-filter(关闭迭代扫描)
    _, err = conn.Exec(ctx, "SET hnsw.iterative_scan = 'off'")
    if err != nil {
        log.Fatal(err)
    }
    rows, err = conn.Query(ctx,
        "SELECT id, name, category FROM items WHERE category = 'vehicle' ORDER BY embedding <=> $1::vector LIMIT 3",
        queryVec,
    )
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Post-filter results (iterative off):")
    for rows.Next() {
        var id int
        var name, category string
        rows.Scan(&id, &name, &category)
        fmt.Printf("  id=%d, name=%s, category=%s\n", id, name, category)
    }
    rows.Close()

    // 7. 迭代扫描(strict模式)
    _, err = conn.Exec(ctx, "SET hnsw.iterative_scan = 'strict_order'")
    if err != nil {
        log.Fatal(err)
    }
    rows, err = conn.Query(ctx,
        "SELECT id, name, category FROM items WHERE category = 'vehicle' ORDER BY embedding <=> $1::vector LIMIT 3",
        queryVec,
    )
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Iterative scan results (strict):")
    for rows.Next() {
        var id int
        var name, category string
        rows.Scan(&id, &name, &category)
        fmt.Printf("  id=%d, name=%s, category=%s\n", id, name, category)
    }
    rows.Close()
}

Python语言示例(使用psycopg2)

import psycopg2

def main():
    conn = psycopg2.connect(
        host="localhost",
        port=5432,
        database="vectordb",
        user="postgres",
        password="postgres"
    )
    cur = conn.cursor()

    # 1. 启用扩展
    cur.execute("CREATE EXTENSION IF NOT EXISTS vector")

    # 2. 建表
    cur.execute("""
        DROP TABLE IF EXISTS items;
        CREATE TABLE items (
            id SERIAL PRIMARY KEY,
            name TEXT,
            category TEXT,
            embedding vector(3)
        );
    """)

    # 3. 插入数据
    items = [
        ("apple", "fruit", "[1.0, 2.0, 3.0]"),
        ("banana", "fruit", "[4.0, 5.0, 6.0]"),
        ("cherry", "fruit", "[7.0, 8.0, 9.0]"),
        ("car", "vehicle", "[2.0, 3.0, 4.0]"),
        ("bus", "vehicle", "[5.0, 6.0, 7.0]"),
        ("train", "vehicle", "[8.0, 9.0, 10.0]"),
    ]
    for name, category, emb in items:
        cur.execute(
            "INSERT INTO items (name, category, embedding) VALUES (%s, %s, %s::vector)",
            (name, category, emb)
        )

    # 4. 创建HNSW索引
    cur.execute("""
        CREATE INDEX IF NOT EXISTS idx_items_embedding_hnsw
        ON items
        USING hnsw (embedding vector_cosine_ops)
        WITH (m = 16, ef_construction = 200);
    """)
    conn.commit()

    query_vec = "[3.0, 4.0, 5.0]"

    # 5. KNN查询(不带过滤)
    cur.execute(
        "SELECT id, name, category FROM items ORDER BY embedding <=> %s::vector LIMIT 3",
        (query_vec,)
    )
    print("KNN results (cosine distance):")
    for row in cur.fetchall():
        print(f"  id={row[0]}, name={row[1]}, category={row[2]}")

    # 6. Post-filter
    cur.execute("SET hnsw.iterative_scan = 'off'")
    cur.execute(
        "SELECT id, name, category FROM items WHERE category = 'vehicle' ORDER BY embedding <=> %s::vector LIMIT 3",
        (query_vec,)
    )
    print("Post-filter results (iterative off):")
    for row in cur.fetchall():
        print(f"  id={row[0]}, name={row[1]}, category={row[2]}")

    # 7. 迭代扫描(strict模式)
    cur.execute("SET hnsw.iterative_scan = 'strict_order'")
    cur.execute(
        "SELECT id, name, category FROM items WHERE category = 'vehicle' ORDER BY embedding <=> %s::vector LIMIT 3",
        (query_vec,)
    )
    print("Iterative scan results (strict):")
    for row in cur.fetchall():
        print(f"  id={row[0]}, name={row[1]}, category={row[2]}")

    cur.close()
    conn.close()

if __name__ == "__main__":
    main()

Java语言示例(使用JDBC)

Java使用标准JDBC,配合PostgreSQL驱动(org.postgresql:postgresql)。向量值以字符串形式传递,通过 ::vector 转换。

import java.sql.*;
import java.util.Arrays;
import java.util.List;

public class PgVectorDemo {
    public static void main(String[] args) throws SQLException {
        String url = "jdbc:postgresql://localhost:5432/vectordb";
        String user = "postgres";
        String password = "postgres";

        try (Connection conn = DriverManager.getConnection(url, user, password);
             Statement stmt = conn.createStatement()) {

            // 1. 启用扩展
            stmt.execute("CREATE EXTENSION IF NOT EXISTS vector");

            // 2. 建表
            stmt.execute("DROP TABLE IF EXISTS items");
            stmt.execute("""
                CREATE TABLE items (
                    id SERIAL PRIMARY KEY,
                    name TEXT,
                    category TEXT,
                    embedding vector(3)
                );
            """);

            // 3. 插入数据
            List<Object[]> items = Arrays.asList(
                new Object[]{"apple", "fruit", "[1.0, 2.0, 3.0]"},
                new Object[]{"banana", "fruit", "[4.0, 5.0, 6.0]"},
                new Object[]{"cherry", "fruit", "[7.0, 8.0, 9.0]"},
                new Object[]{"car", "vehicle", "[2.0, 3.0, 4.0]"},
                new Object[]{"bus", "vehicle", "[5.0, 6.0, 7.0]"},
                new Object[]{"train", "vehicle", "[8.0, 9.0, 10.0]"}
            );
            try (PreparedStatement pstmt = conn.prepareStatement(
                    "INSERT INTO items (name, category, embedding) VALUES (?, ?, ?::vector)")) {
                for (Object[] item : items) {
                    pstmt.setString(1, (String) item[0]);
                    pstmt.setString(2, (String) item[1]);
                    pstmt.setString(3, (String) item[2]);
                    pstmt.executeUpdate();
                }
            }

            // 4. 创建HNSW索引
            stmt.execute("""
                CREATE INDEX IF NOT EXISTS idx_items_embedding_hnsw
                ON items
                USING hnsw (embedding vector_cosine_ops)
                WITH (m = 16, ef_construction = 200);
            """);

            String queryVec = "[3.0, 4.0, 5.0]";

            // 5. KNN查询(不带过滤)
            try (PreparedStatement pstmt = conn.prepareStatement(
                    "SELECT id, name, category FROM items ORDER BY embedding <=> ?::vector LIMIT 3")) {
                pstmt.setString(1, queryVec);
                ResultSet rs = pstmt.executeQuery();
                System.out.println("KNN results (cosine distance):");
                while (rs.next()) {
                    System.out.printf("  id=%d, name=%s, category=%s%n",
                        rs.getInt("id"), rs.getString("name"), rs.getString("category"));
                }
            }

            // 6. Post-filter
            stmt.execute("SET hnsw.iterative_scan = 'off'");
            try (PreparedStatement pstmt = conn.prepareStatement(
                    "SELECT id, name, category FROM items WHERE category = 'vehicle' ORDER BY embedding <=> ?::vector LIMIT 3")) {
                pstmt.setString(1, queryVec);
                ResultSet rs = pstmt.executeQuery();
                System.out.println("Post-filter results (iterative off):");
                while (rs.next()) {
                    System.out.printf("  id=%d, name=%s, category=%s%n",
                        rs.getInt("id"), rs.getString("name"), rs.getString("category"));
                }
            }

            // 7. 迭代扫描(strict模式)
            stmt.execute("SET hnsw.iterative_scan = 'strict_order'");
            try (PreparedStatement pstmt = conn.prepareStatement(
                    "SELECT id, name, category FROM items WHERE category = 'vehicle' ORDER BY embedding <=> ?::vector LIMIT 3")) {
                pstmt.setString(1, queryVec);
                ResultSet rs = pstmt.executeQuery();
                System.out.println("Iterative scan results (strict):");
                while (rs.next()) {
                    System.out.printf("  id=%d, name=%s, category=%s%n",
                        rs.getInt("id"), rs.getString("name"), rs.getString("category"));
                }
            }
        }
    }
}

多语言对比表格

语言推荐驱动向量传递方式占位符风格迭代扫描配置连接示例
Node.jspg字符串 '[1,2,3]' 或 $1::vector$1, $2SET hnsw.iterative_scan = 'strict_order'new Client({ host, port, database, user, password })
Gopgx/v5字符串 '[1,2,3]' 或 $1::vector$1, $2同上pgx.Connect(ctx, "postgres://...")
Pythonpsycopg2字符串 '[1,2,3]' 或 %s::vector%s同上psycopg2.connect(host=..., port=..., ...)
JavaJDBC (org.postgresql)字符串 '[1,2,3]' 或 ?::vector?同上DriverManager.getConnection(url, user, password)

所有示例均遵循相同的逻辑流程:

  1. 启用 vector 扩展
  2. 创建 items 表(embedding vector(3))
  3. 插入6条测试数据(含 category 字段)
  4. 创建 HNSW 索引(余弦距离,m=16, ef_construction=200)
  5. 执行 KNN 查询(无过滤)
  6. 关闭迭代扫描,演示 Post-filter 问题
  7. 启用迭代扫描(strict_order),验证结果准确性

运行前需确保 PostgreSQL 已安装 pgvector 扩展,且数据库 vectordb 已创建。

项目难点与解决方案

基于 pgvector 在实际生产环境中的使用经验,以下归纳常见难点及其应对策略。

核心难点

  1. Pre-filter与Post-filter的权衡:查询既需结构化过滤又需向量相似度排序时,难以同时保证结果准确性和检索性能。
  2. 索引构建与维护:IVFFlat 索引需在数据加载后重建,HNSW 索引构建耗时且内存占用高。
  3. 维度限制:高维向量(>2000)可能导致索引性能下降(TOAST机制限制)。

解决方案

  • 使用 迭代索引扫描(pgvector ≥0.8.0)折中处理,通过调整 max_scan_tuples 或 max_probes 控制扫描深度,平衡准确性与延迟。
  • 对 IVFFlat 索引,采用分阶段构建(先插入数据再 CREATE INDEX),并合理设置 lists 参数(约为 sqrt(行数))。
  • 对 HNSW 索引,调优 m(连接数)和 ef_construction(构建搜索深度)以平衡构建速度与查询精度。
  • 考虑降维或使用量化技术(如 pgvector 0.7.0 引入的量化支持)应对高维场景。

广度

涉及数据库内核、索引算法、查询优化、应用层ORM集成、性能调优等多个领域。

深度

需深入理解PostgreSQL的TOAST机制、索引扫描模式、GUC参数调优,以及 pgvector 的源码实现细节。

复杂度

向量检索与传统关系型查询的结合增加了SQL优化器的决策复杂度,实际生产环境需结合监控与日志反复调整。

官方文档

参考链接

总结

本文系统梳理了PostgreSQL生态中用于向量存储与检索的三种方案:原生 array、cube 扩展以及专用 pgvector 扩展,并深入分析了后者的核心特性,包括距离度量运算符(L2、余弦、内积、L1、汉明)、索引类型(IVFFlat与HNSW),以及0.8.0版本引入的迭代索引扫描机制。

通过对比Pre-filter与Post-filter的优劣,展示了迭代扫描如何在实际查询中平衡准确性与性能。文中的SQL示例及Node.js完整Demo可帮助读者快速上手,并在生产环境中合理配置索引参数与扫描模式。

PostgreSQL向量搜索实战:用pgvector构建语义检索系统 向量搜索是现代AI应用的核心能力,本质是将文本、图像等非结构化数据映射为高维空间中的数学向量,通过余弦相似度等度量实现语义匹配。其技术价值在于突破关键词匹配局限,支撑RAG、智能推荐、语义去重等场景。PostgreSQL凭借ACID事务、SQL表达力与成熟运维体系,成为向量检索落地的理想底座;pgvector作为原生扩展,无需更换数据库即可启用向量索引与相似度计算,显著降低架构复杂度与数据一致性风险。本文聚焦pgvector在真实业务中的部署、调优与排障,覆盖HNSW索引选型、向量归一化、混合查询优化等关键 阅读详情

相关推荐

PostgreSQL向量化存储实战:Pgvector v0.8.0安装与使用避坑指南

本文详细介绍了Pgvector v0.8.0在PostgreSQL中的安装与使用避坑指南,包括环境准备、编译安装、常见问题解决及向量化存储实战技巧。通过实际案例展示了如何优化向量索引和查询性能,帮助开发者高效处理高维数据。

y7z8a的博客 209

【大模型】PostgreSQL是向量数据库吗

PostgreSQL 本身不是一个向量数据库,但通过插件和扩展(如。

起而行动,方能平定心中的惶恐 2874

CentOS7+PostgreSQL+PGVector构建高效向量数据库方案

向量数据库作为处理非结构化数据的核心技术,通过将高维向量嵌入到数据库系统中,实现了高效的相似性搜索。其核心原理是利用近似最近邻(ANN)算法,如IVFFlat或HNSW索引结构,在保证召回率的同时大幅提升检索效率。PGVector作为PostgreSQL的扩展插件,巧妙地将向量搜索能力与传统关系型数据库结合,既保留了SQL的灵活性,又获得了专业的向量处理性能。在实际工程中,这种方案特别适合需要同时处理结构化数据和向量特征的场景,比如电商平台的图像检索、推荐系统的特征匹配等。通过合理配置CentOS7系统参数

weixin_31766003的博客 55

PostgreSQL 作为向量数据库:入门和扩展

本指南将深入研究该特定模式在应用程序中的实现。然而,由于搜索是近似的,搜索的召回率可能不是 100% 相关/准确,因为索引仅遍历数据的子集。它允许您存储和处理具有数千个维度的向量,计算向量化数据之间的欧几里德距离和余弦距离,并执行精确和近似最近邻搜索。为了在数据量和流量不断增加的情况下保持 Postgres 的性能和可扩展性,您可以使用矢量化数据的专用索引和/或使用Postgres 的分布式版本水平扩展存储和计算资源。数据库需要几毫秒的时间来执行精确的最近邻搜索,比较用户提示和 Airbnb 描述的嵌入。

4860

Gemini Embedding 2实战:文本向量化与语义检索优化指南

文本向量化是构建高质量语义检索系统的核心基础,其本质是将自然语言映射到可计算的高维向量空间,通过余弦相似度等度量实现语义匹配。关键技术原理包括动态token权重分配、跨语言语义对齐约束与硬件友好的INT8量化设计,显著提升长尾查询准确率与低延迟响应能力。相比Sentence-BERT等开源模型,Gemini Embedding 2在NDCG@10、部署稳定性及多语言支持上表现更优,特别适用于RAG增强、知识库检索、客服工单分析等企业级非结构化数据搜索场景。本文聚焦Gemini Embedding 2的工程落

weixin_33769125的博客 645

从零搭建企业级 ERP AI 智能体:Spring Boot 3 + Spring AI + Ollama 全链路落地实践(踩坑全集)

这是一个 ERP + AI 智能体 系统的完整落地实录:把传统 ERP(物料管理、库存查询、出入库单据、质检管理)接入本地大模型,让用户用自然语言完成业务操作,数据完全不出企业。

weixin_44694333的博客 421

pgvector 向量数据库完全指南:PostgreSQL 生态的 AI 增强

pgvector是PostgreSQL的开源扩展,为关系型数据库添加向量相似度搜索能力。它完全集成在PostgreSQL内部,复用其存储引擎、事务机制和SQL接口,无需额外基础设施。pgvector支持两种主流索引算法:IVFFlat(适合批量导入)和HNSW(查询快、召回率高)。存储上利用PostgreSQL的TOAST机制,支持压缩和稀疏向量。作为扩展,pgvector添加了新的数据类型、操作符和函数,通过标准SQL即可进行向量操作。部署时可使用官方Docker镜像快速启动,适用于从开发到生产的环境。

心有猛虎细嗅蔷薇 5859

最小可分辨对比度(MRC)

最小可分辨对比度的测试方法如下: 1)选择对比度测试靶板,一般有100%,50%,33.77%,15%,5%。 2)调整照度,确保能够清晰观测到图像中的靶标; 3)利用USAF1951分辨率靶观察找到能够分辨出的靶标。 1951 USAF分辨力测试图目前仍广泛地应用于测试光学成像系统(如显微镜和相机)的分辨能力。这种图案包括几组由三条短线构成组合,短线的尺寸从大到小。成像系统无法辩明的...

6272

PostgreSQL作为向量数据库

当设置hnsw.ef_search = 1000时,SQL 1 检索到28条数据,bus类型数量为17,查询时间16.8ms相较于 SQL 1 使用 hnsw.ef_search = 1000 与默认 hnsw.ef_search = 40 查询参数的检索对比,扩大 hnsw.ef_search 参数后检索结果召回率显著提高,但是检索时间有所增加,执行计划没有改变。随着时间的推移,这可能会导致在创建索引时建立的初始聚簇不再准确地代表数据的情况 ,解决此问题的唯一方法就是定期重建索引。

qq_22201881的博客 1617

基于python的排课表系统,用python编写排课系统

实现一个具体的课程管理系统。(5) 学生可以查看自己选上的课的成绩,以及各个课程的得分、绩点,并给出其平均绩点,但不允许查看年级其他人的成绩。(2) 学生定制专属课表,可以查看整个学期本人的课程安排,包括课程名称、上课时间、上课地点、任课老师、学分等等。(13) 系主任可以查看整个系的全部学生以及他们的平均绩点,可以对每个班进行排名,或者也可以对整个系进行排名。(15) 系主任可以查看整个学期所开设的所有课程,包括这些课程的全部详细信息。(1) 学生基本信息的查询,学生可以对本人的系统登陆密码进行修改。

yang0728y的博客 2000

结构设计3D拆件与骨架模型构建实战:基于Creo 8.0的5个高效建模技巧

本文详细解析了基于Creo 8.0的结构设计3D拆件与骨架模型构建实战技巧,涵盖5个高效建模方法,包括参数化驱动、曲面分割、多实体协同设计等。通过骨架模型的智能应用,设计效率可提升30%以上,特别适合复杂产品的结构设计。文章还提供了TWS耳机充电仓等实战案例,帮助工程师快速掌握工业设计中的核心建模技术。

weixin_30000735的博客 575

13.pgvector入门用PostgreSQL直接实现向量检

pgvector 让 PostgreSQL 可以直接保存向量并执行相似度搜索。对于中小型 RAG、原型和关系查询占主导的应用,它能以较低的系统复杂度完成完整闭环。但当向量规模、并发、隔离和扩展需求不断增长时,仍然要用真实数据评估它的边界。下一篇:《什么时候用 pgvector,什么时候单独部署 Milvus?

像风一样自由的博客 337

基于vue2的echarts3D地球

采用vue2+js实现了echarts3D地球的放大、缩小和旋转

qq_44699269的博客 1133

pgvector性能分析:查询执行计划和优化建议

pgvector作为PostgreSQL的开源向量相似性搜索扩展,在处理高维向量数据时表现出色。然而,要充分发挥其性能潜力,需要深入理解其查询执行机制和优化策略。本文将从执行计划分析、索引选择、参数调优等多个维度,为您提供全面的性能优化指南。 ## 执行计划深度解析 ### 基础查询执行流程 ```sql -- 查看基础查询执行计划 EXPLAIN ANALYZE SELECT * FROM...

gitblog_00896的博客 1069

PLL锁相环基础知识(一)

本文介绍了锁相环(PLL)的核心组件及其工作原理,重点阐述了压控振荡器(VCO)的结构与调谐机制。VCO作为PLL的关键部分,通过变容二极管实现频率调谐,但易受温度、电压等因素影响稳定性。文章详细讲解了VCO的谐振电路原理、硅基集成方案,以及通过分频器和调制器实现的频率控制技术。特别分析了整数型和分数型N分频器的差异,指出高阶德尔塔-西格玛调制器可有效降低分数杂散。文章还探讨了预分频器的应用及其对频率分辨率的影响,揭示了PLL通过反馈环路实现频率锁定的基本原理。

weixin_49761275的博客 3040

【Python程序开发】湖南省职业院校技能大赛python程序开发赛项样题二

【Python程序开发】湖南省职业院校技能大赛python程序开发赛项样题二

况老师话竞赛&blog 2206

OpenDirectory完全解读:64个预制AI Agent Skills,30秒给AI装上专家级营销能力

如果你讨厌写营销文案、做内容分发、搞产品发布,OpenDirectory 正是为你准备的。它是一个专为"讨厌营销的创始人"打造的 AI Agent Skills 技能库,内置 **64 个预制 AI 营销技能**,覆盖内容创作、社媒运营、市场情报、冷启动发布、融资线索等完整 GTM(Go-To-Market)场景。只需一条 npx 命令,30 秒内即可把专家级营销能力装进 Claude Code、

gitblog_00553的博客 880

B站评论情感分析实战:Python批量爬取+BERT正负向分类,精准度92%(附完整代码)

用技术手段自动化挖掘用户真实情感,比人工分析更高效、更客观。这套方案的精度能稳定在90%左右,完全满足实际应用需求。

专注于Python爬虫开发,分享爬虫技巧、项目实战与反爬经验,使用Scrapy、BeautifulSoup等工具,解决数据抓取难题。 1028

dbskill 更新机制完整拆解:6 步执行链路与 5 条安全边界

你刚装完 dbskill——dontbesilent 的商业诊断 Skills 工具箱,里面装着 34 个用于诊断商业模式、打磨内容、管理决策状态的 Skill。用了一阵子,对话末尾跳出一行「dbskill v3.0.3:xxx,回复 1,我现在帮你更新」。你回了个 1,Agent 没有反问「确定吗」,直接开干。它接下来做了哪几件事?会不会顺手把你 `~/.dbs/` 里的诊断存档覆盖掉?这篇 w

gitblog_01014的博客 896

大唐杯历届省赛押题训练(6)

考试-TD-LTE无线网络设备介绍-TD-LTE网络架构一、单选题1TD-LTE的接入网E-UTRAN由下列哪些网元组成( )。0分/1分A、RNCB、BTSC、eNode BD、Node B提交答案:B正确答案:C考点TD-LTE网络架构解析暂无试题解析二、多选题1关于LTE网络整体结构,哪些说法是正确的( )0分/2分A、E-UTRAN用E-NodeB替代原有的RNC-NodeB结构B、E-NodeB间的接口为S1接口C、各网络节点之间的接口使用IP传输。

nimo观察者 641

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

Immich 搜索体系深度解析:Postgres 向量检索、高级过滤器与 CLIP 模型选型实践

本文围绕 Immich 官方的 Searching 文档展开,系统讲解 Immich 的两大搜索体系:基于 Postgres 的元数据/高级过滤器搜索,以及由 VectorChord 扩展与 CLIP 模型驱动的自由文本语义搜索(俗称 Smart Search)。文中不仅完整保留了官方文档的过滤器类型、模型选型方法论与基准数据,还结合服务端与机器学习服务的源码实现,说明从一次查询到向量近邻排序的完

gitblog_01026的博客 322

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

Hindsight 存储架构深度解析:以 PostgreSQL 为唯一核心后端的单库设计与 pg0 内嵌开发方案

Hindsight 的全部记忆数据——向量、全文索引、关系数据、JSON 文档与记忆图谱——都落在一个数据库里:PostgreSQL,企业场景下可替换为 Oracle AI Database。本文基于官方存储文档([storage.md](https://link.gitcode.com/i/b4040dfc649a05f15a5dd31f68f5b44d))并结合 `hindsight-api-

gitblog_00914的博客 71

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

别再用PostgreSQL插件硬扛RAG!5类典型AI工作负载匹配表曝光,错配率高达67.3%——2026奇点大会首曝

破解AI数据库错配困局!2026奇点智能技术大会:AI原生数据库选型首次发布5类典型RAG/Agent/向量检索等AI工作负载匹配表,实测错配率高达67.3%,精准指导选型。覆盖语义搜索、实时推理、多模态索引等场景,显著提升吞吐与延迟表现——值得收藏。

AlgoChat的博客 175

MagicAnimate 完整指南:一张静态照片生成连贯人物动画的 6 步流程

MagicAnimate 是一个基于扩散模型(通过逐步去噪生成图像的生成式模型)的 AI 动画生成工具:输入一张静态人物照片和一段驱动视频,它就能让照片里的人物按照视频中的动作动起来,并保持时间一致性——帧与帧之间不闪烁、不跳变,人物长相和服装也保持稳定。项目出自 CVPR 2024 论文 *MagicAnimate: Temporally Consistent Human Image Anima

gitblog_01112的博客 1047

警报解除,重构开始:2026年数据库从业者的三个“必须关注”

如果说完美的DBA(数据库管理员)画像在五年前是“精通安装配置、性能调优、备份恢复”的管道工,那么2026年的画像则复杂得多。IT168在编译一篇行业文章时提到,2026年的卓越DBA必须具备“理解业务需求”的能力,他们需要懂云计算、懂自动化,甚至要训练和调优AI来放大自身价值。“AI不会取代DBA,但善用AI的DBA将取代其他DBA”。复杂性的指数级增长:Claranet的报告指出,74%的组织现在使用两个或更多数据库平台,混合架构成为常态。

libaike111的博客 426

为什么92%的团队在EF Core 10向量搜索集成中踩坑?——从Microsoft.EntityFrameworkCore.Vector源码第387行开始的致命设计权衡

揭秘EF Core 10向量搜索集成失败根源,通过Entity Framework Core 10 向量搜索扩展 源码分析定位Microsoft.EntityFrameworkCore.Vector第387行设计权衡,覆盖SQL Server/PostgreSQL适配、VectorIndex配置与查询性能瓶颈。掌握正确用法可提升检索准确率40%,值得收藏。

Instrustar的博客 236
上一篇: PostgreSQL笔记43:pgvector向量数据存储机制与索引限制深度解析
下一篇: PostgreSQL笔记45: 向量化核心概念、Embedding模型与相似检索应用
Wang's Blog
博客等级 码龄12年 7438粉丝 2422原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wang's Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值