DuckDB: 向量索引(vss)的一些注意事项

最新推荐文章于 2025-10-08 02:22:00 发布
原创 最新推荐文章于 2025-10-08 02:22:00 发布 · 1k 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#DuckDB #分析工程 #数据分析

DuckDB最近添加了向量索引，这对于刚刚进入人工智能领域的人来说非常棒，但他们仍然喜欢成熟SQL（以及嵌入式/无服务器数据库）的温暖舒适。

VSS索引旨在加快搜索速度——DuckDB已经提供了相似性/距离函数和向量/数组数据类型，所以严格来说，它是一个有就好而不是必须的特性，特别是当您有几个（1000个而不是数百万个）文档时，并且可以在不减慢速度的情况下执行强行全表扫描。
在这里插入图片描述

查询计划

一旦添加了向量索引，就有必要检查DB是否确实使用了索引，特别是对于您想要加速的查询，以及它们是否确实运行得更快。

这篇文章介绍了一些向量搜索SQL查询和它们相关的查询计划。对于那些不习惯阅读查询计划的人，这里有一个快速且非常简单的入门：

  • 每个“框”或节点是数据库在处理查询时执行的一个步骤或操作。操作可以类似于Order By（需要根据某些标准对行进行排序）或Projection（需要选择部分或全部列并忽略其余列）。

  • 通常查询计划是树状或dag状的但我们今天要讲的所有查询计划都是线性的（即一步接着下一步等等）

  • 在OLAP数据库（如DuckDB）中，索引并不是那么重要，因为大多数查询都将扫描整个表（而不是选择一两行来执行事务）。但是，对于某些特殊情况，如全文搜索或向量相似性搜索，索引在OLAP数据库中仍然非常重要。

  • 在我们的示例中，一旦向量索引就绪，我们需要在查询计划中查找节点，其中DB正在执行索引扫描（HNSW_INDEX_SCAN），表明它没有通过顺序扫描（SEQ_SCAN）强行执行。

VSS索引示例

让我们从一些测试数据开始，然后创建索引。在DuckDB中使用矢量索引要记住的第一件事是在运行查询之前总是加载扩展-如果你不这样做，DuckDB不会警告你，它会简单地选择顺序扫描：

install vss;
load vss;
# D set hnsw_enable_experimental_persistence=true;  如果不是内存模式，需要增加该设置项
create table tbl (id integer primary key, vec float[3]);

insert into tbl
select a, array_value(a, a+1,a+2)
from range(1, 1000) ra(a);

create index idx on tbl using hnsw (vec);

limit子句非常有必要

如果没有limit子句，DuckDB会选择顺序扫描——这是正确的操作。这应该不用说了（特别是对于top-K查询），但仍然值得一提：

让我们做一个解释来获取查询计划。

当省略限制子句时：

explain
select * from tbl
order by array_distance(vec, [1, 2, 3]::float[3]) asc;

返回结果显示采用了顺序扫描（看最后部分）：

┌─────────────────────────────┐
│┌───────────────────────────┐│
││       Physical Plan       ││
│└───────────────────────────┘│
└─────────────────────────────┘
┌───────────────────────────┐
│         PROJECTION        │
│    ────────────────────   │
│__internal_decompress_integ│
│     ral_integer(#0, 1)    │
│             #1            │
│                           │
│         ~999 Rows         │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│          ORDER_BY         │
│    ────────────────────   │
│           #2 ASC          │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│         PROJECTION        │
│    ────────────────────   │
│__internal_compress_integra│
│     l_usmallint(#0, 1)    │
│             #1            │
│             #2            │
│                           │
│         ~999 Rows         │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│         PROJECTION        │
│    ────────────────────   │
│             id            │
│            vec            │
│ array_distance(vec, [1.0, │
│         2.0, 3.0])        │
│                           │
│         ~999 Rows         │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│         SEQ_SCAN          │
│    ────────────────────   │
│            tbl            │
│                           │
│        Projections:       │
│             id            │
│            vec            │
│                           │
│         ~999 Rows         │
└───────────────────────────┘

增加limit子句：

explain
select * from tbl
order by array_distance(vec, [1, 2, 3]::float[3]) asc
limit 10;

结果显示采用了索引扫描：

┌─────────────────────────────┐
│┌───────────────────────────┐│
││       Physical Plan       ││
│└───────────────────────────┘│
└─────────────────────────────┘
┌───────────────────────────┐
│         PROJECTION        │
│    ────────────────────   │
│             #0            │
│             #1            │
│                           │
│          ~10 Rows         │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│         PROJECTION        │
│    ────────────────────   │
│             id            │
│            vec            │
│            NULL           │
│                           │
│         ~999 Rows         │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│      HNSW_INDEX_SCAN      │
│    ────────────────────   │
│tbl (HNSW INDEX SCAN : idx)│
│                           │
│        Projections:       │
│             id            │
│            vec            │
│                           │
│         ~999 Rows         │
└───────────────────────────┘

窗口查询和向量索引

关于向量搜索，有些情况下窗口查询非常方便，例如在执行互惠排名融合（Reciprocal Rank Fusion，简称 RRF）时。然而，在这种情况下，让DuckDB选择索引扫描是相当困难的。

让我们从下面的查询开始：

select
    id,
    rank() over(
        order by array_distance(vec, [1, 2, 3]::float[3]) asc
    ) as rank,
from tbl;

它返回每个元组。由于where子句不能包含窗口函数的值，因此我们需要将其封装在CTE中，以便获得排名最高的行：

explain
with res as (
    select
        id,
        rank() over(
            order by array_distance(vec, [1, 2, 3]::float[3]) asc
        ) as rank,
    from tbl
)
select * from res
where rank <= 10;

结果显示执行了顺序扫描：

┌─────────────────────────────┐
│┌───────────────────────────┐│
││       Physical Plan       ││
│└───────────────────────────┘│
└─────────────────────────────┘
┌───────────────────────────┐
│         PROJECTION        │
│    ────────────────────   │
│             #0            │
│             #2            │
│                           │
│         ~199 Rows         │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│           FILTER          │
│    ────────────────────   │
│        (rank <= 10)       │
│                           │
│         ~199 Rows         │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│         PROJECTION        │
│    ────────────────────   │
│             #0            │
│             #1            │
│             #2            │
│                           │
│         ~999 Rows         │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│           WINDOW          │
│    ────────────────────   │
│        Projections:       │
│   RANK() OVER (ORDER BY   │
│  array_distance(vec, [1.0,│
│ 2.0, 3.0]) ASC NULLS LAST)│
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│         SEQ_SCAN          │
│    ────────────────────   │
│            tbl            │
│                           │
│        Projections:       │
│             id            │
│            vec            │
│                           │
│         ~999 Rows         │
└───────────────────────────┘

既然不行，我们可以依赖于隐含的事实，即window子句为我们排序行，因此我们可以插入limit子句：

explain
select
    id,
    rank() over(
        order by array_distance(vec, [1, 2, 3]::float[3]) asc
    ) as rank,
from tbl
limit 10;

但是，这没有多大帮助，db仍然会对这种情况进行顺序扫描。回到CTEs：通过稍微重写它，我们可以让DB使用索引扫描：

explain
with t as (
    select id, vec
    from tbl
    order by array_distance(vec, [1, 2, 3]::float[3]) asc
    limit 10
)
select
    id,
    rank() over(
        order by array_distance(vec, [1, 2, 3]::float[3]) asc
    ) as rank
from t

这次采用索引扫描：

┌─────────────────────────────┐
│┌───────────────────────────┐│
││       Physical Plan       ││
│└───────────────────────────┘│
└─────────────────────────────┘
┌───────────────────────────┐
│         PROJECTION        │
│    ────────────────────   │
│             id            │
│            rank           │
│                           │
│          ~10 Rows         │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│         PROJECTION        │
│    ────────────────────   │
│             #0            │
│             #1            │
│             #2            │
│                           │
│          ~10 Rows         │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│           WINDOW          │
│    ────────────────────   │
│        Projections:       │
│   RANK() OVER (ORDER BY   │
│  array_distance(vec, [1.0,│
│ 2.0, 3.0]) ASC NULLS LAST)│
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│         PROJECTION        │
│    ────────────────────   │
│             #0            │
│             #1            │
│                           │
│          ~10 Rows         │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│         PROJECTION        │
│    ────────────────────   │
│             id            │
│            vec            │
│            NULL           │
│                           │
│         ~999 Rows         │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│      HNSW_INDEX_SCAN      │
│    ────────────────────   │
│tbl (HNSW INDEX SCAN : idx)│
│                           │
│        Projections:       │
│             id            │
│            vec            │
│                           │
│         ~999 Rows         │
└───────────────────────────┘

如果我们把limit子句移到“外部”会怎么样：

explain
with t as (
    select id, vec
    from tbl
    order by array_distance(vec, [1, 2, 3]::float[3]) asc
)
select
    id,
    rank() over(
        order by array_distance(vec, [1, 2, 3]::float[3]) asc
    ) as rank
from t
limit 10 -- it's now here

不幸的是，这让我们回到了顺序扫描：

┌─────────────────────────────┐
│┌───────────────────────────┐│
││       Physical Plan       ││
│└───────────────────────────┘│
└─────────────────────────────┘
┌───────────────────────────┐
│         PROJECTION        │
│    ────────────────────   │
│             id            │
│            rank           │
│                           │
│         ~999 Rows         │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│           LIMIT           │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│         PROJECTION        │
│    ────────────────────   │
│             #0            │
│             #1            │
│             #2            │
│                           │
│         ~999 Rows         │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│           WINDOW          │
│    ────────────────────   │
│        Projections:       │
│   RANK() OVER (ORDER BY   │
│  array_distance(vec, [1.0,│
│ 2.0, 3.0]) ASC NULLS LAST)│
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│         PROJECTION        │
│    ────────────────────   │
│__internal_decompress_integ│
│     ral_integer(#0, 1)    │
│             #1            │
│                           │
│         ~999 Rows         │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│          ORDER_BY         │
│    ────────────────────   │
│           #2 ASC          │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│         PROJECTION        │
│    ────────────────────   │
│__internal_compress_integra│
│     l_usmallint(#0, 1)    │
│             #1            │
│             #2            │
│                           │
│         ~999 Rows         │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│         PROJECTION        │
│    ────────────────────   │
│             id            │
│            vec            │
│ array_distance(vec, [1.0, │
│         2.0, 3.0])        │
│                           │
│         ~999 Rows         │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│         SEQ_SCAN          │
│    ────────────────────   │
│            tbl            │
│                           │
│        Projections:       │
│             id            │
│            vec            │
│                           │
│         ~999 Rows         │
└───────────────────────────┘

余弦举例与余弦相似度

下面采用余弦相似度进行测试：

create or replace table tbl (id integer primary key, vec float[3]);
insert into tbl select a, array_value(a, a+1,a+2) from range(1, 1000) ra(a);

load vss;
create index idx on tbl using hnsw (vec) with (metric='cosine');

explain
select * from tbl
order by array_cosine_similarity(vec, [1, 2, 3]::float[3]) desc
limit 10;

在运行时，db执行顺序扫描。请注意，我们必须使用上面的desc，即从最大的相似分数到最低的顺序，然后选择最高的k。余弦相似分数的范围从1到-1，与查询嵌入相似的值更接近1。

┌─────────────────────────────┐
│┌───────────────────────────┐│
││       Physical Plan       ││
│└───────────────────────────┘│
└─────────────────────────────┘
┌───────────────────────────┐
│         PROJECTION        │
│    ────────────────────   │
│             #0            │
│             #1            │
│                           │
│          ~0 Rows          │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│           TOP_N           │
│    ────────────────────   │
│          Top: 10          │
│     Order By: #2 DESC     │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│         PROJECTION        │
│    ────────────────────   │
│             id            │
│            vec            │
│  array_cosine_similarity  │
│   (vec, [1.0, 2.0, 3.0])  │
│                           │
│          ~0 Rows          │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│         SEQ_SCAN          │
│    ────────────────────   │
│            tbl            │
│                           │
│        Projections:       │
│             id            │
│            vec            │
│                           │
│          ~0 Rows          │
└───────────────────────────┘

让我们切换到asc，即从最不相似到最相似的顺序：

explain
select * from tbl
order by array_cosine_similarity(vec, [1, 2, 3]::float[3]) asc
limit 10;

也没有采用索引扫描，我们从余弦距离切换到余弦相似度：

explain
select * from tbl
order by (1 - array_cosine_similarity(vec, [1, 2, 3]::float[3])) asc
limit 10;

这次db选择了索引扫描：

┌─────────────────────────────┐
│┌───────────────────────────┐│
││       Physical Plan       ││
│└───────────────────────────┘│
└─────────────────────────────┘
┌───────────────────────────┐
│         PROJECTION        │
│    ────────────────────   │
│             #0            │
│             #1            │
│                           │
│          ~0 Rows          │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│         PROJECTION        │
│    ────────────────────   │
│             id            │
│            vec            │
│            NULL           │
│                           │
│          ~0 Rows          │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│      HNSW_INDEX_SCAN      │
│    ────────────────────   │
│tbl (HNSW INDEX SCAN : idx)│
│                           │
│        Projections:       │
│             id            │
│            vec            │
│                           │
│          ~0 Rows          │
└───────────────────────────┘
  • 余弦相似度（Cosine Similarity）：它是通过计算两个向量之间的夹角余弦值来衡量它们的相似程度。余弦相似度的取值范围是[-1, 1]，但通常在文本处理、图像识别等应用场景中，其值范围是[0, 1]，值越接近，表示两个向量越相似。
  • 余弦距离（Cosine Distance）：它是用减去余弦相似度得到的结果，用于衡量两个向量之间的差异程度。余弦距离的取值范围是[0, 2]，值越接近，表示两个向量越相似。
  • 余弦距离=1-余弦相似度距离，余弦距离为0，这意味着两个向量之间的差异程度很低。
    在这里插入图片描述

总结

经过测试，limit位置和距离算法会影响数据库选择索引，当然未来DuckDB会优化的更好，我们也可以采用第三方索引进行规避。

使用DuckDB作为向量存储进行文本搜索
fgayif的博客
02-20 467
DuckDB是一款轻量级的嵌入式数据库，被广泛应用于数据分析领域。结合向量存储，可以用于快速进行文本数据的相似性搜索。在这里，我们将利用LangChain社区提供的封装来简化与DuckDB和OpenAI嵌入服务的集成。
起飞了 ! 使用 DuckDB 的处理11 亿出租车出行数据
xuejianxinokok的专栏
04-03 6952
如果您想知道为什么我不运行基于 Linux 的桌面作为我的主要工作环境，我仍在使用 Nvidia GTX 1080 GPU，它在 Windows 上有更好的驱动程序支持，并且我时不时地使用 ArcGIS Pro仅原生支持 Windows。SSD 的写入速度为 50-150 MB/s，读取速度通常为 5-10 MB/s，而 CPU 几乎处于空闲状态，为 5-10%。因此，我将在更快的驱动器上运行基准测试，但我将在更便宜的驱动器上构建 Parquet 文件。它不依赖于自己的服务器，而是用作客户端。
vss_store:存储VSS
04-01
vss_store 存储以保存您的VSS。 要求（客户端） 在Windows 10上测试必须禁用ScopeSnapshots。 requirements.txt软件包 要求（服务器端） 必须是Linux系统 需要： ~/vss_store/目录。 用法 ToDo 供参考 即将推出.... 执照
DuckDB存储页面布局：B+树索引与数据页的物理结构
最新发布
gitblog_00449的博客
10-08 352
你是否曾好奇数据库如何高效管理海量数据？当执行`SELECT * FROM table WHERE id=100`时，DuckDB如何在毫秒级找到目标数据？本文将深入解析DuckDB的底层存储机制，揭示B+树索引与数据页的物理结构，让你彻底理解数据如何在磁盘上组织和访问。 ## 存储系统概览 DuckDB采用自包含的单文件存储架构，所有数据和元信息都封装在一个文件中。这种设计简化了部署和迁移，...
duckdb-vss：向量相似性搜索加速
gitblog_00577的博客
03-31 1162
duckdb-vss：向量相似性搜索加速 项目介绍 duckdb-vss 是一款为 DuckDB 数据库设计的实验性扩展，它通过引入索引支持来加速向量相似性搜索（Vector Similarity Search）。该扩展利用了 DuckDB 从版本 v0.10.0 引入的新固定大小 ARRAY 类型。duckdb-vss 基于 usearch 库，旨在提供一个自定义索引类型（本例中的 HNSW 索...
利用 DuckDBVectorStore 存储和查询嵌入向量
ppoojjj的博客
07-19 638
在现代的 AI 应用中，存储和查询向量数据变得越来越重要。DuckDBVectorStore 是一种将嵌入向量存储在 DuckDB 数据库中的解决方案。通过这种方式，我们可以在查询时使用 DuckDB 来检索最相似的 k 个节点。本文将介绍如何使用 DuckDBVectorStore 来存储和查询向量，并提供一个简单的示例代码。
使用DuckDB作为向量存储：高效的AI文本检索解决方案
qq_29929123的博客
09-27 717
DuckDB是一个高性能的分析型数据库系统，它支持SQL查询，并且可以直接在进程内运行。将DuckDB用作向量存储，我们可以充分利用其快速查询和分析能力。使用DuckDB作为向量存储为文本检索提供了一个高效、灵活的解决方案。它结合了DuckDB的快速查询能力和向量存储的语义搜索功能，特别适合处理大规模文本数据。DuckDB官方文档LangChain文档中的向量存储部分OpenAI的嵌入API文档。
[利用DuckDB和OpenAI轻松实现高效向量存储！]
ppoojjj的博客
10-07 434
本文展示了如何利用DuckDB和OpenAI实现高效的向量存储与查询。DuckDB文档OpenAI API文档。
对标SQLite的DuckDB怎么样？
qianshanding0708的博客
08-02 5595
第一次对DuckDB有印象是分析SIGMOD2019年的论文，DuckDB 有4页的pdf文档介绍：然后是2020年的CIDR的论文：当时对DuckDB也没有放在心上。近期技术圈里有人在分析DuckDB和PostgreSQL的结合，没想到3年左右，DuckDB发展的这么快。趁着国庆长假，抽点时间对DuckDB进行分析，以帮助大家在数据库选型时多一个选择。DuckDB是一个嵌入式的OLAP分析引擎，...
vue-state-store::postbox:VSS（Vue状态存储）-Vue状态管理（具有“发布和订阅”模式）
03-20
:postbox: vue状态存储（vss） 完全支持打字稿的简单状态管理系统。 :open_mailbox_with_raised_flag: Vue的分布式状态管理模块系统。 [基于Pub＆Sub模型] :globe_showing_Americas:全球的 提供了以下多语言文档...
变量胜于不变：稀疏的VSS-NLMS算法及其在自适应MIMO信道估计中的应用
03-16
在本文中，我们提出了两种稳定的稀疏可变步长NLMS（VSS-NLMS）算法，以提高MIMO信道估计器的精度。 首先，在MIMO-OFDM系统中制定ASCE。 其次，针对ASCE的VSS-NLMS算法引入了不同的稀疏惩罚。 此外，还解释了稀疏ISS...
基于YOLO与Mamba系列：创新结构VSS块及Mamba UNet的联合应用与实验结果分析,YOLOv9创新升级：Mamba UNet结构下的视觉编码器-解码器，在VSS块中实现特征分叉与深度融合
02-12
基于YOLO与Mamba系列：创新结构VSS块及Mamba UNet的联合应用与实验结果分析,YOLOv9创新升级：Mamba UNet结构下的视觉编码器-解码器，在VSS块中实现特征分叉与深度融合，暴力涨点显著，适用于小目标与低对比度场景的...
Vss2Svn migration:Vss2Svn迁移工具-开源
04-26
Subversion是一个广泛使用的集中式版本控制系统，而VSS则是早期的版本控制工具，存在一些局限性，例如并发处理能力有限、备份和恢复困难等。 在进行Vss2Svn迁移过程中，首先需要确保你拥有VSS数据库的完整访问权限...
数据库性能测试：Mysql、Sqlite、Duckdb
xunmeng2002的专栏
08-12 4213
之前有创建两个额外的索引，同时那会还使用的是duckdb C++版本的API，于是乎，我在执行写入数据时发现写入速度成加速下降，最终写了一超过14个小时，才写到500万条数据的样子。我这边测试从创建表开始，首先是将tick数据写入表中，然后根据主键字段的子集（主键是四个字段，我取了其中的三个）进行查询10次，然后对全表进行一次查询。从索引查询来看，duckdb平均在10ms以下，sqlite不太稳定，有一些在10ms以下，也有一些到20ms级别，而mysql则是100ms级。
性能为王：DuckDB架构与优化技巧全解析 | LeetTalk Daily
LinkTime_Cloud的博客
09-29 1925
“LeetTalk Daily”，每日科技前沿，由LeetTools AI精心筛选，为您带来最新鲜、最具洞察力的科技新闻。本报告旨在深入探讨DuckDB的架构及其性能分析。DuckDB是一种高效的内存SQL OLAP数据库管理系统，因其在数据分析中的卓越表现而受到广泛关注。本文将重点介绍DuckDB的核心特性，包括其对大数据集的高效处理能力、对远程文件的支持以及在地理空间数据处理中的潜力。此外，报...
数据库浅谈之 DuckDB AGG 底层实现
优质后端技术知识记录
02-24 2445
DuckDB AGG 聚合算子底层实现
使用 DuckDB 作为向量存储的实践指南
fgayif的博客
03-12 489
DuckDB是一个面向分析的列存储数据库，尤其适合于处理复杂查询和大数据分析任务。在AI应用中，我们常常需要对文档进行向量化，然后存储和检索。将DuckDB与OpenAI的嵌入模型结合，可以实现高效的向量存储和查询。
使用DuckDB作为向量存储的强大实践
aehrutktrjk的博客
11-01 540
DuckDB作为向量存储的高效性使其成为处理大型文本查询的理想选择。通过结合LangChain和OpenAI嵌入，我们能够实现快速准确的文本检索。
SourceAnywhere 5.3.2：远程访问VSS数据库的高效客户端
然而，VSS的设计存在一些局限性，比如网络访问上的限制，通常要求用户在同一局域网内或者通过特定的网络配置才能访问VSS数据库。 SourceAnywhere 5.3.2客户端的推出，就是为了解决这些问题。它允许用户在互联网上的...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值