feat: implement block_builder

Author: Aetherance

src/table/block_build.cc

@@ -0,0 +1,76 @@
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+
+#include "options.h"
+#include "slice.h"
+#include "table/block_builder.h"
+#include "util/coding.h"
+namespace db {
+
+BlockBuilder::BlockBuilder(const Options* options)
+    : options_(options), restarts_(), counter_(0), finished_(false) {
+  assert(options->block_restart_interval >= 1);
+  restarts_.push_back(0);
+}
+
+void BlockBuilder::Reset() {
+  buffer_.clear();
+  restarts_.clear();
+  restarts_.push_back(0);
+  counter_ = 0;
+  finished_ = false;
+  last_key_.clear();
+}
+
+// Return the size of the current block if we finish it immediately without compression.
+size_t BlockBuilder::CurrentSizeEstimate() const {
+  return (buffer_.size() + restarts_.size() * sizeof(uint32_t) + sizeof(uint32_t));
+}
+
+Slice BlockBuilder::Finish() {
+  for (size_t i = 0; i < restarts_.size(); i++) {
+    PutFixed32(&buffer_, restarts_[i]);
+  }
+  PutFixed32(&buffer_, restarts_.size());
+  finished_ = true;
+  return Slice(buffer_);
+}
+
+void BlockBuilder::Add(const Slice& key, const Slice& val) {
+  Slice last_key_piece(last_key_);
+  assert(!finished_);
+  assert(counter_ <= options_->block_restart_interval);
+  // ensure Sorted semantic for string table
+  assert(buffer_.empty() || options_->comparator->Compare(key, last_key_piece) > 0);
+  size_t shared = 0;
+  // get max shared prefix
+  if (counter_ < options_->block_restart_interval) {
+    const size_t min_lenghth = std::min(last_key_piece.Size(), key.Size());
+    while ((shared < min_lenghth) && (last_key_piece[shared] == key[shared])) {
+      shared++;
+    }
+  } else {
+    // case up to block's restart interval, set restarts and reset the counter
+    restarts_.push_back(buffer_.size());
+    counter_ = 0;
+  }
+  const size_t non_shared = key.Size() - shared;
+
+  // metadata
+  PutVarint32(&buffer_, shared);
+  PutVarint32(&buffer_, non_shared);
+  PutVarint32(&buffer_, val.Size());
+
+  // true data
+  buffer_.append(key.Data() + shared, non_shared);
+  buffer_.append(val.Data(), val.Size());
+
+  // reset last_key
+  last_key_.resize(shared);
+  last_key_.append(key.Data() + shared, non_shared);
+  assert(Slice(last_key_) == key);
+  counter_++;
+}
+
+}  // namespace db

src/table/block_builder.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+#include "slice.h"
+
+namespace db {
+
+struct Options;
+
+// * Block Format
+//	[Data-Entry-A]
+//	[Data-Entry-B]
+//	[Data-Entry-C]
+//	[RestartArray]
+//	[Restart-Size]
+class BlockBuilder {
+public:
+  explicit BlockBuilder(const Options* options);
+
+  BlockBuilder(const BlockBuilder&) = delete;
+  BlockBuilder& operator=(const BlockBuilder&) = delete;
+
+  // Reset all data as if the BlockBuilder was just constructed.
+  void Reset();
+
+  // NOTICE: DO NOT call Add() after Finish() called
+  // REQUIRES: key is larger than
+  void Add(const Slice& key, const Slice& value);
+
+  // Finish building the block and returns a slice that refers to the
+  // block contents. The returned slice will remain valid until Reset()
+  // is called or the BlockBuilder deconstructed.
+  //
+  // Add() should not called if Finish() has been called. It is because Finish()
+  // will append [restart array][restart count] at the end of the block.
+  // If Add() called after Finish(), the Block's format will be wrong.
+  Slice Finish();
+
+  // Return an estimate of current size of the block
+  size_t CurrentSizeEstimate() const;
+
+  // return true iff no entries have been added since the last Reset()
+  bool empty() const {
+    return buffer_.empty();
+  }
+
+private:
+  const Options* options_;
+  std::string buffer_;
+  std::vector<uint32_t> restarts_;
+  int counter_;
+  bool finished_;
+  std::string last_key_;
+};
+
+}  // namespace db