实现一个简单的Database5(译文）

麻花痒  金牌会员 | 2022-10-15 16:37:59 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 785|帖子 785|积分 2355


  • GreatSQL社区原创内容未经授权不得随意使用，转载请联系小编并注明来源。
  • GreatSQL是MySQL的国产分支版本，使用上与MySQL一致。
前文回顾

实现一个简单的Database1(译文）
实现一个简单的Database2(译文）
实现一个简单的Database3(译文）
实现一个简单的Database4(译文）
译注：cstsck在github维护了一个简单的、类似SQLite的数据库实现，通过这个简单的项目，可以很好的理解数据库是如何运行的。本文是第五篇，主要是实现数据持久化
Part 5 持久化到磁盘

“Nothing in the world can take the place of persistence.” – Calvin Coolidge(美国第30任总统)
我们数据库能让你插入数据并读取出来，但是只能在程序一直运行的时候才可以。如果你kill掉程序后再次重启以后，你所有的数据就丢失了。
我们期望的行为是这样的，下面是一个spec测试：
  1. it 'keeps data after closing connection' do
  2.   result1 = run_script([
  3.     "insert 1 user1 person1@example.com",
  4.     ".exit",
  5.   ])
  6.   expect(result1).to match_array([
  7.     "db > Executed.",
  8.     "db > ",
  9.   ])
  10.   result2 = run_script([
  11.     "select",
  12.     ".exit",
  13.   ])
  14.   expect(result2).to match_array([
  15.     "db > (1, user1, person1@example.com)",
  16.     "Executed.",
  17.     "db > ",
  18.   ])
  19. end
复制代码
像SQLite一样，我们会把数据持久化，保存整个数据库到一个单一的文件中。
我们已经实现了将行序列化为页面大小的内存块。为数据库增加持久化的功能，我们可以简单的把这些内存中的块（blocks）写入到文件，在下次程序启动时，再把这些数据块读取到内存。
为了让实现更简单点，我们创建了一个叫做pager的抽象。我们向pager请求的数据页page号为x（page number x），然后pager会返给我们一个内存块。请求会首先查看内存中的数据，如果内存中没有（缓存未命中，cache miss），pager就会从磁盘上拷贝数据到内存中（通过读取数据库文件）。



我们的程序是如何与 SQLite 架构匹配的
Pager访问页缓存（page cache）和文件。表对象（Table object）通过Pager请求数据页（pages）：
  1. +typedef struct {
  2. +  int file_descriptor;
  3. +  uint32_t file_length;
  4. +  void* pages[TABLE_MAX_PAGES];
  5. +} Pager;
  6. +
  7. typedef struct {
  8. -  void* pages[TABLE_MAX_PAGES];
  9. +  Pager* pager;
  10.    uint32_t num_rows;
  11. } Table;
复制代码
因为new_table()有了打开一个数据库连接的效果，所以我把new_table()重命名为db_open()。
打开一个连接的含义是：

  • 打开数据库文件
  • 初始化一个Pager数据结构
  • 初始化一个table数据结构
  1. -Table* new_table() {
  2. +Table* db_open(const char* filename) {
  3. +  Pager* pager = pager_open(filename);
  4. +  uint32_t num_rows = pager->file_length / ROW_SIZE;
  5. +
  6.    Table* table = malloc(sizeof(Table));
  7. -  table->num_rows = 0;
  8. +  table->pager = pager;
  9. +  table->num_rows = num_rows;
  11.    return table;
  12. }
复制代码
db_open() 接下来调用 pager_open()，pager_open() 会打开数据库文件并跟踪文件的大小。它也会初始化页缓存（page cache）为NULL（NULL 在 C 语言中为一个宏，定义为: #define NULL 0，也就是0）。
  1. +Pager* pager_open(const char* filename) {
  2. +  int fd = open(filename,
  3. +                O_RDWR |      // Read/Write mode
  4. +                    O_CREAT,  // Create file if it does not exist
  5. +                S_IWUSR |     // User write permission
  6. +                    S_IRUSR   // User read permission
  7. +                );
  8. +
  9. +  if (fd == -1) {
  10. +    printf("Unable to open file\n");
  11. +    exit(EXIT_FAILURE);
  12. +  }
  13. +
  14. +  off_t file_length = lseek(fd, 0, SEEK_END);
  15. +
  16. +  Pager* pager = malloc(sizeof(Pager));
  17. +  pager->file_descriptor = fd;
  18. +  pager->file_length = file_length;
  19. +
  20. +  for (uint32_t i = 0; i < TABLE_MAX_PAGES; i++) {
  21. +    pager->pages[i] = NULL;
  22. +  }
  23. +
  24. +  return pager;
  25. +}
复制代码
有了上面的Pager的抽象，我们把获取一个页面（fetch a page）的逻辑移动到它自己的方法里：
  1. void* row_slot(Table* table, uint32_t row_num) {
  2.   uint32_t page_num = row_num / ROWS_PER_PAGE;
  3. -  void* page = table->pages[page_num];
  4. -  if (page == NULL) {
  5. -    // Allocate memory only when we try to access page
  6. -    page = table->pages[page_num] = malloc(PAGE_SIZE);
  7. -  }
  8. +  void* page = get_page(table->pager, page_num);
  9.   uint32_t row_offset = row_num % ROWS_PER_PAGE;
  10.   uint32_t byte_offset = row_offset * ROW_SIZE;
  11.   return page + byte_offset;
  12. }
复制代码
get_page() 方法有处理缓存未命中（cache miss）的逻辑。我们假设数据页一个接一个地保存在数据库文件中：
Page 0 在 offset 0
page 1 在 offset 4096
page 2 在 offset 8192
等等。
如果请求的page在文件的边界之外，那我们就知道它应该是空白，所以我们只需要分配一些内存并返回它就可以了。当我们flush这些缓存到磁盘时，这些page就会添加到文件中。
  1. +void* get_page(Pager* pager, uint32_t page_num) {
  2. +  if (page_num > TABLE_MAX_PAGES) {
  3. +    printf("Tried to fetch page number out of bounds. %d > %d\n", page_num,
  4. +           TABLE_MAX_PAGES);
  5. +    exit(EXIT_FAILURE);
  6. +  }
  7. +
  8. +  if (pager->pages[page_num] == NULL) {
  9. +    // Cache miss. Allocate memory and load from file.
  10. +    void* page = malloc(PAGE_SIZE);
  11. +    uint32_t num_pages = pager->file_length / PAGE_SIZE;
  12. +
  13. +    // We might save a partial page at the end of the file
  14. +    if (pager->file_length % PAGE_SIZE) {
  15. +      num_pages += 1;
  16. +    }
  17. +
  18. +    if (page_num <= num_pages) {
  19. +      lseek(pager->file_descriptor, page_num * PAGE_SIZE, SEEK_SET);
  20. +      ssize_t bytes_read = read(pager->file_descriptor, page, PAGE_SIZE);
  21. +      if (bytes_read == -1) {
  22. +        printf("Error reading file: %d\n", errno);
  23. +        exit(EXIT_FAILURE);
  24. +      }
  25. +    }
  26. +
  27. +    pager->pages[page_num] = page;
  28. +  }
  29. +
  30. +  return pager->pages[page_num];
  31. +}
复制代码
现在，我们想一直到用户关闭数据库的连接时候再flush这些缓存到磁盘。当用户退出时，我们就调用新的方法：db_close()，方法执行下面几个操作：

  • flush页缓存到磁盘
  • 关闭数据文件
  • 释放Pager、table数据结构的内存
  1. +void db_close(Table* table) {
  2. +  Pager* pager = table->pager;
  3. +  uint32_t num_full_pages = table->num_rows // ROWS_PER_PAGE;
  4. +
  5. +  for (uint32_t i = 0; i < num_full_pages; i++) {
  6. +    if (pager->pages[i] == NULL) {
  7. +      continue;
  8. +    }
  9. +    pager_flush(pager, i, PAGE_SIZE);
  10. +    free(pager->pages[i]);
  11. +    pager->pages[i] = NULL;
  12. +  }
  13. +
  14. +  // There may be a partial page to write to the end of the file
  15. +  // This should not be needed after we switch to a B-tree
  16. +  uint32_t num_additional_rows = table->num_rows % ROWS_PER_PAGE;
  17. +  if (num_additional_rows > 0) {
  18. +    uint32_t page_num = num_full_pages;
  19. +    if (pager->pages[page_num] != NULL) {
  20. +      pager_flush(pager, page_num, num_additional_rows * ROW_SIZE);
  21. +      free(pager->pages[page_num]);
  22. +      pager->pages[page_num] = NULL;
  23. +    }
  24. +  }
  25. +
  26. +  int result = close(pager->file_descriptor);
  27. +  if (result == -1) {
  28. +    printf("Error closing db file.\n");
  29. +    exit(EXIT_FAILURE);
  30. +  }
  31. +  for (uint32_t i = 0; i < TABLE_MAX_PAGES; i++) {
  32. +    void* page = pager->pages[i];
  33. +    if (page) {
  34. +      free(page);
  35. +      pager->pages[i] = NULL;
  36. +    }
  37. +  }
  38. +  free(pager);
  39. +  free(table);
  40. +}
  41. +
  42. -MetaCommandResult do_meta_command(InputBuffer* input_buffer) {
  43. +MetaCommandResult do_meta_command(InputBuffer* input_buffer, Table* table) {
  44.    if (strcmp(input_buffer->buffer, ".exit") == 0) {
  45. +    db_close(table);
  46.      exit(EXIT_SUCCESS);
  47.    } else {
  48.      return META_COMMAND_UNRECOGNIZED_COMMAND;
复制代码
_译注：后面作者会把使用array组织page的方式改为B-tree，有些代码只是暂时这样实现，后面还会修改。
在当前的设计中，文件长度是编码存储多少行来决定，所以我们可能会需要在文件的结尾写入部分页面（partial page，页的一部分，并非全页）。这也是为什么 pager_flush() 同时使用页码（page number）和数据页大小（size）两个参数的原因。这不是最好的设计，但是在我们开始实现B-tree之后，他们就会很快的消失了。
  1. +void pager_flush(Pager* pager, uint32_t page_num, uint32_t size) {
  2. +  if (pager->pages[page_num] == NULL) {
  3. +    printf("Tried to flush null page\n");
  4. +    exit(EXIT_FAILURE);
  5. +  }
  6. +
  7. +  off_t offset = lseek(pager->file_descriptor, page_num * PAGE_SIZE, SEEK_SET);
  8. +
  9. +  if (offset == -1) {
  10. +    printf("Error seeking: %d\n", errno);
  11. +    exit(EXIT_FAILURE);
  12. +  }
  13. +
  14. +  ssize_t bytes_written =
  15. +      write(pager->file_descriptor, pager->pages[page_num], size);
  16. +
  17. +  if (bytes_written == -1) {
  18. +    printf("Error writing: %d\n", errno);
  19. +    exit(EXIT_FAILURE);
  20. +  }
  21. +}
复制代码
最后，我们需要接受一个命令行参数：filname。也不要忘了在 do_meta_command() 添加额外参数：
译注：db_open(filename)返回一个table结构的指针，将这个指针作为参数传给do_meta_command()。
  1. int main(int argc, char* argv[]) {
  2. -  Table* table = new_table();
  3. +  if (argc < 2) {
  4. +    printf("Must supply a database filename.\n");
  5. +    exit(EXIT_FAILURE);
  6. +  }
  7. +
  8. +  char* filename = argv[1];
  9. +  Table* table = db_open(filename);
  10. +
  11.   InputBuffer* input_buffer = new_input_buffer();
  12.   while (true) {
  13.     print_prompt();
  14.     read_input(input_buffer);
  16.     if (input_buffer->buffer[0] == '.') {
  17. -      switch (do_meta_command(input_buffer)) {
  18. +      switch (do_meta_command(input_buffer, table)) {
复制代码
有了这些修改，我们能在关闭然后重新打开数据库时，我们记录仍然还在数据库中。
  1. ~ ./db mydb.db
  2. db > insert 1 cstack foo@bar.com
  3. Executed.
  4. db > insert 2 voltorb volty@example.com
  5. Executed.
  6. db > .exit
  7. ~
  8. ~ ./db mydb.db
  9. db > select
  10. (1, cstack, foo@bar.com)
  11. (2, voltorb, volty@example.com)
  12. Executed.
  13. db > .exit
  14. ~
复制代码
为了多找点乐子，让我们看看 mydb.db 文件中数据库是如何存储的。我使用的是 vim 来作为 hex 编辑器来查看文件在内存中是如何布局的：
  1. vim mydb.db
  2. :%!xxd
复制代码

当前的文件布局
前四个字节是第一行数据的id（四个字节是因为我们存储使用的uint32_t类型）。它以小端字节序存储，因此低位字节首先出现 （01），紧跟的是高位字节（ (00 00 00)）。我们用 memcpy() 从 Row 数据结构拷贝字节到页缓存（page cache）中，这也就意味着这些结构在内存中的布局是小端字节序。这是我编译程序的机器的属性。如果想在我们的机器上写数据文件，然后把它读取到一个大端字节序的机器上，就不得不修改 serialize_row() 和 deserialize_row() 方法（序列化和反序列化）始终使用相同的顺序存储和读取字节。
译注：将多个字节的数据存储在一片连续的地址上，而将数据的各个字节从这片空间的高地址位开始存储还是从低地址位开始存储就决定了系统的存储字节序。大端字节序：高位字节数据存放在低地址处，低位数据存放在高地址处；小端字节序：高位字节数据存放在高地址处，低位数据存放在低地址处。这一般是服务器特性决定的，并不需要特别关注。作者在此浓墨重彩的介绍了一下。
接下来的33字节是存储以null为结尾的 username（占32个字节，未使用位置填充0，结尾以一个字节的null结束）。显然“cstack”在 ASCII 十六进制中是 63 73 74 61 63 6b（占用了6个字节，其余使用0填充），接下来是一个null字符(00)。其余33字节未使用。
接下来的256字节是使用相同方式存储的email（占255个字节，未使用位置填充0，结尾以一个字节的null结束）。在这里能看到在null结束符之后有一些随机的垃圾字符。这很可能是因为在我们的Row结构没有初始化内存导致的。我们拷贝整个256个字节长度 email 缓存写入到文件中，包含了任何在结束符之后的字节。当我们分配该结构内存时，内存中的任何原来的内容还在那里。但是因为我们使用了null结束符，所以它对数据库行为没有影响。
注意：如果我们需要确认所有的字节都被初始化，在 serialize_row() 中拷贝 username 和 email 字段时用 strncpy() 替换 memcpy() 就足够了，像下面这样：
  1. void serialize_row(Row* source, void* destination) {
  2.     memcpy(destination + ID_OFFSET, &(source->id), ID_SIZE);
  3. -    memcpy(destination + USERNAME_OFFSET, &(source->username), USERNAME_SIZE);
  4. -    memcpy(destination + EMAIL_OFFSET, &(source->email), EMAIL_SIZE);
  5. +    strncpy(destination + USERNAME_OFFSET, source->username, USERNAME_SIZE);
  6. +    strncpy(destination + EMAIL_OFFSET, source->email, EMAIL_SIZE);
  7. }
复制代码
结论

好了！我们实现了持久化。这样实现不是最好的。例如，如果你kill程序而不是执行“.exit”退出，你就会丢失你的更新。此外，我们写回所有数据页到磁盘，尽管数据页自从我们从磁盘读取出来就没有被更新。这些都是我们后面可以解决的问题。

下次我们将要介绍游标（cursors）。这会让我们实现B-tree变得更容易。
在此之前，看一下完整代码对比（与上一部分对比）：
  1. +#include <errno.h>
  2. +#include <fcntl.h>
  3. #include <stdbool.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  7. #include <stdint.h>
  8. +#include <unistd.h>
  10. struct InputBuffer_t {
  11.    char* buffer;
  12. @@ -62,9 +65,16 @@ const uint32_t PAGE_SIZE = 4096;
  13. const uint32_t ROWS_PER_PAGE = PAGE_SIZE / ROW_SIZE;
  14. const uint32_t TABLE_MAX_ROWS = ROWS_PER_PAGE * TABLE_MAX_PAGES;
  16. +typedef struct {
  17. +  int file_descriptor;
  18. +  uint32_t file_length;
  19. +  void* pages[TABLE_MAX_PAGES];
  20. +} Pager;
  21. +
  22. typedef struct {
  23.    uint32_t num_rows;
  24. -  void* pages[TABLE_MAX_PAGES];
  25. +  Pager* pager;
  26. } Table;
  28. @@ -84,32 +94,81 @@ void deserialize_row(void *source, Row* destination) {
  29.    memcpy(&(destination->email), source + EMAIL_OFFSET, EMAIL_SIZE);
  30. }
  32. +void* get_page(Pager* pager, uint32_t page_num) {
  33. +  if (page_num > TABLE_MAX_PAGES) {
  34. +     printf("Tried to fetch page number out of bounds. %d > %d\n", page_num,
  35. +             TABLE_MAX_PAGES);
  36. +     exit(EXIT_FAILURE);
  37. +  }
  38. +
  39. +  if (pager->pages[page_num] == NULL) {
  40. +     // Cache miss. Allocate memory and load from file.
  41. +     void* page = malloc(PAGE_SIZE);
  42. +     uint32_t num_pages = pager->file_length / PAGE_SIZE;
  43. +
  44. +     // We might save a partial page at the end of the file
  45. +     if (pager->file_length % PAGE_SIZE) {
  46. +         num_pages += 1;
  47. +     }
  48. +
  49. +     if (page_num <= num_pages) {
  50. +         lseek(pager->file_descriptor, page_num * PAGE_SIZE, SEEK_SET);
  51. +         ssize_t bytes_read = read(pager->file_descriptor, page, PAGE_SIZE);
  52. +         if (bytes_read == -1) {
  53. +             printf("Error reading file: %d\n", errno);
  54. +             exit(EXIT_FAILURE);
  55. +         }
  56. +     }
  57. +
  58. +     pager->pages[page_num] = page;
  59. +  }
  60. +
  61. +  return pager->pages[page_num];
  62. +}
  63. +
  64. void* row_slot(Table* table, uint32_t row_num) {
  65.    uint32_t page_num = row_num / ROWS_PER_PAGE;
  66. -  void *page = table->pages[page_num];
  67. -  if (page == NULL) {
  68. -     // Allocate memory only when we try to access page
  69. -     page = table->pages[page_num] = malloc(PAGE_SIZE);
  70. -  }
  71. +  void *page = get_page(table->pager, page_num);
  72.    uint32_t row_offset = row_num % ROWS_PER_PAGE;
  73.    uint32_t byte_offset = row_offset * ROW_SIZE;
  74.    return page + byte_offset;
  75. }
  77. -Table* new_table() {
  78. -  Table* table = malloc(sizeof(Table));
  79. -  table->num_rows = 0;
  80. +Pager* pager_open(const char* filename) {
  81. +  int fd = open(filename,
  82. +               O_RDWR |         // Read/Write mode
  83. +                   O_CREAT,        // Create file if it does not exist
  84. +               S_IWUSR |        // User write permission
  85. +                   S_IRUSR        // User read permission
  86. +               );
  87. +
  88. +  if (fd == -1) {
  89. +     printf("Unable to open file\n");
  90. +     exit(EXIT_FAILURE);
  91. +  }
  92. +
  93. +  off_t file_length = lseek(fd, 0, SEEK_END);
  94. +
  95. +  Pager* pager = malloc(sizeof(Pager));
  96. +  pager->file_descriptor = fd;
  97. +  pager->file_length = file_length;
  98. +
  99.    for (uint32_t i = 0; i < TABLE_MAX_PAGES; i++) {
  100. -     table->pages[i] = NULL;
  101. +     pager->pages[i] = NULL;
  102.    }
  103. -  return table;
  104. +
  105. +  return pager;
  106. }
  108. -void free_table(Table* table) {
  109. -  for (int i = 0; table->pages[i]; i++) {
  110. -     free(table->pages[i]);
  111. -  }
  112. -  free(table);
  113. +Table* db_open(const char* filename) {
  114. +  Pager* pager = pager_open(filename);
  115. +  uint32_t num_rows = pager->file_length / ROW_SIZE;
  116. +
  117. +  Table* table = malloc(sizeof(Table));
  118. +  table->pager = pager;
  119. +  table->num_rows = num_rows;
  120. +
  121. +  return table;
  122. }
  124. InputBuffer* new_input_buffer() {
  125. @@ -142,10 +201,76 @@ void close_input_buffer(InputBuffer* input_buffer) {
  126.    free(input_buffer);
  127. }
  129. +void pager_flush(Pager* pager, uint32_t page_num, uint32_t size) {
  130. +  if (pager->pages[page_num] == NULL) {
  131. +     printf("Tried to flush null page\n");
  132. +     exit(EXIT_FAILURE);
  133. +  }
  134. +
  135. +  off_t offset = lseek(pager->file_descriptor, page_num * PAGE_SIZE,
  136. +                      SEEK_SET);
  137. +
  138. +  if (offset == -1) {
  139. +     printf("Error seeking: %d\n", errno);
  140. +     exit(EXIT_FAILURE);
  141. +  }
  142. +
  143. +  ssize_t bytes_written = write(
  144. +     pager->file_descriptor, pager->pages[page_num], size
  145. +     );
  146. +
  147. +  if (bytes_written == -1) {
  148. +     printf("Error writing: %d\n", errno);
  149. +     exit(EXIT_FAILURE);
  150. +  }
  151. +}
  152. +
  153. +void db_close(Table* table) {
  154. +  Pager* pager = table->pager;
  155. +  uint32_t num_full_pages = table->num_rows / ROWS_PER_PAGE;
  156. +
  157. +  for (uint32_t i = 0; i < num_full_pages; i++) {
  158. +     if (pager->pages[i] == NULL) {
  159. +         continue;
  160. +     }
  161. +     pager_flush(pager, i, PAGE_SIZE);
  162. +     free(pager->pages[i]);
  163. +     pager->pages[i] = NULL;
  164. +  }
  165. +
  166. +  // There may be a partial page to write to the end of the file
  167. +  // This should not be needed after we switch to a B-tree
  168. +  uint32_t num_additional_rows = table->num_rows % ROWS_PER_PAGE;
  169. +  if (num_additional_rows > 0) {
  170. +     uint32_t page_num = num_full_pages;
  171. +     if (pager->pages[page_num] != NULL) {
  172. +         pager_flush(pager, page_num, num_additional_rows * ROW_SIZE);
  173. +         free(pager->pages[page_num]);
  174. +         pager->pages[page_num] = NULL;
  175. +     }
  176. +  }
  177. +
  178. +  int result = close(pager->file_descriptor);
  179. +  if (result == -1) {
  180. +     printf("Error closing db file.\n");
  181. +     exit(EXIT_FAILURE);
  182. +  }
  183. +  for (uint32_t i = 0; i < TABLE_MAX_PAGES; i++) {
  184. +     void* page = pager->pages[i];
  185. +     if (page) {
  186. +         free(page);
  187. +         pager->pages[i] = NULL;
  188. +     }
  189. +  }
  190. +
  191. +  free(pager);
  192. +  free(table);
  193. +}
  194. +
  195. MetaCommandResult do_meta_command(InputBuffer* input_buffer, Table *table) {
  196.    if (strcmp(input_buffer->buffer, ".exit") == 0) {
  197.      close_input_buffer(input_buffer);
  198. -    free_table(table);
  199. +    db_close(table);
  200.      exit(EXIT_SUCCESS);
  201.    } else {
  202.      return META_COMMAND_UNRECOGNIZED_COMMAND;
  203. @@ -182,6 +308,7 @@ PrepareResult prepare_insert(InputBuffer* input_buffer, Statement* statement) {
  204.      return PREPARE_SUCCESS;
  206. }
  207. +
  208. PrepareResult prepare_statement(InputBuffer* input_buffer,
  209.                                  Statement* statement) {
  210.    if (strncmp(input_buffer->buffer, "insert", 6) == 0) {
  211. @@ -227,7 +354,14 @@ ExecuteResult execute_statement(Statement* statement, Table *table) {
  212. }
  214. int main(int argc, char* argv[]) {
  215. -  Table* table = new_table();
  216. +  if (argc < 2) {
  217. +      printf("Must supply a database filename.\n");
  218. +      exit(EXIT_FAILURE);
  219. +  }
  220. +
  221. +  char* filename = argv[1];
  222. +  Table* table = db_open(filename);
  223. +
  224.    InputBuffer* input_buffer = new_input_buffer();
  225.    while (true) {
  226.      print_prompt();
复制代码
下面是与上一部分的测试不同的地方：
  1. describe 'database' do
  2. +  before do
  3. +    `rm -rf test.db`
  4. +  end
  5. +
  6.   def run_script(commands)
  7.     raw_output = nil
  8. -    IO.popen("./db", "r+") do |pipe|
  9. +    IO.popen("./db test.db", "r+") do |pipe|
  10.       commands.each do |command|
  11.         pipe.puts command
  12.       end
  13. @@ -28,6 +32,27 @@ describe 'database' do
  14.     ])
  15.   end
  17. +  it 'keeps data after closing connection' do
  18. +    result1 = run_script([
  19. +      "insert 1 user1 person1@example.com",
  20. +      ".exit",
  21. +    ])
  22. +    expect(result1).to match_array([
  23. +      "db > Executed.",
  24. +      "db > ",
  25. +    ])
  26. +
  27. +    result2 = run_script([
  28. +      "select",
  29. +      ".exit",
  30. +    ])
  31. +    expect(result2).to match_array([
  32. +      "db > (1, user1, person1@example.com)",
  33. +      "Executed.",
  34. +      "db > ",
  35. +    ])
  36. +  end
  37. +
  38.   it 'prints error message when table is full' do
  39.     script = (1..1401).map do |i|
  40.       "insert #{i} user#{i} person#{i}@example.com"
复制代码
Enjoy GreatSQL
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

麻花痒

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表