PostgreSQL笔记48: 全文检索与向量检索的对比与混合检索实践

OceanBase、PG与ES在向量检索场景下的性能深度剖析:从架构到实战 本文深度剖析了OceanBase、PostgreSQL(PG)和Elasticsearch(ES)在向量检索场景下的性能表现。通过架构解析和实战测试数据对比,揭示OceanBase凭借分布式架构在千万级数据量下仍保持15ms低延迟的显著优势,同时提供PG和ES在不同规模场景下的选型建议。文章特别强调了OceanBase在向量数据库领域的性能突破,为AI时代的非结构化数据处理提供了高效解决方案。 阅读详情

纲要

  • 信息检索的演进阶段
    • 关键词匹配
    • 全文检索
    • 语义检索(向量检索)
  • 全文检索(Full-Text Search)核心机制
    • tsvector 数据类型
    • tsquery 数据类型
    • to_tsvector 与 to_tsquery 函数
    • GIN 索引
    • ts_rank 排序函数
  • 向量检索(Vector Search)核心机制
    • Embedding 模型
    • 相似度计算
    • pgvector 插件
    • HNSW / IVFFlat 索引
  • 全文检索与向量检索的对比
  • 混合检索(Hybrid Search)实践
    • Pre-filter 与 Post-filter 策略
    • 统一 SQL 查询实现
  • API 速览
  • Demo 完整示例
  • 官方文档与参考链接

信息检索的演进:从关键词到语义

信息检索技术的发展大致经历了三个阶段。

第一阶段:关键词匹配(Keyword Matching) 。最初的搜索方式本质上是字符串匹配——用户输入什么,系统就在文档中查找完全相同的字符串。这种方式简单直接,但无法处理同义词、拼写变体等问题。

第二阶段:全文检索(Full-Text Search) 。随着倒排索引(Inverted Index)、分词(Tokenization)和词干提取(Stemming)等技术的成熟,系统能够在海量文本中高效检索关键词。Elasticsearch 是这一领域的代表性产品,PostgreSQL 则通过 tsvector / tsquery 类型与 GIN 索引提供了原生的全文检索能力[reference:0]。

第三阶段:语义检索(Semantic Search / Vector Search) 。进入 AI 与大模型时代,用户的输入越来越自然——可能是一句话、一段文字,甚至是一张图片或一段音频。系统需要理解语义而非仅仅匹配字符。向量检索通过 Embedding 模型将文本转换为向量,再通过相似度计算完成检索。

全文检索“快而准,但死板”——它只关心字符是否匹配。向量检索“懂语义,但模糊”——它能理解“轿车”与“汽车”的语义相似性,但召回率可能不稳定,索引维护成本也更高[reference:1]。

全文检索核心机制

PostgreSQL 自 8.3 版本开始支持全文检索功能(8.3 引入核心支持,后续版本持续增强)。其核心是倒排索引——将每个词(Lexeme)映射到包含它的文档列表,如同书籍的附录索引。

核心数据类型与函数

tsvector :全文检索的文档表示类型。它将文本分词、去除停用词(Stop Words)、词干归一化后,存储为词素(Lexeme)及其位置的排序列表[reference:2]。例如:

SELECT to_tsvector('english', 'a fat cat sat on a mat - it ate a fat rats');

返回结果中不包含 a、on、it 等停用词,rats 被归一化为 rat,标点符号被忽略[reference:3]。

tsquery :全文检索的查询表示类型。它存储待搜索的词素,并支持布尔运算符 &(AND)、|(OR)、!(NOT)以及短语搜索运算符 <->[reference:4][reference:5]。

to_tsvector :将文本转换为 tsvector 类型[reference:6]。

to_tsquery :将查询字符串转换为 tsquery 类型[reference:7]。

@@ 运算符:判断 tsvector 是否匹配 tsquery[reference:8]。

基础示例

-- 创建测试表
CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    title TEXT,
    body TEXT,
    tsv TSVECTOR
);

-- 插入数据并生成 tsvector(使用 English 配置)
INSERT INTO documents (title, body, tsv)
VALUES (
    'PostgreSQL Full-Text Search',
    'PostgreSQL provides powerful full-text search capabilities.',
    to_tsvector('english', 'PostgreSQL provides powerful full-text search capabilities.')
);

-- 全文检索查询:查找包含 "postgresql" 和 "search" 的文档
SELECT title, body
FROM documents
WHERE tsv @@ to_tsquery('english', 'postgresql & search');

GIN 索引加速

对于生产环境,必须创建 GIN(Generalized Inverted Index)索引以加速全文检索[reference:9]:

CREATE INDEX idx_documents_tsv ON documents USING GIN (tsv);

GIN 索引是全文检索的首选索引类型,它存储 tsvector 中每个词素的索引条目[reference:10]。需要注意的是,表达式中必须显式指定文本搜索配置(如 'english'),否则索引无法被使用[reference:11]。

相关性排序

ts_rank 函数用于计算文档与查询的相关性分数,分数越高表示匹配程度越高[reference:12]:

SELECT
    title,
    ts_rank(tsv, to_tsquery('english', 'postgresql & search')) AS rank
FROM documents
WHERE tsv @@ to_tsquery('english', 'postgresql & search')
ORDER BY rank DESC;

向量检索核心机制

向量检索(Vector Search)通过 Embedding 模型将文本、图像、音频等数据转换为高维向量,然后通过计算向量间的相似度(如余弦相似度、欧几里得距离)来检索语义相近的内容。

PostgreSQL 通过 pgvector 扩展支持向量检索。pgvector 提供:

  • vector 数据类型
  • 余弦相似度运算符 <=>
  • 欧几里得距离运算符 <->
  • 内积运算符 <#>
  • HNSW 和 IVFFlat 索引

启用 pgvector

-- 创建扩展
CREATE EXTENSION vector;

-- 创建包含向量列的表
CREATE TABLE embeddings (
    id SERIAL PRIMARY KEY,
    content TEXT,
    embedding VECTOR(768)  -- 维度取决于所使用的 Embedding 模型
);

-- 创建 HNSW 索引(适用于高维向量)
CREATE INDEX idx_embeddings_hnsw ON embeddings
USING hnsw (embedding vector_cosine_ops);

-- 或使用 IVFFlat 索引(适用于数据量较大的场景)
CREATE INDEX idx_embeddings_ivfflat ON embeddings
USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);

向量相似度检索

-- 余弦相似度检索(值越接近 1 越相似)
SELECT content, 1 - (embedding <=> '[0.1, 0.2, ...]') AS similarity
FROM embeddings
ORDER BY embedding <=> '[0.1, 0.2, ...]'
LIMIT 10;

全文检索与向量检索对比

维度全文检索向量检索
核心原理倒排索引 + 分词Embedding + 相似度计算
匹配方式精确关键词匹配语义相似度匹配
优势速度快、精确、成熟稳定理解语义、容错性强、跨模态
局限不理解语义、灵活性差召回率不稳定、索引维护成本高
适用场景日志检索、明确关键词的结构化文本自然语言提问、模糊语义搜索

全文检索与向量检索并非互斥关系,而是互补关系。全文检索在精确定位场景下表现出色,向量检索在自然语言处理与模糊语义场景中更加灵活。

混合检索(Hybrid Search)实践

在实际生产环境中,将全文检索与向量检索结合使用,可以实现“高效、精准、智能”的搜索体验。

数据表设计

CREATE EXTENSION IF NOT EXISTS vector;

CREATE TABLE hybrid_docs (
    id SERIAL PRIMARY KEY,
    title TEXT,
    content TEXT,
    tsv TSVECTOR,
    embedding VECTOR(768)
);

-- 创建 GIN 索引(全文检索)
CREATE INDEX idx_hybrid_docs_tsv ON hybrid_docs USING GIN (tsv);

-- 创建 HNSW 索引(向量检索)
CREATE INDEX idx_hybrid_docs_embedding ON hybrid_docs
USING hnsw (embedding vector_cosine_ops);

策略一:先向量召回,再全文过滤(Post-filter)

先用向量检索召回语义相关的 Top-N 文档,再通过全文检索进行精确过滤:

WITH vector_results AS (
    SELECT id, title, content, 1 - (embedding <=> '[0.1, 0.2, ...]') AS similarity
    FROM hybrid_docs
    ORDER BY embedding <=> '[0.1, 0.2, ...]'
    LIMIT 100
)
SELECT *
FROM vector_results
WHERE tsv @@ to_tsquery('english', 'postgresql & search')
ORDER BY similarity DESC;

策略二:先全文过滤,再向量排序(Pre-filter)

先用全文检索过滤候选文档,再通过向量相似度进行排序:

WITH fulltext_results AS (
    SELECT id, title, content, tsv
    FROM hybrid_docs
    WHERE tsv @@ to_tsquery('english', 'postgresql & search')
)
SELECT
    id,
    title,
    content,
    1 - (embedding <=> '[0.1, 0.2, ...]') AS similarity
FROM fulltext_results
ORDER BY embedding <=> '[0.1, 0.2, ...]'
LIMIT 20;

策略三:加权混合排序

结合全文检索的 ts_rank 分数与向量相似度分数,进行加权综合排序:

SELECT
    id,
    title,
    content,
    ts_rank(tsv, to_tsquery('english', 'postgresql & search')) AS text_score,
    1 - (embedding <=> '[0.1, 0.2, ...]') AS vector_score,
    (0.5 * ts_rank(tsv, to_tsquery('english', 'postgresql & search')) +
     0.5 * (1 - (embedding <=> '[0.1, 0.2, ...]'))) AS hybrid_score
FROM hybrid_docs
WHERE tsv @@ to_tsquery('english', 'postgresql & search')
ORDER BY hybrid_score DESC
LIMIT 20;

API 速览

全文检索核心 API

函数 / 运算符签名说明
to_tsvectorto_tsvector([config regconfig, ] document text) → tsvector将文档文本转换为 tsvector[reference:13]
to_tsqueryto_tsquery([config regconfig, ] query text) → tsquery将查询字符串转换为 tsquery[reference:14]
plainto_tsqueryplainto_tsquery([config regconfig, ] query text) → tsquery将纯文本转换为 tsquery,自动添加 & 运算符[reference:15]
phraseto_tsqueryphraseto_tsquery([config regconfig, ] query text) → tsquery将纯文本转换为短语查询 tsquery[reference:16]
ts_rankts_rank([weights float4[], ] vector tsvector, query tsquery [, normalization integer ]) → float4计算文档与查询的相关性分数
setweightsetweight(vector tsvector, weight "char") → tsvector为 tsvector 中的词素标记权重(A/B/C/D)[reference:17]
@@tsvector @@ tsquery → boolean判断 tsvector 是否匹配 tsquery[reference:18]
``

pgvector 核心 API

函数 / 运算符签名说明
vectorvector(n)创建 n 维向量类型
<=>vector <=> vector → float余弦距离(值越小越相似)
<->vector <-> vector → float欧几里得距离
<#>vector <#> vector → float负内积

Demo 完整示例

以下是一个完整的 Node.js + PostgreSQL 混合检索示例,使用 pg 驱动连接数据库。

运行说明

  1. 确保 PostgreSQL 已安装 pgvector 扩展
  2. 执行下方 SQL 初始化脚本
  3. 安装依赖:npm install pg
  4. 运行脚本:node hybrid-search-demo.js

初始化 SQL

-- 启用 pgvector 扩展
CREATE EXTENSION IF NOT EXISTS vector;

-- 创建混合检索表
DROP TABLE IF EXISTS hybrid_docs;
CREATE TABLE hybrid_docs (
    id SERIAL PRIMARY KEY,
    title TEXT NOT NULL,
    content TEXT NOT NULL,
    tsv TSVECTOR,
    embedding VECTOR(3)  -- 使用 3 维向量便于演示
);

-- 插入示例数据
INSERT INTO hybrid_docs (title, content, tsv, embedding) VALUES
(
    'PostgreSQL Full-Text Search Guide',
    'PostgreSQL provides built-in full-text search using tsvector and tsquery.',
    to_tsvector('english', 'PostgreSQL provides built-in full-text search using tsvector and tsquery.'),
    '[0.9, 0.1, 0.2]'::VECTOR(3)
),
(
    'Vector Search with pgvector',
    'pgvector is a PostgreSQL extension that enables vector similarity search.',
    to_tsvector('english', 'pgvector is a PostgreSQL extension that enables vector similarity search.'),
    '[0.1, 0.8, 0.3]'::VECTOR(3)
),
(
    'Hybrid Search Combining Full-Text and Vectors',
    'Combining full-text search and vector search delivers better search results.',
    to_tsvector('english', 'Combining full-text search and vector search delivers better search results.'),
    '[0.6, 0.6, 0.4]'::VECTOR(3)
),
(
    'Database Indexing Strategies',
    'GIN indexes accelerate full-text search, while HNSW indexes accelerate vector search.',
    to_tsvector('english', 'GIN indexes accelerate full-text search, while HNSW indexes accelerate vector search.'),
    '[0.2, 0.3, 0.9]'::VECTOR(3)
),
(
    'Introduction to Machine Learning',
    'Machine learning models can generate embeddings for text, images, and audio.',
    to_tsvector('english', 'Machine learning models can generate embeddings for text, images, and audio.'),
    '[0.3, 0.2, 0.7]'::VECTOR(3)
);

-- 创建 GIN 索引(全文检索)
CREATE INDEX idx_hybrid_docs_tsv ON hybrid_docs USING GIN (tsv);

-- 创建 HNSW 索引(向量检索)
CREATE INDEX idx_hybrid_docs_embedding ON hybrid_docs
USING hnsw (embedding vector_cosine_ops);

Node.js 代码

const { Pool } = require('pg');

const pool = new Pool({
    host: 'localhost',
    port: 5432,
    database: 'postgres',
    user: 'postgres',
    password: 'your_password',
});

// 查询向量(模拟用户输入 "PostgreSQL search" 的 Embedding)
const QUERY_VECTOR = [0.8, 0.2, 0.3];

async function hybridSearch(queryText, queryVector, limit = 10) {
    const client = await pool.connect();
    try {
        // 混合检索:先全文过滤,再按向量相似度排序
        const result = await client.query(
            `
            WITH filtered AS (
                SELECT
                    id,
                    title,
                    content,
                    tsv,
                    embedding,
                    ts_rank(tsv, to_tsquery('english', $1)) AS text_score
                FROM hybrid_docs
                WHERE tsv @@ to_tsquery('english', $1)
            )
            SELECT
                id,
                title,
                content,
                text_score,
                1 - (embedding <=> $2::VECTOR(3)) AS vector_score,
                (0.5 * ts_rank(tsv, to_tsquery('english', $1)) +
                 0.5 * (1 - (embedding <=> $2::VECTOR(3)))) AS hybrid_score
            FROM filtered
            ORDER BY hybrid_score DESC
            LIMIT $3
            `,
            [queryText, `[${QUERY_VECTOR.join(',')}]`, limit]
        );
        return result.rows;
    } finally {
        client.release();
    }
}

async function main() {
    console.log('=== PostgreSQL 混合检索 Demo ===\n');

    const results = await hybridSearch('postgresql & search', QUERY_VECTOR);

    console.log('查询条件: "postgresql & search"');
    console.log('查询向量:', QUERY_VECTOR);
    console.log('\n检索结果:');
    console.log('-' .repeat(80));

    results.forEach((row, idx) => {
        console.log(`\n[${idx + 1}] ${row.title}`);
        console.log(`  Text Score: ${row.text_score.toFixed(4)}`);
        console.log(`  Vector Score: ${row.vector_score.toFixed(4)}`);
        console.log(`  Hybrid Score: ${row.hybrid_score.toFixed(4)}`);
        console.log(`  Content: ${row.content}`);
    });

    await pool.end();
}

main().catch(console.error);

技术点总结

  • 全文检索:使用 tsvector、tsquery、to_tsvector、to_tsquery 和 @@ 运算符
  • 向量检索:使用 pgvector 的 vector 类型和余弦距离运算符 <=>
  • 混合检索:在同一 SQL 查询中结合全文过滤与向量排序
  • 加权排序:使用 ts_rank 和向量相似度计算综合分数
  • 索引加速:GIN 索引加速全文检索,HNSW 索引加速向量检索

多语言示例

本部分提供 Go、Python 和 Java 三种语言的完整可运行示例,功能与前述 Node.js 版本等价:连接 PostgreSQL 数据库,执行混合检索(全文过滤 + 向量相似度排序),输出综合排序结果。

Go 示例

运行说明
  1. 安装依赖:

    go mod init hybrid-search-demo
    go get github.com/jackc/pgx/v5
    go get github.com/pgvector/pgvector-go
    go get github.com/pgvector/pgvector-go/pgx
    
  2. 数据库准备:确保 PostgreSQL 已安装 pgvector 扩展,并执行 Node.js 示例中的初始化 SQL 脚本。

  3. 运行:

    go run main.go
    
代码说明

Go 示例使用 pgx 作为 PostgreSQL 驱动,pgvector-go 提供 vector 类型的支持[reference:0]。核心流程如下:

  • 通过 pgx.Connect 建立数据库连接
  • 使用 pgxvec.RegisterTypes 注册 vector 类型
  • 执行混合检索 SQL,使用 pgvector.NewVector 构造查询向量
  • 使用余弦距离运算符 <=> 计算相似度
技术点总结
  • 使用 pgx 驱动 + pgvector-go 扩展
  • 通过 pgxvec.RegisterTypes 注册自定义类型
  • 使用 pgvector.NewVector 将 Go 切片转换为数据库 vector 类型
  • 支持 <=> 余弦距离、<-> 欧几里得距离、<#> 负内积运算符
完整代码
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/jackc/pgx/v5"
	"github.com/pgvector/pgvector-go"
	pgxvec "github.com/pgvector/pgvector-go/pgx"
)

type HybridDoc struct {
	ID          int
	Title       string
	Content     string
	TextScore   float64
	VectorScore float64
	HybridScore float64
}

func main() {
	ctx := context.Background()

	// 连接数据库
	conn, err := pgx.Connect(ctx, "postgres://postgres:your_password@localhost:5432/postgres")
	if err != nil {
		log.Fatal("无法连接数据库:", err)
	}
	defer conn.Close(ctx)

	// 注册 pgvector 类型
	if err := pgxvec.RegisterTypes(ctx, conn); err != nil {
		log.Fatal("注册 vector 类型失败:", err)
	}

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

	// 查询向量(模拟用户输入 "PostgreSQL search" 的 Embedding)
	queryVector := pgvector.NewVector([]float32{0.8, 0.2, 0.3})
	queryText := "postgresql & search"
	limit := 10

	// 混合检索 SQL
	sql := `
		WITH filtered AS (
			SELECT
				id,
				title,
				content,
				tsv,
				embedding,
				ts_rank(tsv, to_tsquery('english', $1)) AS text_score
			FROM hybrid_docs
			WHERE tsv @@ to_tsquery('english', $1)
		)
		SELECT
			id,
			title,
			content,
			text_score,
			1 - (embedding <=> $2) AS vector_score,
			(0.5 * ts_rank(tsv, to_tsquery('english', $1)) +
			 0.5 * (1 - (embedding <=> $2))) AS hybrid_score
		FROM filtered
		ORDER BY hybrid_score DESC
		LIMIT $3
	`

	rows, err := conn.Query(ctx, sql, queryText, queryVector, limit)
	if err != nil {
		log.Fatal("查询失败:", err)
	}
	defer rows.Close()

	fmt.Println("=== Go 混合检索 Demo ===")
	fmt.Printf("查询条件: %q\n", queryText)
	fmt.Printf("查询向量: [0.8, 0.2, 0.3]\n\n")
	fmt.Println("检索结果:")
	fmt.Println("--------------------------------------------------------------------------------")

	var results []HybridDoc
	for rows.Next() {
		var doc HybridDoc
		err := rows.Scan(
			&doc.ID,
			&doc.Title,
			&doc.Content,
			&doc.TextScore,
			&doc.VectorScore,
			&doc.HybridScore,
		)
		if err != nil {
			log.Fatal("扫描行失败:", err)
		}
		results = append(results, doc)
	}

	for i, doc := range results {
		fmt.Printf("\n[%d] %s\n", i+1, doc.Title)
		fmt.Printf("  Text Score: %.4f\n", doc.TextScore)
		fmt.Printf("  Vector Score: %.4f\n", doc.VectorScore)
		fmt.Printf("  Hybrid Score: %.4f\n", doc.HybridScore)
		fmt.Printf("  Content: %s\n", doc.Content)
	}
}

Python 示例

运行说明
  1. 安装依赖:

    pip install psycopg2-binary pgvector
    
  2. 数据库准备:确保 PostgreSQL 已安装 pgvector 扩展,并执行 Node.js 示例中的初始化 SQL 脚本。

  3. 运行:

    python hybrid_search_demo.py
    
代码说明

Python 示例使用 psycopg2 作为 PostgreSQL 驱动,pgvector.psycopg2 提供 vector 类型的支持[reference:5]。核心流程如下:

  • 使用 psycopg2.connect 建立数据库连接
  • 调用 register_vector 注册 vector 类型[reference:6][reference:7]
  • 执行混合检索 SQL,使用列表作为向量参数
  • 使用余弦距离运算符 <=> 计算相似度
技术点总结
  • 使用 psycopg2-binary + pgvector Python 包
  • 通过 register_vector 注册自定义类型
  • 向量参数以 Python list 形式传递,自动转换为 PostgreSQL vector
  • 支持 <=> 余弦距离、<-> 欧几里得距离、<#> 负内积运算符
完整代码
import psycopg2
from pgvector.psycopg2 import register_vector

def main():
    # 连接数据库
    conn = psycopg2.connect(
        host="localhost",
        port=5432,
        database="postgres",
        user="postgres",
        password="your_password"
    )
    cur = conn.cursor()

    # 注册 pgvector 类型
    register_vector(conn)

    # 启用扩展(如未启用)
    cur.execute("CREATE EXTENSION IF NOT EXISTS vector")
    conn.commit()

    # 查询向量(模拟用户输入 "PostgreSQL search" 的 Embedding)
    query_vector = [0.8, 0.2, 0.3]
    query_text = "postgresql & search"
    limit = 10

    # 混合检索 SQL
    sql = """
        WITH filtered AS (
            SELECT
                id,
                title,
                content,
                tsv,
                embedding,
                ts_rank(tsv, to_tsquery('english', %s)) AS text_score
            FROM hybrid_docs
            WHERE tsv @@ to_tsquery('english', %s)
        )
        SELECT
            id,
            title,
            content,
            text_score,
            1 - (embedding <=> %s) AS vector_score,
            (0.5 * ts_rank(tsv, to_tsquery('english', %s)) +
             0.5 * (1 - (embedding <=> %s))) AS hybrid_score
        FROM filtered
        ORDER BY hybrid_score DESC
        LIMIT %s
    """

    cur.execute(sql, (query_text, query_text, query_vector, query_text, query_vector, limit))
    results = cur.fetchall()

    print("=== Python 混合检索 Demo ===")
    print(f'查询条件: "{query_text}"')
    print(f"查询向量: {query_vector}\n")
    print("检索结果:")
    print("-" * 80)

    for i, row in enumerate(results):
        doc_id, title, content, text_score, vector_score, hybrid_score = row
        print(f"\n[{i+1}] {title}")
        print(f"  Text Score: {text_score:.4f}")
        print(f"  Vector Score: {vector_score:.4f}")
        print(f"  Hybrid Score: {hybrid_score:.4f}")
        print(f"  Content: {content}")

    cur.close()
    conn.close()

if __name__ == "__main__":
    main()

Java 示例

运行说明
  1. Maven 依赖(pom.xml):

    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.7.3</version>
    </dependency>
    <dependency>
        <groupId>com.pgvector</groupId>
        <artifactId>pgvector</artifactId>
        <version>0.1.6</version>
    </dependency>
    
  2. 数据库准备:确保 PostgreSQL 已安装 pgvector 扩展,并执行 Node.js 示例中的初始化 SQL 脚本。

  3. 编译与运行:

    mvn compile
    mvn exec:java -Dexec.mainClass="com.example.HybridSearchDemo"
    
代码说明

Java 示例使用 JDBC 作为 PostgreSQL 驱动,pgvector 库提供 PGvector 类型支持[reference:9]。核心流程如下:

  • 使用 DriverManager.getConnection 建立数据库连接
  • 调用 PGvector.registerTypes 注册 vector 类型
  • 执行混合检索 SQL,使用 PGvector 对象构造查询向量
  • 使用余弦距离运算符 <=> 计算相似度[reference:12]
技术点总结
  • 使用 JDBC + pgvector Java 库
  • 通过 PGvector.registerTypes 注册自定义类型
  • 使用 setObject 传递 PGvector 参数
  • 支持 <=> 余弦距离、<-> 欧几里得距离、<#> 负内积运算符
完整代码
package com.example;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import com.pgvector.PGvector;

public class HybridSearchDemo {

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

        try (Connection conn = DriverManager.getConnection(url, user, password)) {

            // 注册 pgvector 类型
            PGvector.registerTypes(conn);

            // 启用扩展(如未启用)
            try (PreparedStatement stmt = conn.prepareStatement(
                    "CREATE EXTENSION IF NOT EXISTS vector")) {
                stmt.executeUpdate();
            }

            // 查询向量(模拟用户输入 "PostgreSQL search" 的 Embedding)
            float[] vectorData = {0.8f, 0.2f, 0.3f};
            PGvector queryVector = new PGvector(vectorData);
            String queryText = "postgresql & search";
            int limit = 10;

            // 混合检索 SQL
            String sql = """
                WITH filtered AS (
                    SELECT
                        id,
                        title,
                        content,
                        tsv,
                        embedding,
                        ts_rank(tsv, to_tsquery('english', ?)) AS text_score
                    FROM hybrid_docs
                    WHERE tsv @@ to_tsquery('english', ?)
                )
                SELECT
                    id,
                    title,
                    content,
                    text_score,
                    1 - (embedding <=> ?) AS vector_score,
                    (0.5 * ts_rank(tsv, to_tsquery('english', ?)) +
                     0.5 * (1 - (embedding <=> ?))) AS hybrid_score
                FROM filtered
                ORDER BY hybrid_score DESC
                LIMIT ?
            """;

            try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
                pstmt.setString(1, queryText);
                pstmt.setString(2, queryText);
                pstmt.setObject(3, queryVector);
                pstmt.setString(4, queryText);
                pstmt.setObject(5, queryVector);
                pstmt.setInt(6, limit);

                ResultSet rs = pstmt.executeQuery();

                System.out.println("=== Java 混合检索 Demo ===");
                System.out.printf("查询条件: \"%s\"\n", queryText);
                System.out.printf("查询向量: [0.8, 0.2, 0.3]\n\n");
                System.out.println("检索结果:");
                System.out.println("--------------------------------------------------------------------------------");

                int index = 0;
                while (rs.next()) {
                    index++;
                    int id = rs.getInt("id");
                    String title = rs.getString("title");
                    String content = rs.getString("content");
                    double textScore = rs.getDouble("text_score");
                    double vectorScore = rs.getDouble("vector_score");
                    double hybridScore = rs.getDouble("hybrid_score");

                    System.out.printf("\n[%d] %s\n", index, title);
                    System.out.printf("  Text Score: %.4f\n", textScore);
                    System.out.printf("  Vector Score: %.4f\n", vectorScore);
                    System.out.printf("  Hybrid Score: %.4f\n", hybridScore);
                    System.out.printf("  Content: %s\n", content);
                }
            }

        } catch (SQLException e) {
            System.err.println("数据库错误: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

多语言对比

维度Node.jsGoPythonJava
驱动/库pgpgx + pgvector-gopsycopg2 + pgvectorJDBC + pgvector
类型注册自动(pg 驱动原生支持)pgxvec.RegisterTypesregister_vectorPGvector.registerTypes
向量构造[0.8, 0.2, 0.3](数组字面量)pgvector.NewVector([]float32{...})[0.8, 0.2, 0.3](列表)new PGvector(new float[]{...})
参数传递$1, $2 占位符$1, $2 占位符%s 占位符(psycopg2)? 占位符(JDBC)
异步支持原生 async/await原生 context + goroutine需 asyncpg 或 asyncio需 CompletableFuture / R2DBC
ORM 可选TypeORM / PrismaGORM / Bun / EntSQLAlchemy[reference:14]Hibernate / Spring JDBC
依赖管理npmgo modpipMaven / Gradle
类型安全弱(TypeScript 可选)强弱强

官方文档

参考链接

总结

本文系统梳理了 PostgreSQL 全文检索与向量检索的核心机制、适用场景及实现方式。全文检索以倒排索引为核心,通过 tsvector / tsquery 类型和 GIN 索引实现高效的关键词匹配;向量检索通过 pgvector 扩展和 Embedding 模型实现语义级别的相似度检索。二者并非互斥,而是互补关系——全文检索擅长精确定位,向量检索擅长语义理解。

通过混合检索策略(Pre-filter / Post-filter / 加权排序),可以在同一 PostgreSQL 实例中实现兼具效率与智能的搜索体验。PostgreSQL 同时原生支持全文检索与向量检索,是构建现代检索系统的理想数据库选型。

PostgreSQL原生向量搜索:pgvector实战指南与性能调优 向量搜索是支撑RAG、语义推荐、智能客服等AI应用的核心能力,其本质是将非结构化语义信息转化为可计算的高维向量,并基于余弦相似度、L2距离等数学原理实现高效近似最近邻检索。技术价值在于打破结构化与非结构化数据的壁垒,实现低延迟、强一致、免运维的混合查询。典型应用场景包括PostgreSQL中直接增强商品搜索、用户评论情感聚类、文档语义召回等。pgvector作为深度嵌入PostgreSQL的开源扩展,让向量能力成为数据库一等公民,无需双写、不新增组件,真正实现‘用SQL做语义搜索’。 阅读详情

相关推荐

LightRAG实战踩坑记:当PostgreSQL向量插件遇到子查询别名错误,我是如何解决的

本文详细记录了LightRAG框架在集成PostgreSQL的pgvector插件时遇到的子查询别名错误问题。通过分析错误原因、修改源码并添加防御性编程措施,成功解决了这一技术难题,为开发者提供了实用的解决方案和多数据库兼容建议。

weixin_29197051的博客 378

混合检索的极简主义:PostgreSQL + pgvector 生产级方案

本文介绍了基于PostgreSQL+pgvector的混合检索生产级方案,主要特点包括: 混合检索优势:结合关键词检索(BM25)和语义检索(向量),通过RRF算法融合两路结果,取长补短。 单库解决方案:PostgreSQL通过扩展机制实现"一人三角"——关系数据库、全文检索引擎和向量检索引擎,共享内存池和ACID事务,简化架构。 关键技术选择:推荐使用HNSW向量索引,支持动态插入和高召回率;通过RRF算法在应用层实现融合,保持灵活性。 运维简化:无需消息队列,写入即更新;定期维护全文索引和向量索引即可保

qq_44021627的博客 396

时空数据库与向量检索融合技术解析与应用

时空数据库作为处理地理空间与时间序列数据的核心技术,通过引入向量检索技术实现了从结构化查询到语义理解的跨越。其技术原理在于将空间坐标、时间戳等传统时空数据与深度学习生成的向量表示相结合,构建多模态索引体系。这种融合显著提升了复杂场景下的数据处理效率,特别是在需要同时满足空间约束和语义相似度的应用场景中。以智慧城市和金融风控为代表的领域已经验证了该技术的实用价值,例如通过实时轨迹聚类识别交通热点,或利用设备指纹向量化检测欺诈行为。随着HNSW等近似最近邻算法在数据库内核的集成,以及阿里云GanosBase等产

weixin_33933118的博客 355

RAG混合检索架构:打破向量搜索依赖的工程实践

RAG(检索增强生成)的核心挑战在于检索层的鲁棒性与可维护性。单纯依赖向量搜索虽能缓解语义鸿沟,却在缩写归一化、数字精确匹配、低资源语言处理等场景下表现脆弱,且面临embedding漂移、调试不可见、运维成本高等工程瓶颈。混合检索通过并行融合BM25全文检索、规则引擎与向量搜索,以PostgreSQL为统一底座,实现关键词精准性、结构化过滤能力与语义泛化性的三重互补。其技术价值在于提升线上召回稳定性、降低模型迭代耦合度,并支持query-aware动态加权排序。典型应用场景包括金融合同问答、医疗术语检索、多

clhq71932的博客 416

从Embedding到向量数据库:构建智能语义检索系统的核心技术与实战

在人工智能和机器学习领域,将非结构化数据(如文本、图像)转化为机器可理解的数学表示是核心技术之一。其核心原理在于通过预训练模型,将离散的符号映射到连续的向量空间中,从而捕捉深层的语义信息。这项技术的核心价值在于实现了从传统的关键词匹配到语义理解的范式转变,使得系统能够理解近义词、同义词和上下文关联。在工程实践中,这为智能搜索、推荐系统、问答机器人等应用场景提供了基础能力。例如,结合Embedding模型和向量数据库,可以高效处理海量向量的相似度计算与检索,解决传统数据库在语义搜索上的性能瓶颈。本文聚焦于如何

weixin_34008805的博客 445

多模态RAG核心:向量库级跨模态检索架构设计

多模态检索是现代智能知识系统的基础能力,其本质是将图像、文本、音频等异构数据统一映射到共享语义空间,实现跨模态相似性计算与联合召回。原理上依赖多模态编码器(如CLIP、Qwen-VL)的联合表征能力,并通过向量数据库(如Qdrant)支持多粒度、多向量、结构化payload的索引机制。技术价值在于突破传统RAG仅处理文本的瓶颈,显著提升图文对齐精度、局部区域定位能力和端到端检索响应效率。典型应用场景包括医疗影像辅助诊断、工业图纸智能问答、科研文献图谱构建及产品手册视觉检索。本文聚焦‘Multimodal R

chushang0934的博客 475

基于Transformer与PostgreSQL的向量检索实战:从原理到应用

向量嵌入(Embedding)作为现代机器学习中的核心概念,是将文本、图像等高维数据映射为低维稠密向量的关键技术。其原理通常基于Transformer架构的自注意力机制,能够捕捉数据的深层语义信息。这项技术的核心价值在于,它使得计算机能够理解并比较非结构化数据的语义相似性,从而为智能搜索、推荐系统、问答机器人等应用场景提供了基础。在实际工程中,如何高效存储和检索这些向量成为关键挑战。PostgreSQL结合pgvector扩展,提供了成熟的关系型数据库向量解决方案,支持近似最近邻搜索,有效解决了海量向量数据

427

向量存储实战指南:RAG系统中的语义检索核心架构

向量存储是支撑生成式AI实现精准语义检索的关键基础设施,其本质是将非结构化数据(文本、图像等)通过Embedding模型映射为高维向量,并利用近似最近邻(ANN)算法完成毫秒级相似性匹配。它并非传统数据库的替代品,而是弥补关键词搜索在语义理解上的根本缺陷——例如‘iPhone促销’与‘苹果手机降价’零关键词重合却语义高度一致。技术价值在于 bridging 模型能力与私有数据之间的鸿沟,使RAG系统具备可扩展、低延迟、高相关性的实时召回能力。典型应用场景包括企业知识库问答、智能客服、法律文书比对及电商个性化

dibeichan3033的博客 776

PostgreSQL笔记4: 市场地位、生态全景与行业应用实践

技术能力实现方式适用场景全文检索tsvectortsquery+ GIN 索引内容搜索、日志分析半结构化数据JSONB类型 + GIN 索引灵活 Schema、配置存储向量检索pgvector扩展 + IVFFlat/HNSW 索引RAG、推荐系统、语义搜索混合查询上述能力的 SQL 组合复杂业务场景的统一数据访问表结构创建(若已存在则跳过)插入三条测试数据(包含 JSONB 和向量字段)全文检索查询(tsvectortsqueryJSONB 包含查询(@>运算符)

Wang的专栏 531

OceanBase seekdb:AI原生混合搜索数据库的极简实践

混合搜索是AI应用中融合向量检索、全文匹配与标量过滤的关键技术范式,其核心在于打破数据类型壁垒,实现跨模态语义统一打分与低延迟原子查询。传统方案依赖Elasticsearch、Milvus、PostgreSQL等多引擎拼接,面临网络开销大、结果融合难、事务一致性弱等工程瓶颈;而AI原生数据库通过存储层深度协同与查询优化器内聚设计,将向量索引、倒排表、列式缓存统一调度,显著降低P99延迟并提升召回可信度。OceanBase seekdb正是这一理念的开源落地,它以三行代码封装十五年分布式数据库经验,面向RAG

weixin_30919571的博客 375

Windows沙盒神器Sandboxie Plus保姆级教程:从安装到实战测试可疑软件

本文详细介绍了Windows沙盒神器Sandboxie Plus的安装、配置与实战应用,帮助用户安全测试可疑软件。从系统要求、安装步骤到核心功能如多沙盒管理、文件共享和快照恢复,全面解析了这款轻量级沙盒工具的优势与使用技巧,特别适合需要隔离运行未知程序的用户。

weixin_29323049的博客 1162

8.8 向量数据库与PostgreSQL向量能力介绍

向量数据库是专门用于存储、检索、分析高维向量数据的数据库,核心能力是解决高维空间近似最近邻(ANN)搜索非结构化数据(文本、图像、音频、视频等)经过Embedding模型转换为固定维度的向量(通常维度在128~4096之间)向量数据库通过向量索引技术,快速查找与查询向量最相似的Top N个结果,速度比传统暴力搜索快几个数量级。

qq_28611929的博客 421

可信数据空间关键技术和功能架构研究

可信数据空间(TDS)是实现数据安全共享的基础设施,通过数字合约和使用控制技术确保数据跨域流通的可信与安全。其架构包括服务平台和接入连接器,关键技术涵盖访问控制、隐私计算、区块链等。评估重点在于合规性、连接器能力、互联互通及安全体系。核心在于构建规则引擎而非简单数据汇聚,连接器开发比平台建设更重要。当前面临技术成本博弈、跨域身份互认等挑战,需平衡安全、性能与成本,推动数据要素市场发展。

逸尘的专栏 2231

PostgreSQL 向量检索实战:IVFFlat与HNSW索引的性能调优指南

本文深入探讨了PostgreSQL中IVFFlat与HNSW索引在向量检索中的性能调优策略。通过对比两种索引的构建参数、查询性能及适用场景,提供了针对不同数据规模和需求的优化建议,帮助开发者高效实现相似性搜索。文章特别强调了pgvector插件的应用,展示了如何在实际项目中平衡精度与速度。

food6的博客 125

TwinCAT报SSE invalid operation错误

错误类型 TwinCAT程序中报出以下错误: 严重性 代码 说明 项目 文件 行 禁止显示状态 错误 **** 383 ms | 'Port_851' (851): Exception (Exception Code: 0xc0000090, SSE invalid operation) in PLC Application Untitled1 Instance, Task PlcTask (RBP: 0xffffb3016c80ecc0, RIP: 0xffffe708ee5b5f53, RSP:

akadiao的博客 4164

MultiOTP Credential Provider避坑指南:从安装到RDP双因素认证的全流程解析

本文详细解析了MultiOTP Credential Provider从安装到实现RDP双因素认证(MFA)的全流程,重点分享了Docker部署、Active Directory集成及网络级认证(NLA)兼容性等环节的实战避坑经验,旨在帮助运维人员高效、稳定地部署离线双因素认证方案,提升Windows远程桌面安全性。

weixin_29255731的博客 647

百万向量检索用 PostgreSQL 就够了?pgvector 性能实测:比专用数据库慢 3 倍但省下 80% 运维成本

实测证明用 PostgreSQL 的 pgvector 插件处理百万级向量检索,虽然比 Milvus 等专用数据库慢 3 倍,但能省去额外组件运维成本。本文包含完整配置指南、混合查询性能对比、Python 集成代码,以及生产环境遇到的五大典型问题解决方案。

weixin_47315004的博客 44

史上最强量化工具库 Ta-Lib 从入门到精通,一篇文章就够了!

Ta-Lib 提供的 13 个关键指标,并配上详细的代码示例,确保你看完就能直接上手!🔥。

奔跑的蜗牛 9938

突破万亿向量检索瓶颈:pgvector分布式搜索实战指南

你是否正面临向量数据爆炸式增长带来的检索延迟?当向量规模突破千万级,单节点PostgreSQL已力不从心,分布式部署成为必然选择。本文将系统剖析pgvector在分布式环境下的五大核心挑战,并提供经过生产验证的解决方案,帮助你在保持ACID特性的同时,实现每秒百万级向量检索。 读完本文你将掌握: - 如何通过表分区解决向量数据倾斜问题 - 多节点索引同步的三种高效策略 - Citus分布式扩展的...

gitblog_00751的博客 582

PyCharm 2023最新版安装配置全攻略(附永久激活教程)

本文详细介绍了PyCharm 2023最新版的安装配置全流程,包括版本选择、初始配置、插件生态、工程模板、调试优化及团队协作等关键步骤。特别针对专业版和社区版的功能差异进行对比,帮助开发者高效搭建Python开发环境,提升编码效率与团队协作能力。

p4q5r6s7t的博客 876

使用virtuoso gds转lef操作方法

2) 然后,需要创建Pin,这里Pin的概念不同于label/text,是有实际金属的,二者的区别类似于pr中的port和terminal。1) 首先,需要画prBoundary,这个用drawing层的prBoundary画是不行的,不过建议pr阶段就把prBoundary转到gds里,在virtuoso layout中画prBoundary就比较容易。另外,用Create - Create Pin也可以创建pin,更适用于PG pin,操作时先给pg shape打label,最好放正中间。

m0_61544122的博客 1382

向量数据库选型实战:48小时锁定生产级方案

向量数据库是支撑RAG、语义搜索等AI应用的核心基础设施,其本质是近似最近邻(ANN)检索系统,依赖HNSW、IVF-PQ等索引算法实现高维向量的高效相似性匹配。技术价值在于平衡精度、延迟、吞吐与资源开销,广泛应用于电商搜索、金融风控、医疗知识库等需‘用语义而非关键词找信息’的场景。实际落地中,混合查询能力与生产级可观测性往往比单纯参数指标更关键——例如属性过滤是否走独立索引、监控是否覆盖P95延迟与召回率。本文基于12种向量数据库的压测与替换经验,聚焦向量数据库选型与HNSW与IVF-PQ权衡两大核心热词

weixin_30598225的博客 433

56、Cortex - M33处理器浮点单元(FPU)的使用与优化

本文详细介绍了Cortex-M33处理器浮点单元(FPU)的使用与优化方法,涵盖单双精度浮点计算的选择、编译器命令行配置、ABI模式对比、特殊FPU模式设置(如Flush-to-Zero、Default NaN)、浮点异常处理机制以及FPU电源管理策略。结合代码示例和流程图,提供了在不同应用场景下的最佳实践建议,并总结了常见问题及解决方案,帮助开发者提升嵌入式系统中浮点运算的性能、精度与能效。

bread的博客 155

PostgreSQL向量搜索性能基准:pgvecto.rs vs Elasticsearch vs Milvus – 谁是2024年最快向量数据库?

在AI驱动的应用开发中,向量数据库的选择直接影响系统性能。**pgvecto.rs**作为PostgreSQL的向量搜索插件,正与Elasticsearch、Milvus等专业向量数据库展开激烈竞争。本文通过实测对比三种技术的查询速度、资源占用和易用性,助你找到最适合LLM应用的解决方案。 ## 🚀 为什么向量数据库性能至关重要? 随着大语言模型(LLM)的普及,应用需要处理海量高维向量数据

gitblog_00714的博客 717

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

向量数据库实战指南:pgvector 索引优化与性能调优

本文深入探讨了pgvector向量数据库的索引优化与性能调优实战。通过对比HNSW与IVFFlat两种核心索引的适用场景、构建速度、查询性能及召回率,并结合实际案例,为开发者提供了从参数配置到混合查询的全面调优指南,帮助应对百万级以上向量数据的检索挑战。

git9versioner的博客 991

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

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

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

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

gitblog_01026的博客 322

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

上一篇: PostgreSQL笔记47: pgvector向量索引原理与选型指南
下一篇: PostgreSQL笔记49:向量检索核心算法、索引调优与过滤策略深度解析
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、付费专栏及课程。

余额充值