chore: rename root page -> header page (#508)

* chore: rename root page -> header page

Signed-off-by: Alex Chi <[email protected]>

* fix build

Signed-off-by: Alex Chi <[email protected]>

* newline

Signed-off-by: Alex Chi <[email protected]>

---------

Signed-off-by: Alex Chi <[email protected]>

Author: skyzh

src/include/storage/index/b_plus_tree.h

@@ -31,9 +31,9 @@
 #include "common/macros.h"
 #include "concurrency/transaction.h"
 #include "storage/index/index_iterator.h"
+#include "storage/page/b_plus_tree_header_page.h"
 #include "storage/page/b_plus_tree_internal_page.h"
 #include "storage/page/b_plus_tree_leaf_page.h"
-#include "storage/page/b_plus_tree_root_page.h"
 #include "storage/page/page_guard.h"
 
 namespace bustub {
@@ -46,9 +46,17 @@ namespace bustub {
  */
 class Context {
  public:
+  // When you insert into / remove from the B+ tree, store the write guard of header page here.
+  // Remember to drop the header page guard and set it to nullopt when you want to unlock all.
   std::optional<WritePageGuard> header_page_{std::nullopt};
+
+  // Save the root page id here so that it's easier to know if the current page is the root page.
   page_id_t root_page_id_{INVALID_PAGE_ID};
+
+  // Store the write guards of the pages that you're modifying here.
   std::deque<WritePageGuard> write_set_;
+
+  // You may want to use this when getting value, but not necessary.
   std::deque<ReadPageGuard> read_set_;
 
   auto IsRootPage(page_id_t page_id) -> bool { return page_id == root_page_id_; }

src/include/storage/page/b_plus_tree_root_page.h renamed to src/include/storage/page/b_plus_tree_header_page.h

@@ -1,13 +1,14 @@
 #pragma once
 
 #include "common/config.h"
+
 namespace bustub {
 
-class BPlusTreeRootPage {
+class BPlusTreeHeaderPage {
  public:
   // Delete all constructor / destructor to ensure memory safety
-  BPlusTreeRootPage() = delete;
-  BPlusTreeRootPage(const BPlusTreeRootPage &other) = delete;
+  BPlusTreeHeaderPage() = delete;
+  BPlusTreeHeaderPage(const BPlusTreeHeaderPage &other) = delete;
 
   page_id_t root_page_id_;
 };

src/include/storage/page/b_plus_tree_internal_page.h

@@ -35,15 +35,45 @@ namespace bustub {
 INDEX_TEMPLATE_ARGUMENTS
 class BPlusTreeInternalPage : public BPlusTreePage {
  public:
-  // must call initialize method after "create" a new node
-  void Init(page_id_t page_id, page_id_t parent_id = INVALID_PAGE_ID, int max_size = INTERNAL_PAGE_SIZE);
+  // Deleted to disallow initialization
+  BPlusTreeInternalPage() = delete;
+  BPlusTreeInternalPage(const BPlusTreeInternalPage &other) = delete;
 
+  /**
+   * Writes the necessary header information to a newly created page, must be called after
+   * the creation of a new page to make a valid BPlusTreeInternalPage
+   * @param max_size Maximal size of the page
+   */
+  void Init(int max_size = INTERNAL_PAGE_SIZE);
+
+  /**
+   * @param index The index of the key to get. Index must be non-zero.
+   * @return Key at index
+   */
   auto KeyAt(int index) const -> KeyType;
+
+  /**
+   *
+   * @param index The index of the key to set. Index must be non-zero.
+   * @param key The new value for key
+   */
   void SetKeyAt(int index, const KeyType &key);
+
+  /**
+   *
+   * @param value the value to search for
+   */
+  auto ValueIndex(const ValueType &value) const -> int;
+
+  /**
+   *
+   * @param index the index
+   * @return the value at the index
+   */
   auto ValueAt(int index) const -> ValueType;
 
  private:
   // Flexible array member for page data.
-  MappingType array_[1];
+  MappingType array_[0];
 };
 }  // namespace bustub

src/include/storage/page/b_plus_tree_leaf_page.h

@@ -42,9 +42,17 @@ namespace bustub {
 INDEX_TEMPLATE_ARGUMENTS
 class BPlusTreeLeafPage : public BPlusTreePage {
  public:
-  // After creating a new leaf page from buffer pool, must call initialize
-  // method to set default values
-  void Init(page_id_t page_id, page_id_t parent_id = INVALID_PAGE_ID, int max_size = LEAF_PAGE_SIZE);
+  // Delete all constructor / destructor to ensure memory safety
+  BPlusTreeLeafPage() = delete;
+  BPlusTreeLeafPage(const BPlusTreeLeafPage &other) = delete;
+
+  /**
+   * After creating a new leaf page from buffer pool, must call initialize
+   * method to set default values
+   * @param max_size Max size of the leaf node
+   */
+  void Init(int max_size = LEAF_PAGE_SIZE);
+
   // helper methods
   auto GetNextPageId() const -> page_id_t;
   void SetNextPageId(page_id_t next_page_id);
@@ -53,6 +61,6 @@ class BPlusTreeLeafPage : public BPlusTreePage {
  private:
   page_id_t next_page_id_;
   // Flexible array member for page data.
-  MappingType array_[1];
+  MappingType array_[0];
 };
 }  // namespace bustub

src/include/storage/page/b_plus_tree_page.h

@@ -33,17 +33,19 @@ enum class IndexPageType { INVALID_INDEX_PAGE = 0, LEAF_PAGE, INTERNAL_PAGE };
  * It actually serves as a header part for each B+ tree page and
  * contains information shared by both leaf page and internal page.
  *
- * Header format (size in byte, 24 bytes in total):
+ * Header format (size in byte, 12 bytes in total):
  * ----------------------------------------------------------------------------
- * | PageType (4) | LSN (4) | CurrentSize (4) | MaxSize (4) |
- * ----------------------------------------------------------------------------
- * | ParentPageId (4) | PageId(4) |
+ * | PageType (4) | CurrentSize (4) | MaxSize (4) |
  * ----------------------------------------------------------------------------
  */
 class BPlusTreePage {
  public:
+  // Delete all constructor / destructor to ensure memory safety
+  BPlusTreePage() = delete;
+  BPlusTreePage(const BPlusTreePage &other) = delete;
+  ~BPlusTreePage() = delete;
+
   auto IsLeafPage() const -> bool;
-  auto IsRootPage() const -> bool;
   void SetPageType(IndexPageType page_type);
 
   auto GetSize() const -> int;
@@ -60,16 +62,11 @@ class BPlusTreePage {
   auto GetPageId() const -> page_id_t;
   void SetPageId(page_id_t page_id);
 
-  void SetLSN(lsn_t lsn = INVALID_LSN);
-
  private:
   // member variable, attributes that both internal and leaf page share
   IndexPageType page_type_ __attribute__((__unused__));
-  lsn_t lsn_ __attribute__((__unused__));
   int size_ __attribute__((__unused__));
   int max_size_ __attribute__((__unused__));
-  page_id_t parent_page_id_ __attribute__((__unused__));
-  page_id_t page_id_ __attribute__((__unused__));
 };
 
 }  // namespace bustub

src/storage/index/b_plus_tree.cpp

@@ -4,7 +4,6 @@
 #include "common/logger.h"
 #include "common/rid.h"
 #include "storage/index/b_plus_tree.h"
-#include "storage/page/header_page.h"
 
 namespace bustub {
 
@@ -16,7 +15,11 @@ BPLUSTREE_TYPE::BPlusTree(std::string name, page_id_t header_page_id, BufferPool
       comparator_(std::move(comparator)),
       leaf_max_size_(leaf_max_size),
       internal_max_size_(internal_max_size),
-      header_page_id_(header_page_id) {}
+      header_page_id_(header_page_id) {
+  WritePageGuard guard = bpm_->FetchPageWrite(header_page_id_);
+  auto root_page = guard.AsMut<BPlusTreeHeaderPage>();
+  root_page->root_page_id_ = INVALID_PAGE_ID;
+}
 
 /*
  * Helper function to decide whether current b+tree is empty

src/storage/page/b_plus_tree_internal_page.cpp

@@ -25,7 +25,7 @@ namespace bustub {
  * max page size
  */
 INDEX_TEMPLATE_ARGUMENTS
-void B_PLUS_TREE_INTERNAL_PAGE_TYPE::Init(page_id_t page_id, page_id_t parent_id, int max_size) {}
+void B_PLUS_TREE_INTERNAL_PAGE_TYPE::Init(int max_size) {}
 /*
  * Helper method to get/set the key associated with input "index"(a.k.a
  * array offset)

src/storage/page/b_plus_tree_leaf_page.cpp

@@ -27,7 +27,7 @@ namespace bustub {
  * next page id and set max size
  */
 INDEX_TEMPLATE_ARGUMENTS
-void B_PLUS_TREE_LEAF_PAGE_TYPE::Init(page_id_t page_id, page_id_t parent_id, int max_size) {}
+void B_PLUS_TREE_LEAF_PAGE_TYPE::Init(int max_size) {}
 
 /**
  * Helper methods to set/get next page id

src/storage/page/b_plus_tree_page.cpp

@@ -18,7 +18,6 @@ namespace bustub {
  * Page type enum class is defined in b_plus_tree_page.h
  */
 auto BPlusTreePage::IsLeafPage() const -> bool { return false; }
-auto BPlusTreePage::IsRootPage() const -> bool { return false; }
 void BPlusTreePage::SetPageType(IndexPageType page_type) {}
 
 /*
@@ -53,9 +52,4 @@ void BPlusTreePage::SetParentPageId(page_id_t parent_page_id) {}
 auto BPlusTreePage::GetPageId() const -> page_id_t { return 0; }
 void BPlusTreePage::SetPageId(page_id_t page_id) {}
 
-/*
- * Helper methods to set lsn
- */
-void BPlusTreePage::SetLSN(lsn_t lsn) { lsn_ = lsn; }
-
 }  // namespace bustub