rocksdb-native 2.2.0 → 2.3.0

package/vendor/librocksdb/vendor/rocksdb/include/rocksdb/wide_columns.h

@@ -105,6 +105,16 @@ extern const WideColumns kNoWideColumns;
 // wide-column queries.
 class PinnableWideColumns {
  public:
+  PinnableWideColumns() = default;
+
+  PinnableWideColumns(const PinnableWideColumns&) = delete;
+  PinnableWideColumns& operator=(const PinnableWideColumns&) = delete;
+
+  PinnableWideColumns(PinnableWideColumns&&);
+  PinnableWideColumns& operator=(PinnableWideColumns&&);
+
+  ~PinnableWideColumns() = default;
+
   const WideColumns& columns() const { return columns_; }
   size_t serialized_size() const { return value_.size(); }
 
@@ -121,6 +131,7 @@ class PinnableWideColumns {
   void Reset();
 
  private:
+  void Move(PinnableWideColumns&& other);
   void CopyValue(const Slice& value);
   void PinOrCopyValue(const Slice& value, Cleanable* cleanable);
   void MoveValue(PinnableSlice&& value);
@@ -133,6 +144,42 @@ class PinnableWideColumns {
   WideColumns columns_;
 };
 
+inline void PinnableWideColumns::Reset() {
+  value_.Reset();
+  columns_.clear();
+}
+
+inline void PinnableWideColumns::Move(PinnableWideColumns&& other) {
+  assert(columns_.empty());
+
+  if (other.columns_.empty()) {
+    return;
+  }
+
+  const char* const data = other.value_.data();
+  const bool is_plain_value =
+      other.columns_.size() == 1 &&
+      other.columns_.front().name() == kDefaultWideColumnName &&
+      other.columns_.front().value() == other.value_;
+
+  MoveValue(std::move(other.value_));
+
+  if (value_.data() == data) {
+    columns_ = std::move(other.columns_);
+  } else {
+    if (is_plain_value) {
+      CreateIndexForPlainValue();
+    } else {
+      const Status s = CreateIndexForWideColumns();
+      assert(s.ok());
+
+      s.PermitUncheckedError();
+    }
+  }
+
+  other.Reset();
+}
+
 inline void PinnableWideColumns::CopyValue(const Slice& value) {
   value_.PinSelf(value);
 }
@@ -186,28 +233,61 @@ inline void PinnableWideColumns::SetPlainValue(std::string&& value) {
 
 inline Status PinnableWideColumns::SetWideColumnValue(const Slice& value) {
   CopyValue(value);
-  return CreateIndexForWideColumns();
+
+  const Status s = CreateIndexForWideColumns();
+  if (!s.ok()) {
+    Reset();
+  }
+
+  return s;
 }
 
 inline Status PinnableWideColumns::SetWideColumnValue(const Slice& value,
                                                       Cleanable* cleanable) {
   PinOrCopyValue(value, cleanable);
-  return CreateIndexForWideColumns();
+
+  const Status s = CreateIndexForWideColumns();
+  if (!s.ok()) {
+    Reset();
+  }
+
+  return s;
 }
 
 inline Status PinnableWideColumns::SetWideColumnValue(PinnableSlice&& value) {
   MoveValue(std::move(value));
-  return CreateIndexForWideColumns();
+
+  const Status s = CreateIndexForWideColumns();
+  if (!s.ok()) {
+    Reset();
+  }
+
+  return s;
 }
 
 inline Status PinnableWideColumns::SetWideColumnValue(std::string&& value) {
   MoveValue(std::move(value));
-  return CreateIndexForWideColumns();
+
+  const Status s = CreateIndexForWideColumns();
+  if (!s.ok()) {
+    Reset();
+  }
+
+  return s;
 }
 
-inline void PinnableWideColumns::Reset() {
-  value_.Reset();
-  columns_.clear();
+inline PinnableWideColumns::PinnableWideColumns(PinnableWideColumns&& other) {
+  Move(std::move(other));
+}
+
+inline PinnableWideColumns& PinnableWideColumns::operator=(
+    PinnableWideColumns&& other) {
+  if (this != &other) {
+    Reset();
+    Move(std::move(other));
+  }
+
+  return *this;
 }
 
 inline bool operator==(const PinnableWideColumns& lhs,
@@ -220,69 +300,4 @@ inline bool operator!=(const PinnableWideColumns& lhs,
   return !(lhs == rhs);
 }
 
-// Class representing attribute group. Attribute group is a logical grouping of
-// wide-column entities by leveraging Column Families.
-// Used in Write Path
-class AttributeGroup {
- public:
-  ColumnFamilyHandle* column_family() const { return column_family_; }
-  const WideColumns& columns() const { return columns_; }
-  WideColumns& columns() { return columns_; }
-
-  explicit AttributeGroup(ColumnFamilyHandle* column_family,
-                          const WideColumns& columns)
-      : column_family_(column_family), columns_(columns) {}
-
- private:
-  ColumnFamilyHandle* column_family_;
-  WideColumns columns_;
-};
-
-inline bool operator==(const AttributeGroup& lhs, const AttributeGroup& rhs) {
-  return lhs.column_family() == rhs.column_family() &&
-         lhs.columns() == rhs.columns();
-}
-
-// A collection of Attribute Groups.
-using AttributeGroups = std::vector<AttributeGroup>;
-
-// An empty set of Attribute Groups.
-extern const AttributeGroups kNoAttributeGroups;
-
-// Used in Read Path. Wide-columns returned from the query are pinnable.
-class PinnableAttributeGroup {
- public:
-  ColumnFamilyHandle* column_family() const { return column_family_; }
-  const Status& status() const { return status_; }
-  const WideColumns& columns() const { return columns_.columns(); }
-
-  explicit PinnableAttributeGroup(ColumnFamilyHandle* column_family)
-      : column_family_(column_family), status_(Status::OK()) {}
-
-  void SetStatus(const Status& status);
-  void SetColumns(PinnableWideColumns&& columns);
-
-  void Reset();
-
- private:
-  ColumnFamilyHandle* column_family_;
-  Status status_;
-  PinnableWideColumns columns_;
-};
-
-inline void PinnableAttributeGroup::SetStatus(const Status& status) {
-  status_ = status;
-}
-inline void PinnableAttributeGroup::SetColumns(PinnableWideColumns&& columns) {
-  columns_ = std::move(columns);
-}
-
-inline void PinnableAttributeGroup::Reset() {
-  SetStatus(Status::OK());
-  columns_.Reset();
-}
-
-// A collection of Pinnable Attribute Groups.
-using PinnableAttributeGroups = std::vector<PinnableAttributeGroup>;
-
 }  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/include/rocksdb/write_batch_base.h

@@ -10,8 +10,8 @@
 
 #include <cstddef>
 
+#include "rocksdb/attribute_groups.h"
 #include "rocksdb/rocksdb_namespace.h"
-#include "rocksdb/wide_columns.h"
 
 namespace ROCKSDB_NAMESPACE {
 

package/vendor/librocksdb/vendor/rocksdb/memory/memory_allocator.cc

@@ -77,4 +77,5 @@ Status MemoryAllocator::CreateFromString(
   copy.invoke_prepare_options = true;
   return LoadManagedObject<MemoryAllocator>(copy, value, result);
 }
+
 }  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/options/cf_options.cc

@@ -239,6 +239,10 @@ static std::unordered_map<std::string, OptionTypeInfo>
          {offsetof(class CompactionOptionsUniversal, compression_size_percent),
           OptionType::kInt, OptionVerificationType::kNormal,
           OptionTypeFlags::kMutable}},
+        {"max_read_amp",
+         {offsetof(class CompactionOptionsUniversal, max_read_amp),
+          OptionType::kInt, OptionVerificationType::kNormal,
+          OptionTypeFlags::kMutable}},
         {"stop_style",
          {offsetof(class CompactionOptionsUniversal, stop_style),
           OptionType::kCompactionStopStyle, OptionVerificationType::kNormal,
@@ -519,6 +523,10 @@ static std::unordered_map<std::string, OptionTypeInfo>
          {offsetof(struct MutableCFOptions, bottommost_file_compaction_delay),
           OptionType::kUInt32T, OptionVerificationType::kNormal,
           OptionTypeFlags::kMutable}},
+        {"uncache_aggressiveness",
+         {offsetof(struct MutableCFOptions, uncache_aggressiveness),
+          OptionType::kUInt32T, OptionVerificationType::kNormal,
+          OptionTypeFlags::kMutable}},
         {"block_protection_bytes_per_key",
          {offsetof(struct MutableCFOptions, block_protection_bytes_per_key),
           OptionType::kUInt8T, OptionVerificationType::kNormal,
@@ -1118,11 +1126,12 @@ void MutableCFOptions::Dump(Logger* log) const {
                  report_bg_io_stats);
   ROCKS_LOG_INFO(log, "                              compression: %d",
                  static_cast<int>(compression));
-  ROCKS_LOG_INFO(log,
-                 "                       experimental_mempurge_threshold: %f",
+  ROCKS_LOG_INFO(log, "          experimental_mempurge_threshold: %f",
                  experimental_mempurge_threshold);
   ROCKS_LOG_INFO(log, "         bottommost_file_compaction_delay: %" PRIu32,
                  bottommost_file_compaction_delay);
+  ROCKS_LOG_INFO(log, "                   uncache_aggressiveness: %" PRIu32,
+                 uncache_aggressiveness);
 
   // Universal Compaction Options
   ROCKS_LOG_INFO(log, "compaction_options_universal.size_ratio : %d",
@@ -1137,6 +1146,8 @@ void MutableCFOptions::Dump(Logger* log) const {
   ROCKS_LOG_INFO(log,
                  "compaction_options_universal.compression_size_percent : %d",
                  compaction_options_universal.compression_size_percent);
+  ROCKS_LOG_INFO(log, "compaction_options_universal.max_read_amp:  %d",
+                 compaction_options_universal.max_read_amp);
   ROCKS_LOG_INFO(log, "compaction_options_universal.stop_style : %d",
                  compaction_options_universal.stop_style);
   ROCKS_LOG_INFO(

package/vendor/librocksdb/vendor/rocksdb/options/cf_options.h

@@ -173,7 +173,8 @@ struct MutableCFOptions {
         compression_per_level(options.compression_per_level),
         memtable_max_range_deletions(options.memtable_max_range_deletions),
         bottommost_file_compaction_delay(
-            options.bottommost_file_compaction_delay) {
+            options.bottommost_file_compaction_delay),
+        uncache_aggressiveness(options.uncache_aggressiveness) {
     RefreshDerivedOptions(options.num_levels, options.compaction_style);
   }
 
@@ -223,7 +224,9 @@ struct MutableCFOptions {
         memtable_protection_bytes_per_key(0),
         block_protection_bytes_per_key(0),
         sample_for_compression(0),
-        memtable_max_range_deletions(0) {}
+        memtable_max_range_deletions(0),
+        bottommost_file_compaction_delay(0),
+        uncache_aggressiveness(0) {}
 
   explicit MutableCFOptions(const Options& options);
 
@@ -319,6 +322,7 @@ struct MutableCFOptions {
   std::vector<CompressionType> compression_per_level;
   uint32_t memtable_max_range_deletions;
   uint32_t bottommost_file_compaction_delay;
+  uint32_t uncache_aggressiveness;
 
   // Derived options
   // Per-level target file size.

package/vendor/librocksdb/vendor/rocksdb/options/db_options.cc

@@ -37,6 +37,7 @@ static std::unordered_map<std::string, WALRecoveryMode>
 
 static std::unordered_map<std::string, CacheTier> cache_tier_string_map = {
     {"kVolatileTier", CacheTier::kVolatileTier},
+    {"kVolatileCompressedTier", CacheTier::kVolatileCompressedTier},
     {"kNonVolatileBlockTier", CacheTier::kNonVolatileBlockTier}};
 
 static std::unordered_map<std::string, InfoLogLevel> info_log_level_string_map =
@@ -387,6 +388,10 @@ static std::unordered_map<std::string, OptionTypeInfo>
          {offsetof(struct ImmutableDBOptions, wal_compression),
           OptionType::kCompressionType, OptionVerificationType::kNormal,
           OptionTypeFlags::kNone}},
+        {"background_close_inactive_wals",
+         {offsetof(struct ImmutableDBOptions, background_close_inactive_wals),
+          OptionType::kBoolean, OptionVerificationType::kNormal,
+          OptionTypeFlags::kNone}},
         {"seq_per_batch",
          {0, OptionType::kBoolean, OptionVerificationType::kDeprecated,
           OptionTypeFlags::kNone}},
@@ -558,6 +563,19 @@ static std::unordered_map<std::string, OptionTypeInfo>
          {offsetof(struct ImmutableDBOptions, enforce_single_del_contracts),
           OptionType::kBoolean, OptionVerificationType::kNormal,
           OptionTypeFlags::kNone}},
+        {"follower_refresh_catchup_period_ms",
+         {offsetof(struct ImmutableDBOptions,
+                   follower_refresh_catchup_period_ms),
+          OptionType::kUInt64T, OptionVerificationType::kNormal,
+          OptionTypeFlags::kNone}},
+        {"follower_catchup_retry_count",
+         {offsetof(struct ImmutableDBOptions, follower_catchup_retry_count),
+          OptionType::kUInt64T, OptionVerificationType::kNormal,
+          OptionTypeFlags::kNone}},
+        {"follower_catchup_retry_wait_ms",
+         {offsetof(struct ImmutableDBOptions, follower_catchup_retry_wait_ms),
+          OptionType::kUInt64T, OptionVerificationType::kNormal,
+          OptionTypeFlags::kNone}},
 };
 
 const std::string OptionsHelper::kDBOptionsName = "DBOptions";
@@ -741,6 +759,7 @@ ImmutableDBOptions::ImmutableDBOptions(const DBOptions& options)
       two_write_queues(options.two_write_queues),
       manual_wal_flush(options.manual_wal_flush),
       wal_compression(options.wal_compression),
+      background_close_inactive_wals(options.background_close_inactive_wals),
       atomic_flush(options.atomic_flush),
       avoid_unnecessary_blocking_io(options.avoid_unnecessary_blocking_io),
       persist_stats_to_disk(options.persist_stats_to_disk),
@@ -755,7 +774,11 @@ ImmutableDBOptions::ImmutableDBOptions(const DBOptions& options)
       checksum_handoff_file_types(options.checksum_handoff_file_types),
       lowest_used_cache_tier(options.lowest_used_cache_tier),
       compaction_service(options.compaction_service),
-      enforce_single_del_contracts(options.enforce_single_del_contracts) {
+      enforce_single_del_contracts(options.enforce_single_del_contracts),
+      follower_refresh_catchup_period_ms(
+          options.follower_refresh_catchup_period_ms),
+      follower_catchup_retry_count(options.follower_catchup_retry_count),
+      follower_catchup_retry_wait_ms(options.follower_catchup_retry_wait_ms) {
   fs = env->GetFileSystem();
   clock = env->GetSystemClock().get();
   logger = info_log.get();
@@ -903,6 +926,9 @@ void ImmutableDBOptions::Dump(Logger* log) const {
                    manual_wal_flush);
   ROCKS_LOG_HEADER(log, "            Options.wal_compression: %d",
                    wal_compression);
+  ROCKS_LOG_HEADER(log,
+                   "            Options.background_close_inactive_wals: %d",
+                   background_close_inactive_wals);
   ROCKS_LOG_HEADER(log, "            Options.atomic_flush: %d", atomic_flush);
   ROCKS_LOG_HEADER(log,
                    "            Options.avoid_unnecessary_blocking_io: %d",

package/vendor/librocksdb/vendor/rocksdb/options/db_options.h

@@ -84,6 +84,7 @@ struct ImmutableDBOptions {
   bool two_write_queues;
   bool manual_wal_flush;
   CompressionType wal_compression;
+  bool background_close_inactive_wals;
   bool atomic_flush;
   bool avoid_unnecessary_blocking_io;
   bool persist_stats_to_disk;
@@ -97,13 +98,19 @@ struct ImmutableDBOptions {
   std::string db_host_id;
   FileTypeSet checksum_handoff_file_types;
   CacheTier lowest_used_cache_tier;
-  // Convenience/Helper objects that are not part of the base DBOptions
+  std::shared_ptr<CompactionService> compaction_service;
+  bool enforce_single_del_contracts;
+  uint64_t follower_refresh_catchup_period_ms;
+  uint64_t follower_catchup_retry_count;
+  uint64_t follower_catchup_retry_wait_ms;
+
+  // Beginning convenience/helper objects that are not part of the base
+  // DBOptions
   std::shared_ptr<FileSystem> fs;
   SystemClock* clock;
   Statistics* stats;
   Logger* logger;
-  std::shared_ptr<CompactionService> compaction_service;
-  bool enforce_single_del_contracts;
+  // End of convenience/helper objects.
 
   bool IsWalDirSameAsDBPath() const;
   bool IsWalDirSameAsDBPath(const std::string& path) const;

package/vendor/librocksdb/vendor/rocksdb/options/options.cc

@@ -360,6 +360,9 @@ void ColumnFamilyOptions::Dump(Logger* log) const {
     ROCKS_LOG_HEADER(log,
                      "Options.compaction_options_universal.stop_style: %s",
                      str_compaction_stop_style.c_str());
+    ROCKS_LOG_HEADER(log,
+                     "Options.compaction_options_universal.max_read_amp: %d",
+                     compaction_options_universal.max_read_amp);
     ROCKS_LOG_HEADER(
         log, "Options.compaction_options_fifo.max_table_files_size: %" PRIu64,
         compaction_options_fifo.max_table_files_size);

package/vendor/librocksdb/vendor/rocksdb/options/options_helper.cc

@@ -274,6 +274,7 @@ void UpdateColumnFamilyOptions(const MutableCFOptions& moptions,
   cf_opts->last_level_temperature = moptions.last_level_temperature;
   cf_opts->default_write_temperature = moptions.default_write_temperature;
   cf_opts->memtable_max_range_deletions = moptions.memtable_max_range_deletions;
+  cf_opts->uncache_aggressiveness = moptions.uncache_aggressiveness;
 }
 
 void UpdateColumnFamilyOptions(const ImmutableCFOptions& ioptions,

package/vendor/librocksdb/vendor/rocksdb/port/jemalloc_helper.h

@@ -6,7 +6,7 @@
 #pragma once
 
 #if defined(__clang__) && defined(__GLIBC__)
-// glibc's `posix_memalign()` declaration specifies `throw()` while clang's
+// glibc's `posix_memalign()` declaration specifies `noexcept` while clang's
 // declaration does not. There is a hack in clang to make its re-declaration
 // compatible with glibc's if they are declared consecutively. That hack breaks
 // if yet another `posix_memalign()` declaration comes between glibc's and
@@ -14,7 +14,7 @@
 // declarations both come before "jemalloc.h"'s `posix_memalign()` declaration.
 //
 // This problem could also be avoided if "jemalloc.h"'s `posix_memalign()`
-// declaration did not specify `throw()` when built with clang.
+// declaration did not specify `noexcept` when built with clang.
 #include <mm_malloc.h>
 #endif
 

package/vendor/librocksdb/vendor/rocksdb/port/stack_trace.cc

@@ -39,6 +39,7 @@ void* SaveStack(int* /*num_frames*/, int /*first_frames_to_skip*/) {
 #endif  // OS_OPENBSD
 #ifdef OS_FREEBSD
 #include <sys/sysctl.h>
+#include <sys/wait.h>
 #endif  // OS_FREEBSD
 #ifdef OS_LINUX
 #include <sys/prctl.h>

package/vendor/librocksdb/vendor/rocksdb/port/win/port_win.cc

@@ -101,8 +101,9 @@ bool CondVar::TimedWait(uint64_t abs_time_us) {
   std::unique_lock<std::mutex> lk(mu_->getLock(), std::adopt_lock);
 
   // Work around https://github.com/microsoft/STL/issues/369
-#if defined(_MSC_VER) && \
-    (!defined(_MSVC_STL_UPDATE) || _MSVC_STL_UPDATE < 202008L)
+  // std::condition_variable_any::wait_for had a fix, but
+  // std::condition_variable still doesn't have a fix in STL yet
+#if defined(_MSC_VER)
   if (relTimeUs == std::chrono::microseconds::zero()) {
     lk.unlock();
     lk.lock();

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

@@ -44,9 +44,8 @@ InternalIteratorBase<IndexValue>* BinarySearchIndexReader::NewIterator(
     IndexBlockIter* iter, GetContext* get_context,
     BlockCacheLookupContext* lookup_context) {
   const BlockBasedTable::Rep* rep = table()->get_rep();
-  const bool no_io = (read_options.read_tier == kBlockCacheTier);
   CachableEntry<Block> index_block;
-  const Status s = GetOrReadIndexBlock(no_io, get_context, lookup_context,
+  const Status s = GetOrReadIndexBlock(get_context, lookup_context,
                                        &index_block, read_options);
   if (!s.ok()) {
     if (iter != nullptr) {

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

@@ -293,9 +293,10 @@ struct BlockBasedTableBuilder::Rep {
 
   InternalKeySliceTransform internal_prefix_transform;
   std::unique_ptr<IndexBuilder> index_builder;
+  std::string index_separator_scratch;
   PartitionedIndexBuilder* p_index_builder_ = nullptr;
 
-  std::string last_key;
+  std::string last_ikey;  // Internal key or empty (unset)
   const Slice* first_key_in_next_block = nullptr;
   CompressionType compression_type;
   uint64_t sample_for_compression;
@@ -582,8 +583,10 @@ struct BlockBasedTableBuilder::Rep {
       assert(factory);
 
       std::unique_ptr<InternalTblPropColl> collector{
-          factory->CreateInternalTblPropColl(tbo.column_family_id,
-                                             tbo.level_at_creation)};
+          factory->CreateInternalTblPropColl(
+              tbo.column_family_id, tbo.level_at_creation,
+              tbo.ioptions.num_levels,
+              tbo.last_level_inclusive_max_seqno_threshold)};
       if (collector) {
         table_properties_collectors.emplace_back(std::move(collector));
       }
@@ -626,6 +629,14 @@ struct BlockBasedTableBuilder::Rep {
     } else {
       base_context_checksum = 0;
     }
+
+    if (alignment > 0 && compression_type != kNoCompression) {
+      // With better sanitization in `CompactionPicker::CompactFiles()`, we
+      // would not need to handle this case here and could change it to an
+      // assertion instead.
+      SetStatus(Status::InvalidArgument(
+          "Enable block_align, but compression enabled"));
+    }
   }
 
   Rep(const Rep&) = delete;
@@ -987,24 +998,24 @@ BlockBasedTableBuilder::~BlockBasedTableBuilder() {
   delete rep_;
 }
 
-void BlockBasedTableBuilder::Add(const Slice& key, const Slice& value) {
+void BlockBasedTableBuilder::Add(const Slice& ikey, const Slice& value) {
   Rep* r = rep_;
   assert(rep_->state != Rep::State::kClosed);
   if (!ok()) {
     return;
   }
-  ValueType value_type = ExtractValueType(key);
+  ValueType value_type = ExtractValueType(ikey);
   if (IsValueType(value_type)) {
 #ifndef NDEBUG
     if (r->props.num_entries > r->props.num_range_deletions) {
-      assert(r->internal_comparator.Compare(key, Slice(r->last_key)) > 0);
+      assert(r->internal_comparator.Compare(ikey, Slice(r->last_ikey)) > 0);
     }
 #endif  // !NDEBUG
 
-    auto should_flush = r->flush_block_policy->Update(key, value);
+    auto should_flush = r->flush_block_policy->Update(ikey, value);
     if (should_flush) {
       assert(!r->data_block.empty());
-      r->first_key_in_next_block = &key;
+      r->first_key_in_next_block = &ikey;
       Flush();
       if (r->state == Rep::State::kBuffered) {
         bool exceeds_buffer_limit =
@@ -1039,8 +1050,9 @@ void BlockBasedTableBuilder::Add(const Slice& key, const Slice& value) {
         if (r->IsParallelCompressionEnabled()) {
           r->pc_rep->curr_block_keys->Clear();
         } else {
-          r->index_builder->AddIndexEntry(&r->last_key, &key,
-                                          r->pending_handle);
+          r->index_builder->AddIndexEntry(r->last_ikey, &ikey,
+                                          r->pending_handle,
+                                          &r->index_separator_scratch);
         }
       }
     }
@@ -1049,27 +1061,28 @@ void BlockBasedTableBuilder::Add(const Slice& key, const Slice& value) {
     // builder after being added to index builder.
     if (r->state == Rep::State::kUnbuffered) {
       if (r->IsParallelCompressionEnabled()) {
-        r->pc_rep->curr_block_keys->PushBack(key);
+        r->pc_rep->curr_block_keys->PushBack(ikey);
       } else {
         if (r->filter_builder != nullptr) {
           r->filter_builder->Add(
-              ExtractUserKeyAndStripTimestamp(key, r->ts_sz));
+              ExtractUserKeyAndStripTimestamp(ikey, r->ts_sz));
         }
       }
     }
 
-    r->data_block.AddWithLastKey(key, value, r->last_key);
-    r->last_key.assign(key.data(), key.size());
+    r->data_block.AddWithLastKey(ikey, value, r->last_ikey);
+    r->last_ikey.assign(ikey.data(), ikey.size());
+    assert(!r->last_ikey.empty());
     if (r->state == Rep::State::kBuffered) {
       // Buffered keys will be replayed from data_block_buffers during
       // `Finish()` once compression dictionary has been finalized.
     } else {
       if (!r->IsParallelCompressionEnabled()) {
-        r->index_builder->OnKeyAdded(key);
+        r->index_builder->OnKeyAdded(ikey);
       }
     }
     // TODO offset passed in is not accurate for parallel compression case
-    NotifyCollectTableCollectorsOnAdd(key, value, r->get_offset(),
+    NotifyCollectTableCollectorsOnAdd(ikey, value, r->get_offset(),
                                       r->table_properties_collectors,
                                       r->ioptions.logger);
 
@@ -1083,9 +1096,9 @@ void BlockBasedTableBuilder::Add(const Slice& key, const Slice& value) {
     if (r->ts_sz > 0 && !r->persist_user_defined_timestamps) {
       persisted_end = StripTimestampFromUserKey(value, r->ts_sz);
     }
-    r->range_del_block.Add(key, persisted_end);
+    r->range_del_block.Add(ikey, persisted_end);
     // TODO offset passed in is not accurate for parallel compression case
-    NotifyCollectTableCollectorsOnAdd(key, value, r->get_offset(),
+    NotifyCollectTableCollectorsOnAdd(ikey, value, r->get_offset(),
                                       r->table_properties_collectors,
                                       r->ioptions.logger);
   } else {
@@ -1097,7 +1110,7 @@ void BlockBasedTableBuilder::Add(const Slice& key, const Slice& value) {
   }
 
   r->props.num_entries++;
-  r->props.raw_key_size += key.size();
+  r->props.raw_key_size += ikey.size();
   if (!r->persist_user_defined_timestamps) {
     r->props.raw_key_size -= r->ts_sz;
   }
@@ -1475,14 +1488,15 @@ void BlockBasedTableBuilder::BGWorkWriteMaybeCompressedBlock() {
     ++r->props.num_data_blocks;
 
     if (block_rep->first_key_in_next_block == nullptr) {
-      r->index_builder->AddIndexEntry(&(block_rep->keys->Back()), nullptr,
-                                      r->pending_handle);
+      r->index_builder->AddIndexEntry(block_rep->keys->Back(), nullptr,
+                                      r->pending_handle,
+                                      &r->index_separator_scratch);
     } else {
       Slice first_key_in_next_block =
           Slice(*block_rep->first_key_in_next_block);
-      r->index_builder->AddIndexEntry(&(block_rep->keys->Back()),
-                                      &first_key_in_next_block,
-                                      r->pending_handle);
+      r->index_builder->AddIndexEntry(
+          block_rep->keys->Back(), &first_key_in_next_block, r->pending_handle,
+          &r->index_separator_scratch);
     }
 
     r->pc_rep->ReapBlock(block_rep);
@@ -1566,9 +1580,10 @@ void BlockBasedTableBuilder::WriteFilterBlock(
       // See FilterBlockBuilder::Finish() for more on the difference in
       // transferred filter data payload among different FilterBlockBuilder
       // subtypes.
-      std::unique_ptr<const char[]> filter_data;
-      Slice filter_content =
-          rep_->filter_builder->Finish(filter_block_handle, &s, &filter_data);
+      std::unique_ptr<const char[]> filter_owner;
+      Slice filter_content;
+      s = rep_->filter_builder->Finish(filter_block_handle, &filter_content,
+                                       &filter_owner);
 
       assert(s.ok() || s.IsIncomplete() || s.IsCorruption());
       if (s.IsCorruption()) {
@@ -1977,9 +1992,9 @@ void BlockBasedTableBuilder::EnterUnbuffered() {
         Slice* first_key_in_next_block_ptr = &first_key_in_next_block;
 
         iter->SeekToLast();
-        std::string last_key = iter->key().ToString();
-        r->index_builder->AddIndexEntry(&last_key, first_key_in_next_block_ptr,
-                                        r->pending_handle);
+        r->index_builder->AddIndexEntry(
+            iter->key(), first_key_in_next_block_ptr, r->pending_handle,
+            &r->index_separator_scratch);
       }
     }
     std::swap(iter, next_block_iter);
@@ -2015,7 +2030,8 @@ Status BlockBasedTableBuilder::Finish() {
     // block, we will finish writing all index entries first.
     if (ok() && !empty_data_block) {
       r->index_builder->AddIndexEntry(
-          &r->last_key, nullptr /* no next data block */, r->pending_handle);
+          r->last_ikey, nullptr /* no next data block */, r->pending_handle,
+          &r->index_separator_scratch);
     }
   }