feat: implement extendible htable bucket page helpers (#612)

Signed-off-by: Yuchen Liang <[email protected]>

Author: yliang412

src/include/storage/page/extendible_htable_bucket_page.h

@@ -23,6 +23,7 @@
  */
 #pragma once
 
+#include <optional>
 #include <utility>
 #include <vector>
 
@@ -55,25 +56,33 @@ class ExtendibleHTableBucketPage {
    * method to set default values
    * @param max_size Max size of the bucket array
    */
-  void Init(int max_size = HTableBucketArraySize(sizeof(MappingType)));
+  void Init(uint32_t max_size = HTableBucketArraySize(sizeof(MappingType)));
 
+  /**
+   * Lookup a key
+   *
+   * @param key key to lookup
+   * @param[out] value value to set
+   * @param cmp the comparator
+   * @return true if the key and value are present, false if not found.
+   */
   auto Lookup(const KeyType &key, ValueType &value, const KeyComparator &cmp) const -> bool;
 
   /**
    * Attempts to insert a key and value in the bucket.
    *
    * @param key key to insert
    * @param value value to insert
-   * @return true if inserted, false if duplicate KV pair or bucket is full
+   * @return true if inserted, false if bucket is full or the same key is already present
    */
-  auto Insert(KeyType key, ValueType value, const KeyComparator &cmp) -> bool;
+  auto Insert(const KeyType &key, const ValueType &value, const KeyComparator &cmp) -> bool;
 
   /**
    * Removes a key and value.
    *
    * @return true if removed, false if not found
    */
-  auto Remove(KeyType key, ValueType value, const KeyComparator &cmp) -> bool;
+  auto Remove(const KeyType &key, const KeyComparator &cmp) -> bool;
 
   /**
    * Gets the key at an index in the bucket.
@@ -91,11 +100,6 @@ class ExtendibleHTableBucketPage {
    */
   auto ValueAt(uint32_t bucket_idx) const -> ValueType;
 
-  /**
-   * Remove the KV pair at bucket_idx
-   */
-  void RemoveAt(uint32_t bucket_idx);
-
   /**
    * @return whether the bucket is full
    */

src/storage/page/extendible_htable_bucket_page.cpp

@@ -0,0 +1,76 @@
+//===----------------------------------------------------------------------===//
+//
+//                         BusTub
+//
+// extendible_htable_bucket_page.cpp
+//
+// Identification: src/storage/page/extendible_htable_bucket_page.cpp
+//
+// Copyright (c) 2015-2023, Carnegie Mellon University Database Group
+//
+//===----------------------------------------------------------------------===//
+
+#include "storage/page/extendible_htable_bucket_page.h"
+#include <optional>
+
+namespace bustub {
+
+template <typename KeyType, typename ValueType, typename KeyComparator>
+void ExtendibleHTableBucketPage<KeyType, ValueType, KeyComparator>::Init(uint32_t max_size) {
+  throw NotImplementedException("ExtendibleHTableBucketPage is not implemented");
+}
+
+template <typename KeyType, typename ValueType, typename KeyComparator>
+auto ExtendibleHTableBucketPage<KeyType, ValueType, KeyComparator>::Lookup(const KeyType &key, ValueType &value,
+                                                                           const KeyComparator &cmp) const -> bool {
+  return false;
+}
+
+template <typename KeyType, typename ValueType, typename KeyComparator>
+auto ExtendibleHTableBucketPage<KeyType, ValueType, KeyComparator>::Insert(const KeyType &key, const ValueType &value,
+                                                                           const KeyComparator &cmp) -> bool {
+  return false;
+}
+
+template <typename KeyType, typename ValueType, typename KeyComparator>
+auto ExtendibleHTableBucketPage<KeyType, ValueType, KeyComparator>::Remove(const KeyType &key, const KeyComparator &cmp)
+    -> bool {
+  return false;
+}
+
+template <typename KeyType, typename ValueType, typename KeyComparator>
+auto ExtendibleHTableBucketPage<KeyType, ValueType, KeyComparator>::KeyAt(uint32_t bucket_idx) const -> KeyType {
+  return {};
+}
+
+template <typename KeyType, typename ValueType, typename KeyComparator>
+auto ExtendibleHTableBucketPage<KeyType, ValueType, KeyComparator>::ValueAt(uint32_t bucket_idx) const -> ValueType {
+  return {};
+}
+
+template <typename KeyType, typename ValueType, typename KeyComparator>
+auto ExtendibleHTableBucketPage<KeyType, ValueType, KeyComparator>::IsFull() -> bool {
+  return false;
+}
+
+template <typename KeyType, typename ValueType, typename KeyComparator>
+auto ExtendibleHTableBucketPage<KeyType, ValueType, KeyComparator>::IsEmpty() -> bool {
+  return false;
+}
+
+template <typename KeyType, typename ValueType, typename KeyComparator>
+void ExtendibleHTableBucketPage<KeyType, ValueType, KeyComparator>::PrintBucket() {
+  throw NotImplementedException("PrintBucket is not implemented");
+}
+
+template class ExtendibleHTableBucketPage<GenericKey<4>, RID, GenericComparator<4>>;
+
+template class ExtendibleHTableBucketPage<GenericKey<8>, RID, GenericComparator<8>>;
+
+template class ExtendibleHTableBucketPage<GenericKey<16>, RID, GenericComparator<16>>;
+
+template class ExtendibleHTableBucketPage<GenericKey<32>, RID, GenericComparator<32>>;
+
+template class ExtendibleHTableBucketPage<GenericKey<64>, RID, GenericComparator<64>>;
+
+}  // namespace bustub

test/storage/extendible_htable_bucket_page_test.cpp

@@ -0,0 +1,87 @@
+//===----------------------------------------------------------------------===//
+//
+//                         BusTub
+//
+// extendible_htable_bucket_page_test.cpp
+//
+// Identification: test/storage/extendible_htable_bucket_page_test.cpp
+//
+// Copyright (c) 2015-2023, Carnegie Mellon University Database Group
+//
+//===----------------------------------------------------------------------===//
+
+#include <memory>
+#include <thread>  // NOLINT
+#include <vector>
+
+#include "buffer/buffer_pool_manager.h"
+#include "common/logger.h"
+#include "gtest/gtest.h"
+#include "storage/disk/disk_manager_memory.h"
+#include "storage/index/generic_key.h"
+#include "storage/index/int_comparator.h"
+#include "storage/page/extendible_htable_bucket_page.h"
+#include "storage/page/page_guard.h"
+#include "test_util.h"  // NOLINT
+
+namespace bustub {
+
+// NOLINTNEXTLINE
+TEST(ExtendibleHTableTest, DISABLED_BucketPageSampleTest) {
+  auto disk_mgr = std::make_unique<DiskManagerUnlimitedMemory>();
+  auto bpm = std::make_unique<BufferPoolManager>(5, disk_mgr.get());
+
+  page_id_t bucket_page_id = INVALID_PAGE_ID;
+  {
+    BasicPageGuard guard = bpm->NewPageGuarded(&bucket_page_id);
+    auto bucket_page = guard.AsMut<ExtendibleHTableBucketPage<GenericKey<8>, RID, GenericComparator<8>>>();
+    bucket_page->Init(10);
+
+    auto key_schema = ParseCreateStatement("a bigint");
+    GenericComparator<8> comparator(key_schema.get());
+    GenericKey<8> index_key;
+    RID rid;
+
+    // insert a few (key, value) pairs
+    for (int64_t i = 0; i < 10; i++) {
+      index_key.SetFromInteger(i);
+      rid.Set(i, i);
+      ASSERT_TRUE(bucket_page->Insert(index_key, rid, comparator));
+    }
+
+    index_key.SetFromInteger(11);
+    rid.Set(11, 11);
+    ASSERT_TRUE(bucket_page->IsFull());
+    ASSERT_FALSE(bucket_page->Insert(index_key, rid, comparator));
+
+    // check for the inserted pairs
+    for (unsigned i = 0; i < 10; i++) {
+      index_key.SetFromInteger(i);
+      ASSERT_TRUE(bucket_page->Lookup(index_key, rid, comparator));
+      ASSERT_EQ(rid, RID(i, i));
+    }
+
+    // remove a few pairs
+    for (unsigned i = 0; i < 10; i++) {
+      if (i % 2 == 1) {
+        index_key.SetFromInteger(i);
+        ASSERT_TRUE(bucket_page->Remove(index_key, comparator));
+      }
+    }
+
+    for (unsigned i = 0; i < 10; i++) {
+      if (i % 2 == 1) {
+        // remove the same pairs again
+        index_key.SetFromInteger(i);
+        ASSERT_FALSE(bucket_page->Remove(index_key, comparator));
+      } else {
+        index_key.SetFromInteger(i);
+        ASSERT_TRUE(bucket_page->Remove(index_key, comparator));
+      }
+    }
+
+    ASSERT_TRUE(bucket_page->IsEmpty());
+  }  // page guard dropped
+}
+
+}  // namespace bustub