refactor: redesign table heap (#534)

* refactor: redesign table heap

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

* fix clang-tidy

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

* fix test cases

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

* fix catalog test

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

* rm catalog test

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

---------

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

Author: skyzh

src/catalog/table_generator.cpp

@@ -76,9 +76,8 @@ void TableGenerator::FillTable(TableInfo *info, TableInsertMeta *table_meta) {
       for (const auto &col : values) {
         entry.emplace_back(col[i]);
       }
-      RID rid;
-      bool inserted = info->table_->InsertTuple(Tuple(entry, &info->schema_), &rid, exec_ctx_->GetTransaction());
-      BUSTUB_ENSURE(inserted, "Sequential insertion cannot fail");
+      auto rid = info->table_->InsertTuple(TupleMeta{0, 0, false}, Tuple(entry, &info->schema_));
+      BUSTUB_ENSURE(rid != std::nullopt, "Sequential insertion cannot fail");
       num_inserted++;
     }
   }

src/concurrency/transaction_manager.cpp

@@ -18,6 +18,7 @@
 #include <unordered_set>
 
 #include "catalog/catalog.h"
+#include "common/macros.h"
 #include "storage/table/table_heap.h"
 namespace bustub {
 
@@ -49,12 +50,12 @@ void TransactionManager::Commit(Transaction *txn) {
   // Perform all deletes before we commit.
   auto write_set = txn->GetWriteSet();
   while (!write_set->empty()) {
-    auto &item = write_set->back();
-    auto *table = item.table_;
-    if (item.wtype_ == WType::DELETE) {
-      // Note that this also releases the lock when holding the page latch.
-      table->ApplyDelete(item.rid_, txn);
-    }
+    // auto &item = write_set->back();
+    // auto *table = item.table_;
+    // if (item.wtype_ == WType::DELETE) {
+    //   // Note that this also releases the lock when holding the page latch.
+    //   table->ApplyDelete(item.rid_, txn);
+    // }
     write_set->pop_back();
   }
   write_set->clear();
@@ -70,16 +71,16 @@ void TransactionManager::Abort(Transaction *txn) {
   // Rollback before releasing the lock.
   auto table_write_set = txn->GetWriteSet();
   while (!table_write_set->empty()) {
-    auto &item = table_write_set->back();
-    auto *table = item.table_;
-    if (item.wtype_ == WType::DELETE) {
-      table->RollbackDelete(item.rid_, txn);
-    } else if (item.wtype_ == WType::INSERT) {
-      // Note that this also releases the lock when holding the page latch.
-      table->ApplyDelete(item.rid_, txn);
-    } else if (item.wtype_ == WType::UPDATE) {
-      table->UpdateTuple(item.tuple_, item.rid_, txn);
-    }
+    // auto &item = table_write_set->back();
+    // auto *table = item.table_;
+    // if (item.wtype_ == WType::DELETE) {
+    //   table->RollbackDelete(item.rid_, txn);
+    // } else if (item.wtype_ == WType::INSERT) {
+    //   // Note that this also releases the lock when holding the page latch.
+    //   table->ApplyDelete(item.rid_, txn);
+    // } else if (item.wtype_ == WType::UPDATE) {
+    //   table->UpdateTuple(item.tuple_, item.rid_, txn);
+    // }
     table_write_set->pop_back();
   }
   table_write_set->clear();

src/include/catalog/catalog.h

@@ -136,7 +136,7 @@ class Catalog {
     // When create_table_heap == false, it means that we're running binder tests (where no txn will be provided) or
     // we are running shell without buffer pool. We don't need to create TableHeap in this case.
     if (create_table_heap) {
-      table = std::make_unique<TableHeap>(bpm_, lock_manager_, log_manager_, txn);
+      table = std::make_unique<TableHeap>(bpm_);
     }
 
     // Fetch the table OID for the new table
@@ -230,9 +230,9 @@ class Catalog {
 
     // Populate the index with all tuples in table heap
     auto *table_meta = GetTable(table_name);
-    auto *heap = table_meta->table_.get();
-    for (auto tuple = heap->Begin(txn); tuple != heap->End(); ++tuple) {
-      index->InsertEntry(tuple->KeyFromTuple(schema, key_schema, key_attrs), tuple->GetRid(), txn);
+    for (auto iter = table_meta->table_->MakeIterator(); !iter.IsEnd(); ++iter) {
+      auto [meta, tuple] = iter.GetTuple();
+      index->InsertEntry(tuple.KeyFromTuple(schema, key_schema, key_attrs), tuple.GetRid(), txn);
     }
 
     // Get the next OID for the new index

src/include/concurrency/transaction.h

@@ -64,6 +64,7 @@ using index_oid_t = uint32_t;
  */
 class TableWriteRecord {
  public:
+  // NOLINTNEXTLINE
   TableWriteRecord(RID rid, WType wtype, const Tuple &tuple, TableHeap *table)
       : rid_(rid), wtype_(wtype), tuple_(tuple), table_(table) {}
 
@@ -80,6 +81,7 @@ class TableWriteRecord {
  */
 class IndexWriteRecord {
  public:
+  // NOLINTNEXTLINE
   IndexWriteRecord(RID rid, table_oid_t table_oid, WType wtype, const Tuple &tuple, index_oid_t index_oid,
                    Catalog *catalog)
       : rid_(rid), table_oid_(table_oid), wtype_(wtype), tuple_(tuple), index_oid_(index_oid), catalog_(catalog) {}

src/include/storage/page/table_page.h

@@ -13,17 +13,22 @@
 #pragma once
 
 #include <cstring>
+#include <optional>
+#include <tuple>
+#include <utility>
 
+#include "common/config.h"
 #include "common/rid.h"
 #include "concurrency/lock_manager.h"
 #include "recovery/log_manager.h"
 #include "storage/page/page.h"
+#include "storage/table/table_heap.h"
 #include "storage/table/tuple.h"
 
-static constexpr uint64_t DELETE_MASK = (1U << (8 * sizeof(uint32_t) - 1));
-
 namespace bustub {
 
+static constexpr uint64_t TABLE_PAGE_HEADER_SIZE = 8;
+
 /**
  * Slotted page format:
  *  ---------------------------------------------------------
@@ -34,176 +39,66 @@ namespace bustub {
  *
  *  Header format (size in bytes):
  *  ----------------------------------------------------------------------------
- *  | PageId (4)| LSN (4)| PrevPageId (4)| NextPageId (4)| FreeSpacePointer(4) |
+ *  | NextPageId (4)| NumTuples(2) | NumDeletedTuples(2) |
  *  ----------------------------------------------------------------------------
  *  ----------------------------------------------------------------
- *  | TupleCount (4) | Tuple_1 offset (4) | Tuple_1 size (4) | ... |
+ *  | Tuple_1 offset+size (4) | Tuple_2 offset+size (4) | ... |
  *  ----------------------------------------------------------------
  *
+ * Tuple format:
+ * | meta | data |
  */
-class TablePage : public Page {
+
+class TablePage {
  public:
   /**
    * Initialize the TablePage header.
-   * @param page_id the page ID of this table page
-   * @param page_size the size of this table page
-   * @param prev_page_id the previous table page ID
-   * @param log_manager the log manager in use
-   * @param txn the transaction that this page is created in
    */
-  void Init(page_id_t page_id, uint32_t page_size, page_id_t prev_page_id, LogManager *log_manager, Transaction *txn);
-
-  /** @return the page ID of this table page */
-  auto GetTablePageId() -> page_id_t { return *reinterpret_cast<page_id_t *>(GetData()); }
+  void Init();
 
-  /** @return the page ID of the previous table page */
-  auto GetPrevPageId() -> page_id_t { return *reinterpret_cast<page_id_t *>(GetData() + OFFSET_PREV_PAGE_ID); }
+  /** @return number of tuples in this page */
+  auto GetNumTuples() const -> uint32_t { return num_tuples_; }
 
   /** @return the page ID of the next table page */
-  auto GetNextPageId() -> page_id_t { return *reinterpret_cast<page_id_t *>(GetData() + OFFSET_NEXT_PAGE_ID); }
-
-  /** Set the page id of the previous page in the table. */
-  void SetPrevPageId(page_id_t prev_page_id) {
-    memcpy(GetData() + OFFSET_PREV_PAGE_ID, &prev_page_id, sizeof(page_id_t));
-  }
+  auto GetNextPageId() const -> page_id_t { return next_page_id_; }
 
   /** Set the page id of the next page in the table. */
-  void SetNextPageId(page_id_t next_page_id) {
-    memcpy(GetData() + OFFSET_NEXT_PAGE_ID, &next_page_id, sizeof(page_id_t));
-  }
+  void SetNextPageId(page_id_t next_page_id) { next_page_id_ = next_page_id; }
+
+  /** Get the next offset to insert, return nullopt if this tuple cannot fit in this page */
+  auto GetNextTupleOffset(const TupleMeta &meta, const Tuple &tuple) const -> std::optional<uint16_t>;
 
   /**
    * Insert a tuple into the table.
    * @param tuple tuple to insert
-   * @param[out] rid rid of the inserted tuple
-   * @param txn transaction performing the insert
-   * @param lock_manager the lock manager
-   * @param log_manager the log manager
    * @return true if the insert is successful (i.e. there is enough space)
    */
-  auto InsertTuple(const Tuple &tuple, RID *rid, Transaction *txn, LockManager *lock_manager, LogManager *log_manager)
-      -> bool;
-
-  /**
-   * Mark a tuple as deleted. This does not actually delete the tuple.
-   * @param rid rid of the tuple to mark as deleted
-   * @param txn transaction performing the delete
-   * @param lock_manager the lock manager
-   * @param log_manager the log manager
-   * @return true if marking the tuple as deleted is successful (i.e the tuple exists)
-   */
-  auto MarkDelete(const RID &rid, Transaction *txn, LockManager *lock_manager, LogManager *log_manager) -> bool;
+  auto InsertTuple(const TupleMeta &meta, const Tuple &tuple) -> std::optional<uint16_t>;
 
   /**
    * Update a tuple.
-   * @param new_tuple new value of the tuple
-   * @param[out] old_tuple old value of the tuple
-   * @param rid rid of the tuple
-   * @param txn transaction performing the update
-   * @param lock_manager the lock manager
-   * @param log_manager the log manager
-   * @return true if updating the tuple succeeded
    */
-  auto UpdateTuple(const Tuple &new_tuple, Tuple *old_tuple, const RID &rid, Transaction *txn,
-                   LockManager *lock_manager, LogManager *log_manager) -> bool;
-
-  /** To be called on commit or abort. Actually perform the delete or rollback an insert. */
-  void ApplyDelete(const RID &rid, Transaction *txn, LogManager *log_manager);
-
-  /** To be called on abort. Rollback a delete, i.e. this reverses a MarkDelete. */
-  void RollbackDelete(const RID &rid, Transaction *txn, LogManager *log_manager);
+  void UpdateTupleMeta(const TupleMeta &meta, const RID &rid);
 
   /**
    * Read a tuple from a table.
-   * @param rid rid of the tuple to read
-   * @param[out] tuple the tuple that was read
-   * @param txn transaction performing the read
-   * @param lock_manager the lock manager
-   * @return true if the read is successful (i.e. the tuple exists)
    */
-  auto GetTuple(const RID &rid, Tuple *tuple, Transaction *txn, LockManager *lock_manager) -> bool;
-
-  /** @return the rid of the first tuple in this page */
+  auto GetTuple(const RID &rid) const -> std::pair<TupleMeta, Tuple>;
 
-  /**
-   * @param[out] first_rid the RID of the first tuple in this page
-   * @return true if the first tuple exists, false otherwise
-   */
-  auto GetFirstTupleRid(RID *first_rid) -> bool;
-
-  /**
-   * @param cur_rid the RID of the current tuple
-   * @param[out] next_rid the RID of the tuple following the current tuple
-   * @return true if the next tuple exists, false otherwise
-   */
-  auto GetNextTupleRid(const RID &cur_rid, RID *next_rid) -> bool;
-
- private:
   static_assert(sizeof(page_id_t) == 4);
 
-  static constexpr size_t SIZE_TABLE_PAGE_HEADER = 24;
-  static constexpr size_t SIZE_TUPLE = 8;
-  static constexpr size_t OFFSET_PREV_PAGE_ID = 8;
-  static constexpr size_t OFFSET_NEXT_PAGE_ID = 12;
-  static constexpr size_t OFFSET_FREE_SPACE = 16;
-  static constexpr size_t OFFSET_TUPLE_COUNT = 20;
-  static constexpr size_t OFFSET_TUPLE_OFFSET = 24;  // Naming things is hard.
-  static constexpr size_t OFFSET_TUPLE_SIZE = 28;
-
-  /** @return pointer to the end of the current free space, see header comment */
-  auto GetFreeSpacePointer() -> uint32_t { return *reinterpret_cast<uint32_t *>(GetData() + OFFSET_FREE_SPACE); }
+ private:
+  using TupleInfo = std::tuple<uint16_t, uint16_t, TupleMeta>;
+  char page_start_[0];
+  page_id_t next_page_id_;
+  uint16_t num_tuples_;
+  uint16_t num_deleted_tuples_;
+  TupleInfo tuple_info_[0];
+
+  static constexpr size_t TUPLE_INFO_SIZE = 16;
+  static_assert(sizeof(TupleInfo) == TUPLE_INFO_SIZE);
+};
 
-  /** Sets the pointer, this should be the end of the current free space. */
-  void SetFreeSpacePointer(uint32_t free_space_pointer) {
-    memcpy(GetData() + OFFSET_FREE_SPACE, &free_space_pointer, sizeof(uint32_t));
-  }
+static_assert(sizeof(TablePage) == TABLE_PAGE_HEADER_SIZE);
 
-  /**
-   * @note returned tuple count may be an overestimate because some slots may be empty
-   * @return at least the number of tuples in this page
-   */
-  auto GetTupleCount() -> uint32_t { return *reinterpret_cast<uint32_t *>(GetData() + OFFSET_TUPLE_COUNT); }
-
-  /** Set the number of tuples in this page. */
-  void SetTupleCount(uint32_t tuple_count) { memcpy(GetData() + OFFSET_TUPLE_COUNT, &tuple_count, sizeof(uint32_t)); }
-
-  auto GetFreeSpaceRemaining() -> uint32_t {
-    return GetFreeSpacePointer() - SIZE_TABLE_PAGE_HEADER - SIZE_TUPLE * GetTupleCount();
-  }
-
-  /** @return tuple offset at slot slot_num */
-  auto GetTupleOffsetAtSlot(uint32_t slot_num) -> uint32_t {
-    return *reinterpret_cast<uint32_t *>(GetData() + OFFSET_TUPLE_OFFSET + SIZE_TUPLE * slot_num);
-  }
-
-  /** Set tuple offset at slot slot_num. */
-  void SetTupleOffsetAtSlot(uint32_t slot_num, uint32_t offset) {
-    memcpy(GetData() + OFFSET_TUPLE_OFFSET + SIZE_TUPLE * slot_num, &offset, sizeof(uint32_t));
-  }
-
-  /** @return tuple size at slot slot_num */
-  auto GetTupleSize(uint32_t slot_num) -> uint32_t {
-    return *reinterpret_cast<uint32_t *>(GetData() + OFFSET_TUPLE_SIZE + SIZE_TUPLE * slot_num);
-  }
-
-  /** Set tuple size at slot slot_num. */
-  void SetTupleSize(uint32_t slot_num, uint32_t size) {
-    memcpy(GetData() + OFFSET_TUPLE_SIZE + SIZE_TUPLE * slot_num, &size, sizeof(uint32_t));
-  }
-
-  /** @return true if the tuple is deleted or empty */
-  static auto IsDeleted(uint32_t tuple_size) -> bool {
-    return static_cast<bool>(tuple_size & DELETE_MASK) || tuple_size == 0;
-  }
-
-  /** @return tuple size with the deleted flag set */
-  static auto SetDeletedFlag(uint32_t tuple_size) -> uint32_t {
-    return static_cast<uint32_t>(tuple_size | DELETE_MASK);
-  }
-
-  /** @return tuple size with the deleted flag unset */
-  static auto UnsetDeletedFlag(uint32_t tuple_size) -> uint32_t {
-    return static_cast<uint32_t>(tuple_size & (~DELETE_MASK));
-  }
-};
 }  // namespace bustub