ClickHouse 之 一 mergeTree引擎

最新推荐文章于 2024-04-10 17:17:14 发布
最新推荐文章于 2024-04-10 17:17:14 发布
阅读量390 收藏 1
点赞数
分类专栏： clickhouse
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38424594/article/details/110140232
版权

ClickHouse MergeTree系列分析

VersionedCollapsingMergeTree

为了解决CollapsingMergeTree乱序写入情况下无法正常折叠问题，VersionedCollapsingMergeTree表引擎在建表语句中新增了一列Version，用于在乱序情况下记录状态行与取消行的对应关系。主键相同，且Version相同、Sign相反的行，在Compaction时会被删除。 
建表：
CREATE TABLE UAct
(
    UserID UInt64,
    PageViews UInt8,
    Duration UInt8,
    Sign Int8,
    Version UInt8
)
ENGINE = VersionedCollapsingMergeTree(Sign, Version)
ORDER BY UserID;
插入数据：
INSERT INTO UAct VALUES (4324182021466249494, 5, 146, 1, 1);
INSERT INTO UAct VALUES (4324182021466249494, 5, 146, -1, 1),(4324182021466249494, 6, 185, 1, 2);
上面执行了两个INSERT语句，创建了两个不同的数据片段。如果使用一个INSERT语句，ClickHouse将创建一个数据片段，并且将永远不会执行任何合并。
查询数据：
┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┬─Version─┐
│ 4324182021466249494 │         5 │      146 │    1 │       1 │
└─────────────────────┴───────────┴──────────┴──────┴─────────┘
┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┬─Version─┐
│ 4324182021466249494 │         5 │      146 │   -1 │       1 │
│ 4324182021466249494 │         6 │      185 │    1 │       2 │
└─────────────────────┴───────────┴──────────┴──────┴─────────┘
通过两个INSERT语句，创建了两个数据片段。SELECT查询是在两个线程中执行的，我们得到了随机顺序的行。由于尚未合并数据片段，折叠还未发生。我们无法预测ClickHouse在何时执行数据片段的合并。
因此，我们需要使用聚合：
SELECT
    UserID,
    sum(PageViews * Sign) AS PageViews,
    sum(Duration * Sign) AS Duration,
    Version
FROM UAct
GROUP BY UserID, Version
HAVING sum(Sign) > 0;
┌──────────────UserID─┬─PageViews─┬─Duration─┬─Version─┐
│ 4324182021466249494 │         6 │      185 │       2 │
└─────────────────────┴───────────┴──────────┴─────────┘
如果不使用聚合，可以对FROM子句使用FINAL修饰符进行强制合并：
:) select * from UAct FINAL;
​
┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┬─Version─┐
│ 4324182021466249494 │         6 │      185 │    1 │       2 │
└─────────────────────┴───────────┴──────────┴──────┴─────────┘

SummingMergeTree

drop table summtt;
CREATE TABLE summtt
(
    key String,
    name String,
    value Int32
)
ENGINE = SummingMergeTree()
ORDER BY key;


insert into summtt values('a', 'xiaoa1', 1);
insert into summtt values('a', 'xiaoa2', 2);
insert into summtt values('b', 'xiaob1', 10);
insert into summtt values('b', 'xiaob2', 20);
insert into summtt values('c', 'xiaob1', 10);
insert into summtt values('c', 'xiaob2', -10);

SELECT * FROM summtt;

┌─key─┬─name───┬─value─┐
│ a   │ xiaoa1 │     3 │
│ b   │ xiaob1 │    30 │
│ c   │ xiaob1 │    10 │
└─────┴────────┴───────┘
┌─key─┬─name───┬─value─┐
│ c   │ xiaob2 │   -10 │
└─────┴────────┴───────┘

执行计划外的合并：
optimize table summtt;
 

查看表数据：
select * from summtt;

┌─key─┬─name───┬─value─┐
│ a   │ xiaoa1 │     3 │
│ b   │ xiaob1 │    30 │
└─────┴────────┴───────┘

select key, sum(value) from summtt group by key;
可以发现实现了根据key 累加的情况

ReplacingMergeTree

代码如下（示例）：

示例1： 根据排序键去重
1. 准备数据
建表：
DROP TABLE replacingMergeTreeDemo;
CREATE TABLE replacingMergeTreeDemo
(
    UserID UInt32,
    CounterID UInt32,
    UserName String,
    EventDate Date
) ENGINE = ReplacingMergeTree()
ORDER BY (UserID, CounterID)
PRIMARY KEY (UserID);


2. 插入数据
分三批次插入数据， 为了观察效果， 下面的三段脚本依次按顺序分别执行， 不要一起执行：
批次1：
insert into replacingMergeTreeDemo values(1,100,'xiaohe1','2020-04-21');
insert into replacingMergeTreeDemo values(2,100,'xiaohe2','2020-04-22');
insert into replacingMergeTreeDemo values(3,102,'xiaohe3','2020-04-23');
批次2：
insert into replacingMergeTreeDemo values(3,103,'xiaohe3','2020-04-23');
insert into replacingMergeTreeDemo values(2,101,'xiaohe2','2020-04-24');
insert into replacingMergeTreeDemo values(1,100,'xiaohe1','2020-04-20');
批次3：
insert into replacingMergeTreeDemo values(2,100,'xiaohe2','2020-04-23');


查看数据：
xiaochen :) select * from replacingMergeTreeDemo;
​
SELECT *
FROM replacingMergeTreeDemo
​
┌─UserID─┬─CounterID─┬─UserName─┬──EventDate─┐
│      1 │       100 │ xiaohe1  │ 2020-04-21 │
│      2 │       100 │ xiaohe2  │ 2020-04-22 │
│      2 │       101 │ xiaohe2  │ 2020-04-24 │
│      3 │       102 │ xiaohe3  │ 2020-04-23 │
│      3 │       103 │ xiaohe3  │ 2020-04-23 │
└────────┴───────────┴──────────┴────────────┘
┌─UserID─┬─CounterID─┬─UserName─┬──EventDate─┐
│      1 │       100 │ xiaohe1  │ 2020-04-20 │
└────────┴───────────┴──────────┴────────────┘
┌─UserID─┬─CounterID─┬─UserName─┬──EventDate─┐
│      2 │       100 │ xiaohe2  │ 2020-04-23 │
└────────┴───────────┴──────────┴────────────┘

3. 手工执行计划外合并
执行命令：optimize table replacingMergeTreeDemo
xiaochen :) optimize table replacingMergeTreeDemo;
​
OPTIMIZE TABLE replacingMergeTreeDemo
​
Ok.
​
0 rows in set. Elapsed: 0.005 sec.


4. 查看合并后的数据
 select * from replacingMergeTreeDemo;
​
SELECT * FROM replacingMergeTreeDemo
​
┌─UserID─┬─CounterID─┬─UserName─┬──EventDate─┐
│      1 │       100 │ xiaohe1  │ 2020-04-20 │
│      2 │       100 │ xiaohe2  │ 2020-04-23 │
│      2 │       101 │ xiaohe2  │ 2020-04-24 │
│      3 │       102 │ xiaohe3  │ 2020-04-23 │
│      3 │       103 │ xiaohe3  │ 2020-04-23 │
└────────┴───────────┴──────────┴────────────┘
​
5 rows in set. Elapsed: 0.007 sec.
从这个示例可以发现， ReplacingMergeTree是根据排序项对数据去重的，而不是根据主键。

CollapsingMergeTree

代码如下（示例）：
eg:


建表语句：
CREATE TABLE UAct
(
    UserID UInt64,
    PageViews UInt8,
    Duration UInt8,
    Sign Int8
)
ENGINE = CollapsingMergeTree(Sign)
ORDER BY UserID

首先清空表：
truncate table UAct;
执行如下的数据插入语句：
INSERT INTO UAct VALUES (4324182021466249494, 1, 11, -1),(4324182021466249494, 2, 12, -1);
INSERT INTO UAct VALUES (4324182021466249494, 3, 13, 1);
INSERT INTO UAct VALUES (4324182021466249494, 4, 14, 1);
查看数据：
xiaochen001 :) select * from UAct;
​
┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐
│ 4324182021466249494 │         1 │       11 │   -1 │
│ 4324182021466249494 │         2 │       12 │   -1 │
└─────────────────────┴───────────┴──────────┴──────┘
┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐
│ 4324182021466249494 │         3 │       13 │    1 │
└─────────────────────┴───────────┴──────────┴──────┘
┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐
│ 4324182021466249494 │         4 │       14 │    1 │
└─────────────────────┴───────────┴──────────┴──────┘
​
4 rows in set. Elapsed: 0.011 sec.
执行计划外的片段合并操作：
optimize table UAct;
查看折叠后的数据：
xiaochen001 :) select * from UAct;
​
SELECT *
FROM UAct
​
┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐
│ 4324182021466249494 │         1 │       11 │   -1 │
│ 4324182021466249494 │         4 │       14 │    1 │
└─────────────────────┴───────────┴──────────┴──────┘
​
2 rows in set. Elapsed: 0.005 sec.
从示例中可以观察到，最终的数据片段保留了第一个"cancel"行和最后一个"state"行。

================================================================================================
示例2： 聚合查询
================================================================================================

示例数据：
┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐
│ 4324182021466249494 │         5 │      146 │    1 │
│ 4324182021466249494 │         5 │      146 │   -1 │
│ 4324182021466249494 │         6 │      185 │    1 │
└─────────────────────┴───────────┴──────────┴──────┘
建表：
DROP TABLE UAct;
CREATE TABLE UAct
(
    UserID UInt64,
    PageViews UInt8,
    Duration UInt8,
    Sign Int8
)
ENGINE = CollapsingMergeTree(Sign)
ORDER BY UserID;

插入数据：
INSERT INTO UAct VALUES (4324182021466249494, 5, 146, 1);
INSERT INTO UAct VALUES (4324182021466249494, 5, 146, -1),(4324182021466249494, 6, 185, 1);
上面执行了两个INSERT语句，创建了两个不同的数据片段。如果使用一个INSERT语句，ClickHouse将创建一个数据片段，并且将永远不会执行任何合并。
查询数据：
┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐
│ 4324182021466249494 │         5 │      146 │    1 │
└─────────────────────┴───────────┴──────────┴──────┘
┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐
│ 4324182021466249494 │         5 │      146 │   -1 │
│ 4324182021466249494 │         6 │      185 │    1 │
└─────────────────────┴───────────┴──────────┴──────┘
通过两个INSERT语句，创建了两个数据片段。SELECT查询是在两个线程中执行的，我们得到了随机顺序的行。由于尚未合并数据片段，折叠还未发生。我们无法预测ClickHouse在何时执行数据片段的合并。
因此，我们需要使用聚合：
SELECT
    UserID,
    sum(PageViews * Sign) AS PageViews,
    sum(Duration * Sign) AS Duration
FROM UAct
GROUP BY UserID
HAVING sum(Sign) > 0
┌──────────────UserID─┬─PageViews─┬─Duration─┐
│ 4324182021466249494 │         6 │      185 │
└─────────────────────┴───────────┴──────────┘
如果不使用聚合，可以对FROM子句使用FINAL修饰符进行强制合并：
:) select * from UAct FINAL;
​
┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐
│ 4324182021466249494 │         6 │      185 │    1 │
└─────────────────────┴───────────┴──────────┴──────┘
​
1 rows in set. Elapsed: 0.008 sec.
这种数据查询的方法非常低效，不要在大表中使用这种方法。


================================================================================================
示例3： Cancel状态行取反的聚合查询
================================================================================================
示例数据：
┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐
│ 4324182021466249494 │         5 │      146 │    1 │
│ 4324182021466249494 │        -5 │     -146 │   -1 │
│ 4324182021466249494 │         6 │      185 │    1 │
└─────────────────────┴───────────┴──────────┴──────┘
这个方法的核心思想是仅考虑关键字段，在"cancel"行中，可以指定负数，这些负数的值等于行的前一个版本的关键字段值的取反，这样在求和时就可以不使用Sign列。对于这种方法，必须更改PageViews和Duration字段的数据类型，从UIn8改成Int16。
建表语句：
CREATE TABLE UAct
(
    UserID UInt64,
    PageViews Int16,
    Duration Int16,
    Sign Int8
)
ENGINE = CollapsingMergeTree(Sign)
ORDER BY UserID
插入数据，并测试：
insert into UAct values(4324182021466249494,  5,  146,  1);
insert into UAct values(4324182021466249494, -5, -146, -1);
insert into UAct values(4324182021466249494,  6,  185,  1);
​
select * from UAct final; 
┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐
│ 4324182021466249494 │         6 │      185 │    1 │
└─────────────────────┴───────────┴──────────┴──────┘
使用聚合时，不需要使用Sign列：
SELECT
    UserID,
    sum(PageViews) AS PageViews,
    sum(Duration) AS Duration
FROM UAct
GROUP BY UserID
┌──────────────UserID─┬─PageViews─┬─Duration─┐
│ 4324182021466249494 │         6 │      185 │
└─────────────────────┴───────────┴──────────┘
统计数量：
select count() FROM UAct
┌─count()─┐
│       3 │
└─────────┘
手动执行计划外的合并：
optimize table UAct final;
​
select * FROM UAct
┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐
│ 4324182021466249494 │         6 │      185 │    1 │
└─────────────────────┴───────────┴──────────┴──────┘

AggregatingMergeTree


 
DROP TABLE IF EXISTS test_aggregates;
CREATE TABLE test_aggregates
(
    d Date,
    sumV AggregateFunction(sum, UInt64),
    uniqV AggregateFunction(uniq, UInt64)
)
ENGINE = AggregatingMergeTree()
ORDER BY d;

INSERT INTO test_aggregates
SELECT
    toDate('2020-06-01') AS d,
    sumState(number) as sumV,
    uniqState(number) AS uniqV
FROM
(
    SELECT toUInt64(number%8) as number FROM system.numbers LIMIT 10
);


SELECT sumMerge(sumV), uniqMerge(uniqV) FROM test_aggregates;


示例2：物化视图的使用
drop table t_basic;
create table t_basic(key String, sign UInt8, userId String) ENGINE=MergeTree order by key;

drop table t_m_view;
CREATE MATERIALIZED VIEW t_m_view
ENGINE = AggregatingMergeTree() ORDER BY (key)
AS SELECT
    key,
    sumState(sign)    AS sumSign,
    uniqState(userId) AS uniqUsers
FROM t_basic
GROUP BY key;

插入3条记录：
insert into t_basic values('a', 1, '11'),
                      ('a', 2, '22'),
                      ('a', 3, '11');

select * from t_basic;
┌─key─┬─sign─┬─userId─┐
│ a   │    1 │ 11     │
│ a   │    2 │ 22     │
│ a   │    3 │ 11     │
└─────┴──────┴────────┘


select key, sumMerge(sumSign), uniqMerge(uniqUsers) from t_m_view group by key;
┌─key─┬─sumMerge(sumSign)─┬─uniqMerge(uniqUsers)─┐
│ a   │                 6 │                    2 │
└─────┴───────────────────┴──────────────────────┘
Lara1111
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
3、ClickHouse表引擎-MergeTree引擎
05-29
3、ClickHouse表引擎-MergeTree引擎 网址：https://blog.csdn.net/chenwewi520feng/article/details/130502351 介绍clickhouse 的表引擎，即mergetree引擎的使用
clickhouse的mergetree表引擎数据查找流程图及特性
lixia0417mul2的博客
04-19 612
mergetree表数据查找流程 mergetree 合并树特点 mergetree合并表特色
ClickHouse的VersionedCollapsingMergeTree表引擎
最新发布
weixin_52452030的博客
04-10 156
如果sign=-1和sign=1 的数据行一样多，并且最新一行是sign=1，则保留版本号最老的sign=-1的数据和版本号最新的sign=1的数据。行的顺序并不重要（也就是会删除sign值1和 -1 这一对的数据）。如果sign=-1和sign=1 的数据行一样多，并且最新一行是sign=-1，则什么也不保留。如果sign=-1比sign=1 的数据多一行，则保留版本号最老的一行sign为-1的数据。如果sign=1比sign=-1 的数据多一行，则保留版本号最新的一行sign为1的数据。
ClickHouse表引擎（一）之MergeTree系列
style_boy的博客
03-18 779
本文将介绍ClickHouse中一个非常重要的概念—表引擎(table engine)。如果对MySQL熟悉的话，或许你应该听说过InnoDB和MyISAM存储引擎。那不同的存储引擎提供着不同的存储机制、索引方式、锁定水平等功能，也可以称之为表类型。 对于ClickHouse 的表引擎提供了四个系列（MergeTree、Log、Integration、Special）大约 28 种表引擎，各有各的用途。比如 MergeTree 系列用来做大数据量分析，Log 系列用来做小表数据分析，而 Integratio
大数据-ClickHouse技术三（SQL参考）
qq_36602951的博客
09-27 1093
ClickHouse的数据库表引擎与SQL语法
ClickHouse(12)ClickHouse合并树MergeTree家族表引擎之AggregatingMergeTree详细解析
编程代码，数据学习开发的日常总结。欢迎关注VX公众号：张飞的猪大数据分享
10-07 1695
AggregatingMergeTree引擎继承自 MergeTree，并改变了数据片段的合并逻辑。ClickHouse会将一个数据片段内所有具有相同主键（准确的说是排序键）的行替换成一行，这一行会存储一系列聚合函数的状态。可以使用AggregatingMergeTree表来做增量数据的聚合统计，包括物化视图的数据聚合。AggregatingMergeTree适用于能够按照一定的规则缩减行数的情况。
MergeTree系列引擎概述与存储结构
lyq7269的博客
03-18 254
MergeTree系列引擎介绍 MergeTree系列引擎事clickhouse中最强大的表引擎 数据按照片段被一批批写入表 数据片段在后台按照一定规则进行合并。 主要特性 数据按照 主键排序，稀疏索引快速检索数据 数据分区 增加查询性能 数据副本 ReplicatedMergeTree系列的引擎支持数据副本，替身查询性能和容错 数据采样 设置采样方法，快速分析数据 建表模板 CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster
ClickHouse-MergeTree引擎
just love code
05-26 853
order by 设定了分区内的数据按照哪些字段顺序进行有序保存 order by是MergeTree中唯一一个必填项目，甚至primary key还重要，因为用户不设置主键的情况，很多处理会依照order by 的字段进行处理 主键必须是order by字段的前缀字段必须包含主键字段 创建二级索引测试表： CREATE TABLE t_order_mt2 ( id UInt32, sku_id String, total_amount DECIMAL ( 16, 2 ), create_
ClickHouse学习笔记（四）：MergeTree 系列表引擎
u011047968的专栏
03-29 1090
MergeTree系列表引擎介绍
什么是物化视图
HANG.NIAN
09-28 5859
ClickHouse拥有普通和物化两种视图，其中物化视图拥有独立的存储，而普通视图只是一层简单的查询代理 普通视图不会存储任何数据，它只是一层单纯的SELECT查询映射，起着简化查询、明晰语义的作用，对查询性能不会有任何增强。 物化视图 物化视图支持表引擎，数据保存形式由它的表引擎决定，创建物化视图的完整语法如下所示 create materialized view mv_log engine=Log populate as select * from log ; 物化视图创建好之后，如果源表被写
Clickhouse引擎二： MergeTree 家族引擎
xiaozhaoshigedasb的博客
04-16 393
Clickhouse引擎二： MergeTree 家族引擎 MergeTree 系列的表引擎是 ClickHouse 数据存储功能的核心。它们提供了用于弹性和高性能数据 检索的大多数功能：列存储，自定义分区，稀疏的主索引，辅助数据跳过索引等。 基本 MergeTree 表引擎可以被认为是单节点 ClickHouse 实例的默认表引擎，因为它在各种用例中通用 且实用。 除了基础表引擎 MergeTree 之 外，常用的表引擎还有 ReplacingMergeTree、SummingMergeTree、 Agg
ClickHouse MergeTree.pdf
07-01
ClickHouse MergeTree.pdf
ClickHouse-架构原理和表引擎详解
03-04
ClickHouse-架构原理和表引擎详解
ClickHouse数据分析引擎入门到精通
04-10
11_ClickHouse入门_MergeTree引擎_Order by.mp4 15_ClickHouse入门_SummingMergeTree引擎.mp4 16_ClickHouse入门_开发中引擎的选择.mp4 19_ClickHouse入门_SQL操作_多维分析函数.mp4 20_ClickHouse入门_SQL操作_...
基于ClickHouse的 实时分析引擎应用实践
11-10
基于ClickHouse的 实时分析引擎应用实践
Clickhouse MergeTree引擎原理[读书笔记]
optimus
07-26 203
文章目录概述创建&使用文件结构目录结构分区分区目录结构分区合并的过程索引一级索引二级索引压缩数据块文件块的结构Block合并的判断依据数据标记执行过程写入过程查询过程MergeTree派生引擎单副本派生引擎多副本派生引擎其他引擎 概述 Clickhouse作为一个数据库，主要用于管理数据的结构化存储，优化查询等操作。 对于引擎的知识点，需要搞明白： 创建方式，使用方式 数据存储结构 数据查询原理 ClickHouse拥有非常庞大的表引擎体系，主要包括6大类：MergeTree家族、外部存储、
clickhouse表引擎megerTree
weixin_40413961的博客
08-26 534
clickhouse 表引擎 官方文档：https://clickhouse.tech/docs/zh/engines/table-engines/mergetree-family/mergetree/#choosing-a-primary-key-that-differs-from-the-sorting-key clickhouse是一个列式存储的应用于OLAP场景的数据库管理系统。数据库管理系统分为：客户端底层存储的表引擎。包括我们所熟悉的MYSQL。表引擎的不一样，其数据库的特性区别也很大。对于列式
clickhouseMergeTree系列引擎之SummingMergeTree
lyq7269的博客
04-02 438
SummingMergeTree引擎功能介绍 根据排序见对数值类型的列进行汇总求和 相同排序见的行合并为一行。 如果一个排序键对应大量的行，则该引擎能显著减少存储空间并加快数据查询速度。 建议该引擎于MergeTree引擎结合使用。完整的数据存储在MergeTree表中，使用SummingMergeTree存储聚合数据，可以防止排序键的组合不正确而丢失有价值的数据。 指定表引擎 ENGINE = SummingMergeTree([columns]) 参数: columns,具有列名称的元组，其中的值
clickhouse学习笔记-3-MerageTree原理解析
hjklnmyuiop的博客
04-30 233
一、名字由来 MergeTree 在写入一批数据时，数据总会以数据片段的形式写入磁盘，且数据片段不可修改。为避免片段过多，ClickHouse 会通过后台线程定期合并这些数据片段，属于相同分区的数据片段会被合成一个新的片段。这种数据片段往复合并的特点也正是合并树的名称由来。 二、建表解析 ... )ENGING = MergeTree() [PARTITION BY expr] # 分区键 [ORDER BY expr] # 排序键 MergeTree引擎的关键参数 [PRIMARY
clickhouse MergeTree
09-03
ClickHouse Mergetree是ClickHouse数据库中的一种存储引擎，它是一种基于日志结构的合并树存储引擎。它使用了一种称为“合并树”的数据结构，可以高效地处理大量的数据。它的主要特点是支持高并发、高吞吐量的数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值