rocksdb-native 2.2.0 → 2.3.0

package/vendor/librocksdb/vendor/rocksdb/table/block_based/index_builder.cc

@@ -73,37 +73,47 @@ IndexBuilder* IndexBuilder::CreateIndexBuilder(
   return result;
 }
 
-void ShortenedIndexBuilder::FindShortestInternalKeySeparator(
-    const Comparator& comparator, std::string* start, const Slice& limit) {
+Slice ShortenedIndexBuilder::FindShortestInternalKeySeparator(
+    const Comparator& comparator, const Slice& start, const Slice& limit,
+    std::string* scratch) {
   // Attempt to shorten the user portion of the key
-  Slice user_start = ExtractUserKey(*start);
+  Slice user_start = ExtractUserKey(start);
   Slice user_limit = ExtractUserKey(limit);
-  std::string tmp(user_start.data(), user_start.size());
-  comparator.FindShortestSeparator(&tmp, user_limit);
-  if (tmp.size() <= user_start.size() &&
-      comparator.Compare(user_start, tmp) < 0) {
+  scratch->assign(user_start.data(), user_start.size());
+  comparator.FindShortestSeparator(scratch, user_limit);
+  assert(comparator.Compare(user_start, *scratch) <= 0);
+  assert(comparator.Compare(user_start, user_limit) >= 0 ||
+         comparator.Compare(*scratch, user_limit) < 0);
+  if (scratch->size() <= user_start.size() &&
+      comparator.Compare(user_start, *scratch) < 0) {
     // User key has become shorter physically, but larger logically.
     // Tack on the earliest possible number to the shortened user key.
-    PutFixed64(&tmp,
+    PutFixed64(scratch,
                PackSequenceAndType(kMaxSequenceNumber, kValueTypeForSeek));
-    assert(InternalKeyComparator(&comparator).Compare(*start, tmp) < 0);
-    assert(InternalKeyComparator(&comparator).Compare(tmp, limit) < 0);
-    start->swap(tmp);
+    assert(InternalKeyComparator(&comparator).Compare(start, *scratch) < 0);
+    assert(InternalKeyComparator(&comparator).Compare(*scratch, limit) < 0);
+    return *scratch;
+  } else {
+    return start;
   }
 }
 
-void ShortenedIndexBuilder::FindShortInternalKeySuccessor(
-    const Comparator& comparator, std::string* key) {
-  Slice user_key = ExtractUserKey(*key);
-  std::string tmp(user_key.data(), user_key.size());
-  comparator.FindShortSuccessor(&tmp);
-  if (tmp.size() <= user_key.size() && comparator.Compare(user_key, tmp) < 0) {
+Slice ShortenedIndexBuilder::FindShortInternalKeySuccessor(
+    const Comparator& comparator, const Slice& key, std::string* scratch) {
+  Slice user_key = ExtractUserKey(key);
+  scratch->assign(user_key.data(), user_key.size());
+  comparator.FindShortSuccessor(scratch);
+  assert(comparator.Compare(user_key, *scratch) <= 0);
+  if (scratch->size() <= user_key.size() &&
+      comparator.Compare(user_key, *scratch) < 0) {
     // User key has become shorter physically, but larger logically.
     // Tack on the earliest possible number to the shortened user key.
-    PutFixed64(&tmp,
+    PutFixed64(scratch,
                PackSequenceAndType(kMaxSequenceNumber, kValueTypeForSeek));
-    assert(InternalKeyComparator(&comparator).Compare(*key, tmp) < 0);
-    key->swap(tmp);
+    assert(InternalKeyComparator(&comparator).Compare(key, *scratch) < 0);
+    return *scratch;
+  } else {
+    return key;
   }
 }
 
@@ -135,7 +145,6 @@ PartitionedIndexBuilder::PartitionedIndexBuilder(
           BlockBasedTableOptions::kDataBlockBinarySearch /* index_type */,
           0.75 /* data_block_hash_table_util_ratio */, ts_sz,
           persist_user_defined_timestamps, true /* is_user_key */),
-      sub_index_builder_(nullptr),
       table_opt_(table_opt),
       // We start by false. After each partition we revise the value based on
       // what the sub_index_builder has decided. If the feature is disabled
@@ -146,13 +155,9 @@ PartitionedIndexBuilder::PartitionedIndexBuilder(
       seperator_is_key_plus_seq_(false),
       use_value_delta_encoding_(use_value_delta_encoding) {}
 
-PartitionedIndexBuilder::~PartitionedIndexBuilder() {
-  delete sub_index_builder_;
-}
-
 void PartitionedIndexBuilder::MakeNewSubIndexBuilder() {
   assert(sub_index_builder_ == nullptr);
-  sub_index_builder_ = new ShortenedIndexBuilder(
+  sub_index_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_,
@@ -180,33 +185,35 @@ void PartitionedIndexBuilder::RequestPartitionCut() {
   partition_cut_requested_ = true;
 }
 
-void PartitionedIndexBuilder::AddIndexEntry(
-    std::string* last_key_in_current_block,
-    const Slice* first_key_in_next_block, const BlockHandle& block_handle) {
+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({{}, {}});
     }
-    sub_index_builder_->AddIndexEntry(last_key_in_current_block,
-                                      first_key_in_next_block, block_handle);
+    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_) {
-      // then we need to apply it to all sub-index builders and reset
-      // flush_policy to point to Block Builder of sub_index_builder_ that store
-      // internal keys.
+      // We need to apply !seperator_is_key_plus_seq to all sub-index builders
       seperator_is_key_plus_seq_ = true;
-      flush_policy_.reset(FlushBlockBySizePolicyFactory::NewFlushBlockPolicy(
-          table_opt_.metadata_block_size, table_opt_.block_size_deviation,
-          sub_index_builder_->index_block_builder_));
+      // Would associate flush_policy with the appropriate builder, but it won't
+      // be used again with no more keys
+      flush_policy_.reset();
     }
-    sub_index_last_key_ = std::string(*last_key_in_current_block);
-    entries_.push_back(
-        {sub_index_last_key_,
-         std::unique_ptr<ShortenedIndexBuilder>(sub_index_builder_)});
-    sub_index_builder_ = nullptr;
+    entries_.back().key.assign(sep.data(), sep.size());
+    assert(entries_.back().value == nullptr);
+    std::swap(entries_.back().value, sub_index_builder_);
     cut_filter_block = true;
+    return sep;
   } else {
     // apply flush policy only to non-empty sub_index_builder_
     if (sub_index_builder_ != nullptr) {
@@ -214,31 +221,33 @@ void PartitionedIndexBuilder::AddIndexEntry(
       block_handle.EncodeTo(&handle_encoding);
       bool do_flush =
           partition_cut_requested_ ||
-          flush_policy_->Update(*last_key_in_current_block, handle_encoding);
+          flush_policy_->Update(last_key_in_current_block, handle_encoding);
       if (do_flush) {
-        entries_.push_back(
-            {sub_index_last_key_,
-             std::unique_ptr<ShortenedIndexBuilder>(sub_index_builder_)});
+        assert(entries_.back().value == nullptr);
+        std::swap(entries_.back().value, sub_index_builder_);
         cut_filter_block = true;
-        sub_index_builder_ = nullptr;
       }
     }
     if (sub_index_builder_ == nullptr) {
       MakeNewSubIndexBuilder();
+      // Reserve next partition entry, where we will modify the key and
+      // eventually set the value
+      entries_.push_back({{}, {}});
     }
-    sub_index_builder_->AddIndexEntry(last_key_in_current_block,
-                                      first_key_in_next_block, block_handle);
-    sub_index_last_key_ = std::string(*last_key_in_current_block);
+    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_) {
-      // then we need to apply it to all sub-index builders and reset
-      // flush_policy to point to Block Builder of sub_index_builder_ that store
-      // internal keys.
+      // 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;
   }
 }
 

package/vendor/librocksdb/vendor/rocksdb/table/block_based/index_builder.h

@@ -57,19 +57,24 @@ class IndexBuilder {
   virtual ~IndexBuilder() = default;
 
   // Add a new index entry to index block.
+  //
   // To allow further optimization, we provide `last_key_in_current_block` and
   // `first_key_in_next_block`, based on which the specific implementation can
   // determine the best index key to be used for the index block.
   // Called before the OnKeyAdded() call for first_key_in_next_block.
-  // @last_key_in_current_block: this parameter maybe overridden with the value
-  //                             "substitute key".
+  // @last_key_in_current_block: TODO lifetime details
   // @first_key_in_next_block: it will be nullptr if the entry being added is
   //                           the last one in the table
-  //
+  // @separator_scratch: a scratch buffer to back a computed separator between
+  //                     those, as needed. May be modified on each call.
+  // @return: the key or separator stored in the index, which could be
+  //          last_key_in_current_block or a computed separator backed by
+  //          separator_scratch or last_key_in_current_block.
   // REQUIRES: Finish() has not yet been called.
-  virtual void AddIndexEntry(std::string* last_key_in_current_block,
-                             const Slice* first_key_in_next_block,
-                             const BlockHandle& block_handle) = 0;
+  virtual Slice AddIndexEntry(const Slice& last_key_in_current_block,
+                              const Slice* first_key_in_next_block,
+                              const BlockHandle& block_handle,
+                              std::string* separator_scratch) = 0;
 
   // This method will be called whenever a key is added. The subclasses may
   // override OnKeyAdded() if they need to collect additional information.
@@ -181,29 +186,35 @@ class ShortenedIndexBuilder : public IndexBuilder {
     }
   }
 
-  void AddIndexEntry(std::string* last_key_in_current_block,
-                     const Slice* first_key_in_next_block,
-                     const BlockHandle& block_handle) override {
+  Slice AddIndexEntry(const Slice& last_key_in_current_block,
+                      const Slice* first_key_in_next_block,
+                      const BlockHandle& block_handle,
+                      std::string* separator_scratch) override {
+    Slice separator;
     if (first_key_in_next_block != nullptr) {
       if (shortening_mode_ !=
           BlockBasedTableOptions::IndexShorteningMode::kNoShortening) {
-        FindShortestInternalKeySeparator(*comparator_->user_comparator(),
-                                         last_key_in_current_block,
-                                         *first_key_in_next_block);
+        separator = FindShortestInternalKeySeparator(
+            *comparator_->user_comparator(), last_key_in_current_block,
+            *first_key_in_next_block, separator_scratch);
+      } else {
+        separator = last_key_in_current_block;
       }
       if (!seperator_is_key_plus_seq_ &&
-          ShouldUseKeyPlusSeqAsSeparator(*last_key_in_current_block,
+          ShouldUseKeyPlusSeqAsSeparator(last_key_in_current_block,
                                          *first_key_in_next_block)) {
         seperator_is_key_plus_seq_ = true;
       }
     } else {
       if (shortening_mode_ == BlockBasedTableOptions::IndexShorteningMode::
                                   kShortenSeparatorsAndSuccessor) {
-        FindShortInternalKeySuccessor(*comparator_->user_comparator(),
-                                      last_key_in_current_block);
+        separator = FindShortInternalKeySuccessor(
+            *comparator_->user_comparator(), last_key_in_current_block,
+            separator_scratch);
+      } else {
+        separator = last_key_in_current_block;
       }
     }
-    auto sep = Slice(*last_key_in_current_block);
 
     assert(!include_first_key_ || !current_block_first_internal_key_.empty());
     // When UDT should not be persisted, the index block builders take care of
@@ -241,13 +252,15 @@ class ShortenedIndexBuilder : public IndexBuilder {
     // away the UDT from key in index block as data block does the same thing.
     // What are the implications if a "FindShortInternalKeySuccessor"
     // optimization is provided.
-    index_block_builder_.Add(sep, encoded_entry, &delta_encoded_entry_slice);
+    index_block_builder_.Add(separator, encoded_entry,
+                             &delta_encoded_entry_slice);
     if (!seperator_is_key_plus_seq_) {
-      index_block_builder_without_seq_.Add(ExtractUserKey(sep), encoded_entry,
-                                           &delta_encoded_entry_slice);
+      index_block_builder_without_seq_.Add(
+          ExtractUserKey(separator), encoded_entry, &delta_encoded_entry_slice);
     }
 
     current_block_first_internal_key_.clear();
+    return separator;
   }
 
   using IndexBuilder::Finish;
@@ -271,12 +284,14 @@ class ShortenedIndexBuilder : public IndexBuilder {
 
   // Changes *key to a short string >= *key.
   //
-  static void FindShortestInternalKeySeparator(const Comparator& comparator,
-                                               std::string* start,
-                                               const Slice& limit);
+  static Slice FindShortestInternalKeySeparator(const Comparator& comparator,
+                                                const Slice& start,
+                                                const Slice& limit,
+                                                std::string* scratch);
 
-  static void FindShortInternalKeySuccessor(const Comparator& comparator,
-                                            std::string* key);
+  static Slice FindShortInternalKeySuccessor(const Comparator& comparator,
+                                             const Slice& key,
+                                             std::string* scratch);
 
   friend class PartitionedIndexBuilder;
 
@@ -333,12 +348,14 @@ class HashIndexBuilder : public IndexBuilder {
                                ts_sz, persist_user_defined_timestamps),
         hash_key_extractor_(hash_key_extractor) {}
 
-  void AddIndexEntry(std::string* last_key_in_current_block,
-                     const Slice* first_key_in_next_block,
-                     const BlockHandle& block_handle) override {
+  Slice AddIndexEntry(const Slice& last_key_in_current_block,
+                      const Slice* first_key_in_next_block,
+                      const BlockHandle& block_handle,
+                      std::string* separator_scratch) override {
     ++current_restart_index_;
-    primary_index_builder_.AddIndexEntry(last_key_in_current_block,
-                                         first_key_in_next_block, block_handle);
+    return primary_index_builder_.AddIndexEntry(
+        last_key_in_current_block, first_key_in_next_block, block_handle,
+        separator_scratch);
   }
 
   void OnKeyAdded(const Slice& key) override {
@@ -441,11 +458,10 @@ class PartitionedIndexBuilder : public IndexBuilder {
                           bool use_value_delta_encoding, size_t ts_sz,
                           bool persist_user_defined_timestamps);
 
-  ~PartitionedIndexBuilder() override;
-
-  void AddIndexEntry(std::string* last_key_in_current_block,
-                     const Slice* first_key_in_next_block,
-                     const BlockHandle& block_handle) override;
+  Slice AddIndexEntry(const Slice& last_key_in_current_block,
+                      const Slice* first_key_in_next_block,
+                      const BlockHandle& block_handle,
+                      std::string* separator_scratch) override;
 
   Status Finish(IndexBlocks* index_blocks,
                 const BlockHandle& last_partition_block_handle) override;
@@ -463,7 +479,10 @@ class PartitionedIndexBuilder : public IndexBuilder {
     return false;
   }
 
-  std::string& GetPartitionKey() { return sub_index_last_key_; }
+  const std::string& GetPartitionKey() {
+    static const std::string kEmptyKey;
+    return entries_.empty() ? kEmptyKey : entries_.back().key;
+  }
 
   // Called when an external entity (such as filter partition builder) request
   // cutting the next partition
@@ -489,13 +508,16 @@ class PartitionedIndexBuilder : public IndexBuilder {
     std::string key;
     std::unique_ptr<ShortenedIndexBuilder> value;
   };
-  std::list<Entry> entries_;  // list of partitioned indexes and their keys
+  // List of partitioned indexes and their keys. Note that when
+  // sub_index_builder_ is not null (during construction), there
+  // will be a placeholder entry at the back of this list tracking
+  // the possible key for that next entry.
+  std::list<Entry> entries_;
   BlockBuilder index_block_builder_;              // top-level index builder
   BlockBuilder index_block_builder_without_seq_;  // same for user keys
   // the active partition index builder
-  ShortenedIndexBuilder* sub_index_builder_;
+  std::unique_ptr<ShortenedIndexBuilder> sub_index_builder_;
   // the last key in the active partition index builder
-  std::string sub_index_last_key_;
   std::unique_ptr<FlushBlockPolicy> flush_policy_;
   // true if Finish is called once but not complete yet.
   bool finishing_indexes = false;

package/vendor/librocksdb/vendor/rocksdb/table/block_based/index_reader_common.cc

@@ -35,9 +35,8 @@ Status BlockBasedTable::IndexReaderCommon::ReadIndexBlock(
 }
 
 Status BlockBasedTable::IndexReaderCommon::GetOrReadIndexBlock(
-    bool no_io, GetContext* get_context,
-    BlockCacheLookupContext* lookup_context, CachableEntry<Block>* index_block,
-    const ReadOptions& ro) const {
+    GetContext* get_context, BlockCacheLookupContext* lookup_context,
+    CachableEntry<Block>* index_block, const ReadOptions& ro) const {
   assert(index_block != nullptr);
 
   if (!index_block_.IsEmpty()) {
@@ -45,13 +44,19 @@ Status BlockBasedTable::IndexReaderCommon::GetOrReadIndexBlock(
     return Status::OK();
   }
 
-  ReadOptions read_options = ro;
-  if (no_io) {
-    read_options.read_tier = kBlockCacheTier;
-  }
-
-  return ReadIndexBlock(table_, /*prefetch_buffer=*/nullptr, read_options,
+  return ReadIndexBlock(table_, /*prefetch_buffer=*/nullptr, ro,
                         cache_index_blocks(), get_context, lookup_context,
                         index_block);
 }
+
+void BlockBasedTable::IndexReaderCommon::EraseFromCacheBeforeDestruction(
+    uint32_t uncache_aggressiveness) {
+  if (uncache_aggressiveness > 0) {
+    if (index_block_.IsCached()) {
+      index_block_.ResetEraseIfLastRef();
+    } else {
+      table()->EraseFromCache(table()->get_rep()->index_handle);
+    }
+  }
+}
 }  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/table/block_based/index_reader_common.h

@@ -24,6 +24,9 @@ class BlockBasedTable::IndexReaderCommon : public BlockBasedTable::IndexReader {
     assert(table_ != nullptr);
   }
 
+  void EraseFromCacheBeforeDestruction(
+      uint32_t /*uncache_aggressiveness*/) override;
+
  protected:
   static Status ReadIndexBlock(const BlockBasedTable* table,
                                FilePrefetchBuffer* prefetch_buffer,
@@ -71,7 +74,7 @@ class BlockBasedTable::IndexReaderCommon : public BlockBasedTable::IndexReader {
     return table_->get_rep()->user_defined_timestamps_persisted;
   }
 
-  Status GetOrReadIndexBlock(bool no_io, GetContext* get_context,
+  Status GetOrReadIndexBlock(GetContext* get_context,
                              BlockCacheLookupContext* lookup_context,
                              CachableEntry<Block>* index_block,
                              const ReadOptions& read_options) const;