一起做个简单的数据库（三）：一个在内存中仅能做追加操作的单表数据库

最新推荐文章于 2022-04-21 11:34:46 发布
最新推荐文章于 2022-04-21 11:34:46 发布
阅读量245 收藏
点赞数
原文链接：https://mp.weixin.qq.com/s/IVTTjAVnngUl0bEDSDiPhA#rd
版权

本系列文章一共13篇，本文为第3篇，请关注公众号，后续文章会陆续发布。

系列文章列表：

  1. 《手把手教你从零开始实现一个数据库系统》

  2. 《世上最简单的SQL编译器和虚拟机》

我们将从数据库的诸多限制开始，比如，这个数据库将会：

  • 仅支持两个操作：插入行并打印所有行

  • 数据只会存储在内存中（不会在硬盘做持久化存储）

  • 支持硬编码（hard coded）单表

我们的硬编码（hard coded）表将会按如下结构存储信息：

 

columntype
idinteger
usernamevarchar(32)
emailvarchar(255)


这个表的数据模式非常简单，但是它可以支持多种数据类型和不同大小的文本数据类型。

Insert statement如下：

insert 1 cstack foo@bar.com

我们还需要升级prepare_statement用来解析该语句：

   if (strncmp(input_buffer->buffer, "insert", 6) == 0) {
     statement->type = STATEMENT_INSERT;
+    int args_assigned = sscanf(
+        input_buffer->buffer, "insert %d %s %s", &(statement->row_to_insert.id),
+        statement->row_to_insert.username, statement->row_to_insert.email);
+    if (args_assigned < 3) {
+      return PREPARE_SYNTAX_ERROR;
+    }
     return PREPARE_SUCCESS;
   }
   if (strcmp(input_buffer->buffer, "select") == 0) {

我们将这些解析后的参数存储到语句对象内部的new Row data中：

+#define COLUMN_USERNAME_SIZE 32
+#define COLUMN_EMAIL_SIZE 255
+typedef struct {
+  uint32_t id;
+  char username[COLUMN_USERNAME_SIZE];
+  char email[COLUMN_EMAIL_SIZE];
+} Row;
+
 typedef struct {
   StatementType type;
+  Row row_to_insert;  // only used by insert statement
 } Statement;

现在我们需要拷贝这些数据并以某种格式存储在表中。SQLite使用B树进行快速查找，插入和删除。我们将从简单的内容开始。像B树一样，它将rows分组并存储在page中， page不会被排列为树，page会以数组的形式排列。

我的定义如下：

  • page：存储在内存块中的rows

  • 每个page存储尽可能多的rows

  • rows被序列化的存储在每一个page的compact representation中

    page按需分配

  • 指向page的指针数组固定大小

首先，我们定义row的compact representation：

+#define size_of_attribute(Struct, Attribute) sizeof(((Struct*)0)->Attribute)
+
+const uint32_t ID_SIZE = size_of_attribute(Row, id);
+const uint32_t USERNAME_SIZE = size_of_attribute(Row, username);
+const uint32_t EMAIL_SIZE = size_of_attribute(Row, email);
+const uint32_t ID_OFFSET = 0;
+const uint32_t USERNAME_OFFSET = ID_OFFSET + ID_SIZE;
+const uint32_t EMAIL_OFFSET = USERNAME_OFFSET + USERNAME_SIZE;
+const uint32_t ROW_SIZE = ID_SIZE + USERNAME_SIZE + EMAIL_SIZE;

被序列化的row将按如下布局：

columnsize (bytes)offset
id40
username324
email25536
total291


我们还需要代码来转换compact representation：

+void serialize_row(Row* source, void* destination) {
+  memcpy(destination + ID_OFFSET, &(source->id), ID_SIZE);
+  memcpy(destination + USERNAME_OFFSET, &(source->username), USERNAME_SIZE);
+  memcpy(destination + EMAIL_OFFSET, &(source->email), EMAIL_SIZE);
+}
+
+void deserialize_row(void* source, Row* destination) {
+  memcpy(&(destination->id), source + ID_OFFSET, ID_SIZE);
+  memcpy(&(destination->username), source + USERNAME_OFFSET, USERNAME_SIZE);
+  memcpy(&(destination->email), source + EMAIL_OFFSET, EMAIL_SIZE);
+}

接下来用一个Table结构指向page并跟踪有多少row：

+const uint32_t PAGE_SIZE = 4096;
+#define TABLE_MAX_PAGES 100
+const uint32_t ROWS_PER_PAGE = PAGE_SIZE / ROW_SIZE;
+const uint32_t TABLE_MAX_ROWS = ROWS_PER_PAGE * TABLE_MAX_PAGES;
+
+typedef struct {
+  uint32_t num_rows;
+  void* pages[TABLE_MAX_PAGES];
+} Table;

我将page大小设为4 KB，因为它与大多数计算机体系结构的虚拟内存系统使用的page大小相同。这意味着数据库中的page对应于操作系统使用的page。操作系统将page作为整体单元移入和移出内存，而不是将其拆分。

我将100作为我们可分配的page数量的上限。当我们切换到树形结构时，数据库的最大大小将仅受文件最大大小的限制。（我们仍然会限制内存中page的数量。）

Rows应该不会溢出page的边界。由于内存中的page大概率不会彼此相邻，如果假设正确，读取/写入rows会更加容易。

说到这，下面就是我们如何确定特定row在内存中的读取/写入位置：

+void* row_slot(Table* table, uint32_t row_num) {
+  uint32_t page_num = row_num / ROWS_PER_PAGE;
+  void* page = table->pages[page_num];
+  if (page == NULL) {
+    // Allocate memory only when we try to access page
+    page = table->pages[page_num] = malloc(PAGE_SIZE);
+  }
+  uint32_t row_offset = row_num % ROWS_PER_PAGE;
+  uint32_t byte_offset = row_offset * ROW_SIZE;
+  return page + byte_offset;
+}

现在我们可以用execute_statement从表中进行读写：

-void execute_statement(Statement* statement) {
+ExecuteResult execute_insert(Statement* statement, Table* table) {
+  if (table->num_rows >= TABLE_MAX_ROWS) {
+    return EXECUTE_TABLE_FULL;
+  }
+
+  Row* row_to_insert = &(statement->row_to_insert);
+
+  serialize_row(row_to_insert, row_slot(table, table->num_rows));
+  table->num_rows += 1;
+
+  return EXECUTE_SUCCESS;
+}
+
+ExecuteResult execute_select(Statement* statement, Table* table) {
+  Row row;
+  for (uint32_t i = 0; i < table->num_rows; i++) {
+    deserialize_row(row_slot(table, i), &row);
+    print_row(&row);
+  }
+  return EXECUTE_SUCCESS;
+}
+
+ExecuteResult execute_statement(Statement* statement, Table* table) {
   switch (statement->type) {
     case (STATEMENT_INSERT):
-      printf("This is where we would do an insert.\n");
-      break;
+      return execute_insert(statement, table);
     case (STATEMENT_SELECT):
-      printf("This is where we would do a select.\n");
-      break;
+      return execute_select(statement, table);
   }
 }

最后我们需要初始化表，创建内存释放函数并且处理一些小错误：

+ Table* new_table() {
+  Table* table = malloc(sizeof(Table));
+  table->num_rows = 0;
+  for (uint32_t i = 0; i < TABLE_MAX_PAGES; i++) {
+     table->pages[i] = NULL;
+  }
+  return table;
+}
+
+void free_table(Table* table) {
+    for (int i = 0; table->pages[i]; i++) {
+    free(table->pages[i]);
+    }
+    free(table);
+}

 int main(int argc, char* argv[]) {
+  Table* table = new_table();
   InputBuffer* input_buffer = new_input_buffer();
   while (true) {
     print_prompt();
@@ -105,13 +203,22 @@ int main(int argc, char* argv[]) {
     switch (prepare_statement(input_buffer, &statement)) {
       case (PREPARE_SUCCESS):
         break;
+      case (PREPARE_SYNTAX_ERROR):
+        printf("Syntax error. Could not parse statement.\n");
+        continue;
       case (PREPARE_UNRECOGNIZED_STATEMENT):
         printf("Unrecognized keyword at start of '%s'.\n",
                input_buffer->buffer);
         continue;
     }
-    execute_statement(&statement);
-    printf("Executed.\n");
+    switch (execute_statement(&statement, table)) {
+      case (EXECUTE_SUCCESS):
+        printf("Executed.\n");
+        break;
+      case (EXECUTE_TABLE_FULL):
+        printf("Error: Table full.\n");
+        break;
+    }
   }
 }

通过这些更改，我们实际上可以将数据保存在数据库中！

~ ./db
db > insert 1 cstack foo@bar.com
Executed.
db > insert 2 bob bob@example.com
Executed.
db > select
(1, cstack, foo@bar.com)
(2, bob, bob@example.com)
Executed.
db > insert foo bar 1
Syntax error. Could not parse statement.
db > .exit
~

现在，基于如下原因，我们可以进行测试了：

  • 我们计划大幅改变存储表的数据结构以增强数据表，并且测试将捕获回归

  • 有些极端情况我们并没有测试（比如将数据表写满）

下一章我们回来处理这些问题，本章的代码如下：

@@ -2,6 +2,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdint.h>
 typedef struct {
   char* buffer;
@@ -10,6 +11,105 @@ typedef struct {
 } InputBuffer;
+typedef enum { EXECUTE_SUCCESS, EXECUTE_TABLE_FULL } ExecuteResult;
+
+typedef enum {
+  META_COMMAND_SUCCESS,
+  META_COMMAND_UNRECOGNIZED_COMMAND
+} MetaCommandResult;
+
+typedef enum {
+  PREPARE_SUCCESS,
+  PREPARE_SYNTAX_ERROR,
+  PREPARE_UNRECOGNIZED_STATEMENT
+ } PrepareResult;
+
+typedef enum { STATEMENT_INSERT, STATEMENT_SELECT } StatementType;
+
+#define COLUMN_USERNAME_SIZE 32
+#define COLUMN_EMAIL_SIZE 255
+typedef struct {
+  uint32_t id;
+  char username[COLUMN_USERNAME_SIZE];
+  char email[COLUMN_EMAIL_SIZE];
+} Row;
+
+typedef struct {
+  StatementType type;
+  Row row_to_insert; //only used by insert statement
+} Statement;
+
+#define size_of_attribute(Struct, Attribute) sizeof(((Struct*)0)->Attribute)
+
+const uint32_t ID_SIZE = size_of_attribute(Row, id);
+const uint32_t USERNAME_SIZE = size_of_attribute(Row, username);
+const uint32_t EMAIL_SIZE = size_of_attribute(Row, email);
+const uint32_t ID_OFFSET = 0;
+const uint32_t USERNAME_OFFSET = ID_OFFSET + ID_SIZE;
+const uint32_t EMAIL_OFFSET = USERNAME_OFFSET + USERNAME_SIZE;
+const uint32_t ROW_SIZE = ID_SIZE + USERNAME_SIZE + EMAIL_SIZE;
+
+const uint32_t PAGE_SIZE = 4096;
+#define TABLE_MAX_PAGES 100
+const uint32_t ROWS_PER_PAGE = PAGE_SIZE / ROW_SIZE;
+const uint32_t TABLE_MAX_ROWS = ROWS_PER_PAGE * TABLE_MAX_PAGES;
+
+typedef struct {
+  uint32_t num_rows;
+  void* pages[TABLE_MAX_PAGES];
+} Table;
+
+void print_row(Row* row) {
+  printf("(%d, %s, %s)\n", row->id, row->username, row->email);
+}
+
+void serialize_row(Row* source, void* destination) {
+  memcpy(destination + ID_OFFSET, &(source->id), ID_SIZE);
+  memcpy(destination + USERNAME_OFFSET, &(source->username), USERNAME_SIZE);
+  memcpy(destination + EMAIL_OFFSET, &(source->email), EMAIL_SIZE);
+}
+
+void deserialize_row(void *source, Row* destination) {
+  memcpy(&(destination->id), source + ID_OFFSET, ID_SIZE);
+  memcpy(&(destination->username), source + USERNAME_OFFSET, USERNAME_SIZE);
+  memcpy(&(destination->email), source + EMAIL_OFFSET, EMAIL_SIZE);
+}
+
+void* row_slot(Table* table, uint32_t row_num) {
+  uint32_t page_num = row_num / ROWS_PER_PAGE;
+  void *page = table->pages[page_num];
+  if (page == NULL) {
+     // Allocate memory only when we try to access page
+     page = table->pages[page_num] = malloc(PAGE_SIZE);
+  }
+  uint32_t row_offset = row_num % ROWS_PER_PAGE;
+  uint32_t byte_offset = row_offset * ROW_SIZE;
+  return page + byte_offset;
+}
+
+Table* new_table() {
+  Table* table = malloc(sizeof(Table));
+  table->num_rows = 0;
+  for (uint32_t i = 0; i < TABLE_MAX_PAGES; i++) {
+     table->pages[i] = NULL;
+  }
+  return table;
+}
+
+void free_table(Table* table) {
+  for (int i = 0; table->pages[i]; i++) {
+     free(table->pages[i]);
+  }
+  free(table);
+}
+
 InputBuffer* new_input_buffer() {
   InputBuffer* input_buffer = malloc(sizeof(InputBuffer));
   input_buffer->buffer = NULL;
@@ -40,17 +140,105 @@ void close_input_buffer(InputBuffer* input_buffer) {
     free(input_buffer);
 }
+MetaCommandResult do_meta_command(InputBuffer* input_buffer, Table *table) {
+  if (strcmp(input_buffer->buffer, ".exit") == 0) {
+    close_input_buffer(input_buffer);
+    free_table(table);
+    exit(EXIT_SUCCESS);
+  } else {
+    return META_COMMAND_UNRECOGNIZED_COMMAND;
+  }
+}
+
+PrepareResult prepare_statement(InputBuffer* input_buffer,
+                                Statement* statement) {
+  if (strncmp(input_buffer->buffer, "insert", 6) == 0) {
+    statement->type = STATEMENT_INSERT;
+    int args_assigned = sscanf(
+    input_buffer->buffer, "insert %d %s %s", &(statement->row_to_insert.id),
+    statement->row_to_insert.username, statement->row_to_insert.email
+    );
+    if (args_assigned < 3) {
+    return PREPARE_SYNTAX_ERROR;
+    }
+    return PREPARE_SUCCESS;
+  }
+  if (strcmp(input_buffer->buffer, "select") == 0) {
+    statement->type = STATEMENT_SELECT;
+    return PREPARE_SUCCESS;
+  }
+
+  return PREPARE_UNRECOGNIZED_STATEMENT;
+}
+
+ExecuteResult execute_insert(Statement* statement, Table* table) {
+  if (table->num_rows >= TABLE_MAX_ROWS) {
+     return EXECUTE_TABLE_FULL;
+  }
+
+  Row* row_to_insert = &(statement->row_to_insert);
+
+  serialize_row(row_to_insert, row_slot(table, table->num_rows));
+  table->num_rows += 1;
+
+  return EXECUTE_SUCCESS;
+}
+
+ExecuteResult execute_select(Statement* statement, Table* table) {
+  Row row;
+  for (uint32_t i = 0; i < table->num_rows; i++) {
+     deserialize_row(row_slot(table, i), &row);
+     print_row(&row);
+  }
+  return EXECUTE_SUCCESS;
+}
+
+ExecuteResult execute_statement(Statement* statement, Table *table) {
+  switch (statement->type) {
+    case (STATEMENT_INSERT):
+           return execute_insert(statement, table);
+    case (STATEMENT_SELECT):
+    return execute_select(statement, table);
+  }
+}
+
 int main(int argc, char* argv[]) {
+  Table* table = new_table();
   InputBuffer* input_buffer = new_input_buffer();
   while (true) {
     print_prompt();
     read_input(input_buffer);
-    if (strcmp(input_buffer->buffer, ".exit") == 0) {
-      close_input_buffer(input_buffer);
-      exit(EXIT_SUCCESS);
-    } else {
-      printf("Unrecognized command '%s'.\n", input_buffer->buffer);
+    if (input_buffer->buffer[0] == '.') {
+      switch (do_meta_command(input_buffer, table)) {
+        case (META_COMMAND_SUCCESS):
+          continue;
+        case (META_COMMAND_UNRECOGNIZED_COMMAND):
+          printf("Unrecognized command '%s'\n", input_buffer->buffer);
+          continue;
+      }
+    }
+
+    Statement statement;
+    switch (prepare_statement(input_buffer, &statement)) {
+      case (PREPARE_SUCCESS):
+        break;
+      case (PREPARE_SYNTAX_ERROR):
+    printf("Syntax error. Could not parse statement.\n");
+    continue;
+      case (PREPARE_UNRECOGNIZED_STATEMENT):
+        printf("Unrecognized keyword at start of '%s'.\n",
+               input_buffer->buffer);
+        continue;
+    }
+
+    switch (execute_statement(&statement, table)) {
+    case (EXECUTE_SUCCESS):
+        printf("Executed.\n");
+        break;
+    case (EXECUTE_TABLE_FULL):
+        printf("Error: Table full.\n");
+        break;
     }
   }
 }

原文链接：https://cstack.github.io/db_tutorial/parts/part3.html

基于Kubernetes的DevOps实战培训

基于Kubernetes的DevOps实战培训将于2020年5月15日在上海开课，3天时间带你系统掌握Kubernetes，学习效果不好可以继续学习。本次培训包括：容器特性、镜像、网络；Kubernetes架构、核心组件、基本功能；Kubernetes设计理念、架构设计、基本功能、常用对象、设计原则；Kubernetes的数据库、运行时、网络、插件已经落地经验；微服务架构、组件、监控方案等，点击下方图片或者阅读原文链接查看详情。

Docker_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
内存型数据库Redis持久化小结
12-16
因为Redis是内存型数据库，所以为了防止因为系统崩溃等原因导致数据丢失的问题，Redis提供了两种不同的持久化方法来将数据存储在硬盘里面，一种方法是快照（RDB），它可以将存在于某一个时刻的所有数据都写入到硬盘...
构建一个简单的数据库系列（五）持久化到硬盘
-= 大 明 =- 的专栏
03-24 479
英文链接：https://cstack.github.io/db_tutorial/parts/part5.html “Nothing in the world can take the place of persistence.” –Calvin Coolidge 像sqlite一样，我们通过保存整个数据库到一个文件到方式进行记录的持久化。 我们已经实现了把记录反序列化到页大小到内存块中...
sizeof(struct)的结果分析及其原因
syyyy712的博客
05-06 2562
sizeof是面试经常考的知识点，现我从网上转载了一篇文章讲的很精彩，可以参考！ 转载地址：http://blog.csdn.net/xinjixjz/article/details/6769344 有的时候，在脑海中停顿了很久的“显而易见”的东西，其实根本上就是错误的。就拿下面的问题来看： struct T { char ch; int i ; }; 使用size...
关于结构体的内存分配问题--sizeof(/*struct*/A)
BayINGbf的专栏
03-22 814
问题描述：C、C++中的结构体 struct A{变量列表}; 是定义类的一种方式，与class 关键字类似，同样可以定义继承方式为public、private、protected三种方式，但是不同的是一点是，struct默认集成方式为public，而class默认继承方式为private。 - 两者的内存分配具体方式都需要考虑 内存对齐 问题。 - 这里先分析struct的内存分配方式基本类型的
Redis桌面管理器（又名RDM） - 是一个用于Windows，Linux和MacOS的快速开源Redis数据库管理应用程序。
05-04
Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。redis是一个key-value存储系统。和...
用100多行python代码写一个数据库
03-17
只对日志记录的时间做索引， 简介里大概说了下索引的实现，二分查找肯定没B Tree效率高，但一般情况下也差不了一个数量级，而且实现特别简单。 因为是稀疏索引，并不是每条日志都有索引记录它的偏移量，所以读取...
大数据高性能数据库Redis在Windows上的使用教程
12-14
Redis简介 　redis是一个key-value存储系统...与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-s
redis非关系型数据库
05-21
它的出现是为了弥补RDB的不足（数据的不一致性），所以它采用日志的形式来记录每个写操作，并追加到文件中。Redis 重启的会根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作。 二、特点 1 Redis...
kissdb:（保持）简单的愚蠢数据库
05-15
一个好的大小通常约为您期望的平均条目数的1/2。 特征： Tiny，在x86_64 Linux系统上编译为〜4k 内存占用量小（仅缓存哈希表） 如果使用小的哈希表，则非常节省空间（在磁盘上） 竭尽全力使功率损耗稳定 相当...
Redis如何实现数据库读写分离详解
12-16
Redis是一种NoSQL的文档数据库，通过key-value的结构存储在内存中，Redis读的速度是110000次/s，写的速度是81000次/s，性能很高，使用范围也很广。Redis是一个key-value存储系统。和Memcached类似，为了保证效率，...
关于使用key/value数据库redis和TTSERVER的心得体会
12-19
先说redisredis是一个类似memcached的key/value存储系统，它支持存储的value类型相对较多，包括string(字符串)、 list(链表)、set(集合)和zset(有序集合)。在此基础上，redis支持各种不同方式的排序。与memcached...
Redis非关系型数据库笔记-数据持久化-主从同步-缓存-笔记-五大数据类型-三大特殊数据类型
最新发布
02-26
Redis（Remote Dictionary Server）是一个开源的、使用ANSI C语言编写的、支持网络连接的、基于内存并可持久化的日志型Key-Value数据库，它提供了多种语言的API。Redis的主要特点包括： 数据类型丰富：Redis支持...
MySql减少内存占用的方法详解
01-19
前言 默认设置下，mysql会初始化很大的内存块用于缓存数据库查询数据。...在配置末尾追加如下配置 performance_schema_max_table_instances=150 table_definition_cache=150 table_open_cache=64 然后 service mysql r
sizeof(结构体)占用空间大小问题
zwhdldz的博客
10-27 587
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、sizeof(结构体)二、普通结构体1.规则2.举例三、嵌套结构体1.在原始规则上附加规则2.举例 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、sizeof(结构体) 结构体成员按照定义时的顺序依次存储在连续的内存空间，但是结构体的大小并不是简单
构建一个简单的数据库系列（八）B-tree叶子节点格式之二
-= 大 明 =- 的专栏
03-31 254
英文原文链接：https://cstack.github.io/db_tutorial/parts/part8.html 如何向叶子节点插入数据 这一节我们只实现一个单节点树。回想下上节的内容，一颗树是从一颗空的叶子节点数开始演变的。 图 空树 键值对可以被一直添加直到叶子节点填满。 图 1个节点的B-tree 当第一次打开数据库时，数据库文件是一个空文件，我们初始化page=...
SQLite克隆|第三步：实现内存中的最简单的数据表
励志长大
05-24 285
实现内存中的最简单的数据表 首先要解释一下所谓最简单的数据表的定义，它满足以下几个功能： 支持两种操作：插入一行，打印所有行 仅驻留在内存中（对磁盘没有持久性） 支持单个硬编码表，所谓硬编码，即将数据直接写在代码（程序）中。 硬编码格式如下： column type id integer username varchar(32) email varchar(255) ...
闲来无事，写个数据库吧（3）
weixin_51275728的博客
04-21 1070
写写数据库
java 向量数据库
08-22
Java 向量数据库是一种...综上所述，Java 向量数据库是一种简单易用、灵活可扩展、高性能、内存管理良好且具备可移植性的数据库管理系统。它可以帮助开发者高效地存储和管理数据，并为应用程序提供快速的数据访问能力。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值