Part 12 - Scanning a Multi-Level B-Tree

Part 11 - Recursively Searching the B-Tree

Part 13 - Updating Parent Node After a Split

We now support constructing a multi-level btree, but we’ve broken select statements in the process. Here’s a test case that inserts 15 rows and then tries to print them.

  1. +  it 'prints all rows in a multi-level tree' do
  2. +    script = []
  3. +    (1..15).each do |i|
  4. +      script << "insert #{i} user#{i} person#{i}@example.com"
  5. +    end
  6. +    script << "select"
  7. +    script << ".exit"
  8. +    result = run_script(script)
  9. +
  10. +    expect(result[15...result.length]).to match_array([
  11. +      "db > (1, user1, person1@example.com)",
  12. +      "(2, user2, person2@example.com)",
  13. +      "(3, user3, person3@example.com)",
  14. +      "(4, user4, person4@example.com)",
  15. +      "(5, user5, person5@example.com)",
  16. +      "(6, user6, person6@example.com)",
  17. +      "(7, user7, person7@example.com)",
  18. +      "(8, user8, person8@example.com)",
  19. +      "(9, user9, person9@example.com)",
  20. +      "(10, user10, person10@example.com)",
  21. +      "(11, user11, person11@example.com)",
  22. +      "(12, user12, person12@example.com)",
  23. +      "(13, user13, person13@example.com)",
  24. +      "(14, user14, person14@example.com)",
  25. +      "(15, user15, person15@example.com)",
  26. +      "Executed.", "db > ",
  27. +    ])
  28. +  end

But when we run that test case right now, what actually happens is:

  1. db > select
  2. (2, user1, person1@example.com)
  3. Executed.

That’s weird. It’s only printing one row, and that row looks corrupted (notice the id doesn’t match the username).

The weirdness is because execute_select() begins at the start of the table, and our current implementation of table_start() returns cell 0 of the root node. But the root of our tree is now an internal node which doesn’t contain any rows. The data that was printed must have been left over from when the root node was a leaf. execute_select() should really return cell 0 of the leftmost leaf node.

So get rid of the old implementation:

  1. -Cursor* table_start(Table* table) {
  2. -  Cursor* cursor = malloc(sizeof(Cursor));
  3. -  cursor->table = table;
  4. -  cursor->page_num = table->root_page_num;
  5. -  cursor->cell_num = 0;
  6. -
  7. -  void* root_node = get_page(table->pager, table->root_page_num);
  8. -  uint32_t num_cells = *leaf_node_num_cells(root_node);
  9. -  cursor->end_of_table = (num_cells == 0);
  10. -
  11. -  return cursor;
  12. -}

And add a new implementation that searches for key 0 (the minimum possible key). Even if key 0 does not exist in the table, this method will return the position of the lowest id (the start of the left-most leaf node).

  1. +Cursor* table_start(Table* table) {
  2. +  Cursor* cursor =  table_find(table, 0);
  3. +
  4. +  void* node = get_page(table->pager, cursor->page_num);
  5. +  uint32_t num_cells = *leaf_node_num_cells(node);
  6. +  cursor->end_of_table = (num_cells == 0);
  7. +
  8. +  return cursor;
  9. +}

With those changes, it still only prints out one node’s worth of rows:

  1. db > select
  2. (1, user1, person1@example.com)
  3. (2, user2, person2@example.com)
  4. (3, user3, person3@example.com)
  5. (4, user4, person4@example.com)
  6. (5, user5, person5@example.com)
  7. (6, user6, person6@example.com)
  8. (7, user7, person7@example.com)
  9. Executed.
  10. db >

With 15 entries, our btree consists of one internal node and two leaf nodes, which looks something like this:

|structure of our btree

To scan the entire table, we need to jump to the second leaf node after we reach the end of the first. To do that, we’re going to save a new field in the leaf node header called “next_leaf”, which will hold the page number of the leaf’s sibling node on the right. The rightmost leaf node will have a next_leaf value of 0 to denote no sibling (page 0 is reserved for the root node of the table anyway).

Update the leaf node header format to include the new field:

  1.  const uint32_t LEAF_NODE_NUM_CELLS_SIZE = sizeof(uint32_t);
  2.  const uint32_t LEAF_NODE_NUM_CELLS_OFFSET = COMMON_NODE_HEADER_SIZE;
  3. -const uint32_t LEAF_NODE_HEADER_SIZE =
  4. -    COMMON_NODE_HEADER_SIZE + LEAF_NODE_NUM_CELLS_SIZE;
  5. +const uint32_t LEAF_NODE_NEXT_LEAF_SIZE = sizeof(uint32_t);
  6. +const uint32_t LEAF_NODE_NEXT_LEAF_OFFSET =
  7. +    LEAF_NODE_NUM_CELLS_OFFSET + LEAF_NODE_NUM_CELLS_SIZE;
  8. +const uint32_t LEAF_NODE_HEADER_SIZE = COMMON_NODE_HEADER_SIZE +
  9. +                                       LEAF_NODE_NUM_CELLS_SIZE +
  10. +                                       LEAF_NODE_NEXT_LEAF_SIZE;
  11.

Add a method to access the new field:

  1. +uint32_t* leaf_node_next_leaf(void* node) {
  2. +  return node + LEAF_NODE_NEXT_LEAF_OFFSET;
  3. +}

Set next_leaf to 0 by default when initializing a new leaf node:

  1. @@ -322,6 +330,7 @@ void initialize_leaf_node(void* node) {
  2.    set_node_type(node, NODE_LEAF);
  3.    set_node_root(node, false);
  4.    *leaf_node_num_cells(node) = 0;
  5. +  *leaf_node_next_leaf(node) = 0;  // 0 represents no sibling
  6.  }

Whenever we split a leaf node, update the sibling pointers. The old leaf’s sibling becomes the new leaf, and the new leaf’s sibling becomes whatever used to be the old leaf’s sibling.

  1. @@ -659,6 +671,8 @@ void leaf_node_split_and_insert(Cursor* cursor, uint32_t key, Row* value) {
  2.    uint32_t new_page_num = get_unused_page_num(cursor->table->pager);
  3.    void* new_node = get_page(cursor->table->pager, new_page_num);
  4.    initialize_leaf_node(new_node);
  5. +  *leaf_node_next_leaf(new_node) = *leaf_node_next_leaf(old_node);
  6. +  *leaf_node_next_leaf(old_node) = new_page_num;

Adding a new field changes a few constants:

  1.    it 'prints constants' do
  2.      script = [
  3.        ".constants",
  4. @@ -199,9 +228,9 @@ describe 'database' do
  5.        "db > Constants:",
  6.        "ROW_SIZE: 293",
  7.        "COMMON_NODE_HEADER_SIZE: 6",
  8. -      "LEAF_NODE_HEADER_SIZE: 10",
  9. +      "LEAF_NODE_HEADER_SIZE: 14",
  10.        "LEAF_NODE_CELL_SIZE: 297",
  11. -      "LEAF_NODE_SPACE_FOR_CELLS: 4086",
  12. +      "LEAF_NODE_SPACE_FOR_CELLS: 4082",
  13.        "LEAF_NODE_MAX_CELLS: 13",
  14.        "db > ",
  15.      ])

Now whenever we want to advance the cursor past the end of a leaf node, we can check if the leaf node has a sibling. If it does, jump to it. Otherwise, we’re at the end of the table.

  1. @@ -428,7 +432,15 @@ void cursor_advance(Cursor* cursor) {
  2.  
  3.    cursor->cell_num += 1;
  4.    if (cursor->cell_num >= (*leaf_node_num_cells(node))) {
  5. -    cursor->end_of_table = true;
  6. +    /* Advance to next leaf node */
  7. +    uint32_t next_page_num = *leaf_node_next_leaf(node);
  8. +    if (next_page_num == 0) {
  9. +      /* This was rightmost leaf */
  10. +      cursor->end_of_table = true;
  11. +    } else {
  12. +      cursor->page_num = next_page_num;
  13. +      cursor->cell_num = 0;
  14. +    }
  15.    }
  16.  }

After those changes, we actually print 15 rows…

  1. db > select
  2. (1, user1, person1@example.com)
  3. (2, user2, person2@example.com)
  4. (3, user3, person3@example.com)
  5. (4, user4, person4@example.com)
  6. (5, user5, person5@example.com)
  7. (6, user6, person6@example.com)
  8. (7, user7, person7@example.com)
  9. (8, user8, person8@example.com)
  10. (9, user9, person9@example.com)
  11. (10, user10, person10@example.com)
  12. (11, user11, person11@example.com)
  13. (12, user12, person12@example.com)
  14. (13, user13, person13@example.com)
  15. (1919251317, 14, on14@example.com)
  16. (15, user15, person15@example.com)
  17. Executed.
  18. db >

…but one of them looks corrupted

  1. (1919251317, 14, on14@example.com)

After some debugging, I found out it’s because of a bug in how we split leaf nodes:

  1. @@ -676,7 +690,9 @@ void leaf_node_split_and_insert(Cursor* cursor, uint32_t key, Row* value) {
  2.      void* destination = leaf_node_cell(destination_node, index_within_node);
  4.      if (i == cursor->cell_num) {
  5. -      serialize_row(value, destination);
  6. +      serialize_row(value,
  7. +                    leaf_node_value(destination_node, index_within_node));
  8. +      *leaf_node_key(destination_node, index_within_node) = key;
  9.      } else if (i > cursor->cell_num) {
  10.        memcpy(destination, leaf_node_cell(old_node, i - 1), LEAF_NODE_CELL_SIZE);
  11.      } else {

Remember that each cell in a leaf node consists of first a key then a value:

|Original leaf node format

We were writing the new row (value) into the start of the cell, where the key should go. That means part of the username was going into the section for id (hence the crazy large id).

After fixing that bug, we finally print out the entire table as expected:

  1. db > select
  2. (1, user1, person1@example.com)
  3. (2, user2, person2@example.com)
  4. (3, user3, person3@example.com)
  5. (4, user4, person4@example.com)
  6. (5, user5, person5@example.com)
  7. (6, user6, person6@example.com)
  8. (7, user7, person7@example.com)
  9. (8, user8, person8@example.com)
  10. (9, user9, person9@example.com)
  11. (10, user10, person10@example.com)
  12. (11, user11, person11@example.com)
  13. (12, user12, person12@example.com)
  14. (13, user13, person13@example.com)
  15. (14, user14, person14@example.com)
  16. (15, user15, person15@example.com)
  17. Executed.
  18. db >

Whew! One bug after another, but we’re making progress.

Until next time.

Part 11 - Recursively Searching the B-Tree

Part 13 - Updating Parent Node After a Split

原文: https://cstack.github.io/db_tutorial/parts/part12.html