@nxtedition/rocksdb 13.5.13 → 14.0.0

package/deps/rocksdb/rocksdb/table/block_based/block_builder.h

@@ -80,6 +80,8 @@ class BlockBuilder {
   // Return true iff no entries have been added since the last Reset()
   bool empty() const { return buffer_.empty(); }
 
+  std::string& MutableBuffer() { return buffer_; }
+
  private:
   inline void AddWithLastKeyImpl(const Slice& key, const Slice& value,
                                  const Slice& last_key,

package/deps/rocksdb/rocksdb/table/block_based/flush_block_policy.cc

@@ -19,7 +19,7 @@
 namespace ROCKSDB_NAMESPACE {
 
 // Flush block by size
-class FlushBlockBySizePolicy : public FlushBlockPolicy {
+class FlushBlockBySizePolicy : public RetargetableFlushBlockPolicy {
  public:
   // @params block_size:           Approximate size of user data packed per
   //                               block.
@@ -28,19 +28,19 @@ class FlushBlockBySizePolicy : public FlushBlockPolicy {
   FlushBlockBySizePolicy(const uint64_t block_size,
                          const uint64_t block_size_deviation, const bool align,
                          const BlockBuilder& data_block_builder)
-      : block_size_(block_size),
+      : RetargetableFlushBlockPolicy(data_block_builder),
+        block_size_(block_size),
         block_size_deviation_limit_(
             ((block_size * (100 - block_size_deviation)) + 99) / 100),
-        align_(align),
-        data_block_builder_(data_block_builder) {}
+        align_(align) {}
 
   bool Update(const Slice& key, const Slice& value) override {
     // it makes no sense to flush when the data block is empty
-    if (data_block_builder_.empty()) {
+    if (data_block_builder_->empty()) {
       return false;
     }
 
-    auto curr_size = data_block_builder_.CurrentSizeEstimate();
+    auto curr_size = data_block_builder_->CurrentSizeEstimate();
 
     // Do flush if one of the below two conditions is true:
     // 1) if the current estimated size already exceeds the block size,
@@ -56,9 +56,9 @@ class FlushBlockBySizePolicy : public FlushBlockPolicy {
       return false;
     }
 
-    const auto curr_size = data_block_builder_.CurrentSizeEstimate();
+    const auto curr_size = data_block_builder_->CurrentSizeEstimate();
     auto estimated_size_after =
-        data_block_builder_.EstimateSizeAfterKV(key, value);
+        data_block_builder_->EstimateSizeAfterKV(key, value);
 
     if (align_) {
       estimated_size_after += BlockBasedTable::kBlockTrailerSize;
@@ -72,7 +72,6 @@ class FlushBlockBySizePolicy : public FlushBlockPolicy {
   const uint64_t block_size_;
   const uint64_t block_size_deviation_limit_;
   const bool align_;
-  const BlockBuilder& data_block_builder_;
 };
 
 FlushBlockPolicy* FlushBlockBySizePolicyFactory::NewFlushBlockPolicy(
@@ -83,10 +82,18 @@ FlushBlockPolicy* FlushBlockBySizePolicyFactory::NewFlushBlockPolicy(
       table_options.block_align, data_block_builder);
 }
 
+std::unique_ptr<RetargetableFlushBlockPolicy> NewFlushBlockBySizePolicy(
+    const uint64_t size, const int deviation,
+    const BlockBuilder& data_block_builder) {
+  return std::make_unique<FlushBlockBySizePolicy>(size, deviation, false,
+                                                  data_block_builder);
+}
+
 FlushBlockPolicy* FlushBlockBySizePolicyFactory::NewFlushBlockPolicy(
     const uint64_t size, const int deviation,
     const BlockBuilder& data_block_builder) {
-  return new FlushBlockBySizePolicy(size, deviation, false, data_block_builder);
+  return NewFlushBlockBySizePolicy(size, deviation, data_block_builder)
+      .release();
 }
 
 static int RegisterFlushBlockPolicyFactories(ObjectLibrary& library,

package/deps/rocksdb/rocksdb/table/block_based/flush_block_policy_impl.h

@@ -3,6 +3,7 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
+#pragma once
 #include "rocksdb/flush_block_policy.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -37,4 +38,23 @@ class FlushBlockEveryKeyPolicyFactory : public FlushBlockPolicyFactory {
   }
 };
 
+// For internal use, policy that is stateless after creation, meaning it can
+// be safely re-targeted to another block builder.
+class RetargetableFlushBlockPolicy : public FlushBlockPolicy {
+ public:
+  explicit RetargetableFlushBlockPolicy(const BlockBuilder& data_block_builder)
+      : data_block_builder_(&data_block_builder) {}
+
+  void Retarget(const BlockBuilder& data_block_builder) {
+    data_block_builder_ = &data_block_builder;
+  }
+
+ protected:
+  const BlockBuilder* data_block_builder_;
+};
+
+std::unique_ptr<RetargetableFlushBlockPolicy> NewFlushBlockBySizePolicy(
+    const uint64_t size, const int deviation,
+    const BlockBuilder& data_block_builder);
+
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/table/block_based/index_builder.cc

@@ -152,32 +152,43 @@ PartitionedIndexBuilder::PartitionedIndexBuilder(
       // sub_index_builder. Otherwise, it could be set to true even one of the
       // sub_index_builders could not safely exclude seq from the keys, then it
       // wil be enforced on all sub_index_builders on ::Finish.
-      seperator_is_key_plus_seq_(false),
-      use_value_delta_encoding_(use_value_delta_encoding) {}
+      must_use_separator_with_seq_(false),
+      use_value_delta_encoding_(use_value_delta_encoding) {
+  MakeNewSubIndexBuilder();
+}
 
 void PartitionedIndexBuilder::MakeNewSubIndexBuilder() {
-  assert(sub_index_builder_ == nullptr);
-  sub_index_builder_ = std::make_unique<ShortenedIndexBuilder>(
+  auto new_builder = std::make_unique<ShortenedIndexBuilder>(
       comparator_, table_opt_.index_block_restart_interval,
       table_opt_.format_version, use_value_delta_encoding_,
       table_opt_.index_shortening, /* include_first_key */ false, ts_sz_,
       persist_user_defined_timestamps_);
+  sub_index_builder_ = new_builder.get();
+  // Start next partition entry, where we will modify the key
+  entries_.push_back({{}, std::move(new_builder)});
 
-  // Set sub_index_builder_->seperator_is_key_plus_seq_ to true if
-  // seperator_is_key_plus_seq_ is true (internal-key mode) (set to false by
+  BlockBuilder* builder_to_monitor;
+  // Set sub_index_builder_->must_use_separator_with_seq_ to true if
+  // must_use_separator_with_seq_ is true (internal-key mode) (set to false by
   // default on Creation) so that flush policy can point to
   // sub_index_builder_->index_block_builder_
-  if (seperator_is_key_plus_seq_) {
-    sub_index_builder_->seperator_is_key_plus_seq_ = true;
+  if (must_use_separator_with_seq_) {
+    sub_index_builder_->must_use_separator_with_seq_ = true;
+    builder_to_monitor = &sub_index_builder_->index_block_builder_;
+  } else {
+    builder_to_monitor = &sub_index_builder_->index_block_builder_without_seq_;
   }
 
-  flush_policy_.reset(FlushBlockBySizePolicyFactory::NewFlushBlockPolicy(
-      table_opt_.metadata_block_size, table_opt_.block_size_deviation,
-      // Note: this is sub-optimal since sub_index_builder_ could later reset
-      // seperator_is_key_plus_seq_ but the probability of that is low.
-      sub_index_builder_->seperator_is_key_plus_seq_
-          ? sub_index_builder_->index_block_builder_
-          : sub_index_builder_->index_block_builder_without_seq_));
+  if (flush_policy_ == nullptr) {
+    // Note: some partitions could be sub-optimal since sub_index_builder_
+    // could later reset must_use_separator_with_seq_ but the probability and
+    // impact of that are low.
+    flush_policy_ = NewFlushBlockBySizePolicy(table_opt_.metadata_block_size,
+                                              table_opt_.block_size_deviation,
+                                              *builder_to_monitor);
+  } else {
+    flush_policy_->Retarget(*builder_to_monitor);
+  }
   partition_cut_requested_ = false;
 }
 
@@ -185,101 +196,117 @@ void PartitionedIndexBuilder::RequestPartitionCut() {
   partition_cut_requested_ = true;
 }
 
+std::unique_ptr<IndexBuilder::PreparedIndexEntry>
+PartitionedIndexBuilder::CreatePreparedIndexEntry() {
+  // Fortunately, for ShortenedIndexBuilder, we can prepare an entry from one
+  // similarly configured builder and finish it at another.
+  return entries_.front().value->CreatePreparedIndexEntry();
+}
+void PartitionedIndexBuilder::PrepareIndexEntry(
+    const Slice& last_key_in_current_block,
+    const Slice* first_key_in_next_block, PreparedIndexEntry* out) {
+  // Fortunately, for ShortenedIndexBuilder, we can prepare an entry from one
+  // similarly configured builder and finish it at another. We just have to
+  // keep in mind that this first sub builder keeps track of the original
+  // must_use_separator_with_seq_ in the pipeline that is then propagated.
+  return entries_.front().value->PrepareIndexEntry(
+      last_key_in_current_block, first_key_in_next_block, out);
+}
+
+void PartitionedIndexBuilder::MaybeFlush(const Slice& index_key,
+                                         const BlockHandle& index_value) {
+  bool do_flush = !sub_index_builder_->index_block_builder_.empty() &&
+                  (partition_cut_requested_ ||
+                   flush_policy_->Update(
+                       index_key, EncodedBlockHandle(index_value).AsSlice()));
+  if (do_flush) {
+    assert(entries_.back().value.get() == sub_index_builder_);
+    cut_filter_block = true;
+    MakeNewSubIndexBuilder();
+  }
+}
+
+void PartitionedIndexBuilder::FinishIndexEntry(const BlockHandle& block_handle,
+                                               PreparedIndexEntry* base_entry) {
+  using SPIE = ShortenedIndexBuilder::ShortenedPreparedIndexEntry;
+  SPIE* entry = static_cast<SPIE*>(base_entry);
+
+  MaybeFlush(entry->separator_with_seq, block_handle);
+
+  sub_index_builder_->FinishIndexEntry(block_handle, base_entry);
+  std::swap(entries_.back().key, entry->separator_with_seq);
+
+  if (!must_use_separator_with_seq_ && entry->must_use_separator_with_seq) {
+    // We need to apply !must_use_separator_with_seq to all sub-index builders
+    must_use_separator_with_seq_ = true;
+    flush_policy_->Retarget(sub_index_builder_->index_block_builder_);
+  }
+  // NOTE: not compatible with coupled partitioned filters so don't need to
+  // cut_filter_block
+}
+
 Slice PartitionedIndexBuilder::AddIndexEntry(
     const Slice& last_key_in_current_block,
     const Slice* first_key_in_next_block, const BlockHandle& block_handle,
     std::string* separator_scratch) {
-  // Note: to avoid two consecuitive flush in the same method call, we do not
-  // check flush policy when adding the last key
-  if (UNLIKELY(first_key_in_next_block == nullptr)) {  // no more keys
-    if (sub_index_builder_ == nullptr) {
-      MakeNewSubIndexBuilder();
-      // Reserve next partition entry, where we will modify the key and
-      // eventually set the value
-      entries_.push_back({{}, {}});
-    }
-    auto sep = sub_index_builder_->AddIndexEntry(
-        last_key_in_current_block, first_key_in_next_block, block_handle,
-        separator_scratch);
-    if (!seperator_is_key_plus_seq_ &&
-        sub_index_builder_->seperator_is_key_plus_seq_) {
-      // We need to apply !seperator_is_key_plus_seq to all sub-index builders
-      seperator_is_key_plus_seq_ = true;
-      // Would associate flush_policy with the appropriate builder, but it won't
-      // be used again with no more keys
-      flush_policy_.reset();
-    }
-    entries_.back().key.assign(sep.data(), sep.size());
-    assert(entries_.back().value == nullptr);
-    std::swap(entries_.back().value, sub_index_builder_);
+  // At least when running without parallel compression, maintain behavior of
+  // avoiding a last index partition with just one entry
+  if (first_key_in_next_block) {
+    MaybeFlush(last_key_in_current_block, block_handle);
+  }
+
+  auto sep = sub_index_builder_->AddIndexEntry(last_key_in_current_block,
+                                               first_key_in_next_block,
+                                               block_handle, separator_scratch);
+  entries_.back().key.assign(sep.data(), sep.size());
+
+  if (!must_use_separator_with_seq_ &&
+      sub_index_builder_->must_use_separator_with_seq_) {
+    // We need to apply !must_use_separator_with_seq to all sub-index builders
+    must_use_separator_with_seq_ = true;
+    flush_policy_->Retarget(sub_index_builder_->index_block_builder_);
+  }
+  if (UNLIKELY(first_key_in_next_block == nullptr)) {
+    // no more keys
     cut_filter_block = true;
-    return sep;
-  } else {
-    // apply flush policy only to non-empty sub_index_builder_
-    if (sub_index_builder_ != nullptr) {
-      std::string handle_encoding;
-      block_handle.EncodeTo(&handle_encoding);
-      bool do_flush =
-          partition_cut_requested_ ||
-          flush_policy_->Update(last_key_in_current_block, handle_encoding);
-      if (do_flush) {
-        assert(entries_.back().value == nullptr);
-        std::swap(entries_.back().value, sub_index_builder_);
-        cut_filter_block = true;
-      }
-    }
-    if (sub_index_builder_ == nullptr) {
-      MakeNewSubIndexBuilder();
-      // Reserve next partition entry, where we will modify the key and
-      // eventually set the value
-      entries_.push_back({{}, {}});
-    }
-    auto sep = sub_index_builder_->AddIndexEntry(
-        last_key_in_current_block, first_key_in_next_block, block_handle,
-        separator_scratch);
-    entries_.back().key.assign(sep.data(), sep.size());
-    if (!seperator_is_key_plus_seq_ &&
-        sub_index_builder_->seperator_is_key_plus_seq_) {
-      // We need to apply !seperator_is_key_plus_seq to all sub-index builders
-      seperator_is_key_plus_seq_ = true;
-      // And use a flush_policy with the appropriate builder
-      flush_policy_.reset(FlushBlockBySizePolicyFactory::NewFlushBlockPolicy(
-          table_opt_.metadata_block_size, table_opt_.block_size_deviation,
-          sub_index_builder_->index_block_builder_));
-    }
-    return sep;
   }
+  return sep;
 }
 
 Status PartitionedIndexBuilder::Finish(
     IndexBlocks* index_blocks, const BlockHandle& last_partition_block_handle) {
   if (partition_cnt_ == 0) {
-    partition_cnt_ = entries_.size();
+    sub_index_builder_ = nullptr;
+    if (!entries_.empty()) {
+      // Remove the last entry if it is empty
+      if (entries_.back().value->index_block_builder_.empty()) {
+        assert(entries_.back().key.empty());
+        entries_.pop_back();
+      }
+      partition_cnt_ = entries_.size();
+    }
   }
-  // It must be set to null after last key is added
-  assert(sub_index_builder_ == nullptr);
-  if (finishing_indexes == true) {
+  if (finishing_indexes_ == true) {
     Entry& last_entry = entries_.front();
-    std::string handle_encoding;
-    last_partition_block_handle.EncodeTo(&handle_encoding);
+    EncodedBlockHandle handle_encoding(last_partition_block_handle);
     std::string handle_delta_encoding;
     PutVarsignedint64(
         &handle_delta_encoding,
         last_partition_block_handle.size() - last_encoded_handle_.size());
     last_encoded_handle_ = last_partition_block_handle;
     const Slice handle_delta_encoding_slice(handle_delta_encoding);
-    index_block_builder_.Add(last_entry.key, handle_encoding,
+    index_block_builder_.Add(last_entry.key, handle_encoding.AsSlice(),
                              &handle_delta_encoding_slice);
-    if (!seperator_is_key_plus_seq_) {
+    if (!must_use_separator_with_seq_) {
       index_block_builder_without_seq_.Add(ExtractUserKey(last_entry.key),
-                                           handle_encoding,
+                                           handle_encoding.AsSlice(),
                                            &handle_delta_encoding_slice);
     }
     entries_.pop_front();
   }
   // If there is no sub_index left, then return the 2nd level index.
   if (UNLIKELY(entries_.empty())) {
-    if (seperator_is_key_plus_seq_) {
+    if (must_use_separator_with_seq_) {
       index_blocks->index_block_contents = index_block_builder_.Finish();
     } else {
       index_blocks->index_block_contents =
@@ -293,10 +320,10 @@ Status PartitionedIndexBuilder::Finish(
     // expect more calls to Finish
     Entry& entry = entries_.front();
     // Apply the policy to all sub-indexes
-    entry.value->seperator_is_key_plus_seq_ = seperator_is_key_plus_seq_;
+    entry.value->must_use_separator_with_seq_ = must_use_separator_with_seq_;
     auto s = entry.value->Finish(index_blocks);
     index_size_ += index_blocks->index_block_contents.size();
-    finishing_indexes = true;
+    finishing_indexes_ = true;
     return s.ok() ? Status::Incomplete() : s;
   }
 }