数据仓库之拉链表（二）使用拉链表更新数据

最新推荐文章于 2024-09-24 20:51:31 发布
最新推荐文章于 2024-09-24 20:51:31 发布
阅读量1.5k 收藏 8
点赞数 1
分类专栏： 大数据 文章标签： 数据仓库
原文链接：https://blog.csdn.net/weixin_43679675/article/details/89457995?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.control
版权

前提假设：

  • 数据仓库中订单历史表的刷新频率为一天，当天更新前一天的增量数据；

  • 如果一个订单在一天内有多次状态变化，则只会记录最后一个状态的历史；

  • 订单状态包括三个：创建、支付、完成

  • 创建时间和修改时间只取到天，如果原订单表中没有状态修改时间，那么抽取增量就比较麻烦，需要有个机制来确保能抽取到每天的增量数据；

  • 原系统中订单表结构为：
    CREATE TABLE orders (
    orderid INT,
    createtime STRING,
    modifiedtime STRING,
    status STRING
    ) stored AS textfile;

  • 在数据仓库的ODS层，有一张订单的增量数据表，按天分区，存放每天的增量数据：
    CREATE TABLE t_ods_orders_inc (
    orderid INT,
    createtime STRING,
    modifiedtime STRING,
    status STRING
    ) PARTITIONED BY (day STRING)
    stored AS textfile;

  • 在数据仓库的DW层，有一张订单的历史数据拉链表，存放订单的历史状态数据：
    CREATE TABLE t_dw_orders_his (
    orderid INT,
    createtime STRING,
    modifiedtime STRING,
    status STRING,
    dw_start_date STRING,
    dw_end_date STRING
    ) stored AS textfile;

  • 暂未考虑Hive上表的查询性能问题，只实现功能；

每天的原系统订单表的数据如下（红色标出的为当天发生变化的订单，即增量数据）：
2015-08-21订单表数据：

订单编号订单创建时间订单修改时间订单状态
orderidcreatetimemodifiedtimestatus
12015-08-182015-08-18创建
22015-08-182015-08-18创建
32015-08-192015-08-21支付
42015-08-192015-08-21完成
52015-08-192015-08-20支付
62015-08-202015-08-20创建
72015-08-202015-08-21支付
82015-08-212015-08-21创建

2015-08-22订单表数据：

订单编号订单创建时间订单修改时间订单状态
orderidcreatetimemodifiedtimestatus
12015-08-182015-08-22支付
22015-08-182015-08-22完成
32015-08-192015-08-21支付
42015-08-192015-08-21完成
52015-08-192015-08-20支付
62015-08-202015-08-22支付
72015-08-202015-08-21支付
82015-08-212015-08-22支付
92015-08-222015-08-22创建
102015-08-222015-08-22支付

2015-08-23订单表数据：

订单编号订单创建时间订单修改时间订单状态
orderidcreatetimemodifiedtimestatus
12015-08-182015-08-23完成
22015-08-182015-08-22完成
32015-08-192015-08-23完成
42015-08-192015-08-21完成
52015-08-192015-08-23完成
62015-08-202015-08-22支付
72015-08-202015-08-21支付
82015-08-212015-08-23完成
92015-08-222015-08-22创建
102015-08-222015-08-22支付
112015-08-232015-08-23创建
122015-08-232015-08-23创建
132015-08-232015-08-23支付

全量初始化

在数据从原业务系统每天正常抽取和刷新到dw订单历史表之前，需要做一次全量的初始化，就是从原订单表中昨天以前的数据全部抽取到ods，并刷新到dw

以上面的数据为例，比如在2015-08-21这天做全量初始化，那么我需要将包括2015-08-20之前的所有的数据都抽取并刷新到dw：
第一步，抽取全量数据到ods

insert overwrite table t_ods_orders_inc partition(day=‘2015-08-20’) select orderid,createtime,modifiedtime,status from orders where createtime<=‘2015-08-20’;

第二步，从ods刷新到dw：
insert overwrite table t_dw_orders_his
select orderid,createtime,modifiedtime,status,createtime as dw_start_date,‘9999-12-31’ as dw_end_date from t_ods_orders_inc where day=‘2015-08-20’;

完成后，dw订单历史表中数据如下：

<span style="color:#000000"><code>spark-sql> select * from t_dw_orders_his;
1       2015-08-18      2015-08-18      创建    2015-08-18      9999-12-31      
2       2015-08-18      2015-08-18      创建    2015-08-18      9999-12-31
3       2015-08-19      2015-08-21      支付    2015-08-19      9999-12-31
4       2015-08-19      2015-08-21      完成    2015-08-19      9999-12-31
5       2015-08-19      2015-08-20      支付    2015-08-19      9999-12-31
6       2015-08-20      2015-08-20      创建    2015-08-20      9999-12-31
7       2015-08-20      2015-08-21      支付    2015-08-20      9999-12-31
</code></span>

增量抽取

每天，从原系统订单表中，将前一天的增量数据抽取到ods层的增量数据表中；这里的增量需要通过订单表中的创建时间和修改时间来确定：
insert overwrite table t_ods_orders_inc partition(day=’{day}’)
select orderid,createtime,modifiedtime,status from orders where createtime=’{day}’ or modifiedtime=’{day}’;

注意：在ods层按天分区的增量表，最好保留一段时间的数据，比如半年，为了防止某一天的数据有问题而回滚重做数据。

增量刷新历史数据

从2015-08-22开始，需要每天正常刷新前一天（2015-08–21）的增量数据到历史表

第一步，通过增量抽取，将2015-08-21的数据抽取到ods：

insert overwrite table t_ods_orders_inc partition(day=‘2015-08-21’)
select orderid,createtime,modifiedtime,status
from orders where createtime=‘2015-08-21’ or modifiedtime=‘2015-08-21’;

ods增量表中2015-08-21的数据如下：

<span style="color:#000000"><code>spark-sql> select * from t_ods_orders_inc where day = '2015-08-21';
3       2015-08-19      2015-08-21      支付    2015-08-21
4       2015-08-19      2015-08-21      完成    2015-08-21
7       2015-08-20      2015-08-21      支付    2015-08-21
8       2015-08-21      2015-08-21      创建    2015-08-21
</code></span>

第二步，通过dw历史数据（数据日期为2015-08-20）和ods增量数据（2015-08-21）刷新历史表：
先把数据放到一张临时表中：

<span style="color:#000000"><code>DROP TABLE IF EXISTS t_dw_orders_his_tmp;
CREATE TABLE t_dw_orders_his_tmp AS 
SELECT orderid,
createtime,
modifiedtime,
status,
dw_start_date,
dw_end_date 
FROM (
    SELECT a.orderid,
    a.createtime,
    a.modifiedtime,
    a.status,
    a.dw_start_date,
    CASE WHEN b.orderid IS NOT NULL AND a.dw_end_date > '2015-08-21' THEN '2015-08-20' ELSE a.dw_end_date END AS dw_end_date 
    FROM t_dw_orders_his a 
    left outer join (SELECT * FROM t_ods_orders_inc WHERE day = '2015-08-21') b 
    ON (a.orderid = b.orderid) 
    UNION
    SELECT orderid,
    createtime,
    modifiedtime,
    status,
    modifiedtime AS dw_start_date,
    '9999-12-31' AS dw_end_date 
    FROM t_ods_orders_inc 
    WHERE day = '2015-08-21' 
) x 
ORDER BY orderid,dw_start_date;
</code></span>

其中：
UNION ALL的两个结果集中，第一个是用历史表left outer join 日期为 {yyy-MM-dd} 的增量，能关联上的，并且dw_end_date > {yyy-MM-dd}，说明状态有变化，则把原来的dw_end_date置为({yyy-MM-dd} – 1), 关联不上的，说明状态无变化，dw_end_date无变化。

第二个结果集是直接将增量数据插入历史表。

最后把临时表中数据插入历史表：
INSERT overwrite TABLE t_dw_orders_his
SELECT * FROM t_dw_orders_his_tmp;

刷新完后，历史表中数据如下：

<span style="color:#000000"><code>spark-sql> select * from t_dw_orders_his order by orderid,dw_start_date;
1       2015-08-18      2015-08-18      创建    2015-08-18      9999-12-31
2       2015-08-18      2015-08-18      创建    2015-08-18      9999-12-31
3       2015-08-19      2015-08-21      支付    2015-08-19      2015-08-20
3       2015-08-19      2015-08-21      支付    2015-08-21      9999-12-31
4       2015-08-19      2015-08-21      完成    2015-08-19      2015-08-20
4       2015-08-19      2015-08-21      完成    2015-08-21      9999-12-31
5       2015-08-19      2015-08-20      支付    2015-08-19      9999-12-31
6       2015-08-20      2015-08-20      创建    2015-08-20      9999-12-31
7       2015-08-20      2015-08-21      支付    2015-08-20      2015-08-20
7       2015-08-20      2015-08-21      支付    2015-08-21      9999-12-31
8       2015-08-21      2015-08-21      创建    2015-08-21      9999-12-31
</code></span>

由于在2015-08-21做了8月20日以前的数据全量初始化，而订单3，4，7在2015-08-21的增量数据中也存在，因此都有两条记录，但不影响后面的查询。

将2015-08-22的增量数据刷新到历史表

<span style="color:#000000"><code>INSERT overwrite TABLE t_ods_orders_inc PARTITION (day = '2015-08-22') 
SELECT orderid,createtime,modifiedtime,status 
FROM orders 
WHERE createtime = '2015-08-22' OR modifiedtime = '2015-08-22';
 
DROP TABLE IF EXISTS t_dw_orders_his_tmp;
CREATE TABLE t_dw_orders_his_tmp AS 
SELECT orderid,
createtime,
modifiedtime,
status,
dw_start_date,
dw_end_date 
FROM (
    SELECT a.orderid,
    a.createtime,
    a.modifiedtime,
    a.status,
    a.dw_start_date,
    CASE WHEN b.orderid IS NOT NULL AND a.dw_end_date > '2015-08-22' THEN '2015-08-21' ELSE a.dw_end_date END AS dw_end_date 
    FROM t_dw_orders_his a 
    left outer join (SELECT * FROM t_ods_orders_inc WHERE day = '2015-08-22') b 
    ON (a.orderid = b.orderid) 
    UNION ALL 
    SELECT orderid,
    createtime,
    modifiedtime,
    status,
    modifiedtime AS dw_start_date,
    '9999-12-31' AS dw_end_date 
    FROM t_ods_orders_inc 
    WHERE day = '2015-08-22' 
) x 
ORDER BY orderid,dw_start_date;
 
 
INSERT overwrite TABLE t_dw_orders_his 
SELECT * FROM t_dw_orders_his_tmp;
</code></span>

刷新完成后历史拉链表数据如下：

<span style="color:#000000"><code>spark-sql> select * from t_dw_orders_his order by orderid,dw_start_date;
1       2015-08-18      2015-08-18      创建    2015-08-18      2015-08-21
1       2015-08-18      2015-08-22      支付    2015-08-22      9999-12-31
2       2015-08-18      2015-08-18      创建    2015-08-18      2015-08-21
2       2015-08-18      2015-08-22      完成    2015-08-22      9999-12-31
3       2015-08-19      2015-08-21      支付    2015-08-19      2015-08-20
3       2015-08-19      2015-08-21      支付    2015-08-21      9999-12-31
4       2015-08-19      2015-08-21      完成    2015-08-19      2015-08-20
4       2015-08-19      2015-08-21      完成    2015-08-21      9999-12-31
5       2015-08-19      2015-08-20      支付    2015-08-19      9999-12-31
6       2015-08-20      2015-08-20      创建    2015-08-20      2015-08-21
6       2015-08-20      2015-08-22      支付    2015-08-22      9999-12-31
7       2015-08-20      2015-08-21      支付    2015-08-20      2015-08-20
7       2015-08-20      2015-08-21      支付    2015-08-21      9999-12-31
8       2015-08-21      2015-08-21      创建    2015-08-21      2015-08-21
8       2015-08-21      2015-08-22      支付    2015-08-22      9999-12-31
9       2015-08-22      2015-08-22      创建    2015-08-22      9999-12-31
10      2015-08-22      2015-08-22      支付    2015-08-22      9999-12-31
</code></span>

查看2015-08-21的历史快照数据：

<span style="color:#000000"><code>spark-sql> select * from t_dw_orders_his where dw_start_date <= '2015-08-21' and dw_end_date >= '2015-08-21';
1       2015-08-18      2015-08-18      创建    2015-08-18      2015-08-21
2       2015-08-18      2015-08-18      创建    2015-08-18      2015-08-21
3       2015-08-19      2015-08-21      支付    2015-08-21      9999-12-31
4       2015-08-19      2015-08-21      完成    2015-08-21      9999-12-31
5       2015-08-19      2015-08-20      支付    2015-08-19      9999-12-31
6       2015-08-20      2015-08-20      创建    2015-08-20      2015-08-21
7       2015-08-20      2015-08-21      支付    2015-08-21      9999-12-31
8       2015-08-21      2015-08-21      创建    2015-08-21      2015-08-21
</code></span>

订单1在2015-08-21的时候还处于创建的状态，在2015-08-22的时候状态变为支付。

再刷新2015-08-23的增量数据：

<span style="color:#000000"><code>spark-sql> select * from t_dw_orders_his order by orderid,dw_start_date;
1       2015-08-18      2015-08-18      创建    2015-08-18      2015-08-21
1       2015-08-18      2015-08-22      支付    2015-08-22      2015-08-22
1       2015-08-18      2015-08-23      完成    2015-08-23      9999-12-31
2       2015-08-18      2015-08-18      创建    2015-08-18      2015-08-21
2       2015-08-18      2015-08-22      完成    2015-08-22      9999-12-31
3       2015-08-19      2015-08-21      支付    2015-08-19      2015-08-20
3       2015-08-19      2015-08-21      支付    2015-08-21      2015-08-22
3       2015-08-19      2015-08-23      完成    2015-08-23      9999-12-31
4       2015-08-19      2015-08-21      完成    2015-08-19      2015-08-20
4       2015-08-19      2015-08-21      完成    2015-08-21      9999-12-31
5       2015-08-19      2015-08-20      支付    2015-08-19      2015-08-22
5       2015-08-19      2015-08-23      完成    2015-08-23      9999-12-31
6       2015-08-20      2015-08-20      创建    2015-08-20      2015-08-21
6       2015-08-20      2015-08-22      支付    2015-08-22      9999-12-31
7       2015-08-20      2015-08-21      支付    2015-08-20      2015-08-20
7       2015-08-20      2015-08-21      支付    2015-08-21      9999-12-31
8       2015-08-21      2015-08-21      创建    2015-08-21      2015-08-21
8       2015-08-21      2015-08-22      支付    2015-08-22      2015-08-22
8       2015-08-21      2015-08-23      完成    2015-08-23      9999-12-31
9       2015-08-22      2015-08-22      创建    2015-08-22      9999-12-31
10      2015-08-22      2015-08-22      支付    2015-08-22      9999-12-31
11      2015-08-23      2015-08-23      创建    2015-08-23      9999-12-31
12      2015-08-23      2015-08-23      创建    2015-08-23      9999-12-31
13      2015-08-23      2015-08-23      支付    2015-08-23      9999-12-31
</code></span>

订单1从20号-23号，状态变化了三次，历史表中有三条记录

<span style="color:#000000"><code>//查看2015-08-22当天的历史快照，可以看出，和上面图中2015-08-22时候订单表中的数据是一样的
spark-sql> select * from t_dw_orders_his where dw_start_date <= '2015-08-22' and dw_end_date >= '2015-08-22';
1       2015-08-18      2015-08-22      支付    2015-08-22      2015-08-22
2       2015-08-18      2015-08-22      完成    2015-08-22      9999-12-31
3       2015-08-19      2015-08-21      支付    2015-08-21      2015-08-22
4       2015-08-19      2015-08-21      完成    2015-08-21      9999-12-31
5       2015-08-19      2015-08-20      支付    2015-08-19      2015-08-22
6       2015-08-20      2015-08-22      支付    2015-08-22      9999-12-31
7       2015-08-20      2015-08-21      支付    2015-08-21      9999-12-31
8       2015-08-21      2015-08-22      支付    2015-08-22      2015-08-22
9       2015-08-22      2015-08-22      创建    2015-08-22      9999-12-31
10      2015-08-22      2015-08-22      支付    2015-08-22      9999-12-31
Time taken: 0.328 seconds, Fetched 10 row(s)
//查看当前所有订单的最新状态
spark-sql> select * from t_dw_orders_his where dw_end_date = '9999-12-31';                                   
1       2015-08-18      2015-08-23      完成    2015-08-23      9999-12-31
2       2015-08-18      2015-08-22      完成    2015-08-22      9999-12-31
3       2015-08-19      2015-08-23      完成    2015-08-23      9999-12-31
4       2015-08-19      2015-08-21      完成    2015-08-21      9999-12-31
5       2015-08-19      2015-08-23      完成    2015-08-23      9999-12-31
6       2015-08-20      2015-08-22      支付    2015-08-22      9999-12-31
7       2015-08-20      2015-08-21      支付    2015-08-21      9999-12-31
8       2015-08-21      2015-08-23      完成    2015-08-23      9999-12-31
9       2015-08-22      2015-08-22      创建    2015-08-22      9999-12-31
10      2015-08-22      2015-08-22      支付    2015-08-22      9999-12-31
11      2015-08-23      2015-08-23      创建    2015-08-23      9999-12-31
12      2015-08-23      2015-08-23      创建    2015-08-23      9999-12-31
13      2015-08-23      2015-08-23      支付    2015-08-23      9999-12-31</code></span>
ACanswer
关注
专栏目录
数据仓库之【商品订单数据数仓】08：拉链表：什么是拉链表、创建拉链表
weixin_40612128的博客
03-12 4560
一、什么是拉链表 针对订单表、订单商品表，流水表，这些表中的数据是比较多的，如果使用全量的方式，会造成大量的数据冗余，浪费磁盘空间。 所以这种表，一般使用增量的方式，每日采集新增的数据。 在这注意一点：针对订单表，如果单纯的按照订单产生时间增量采集数据，是有问题的，因为用户可能今天下单，明天才支付，但是Hive是不支持数据更新的，这样虽然MySQL中订单的状态改变了，但是Hive中订单的状态还是之前的状态。 想要解决这个问题，一般有这么几种方案： 第一种：每天全量导入订单表的数据，这种方案在项目启动初期是没
oracle 拉链表如何分区,关于数据仓库历史拉链表新更新方法的说明
weixin_29233857的博客
04-06 1000
原始资料：数据仓库保留了大量的历史数据，这是区别于其他数据库的显著特点之一。历史数据能够使数据仓库重现任意时点的现场，对时间维度上的数据分析工作提供了重要的手段。保留历史数据最常见的办法就是使用历史拉链表。历史拉链表仅当生产数据发生变更时，才相应地发生变更，既能有效保留历史数据的变动信息，又不浪费存储空间。以数据仓库中每日增量更新的订单历史拉链表(假设表名为EVT_ORDER_HIST)为例，假设...
4、千亿级数仓项目（二）拉链表--增量数据
qq_43742212的博客
05-22 2475
周末在更新
拉链表数据的更新
weixin_49196517的博客
11-21 470
拉链表
数仓拉链表超详细讲解（通俗易懂）
最新发布
weixin_53709379的博客
09-24 1314
数仓拉链表超详细讲解（通俗易懂）
拉链表的更新思路
lunan的博客
01-25 729
拉链表：t_chain(id, status, start_date, end_date) 流水表：t_flow(id, status, start_date) 临时拉链表：t_chain_tmp(id, status, start_date, end_date) 拉链表的更新思路： 1、针对流水表t_flow中start_date是“当日”的记录进行处理 2、因为流水表中一个id可能先后有多个状态，先将流水表中非最终状态的记录插入t_chain_tmp，起止日期都是“当日” 3、原拉链表.
数据仓库中的拉链表
李美静 廊坊师范学院信息技术提高班十三期
12-10 1800
1、什么是拉链表 拉链表是针对数据仓库设计中表存储数据的方式而定义的，顾名思义，所谓拉链，就是记录历史。记录一个事物从开始，一直到当前状态的所有变化的信息。 拉链表的使用场景 在数据仓库的数据模型设计过程中，经常会遇到下面这种表的设计： 有一些表的数据量很大，比如一张用户表，大约10亿条记录，50个字段，这种表，即使使用ORC压缩，单张表的存储也会超过100G，在HDFS使用双备份或者三备...
如何在Hive中更新拉链表
机械工程跑路哥
08-28 1717
拉链表有start_time和end_time字段用来记录每条数据的生命周期；用来记录历史数据，记录一个事物从开始一直到当前状态的所有变化的信息。使用union all 进行上下合并（union会去重）；即只需要更新的数据处理，让数据过期；目的是将需要更新的数据置为过期；不等于‘9999-12-31’：包含新增和更新的数据。..................
数据仓库拉链表
02-14
在数据分析中有时会需要维护一些历史状态，比如订单状态变化，评分变化，为了保存下来这些状态变化的路径，可以同过拉链表实现 -- 使用场景 1、数据量比计较大，但业务要求每次需要查询全量历史，每天存储一份全量...
数据仓库中的拉链表-Clickhouse实现.pdf
08-26
传统数据库在数据大小比较小，索引大小适合内存，数据缓存命中率足够高的情形下能正常提供服务。但残酷的是，这种理想情形最终会随着业务的增长走到尽头，查询会变得越来越慢。你可能通过增加更多的内存，订购更快的...
拉链表的使用.docx
08-31
通过拉链表，可以实现在数据仓库中记录数据变化、解决存储空间问题、加快表更新速度等多种功能。它是数据仓库中的一种非常重要的技术解决方案。 在实际项目中，拉链表可以应用于各种场景。例如，在银行卡账户信息表...
解决增量新增及更新中的拉链表
l5261_1625的博客
05-12 510
解决增量新增及更新中的拉链表
数据仓库之拉链表
HW_870754395的博客
06-03 4870
数据仓库之拉链表一、常用表介绍1. 全量表2. 增量表3. 拉链表4. 流水表5. 拉链表 VS 流水表二. 拉链表适用情况及优点1. 适用情况2. 优点三. 拉链表举例（订单域）1. 订单表结构2. 为实现订单表存储，常用解决方案及存在问题（1）快照表（2）全量历史表==（3）历史拉链表== 一、常用表介绍 1. 全量表 每天的所有的最新状态的数据 2. 增量表 每天的新增数据 3. 拉链表 维...
大数据拉链表是什么
别人笑我太疯癫，我笑他人看不穿。
05-08 1167
大数据中的拉链表说的是一种数据留痕的操作，记录着一个实体对象从出生到死亡的全部过程，普遍的实现方式都是依赖时间字段做状态的更新，下面给大家用一个例子做说明 上面的这个例子sql是对商品订单做拉链表的实现，其中涉及到的表有三张dwd_order_info为订单表、dwd_order_info_his为订单的拉链表、dwd_order_info_his_tmp是拉 ...
数据仓库之拉链表的更新方法
fuyun6363的博客
02-24 4050
目录前言创建模拟数据库和表第一种情况：stg层中的order表是增量抽取最新数据（插入方式是先truncate，再增量插入最新数据）插入第一批模拟数据执行拉链操作脚本更新stg层order表数据再次执行脚本后查看ods层order表数据情况第二种情况：stg层的数据是全量抽取最新数据（先truncate表，再全量插入最新数据）清空stg和ods层order表的数据再插入模拟数据执行脚本查看ods层...
全量拉链执行全过程，记录历史数据变化痕迹
yaoxiaofeng001的博客
11-04 2556
数据仓库、ETL、拉链算法
面试总结
weixin_43927280的博客
04-07 180
1、自我介绍 2、自己最近从事的项目 3、spring相关 【1】为何要用spring 【2】解释下IOC和AOP IOC就是依赖控制转化，利用java的反射机制，将示例的初始化都交给spring。spring可以通过配置文件管理实例。 那为何不用工厂模式？ 因为本质上IOC是通过反射机制来实现的。当我们的需求出现变动时候，工厂模式需...
数据仓库实践杂谈（十）——拉链处理
cfy_fantasyxx的博客
01-20 4085
现代业务系统处理的数据越来越大，尤其大型金融机构、电商平台等，账户表，订单表都是庞大的。数据仓库要保留历史变更情况，需要每天加载当天的变更数据到仓库。相比整个全量数据来说，每天变化的数据还是属于少数的。比如千万账户级别的银行每天交易量一般也就是几十万条，也就意味着账户表中涉及变动的记录最多也就是几十万条。电商订单表可能数千万条，但每天新增以及之前订单变化的，可能不到一百万条。这种情况下，拉链方式做增量存储是最合适的方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值