@nxtedition/rocksdb 13.5.13 → 15.0.1

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

@@ -18,6 +18,7 @@
 #include "rocksdb/comparator.h"
 #include "table/block_based/block_based_table_factory.h"
 #include "table/block_based/block_builder.h"
+#include "table/block_based/flush_block_policy_impl.h"
 #include "table/format.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -76,6 +77,49 @@ class IndexBuilder {
                               const BlockHandle& block_handle,
                               std::string* separator_scratch) = 0;
 
+  // An abstract (extensible) holder for passing data from PrepareIndexEntry to
+  // FinishIndexEntry (see below).
+  struct PreparedIndexEntry {
+    virtual ~PreparedIndexEntry() = default;
+  };
+
+  // Parallel compression/construction alternative to AddIndexEntry, 1/3
+  //
+  // This function creates a holder for data that needs to be passed from
+  // PrepareIndexEntry to FinishIndexEntry, depending on the implementation
+  // of those. Few of these are created and reused, so construction/destruction
+  // performance is not critical.
+  virtual std::unique_ptr<PreparedIndexEntry> CreatePreparedIndexEntry() = 0;
+
+  // Parallel compression/construction alternative to AddIndexEntry, 2/3
+  //
+  // One thread calls this function for successive index entries to compute and
+  // record in `out` what is needed to build the index entry EXCEPT for the
+  // BlockHandle, which will only be known later. That thread is generally the
+  // same thread as calls every other function such as OnKeyAdded EXCEPT
+  // FinishIndexEntry (see below). This function should be considered "mostly
+  // stateless" but might modify state distinct from what is modified by
+  // FinishIndexEntry. Ideally synchronization within the IndexBuilder can be
+  // avoided.
+  //
+  // The passed-in PreparedIndexEntry object is likely reused so might be
+  // passed-in in any state.
+  virtual void PrepareIndexEntry(const Slice& last_key_in_current_block,
+                                 const Slice* first_key_in_next_block,
+                                 PreparedIndexEntry* out) = 0;
+
+  // Parallel compression/construction alternative to AddIndexEntry, 3/3
+  //
+  // This function is called by a different thread than PrepareIndexEntry, but
+  // is called on entries in the same order as PrepareIndexEntry, passed in the
+  // PreparedIndexEntry objects populated by PrepareIndexEntry. This function
+  // finishes the same effect of AddIndexEntry but split across a few functions.
+  //
+  // External synchronization ensures Finish is only called after all the
+  // FinishIndexEntry calls have completed.
+  virtual void FinishIndexEntry(const BlockHandle& block_handle,
+                                PreparedIndexEntry* entry) = 0;
+
   // This method will be called whenever a key is added. The subclasses may
   // override OnKeyAdded() if they need to collect additional information.
   virtual void OnKeyAdded(const Slice& /*key*/,
@@ -109,7 +153,7 @@ class IndexBuilder {
   // Get the size for index block. Must be called after ::Finish.
   virtual size_t IndexSize() const = 0;
 
-  virtual bool seperator_is_key_plus_seq() { return true; }
+  virtual bool separator_is_key_plus_seq() { return true; }
 
  protected:
   // Given the last key in current block and the first key in the next block,
@@ -117,7 +161,7 @@ class IndexBuilder {
   // can be used as separator.
   inline bool ShouldUseKeyPlusSeqAsSeparator(
       const Slice& last_key_in_current_block,
-      const Slice& first_key_in_next_block) {
+      const Slice& first_key_in_next_block) const {
     Slice l_user_key = ExtractUserKey(last_key_in_current_block);
     Slice r_user_key = ExtractUserKey(first_key_in_next_block);
     // If user defined timestamps are not persisted. All the user keys will
@@ -178,7 +222,7 @@ class ShortenedIndexBuilder : public IndexBuilder {
         include_first_key_(include_first_key),
         shortening_mode_(shortening_mode) {
     // Making the default true will disable the feature for old versions
-    seperator_is_key_plus_seq_ = (format_version <= 2);
+    must_use_separator_with_seq_ = (format_version <= 2);
   }
 
   void OnKeyAdded(const Slice& key,
@@ -188,49 +232,61 @@ class ShortenedIndexBuilder : public IndexBuilder {
     }
   }
 
-  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;
+  Slice GetSeparatorWithSeq(const Slice& last_key_in_current_block,
+                            const Slice* first_key_in_next_block,
+                            std::string* separator_scratch) {
+    Slice separator_with_seq;
     if (first_key_in_next_block != nullptr) {
       if (shortening_mode_ !=
           BlockBasedTableOptions::IndexShorteningMode::kNoShortening) {
-        separator = FindShortestInternalKeySeparator(
+        separator_with_seq = FindShortestInternalKeySeparator(
             *comparator_->user_comparator(), last_key_in_current_block,
             *first_key_in_next_block, separator_scratch);
       } else {
-        separator = last_key_in_current_block;
+        separator_with_seq = last_key_in_current_block;
       }
-      if (!seperator_is_key_plus_seq_ &&
+      if (!must_use_separator_with_seq_ &&
           ShouldUseKeyPlusSeqAsSeparator(last_key_in_current_block,
                                          *first_key_in_next_block)) {
-        seperator_is_key_plus_seq_ = true;
+        must_use_separator_with_seq_ = true;
       }
     } else {
       if (shortening_mode_ == BlockBasedTableOptions::IndexShorteningMode::
                                   kShortenSeparatorsAndSuccessor) {
-        separator = FindShortInternalKeySuccessor(
+        separator_with_seq = FindShortInternalKeySuccessor(
             *comparator_->user_comparator(), last_key_in_current_block,
             separator_scratch);
       } else {
-        separator = last_key_in_current_block;
+        separator_with_seq = last_key_in_current_block;
       }
     }
+    return separator_with_seq;
+  }
 
-    assert(!include_first_key_ || !current_block_first_internal_key_.empty());
+  Slice GetFirstInternalKey(std::string* first_internal_key_buf) const {
+    if (!include_first_key_) {
+      return Slice();
+    }
+    assert(!current_block_first_internal_key_.empty());
     // When UDT should not be persisted, the index block builders take care of
     // stripping UDT from the key, for the first internal key contained in the
     // IndexValue, we need to explicitly do the stripping here before passing
     // it to the block builders.
-    std::string first_internal_key_buf;
     Slice first_internal_key = current_block_first_internal_key_;
     if (!current_block_first_internal_key_.empty() && ts_sz_ > 0 &&
         !persist_user_defined_timestamps_) {
-      StripTimestampFromInternalKey(&first_internal_key_buf,
+      first_internal_key_buf->clear();
+      StripTimestampFromInternalKey(first_internal_key_buf,
                                     current_block_first_internal_key_, ts_sz_);
-      first_internal_key = first_internal_key_buf;
+      first_internal_key = *first_internal_key_buf;
     }
+    return first_internal_key;
+  }
+
+  void AddIndexEntryImpl(const Slice& separator_with_seq,
+                         const Slice& first_internal_key,
+                         const BlockHandle& block_handle,
+                         bool must_use_separator_with_seq) {
     IndexValue entry(block_handle, first_internal_key);
     std::string encoded_entry;
     std::string delta_encoded_entry;
@@ -254,21 +310,91 @@ 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(separator, encoded_entry,
+    index_block_builder_.Add(separator_with_seq, encoded_entry,
                              &delta_encoded_entry_slice);
-    if (!seperator_is_key_plus_seq_) {
-      index_block_builder_without_seq_.Add(
-          ExtractUserKey(separator), encoded_entry, &delta_encoded_entry_slice);
+    if (!must_use_separator_with_seq) {
+      index_block_builder_without_seq_.Add(ExtractUserKey(separator_with_seq),
+                                           encoded_entry,
+                                           &delta_encoded_entry_slice);
     }
+  }
+
+  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_with_seq = GetSeparatorWithSeq(
+        last_key_in_current_block, first_key_in_next_block, separator_scratch);
 
+    std::string first_internal_key_buf;
+    Slice first_internal_key = GetFirstInternalKey(&first_internal_key_buf);
+
+    AddIndexEntryImpl(separator_with_seq, first_internal_key, block_handle,
+                      must_use_separator_with_seq_);
+    current_block_first_internal_key_.clear();
+    return separator_with_seq;
+  }
+
+  struct ShortenedPreparedIndexEntry : public PreparedIndexEntry {
+    std::string separator_with_seq;
+    std::string first_internal_key;
+    bool must_use_separator_with_seq = false;
+    void SaveFrom(const Slice& from_separator,
+                  const Slice& from_first_internal_key,
+                  bool from_must_use_separator_with_seq) {
+      assert(from_separator.size() >= kNumInternalBytes);
+      if (from_separator.data() == separator_with_seq.data()) {
+        // No need to copy
+        assert(from_separator.size() == separator_with_seq.size());
+      } else {
+        // Copy the separator
+        separator_with_seq.assign(from_separator.data(), from_separator.size());
+      }
+      // first_internal_key is optional, so it may be empty.
+      assert(from_first_internal_key.empty() ||
+             from_first_internal_key.size() >= kNumInternalBytes);
+      if (from_first_internal_key.data() == first_internal_key.data()) {
+        // No need to copy
+        assert(from_first_internal_key.size() == first_internal_key.size());
+      } else {
+        // Copy the first internal key
+        first_internal_key.assign(from_first_internal_key.data(),
+                                  from_first_internal_key.size());
+      }
+      must_use_separator_with_seq = from_must_use_separator_with_seq;
+    }
+  };
+
+  std::unique_ptr<PreparedIndexEntry> CreatePreparedIndexEntry() override {
+    return std::make_unique<ShortenedPreparedIndexEntry>();
+  }
+
+  void PrepareIndexEntry(const Slice& last_key_in_current_block,
+                         const Slice* first_key_in_next_block,
+                         PreparedIndexEntry* out) override {
+    ShortenedPreparedIndexEntry* entry =
+        static_cast<ShortenedPreparedIndexEntry*>(out);
+    Slice separator =
+        GetSeparatorWithSeq(last_key_in_current_block, first_key_in_next_block,
+                            &entry->separator_with_seq);
+    Slice first_internal_key = GetFirstInternalKey(&entry->first_internal_key);
+    entry->SaveFrom(separator, first_internal_key,
+                    must_use_separator_with_seq_);
     current_block_first_internal_key_.clear();
-    return separator;
+  }
+
+  void FinishIndexEntry(const BlockHandle& block_handle,
+                        PreparedIndexEntry* base_entry) override {
+    ShortenedPreparedIndexEntry* entry =
+        static_cast<ShortenedPreparedIndexEntry*>(base_entry);
+    AddIndexEntryImpl(entry->separator_with_seq, entry->first_internal_key,
+                      block_handle, entry->must_use_separator_with_seq);
   }
 
   using IndexBuilder::Finish;
   Status Finish(IndexBlocks* index_blocks,
                 const BlockHandle& /*last_partition_block_handle*/) override {
-    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 =
@@ -280,8 +406,8 @@ class ShortenedIndexBuilder : public IndexBuilder {
 
   size_t IndexSize() const override { return index_size_; }
 
-  bool seperator_is_key_plus_seq() override {
-    return seperator_is_key_plus_seq_;
+  bool separator_is_key_plus_seq() override {
+    return must_use_separator_with_seq_;
   }
 
   // Changes *key to a short string >= *key.
@@ -299,9 +425,13 @@ class ShortenedIndexBuilder : public IndexBuilder {
 
  private:
   BlockBuilder index_block_builder_;
+  // TODO: consider optimizing to only one builder. When discovering that
+  // sequence numbers are needed, read existing entries without seq and rewrite
+  // them with seq (which should be trivial to populate since seq wasn't needed
+  // before).
   BlockBuilder index_block_builder_without_seq_;
   const bool use_value_delta_encoding_;
-  bool seperator_is_key_plus_seq_;
+  bool must_use_separator_with_seq_;
   const bool include_first_key_;
   BlockBasedTableOptions::IndexShorteningMode shortening_mode_;
   BlockHandle last_encoded_handle_ = BlockHandle::NullBlockHandle();
@@ -360,6 +490,23 @@ class HashIndexBuilder : public IndexBuilder {
         separator_scratch);
   }
 
+  std::unique_ptr<PreparedIndexEntry> CreatePreparedIndexEntry() override {
+    return primary_index_builder_.CreatePreparedIndexEntry();
+  }
+
+  void PrepareIndexEntry(const Slice& last_key_in_current_block,
+                         const Slice* first_key_in_next_block,
+                         PreparedIndexEntry* out) override {
+    ++current_restart_index_;
+    primary_index_builder_.PrepareIndexEntry(last_key_in_current_block,
+                                             first_key_in_next_block, out);
+  }
+
+  void FinishIndexEntry(const BlockHandle& block_handle,
+                        PreparedIndexEntry* entry) override {
+    primary_index_builder_.FinishIndexEntry(block_handle, entry);
+  }
+
   void OnKeyAdded(const Slice& key,
                   const std::optional<Slice>& /*value*/) override {
     auto key_prefix = hash_key_extractor_->Transform(key);
@@ -407,8 +554,8 @@ class HashIndexBuilder : public IndexBuilder {
            prefix_meta_block_.size();
   }
 
-  bool seperator_is_key_plus_seq() override {
-    return primary_index_builder_.seperator_is_key_plus_seq();
+  bool separator_is_key_plus_seq() override {
+    return primary_index_builder_.separator_is_key_plus_seq();
   }
 
  private:
@@ -466,6 +613,14 @@ class PartitionedIndexBuilder : public IndexBuilder {
                       const BlockHandle& block_handle,
                       std::string* separator_scratch) override;
 
+  std::unique_ptr<PreparedIndexEntry> CreatePreparedIndexEntry() override;
+  void PrepareIndexEntry(const Slice& last_key_in_current_block,
+                         const Slice* first_key_in_next_block,
+                         PreparedIndexEntry* out) override;
+  void FinishIndexEntry(const BlockHandle& block_handle,
+                        PreparedIndexEntry* entry) override;
+  void MaybeFlush(const Slice& index_key, const BlockHandle& index_value);
+
   Status Finish(IndexBlocks* index_blocks,
                 const BlockHandle& last_partition_block_handle) override;
 
@@ -491,8 +646,8 @@ class PartitionedIndexBuilder : public IndexBuilder {
   // cutting the next partition
   void RequestPartitionCut();
 
-  bool seperator_is_key_plus_seq() override {
-    return seperator_is_key_plus_seq_;
+  bool separator_is_key_plus_seq() override {
+    return must_use_separator_with_seq_;
   }
 
   bool get_use_value_delta_encoding() const {
@@ -518,14 +673,14 @@ class PartitionedIndexBuilder : public IndexBuilder {
   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
-  std::unique_ptr<ShortenedIndexBuilder> sub_index_builder_;
+  // the active partition index builder (owned by an Entry in entries_)
+  ShortenedIndexBuilder* sub_index_builder_;
   // the last key in the active partition index builder
-  std::unique_ptr<FlushBlockPolicy> flush_policy_;
+  std::unique_ptr<RetargetableFlushBlockPolicy> flush_policy_;
   // true if Finish is called once but not complete yet.
-  bool finishing_indexes = false;
+  bool finishing_indexes_ = false;
   const BlockBasedTableOptions& table_opt_;
-  bool seperator_is_key_plus_seq_;
+  bool must_use_separator_with_seq_;
   bool use_value_delta_encoding_;
   // true if an external entity (such as filter partition builder) request
   // cutting the next partition

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

@@ -240,7 +240,7 @@ Status PartitionedFilterBlockBuilder::Finish(
 
     index_on_filter_block_builder_.Add(e.ikey, handle_encoding,
                                        &handle_delta_encoding_slice);
-    if (!p_index_builder_->seperator_is_key_plus_seq()) {
+    if (!p_index_builder_->separator_is_key_plus_seq()) {
       index_on_filter_block_builder_without_seq_.Add(
           ExtractUserKey(e.ikey), handle_encoding,
           &handle_delta_encoding_slice);
@@ -267,7 +267,7 @@ Status PartitionedFilterBlockBuilder::Finish(
     if (UNLIKELY(filters_.empty())) {
       if (!index_on_filter_block_builder_.empty()) {
         // Simplest to just add them all at the end
-        if (p_index_builder_->seperator_is_key_plus_seq()) {
+        if (p_index_builder_->separator_is_key_plus_seq()) {
           *filter = index_on_filter_block_builder_.Finish();
         } else {
           *filter = index_on_filter_block_builder_without_seq_.Finish();

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

@@ -27,7 +27,7 @@ class MockedBlockBasedTable : public BlockBasedTable {
   MockedBlockBasedTable(Rep* rep, PartitionedIndexBuilder* pib)
       : BlockBasedTable(rep, /*block_cache_tracer=*/nullptr) {
     // Initialize what Open normally does as much as necessary for the test
-    rep->index_key_includes_seq = pib->seperator_is_key_plus_seq();
+    rep->index_key_includes_seq = pib->separator_is_key_plus_seq();
     rep->index_value_is_full = !pib->get_use_value_delta_encoding();
   }
 };

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

@@ -46,23 +46,57 @@ class UserDefinedIndexBuilderWrapper : public IndexBuilder {
     handle.offset = block_handle.offset();
     handle.size = block_handle.size();
     // Forward the call to both index builders
-    user_defined_index_builder_->AddIndexEntry(last_key_in_current_block,
-                                               first_key_in_next_block, handle,
-                                               separator_scratch);
+    ParsedInternalKey pkey_last;
+    ParsedInternalKey pkey_first;
+    // There's no way to return an error here, so we remember the statsu and
+    // return it in Finish()
+    if (status_.ok()) {
+      status_ = ParseInternalKey(last_key_in_current_block, &pkey_last,
+                                 /*lof_err_key*/ false);
+    }
+    if (status_.ok() && first_key_in_next_block) {
+      status_ = ParseInternalKey(*first_key_in_next_block, &pkey_first,
+                                 /*lof_err_key*/ false);
+    }
+    if (status_.ok()) {
+      user_defined_index_builder_->AddIndexEntry(
+          pkey_last.user_key,
+          first_key_in_next_block ? &pkey_first.user_key : nullptr, handle,
+          separator_scratch);
+    }
     return internal_index_builder_->AddIndexEntry(
         last_key_in_current_block, first_key_in_next_block, block_handle,
         separator_scratch);
   }
 
+  // Not supported with parallel compression
+  std::unique_ptr<PreparedIndexEntry> CreatePreparedIndexEntry() override {
+    return nullptr;
+  }
+  void PrepareIndexEntry(const Slice& last_key_in_current_block,
+                         const Slice* first_key_in_next_block,
+                         PreparedIndexEntry* out) override {
+    (void)last_key_in_current_block;
+    (void)first_key_in_next_block;
+    (void)out;
+    assert(false);
+  }
+  void FinishIndexEntry(const BlockHandle& block_handle,
+                        PreparedIndexEntry* entry) override {
+    (void)block_handle;
+    (void)entry;
+    assert(false);
+  }
+
   void OnKeyAdded(const Slice& key,
                   const std::optional<Slice>& value) override {
+    ParsedInternalKey pkey;
     if (status_.ok()) {
       if (!value.has_value()) {
         status_ = Status::InvalidArgument(
             "user_defined_index_factory not supported with parallel "
             "compression");
       } else {
-        ParsedInternalKey pkey;
         status_ = ParseInternalKey(key, &pkey, /*lof_err_key*/ false);
         if (status_.ok() && pkey.type != ValueType::kTypeValue) {
           status_ = Status::InvalidArgument(
@@ -76,16 +110,38 @@ class UserDefinedIndexBuilderWrapper : public IndexBuilder {
 
     // Forward the call to both index builders
     internal_index_builder_->OnKeyAdded(key, value);
+
+    // Pass the user key to the UDI. We don't expect multiple entries with
+    // different sequence numbers for the same key in the file. RocksDB may
+    // enforce it in the future by allowing UDIs only for read only
+    // bulkloaded use cases, and only allow ingestion of files with
+    // sequence number 0.
     user_defined_index_builder_->OnKeyAdded(
-        key, UserDefinedIndexBuilder::ValueType::kValue, value.value());
+        pkey.user_key, UserDefinedIndexBuilder::ValueType::kValue,
+        value.value());
   }
 
   Status Finish(IndexBlocks* index_blocks,
                 const BlockHandle& last_partition_block_handle) override {
-    if (!status_.ok()) {
+    if (!status_.ok() && !status_.IsIncomplete()) {
       return status_;
     }
 
+    if (!udi_finished_) {
+      // Finish the user defined index builder
+      Slice user_index_contents;
+      status_ = user_defined_index_builder_->Finish(&user_index_contents);
+      if (!status_.ok()) {
+        return status_;
+      }
+
+      // Add the user defined index to the meta blocks
+      std::string block_name = kUserDefinedIndexPrefix + name_;
+      index_blocks->meta_blocks.insert(
+          {block_name, {BlockType::kUserDefinedIndex, user_index_contents}});
+      udi_finished_ = true;
+    }
+
     // Finish the internal index builder
     status_ = internal_index_builder_->Finish(index_blocks,
                                               last_partition_block_handle);
@@ -93,26 +149,14 @@ class UserDefinedIndexBuilderWrapper : public IndexBuilder {
       return status_;
     }
 
-    // Finish the user defined index builder
-    Slice user_index_contents;
-    status_ = user_defined_index_builder_->Finish(&user_index_contents);
-    if (!status_.ok()) {
-      return status_;
-    }
-
-    // Add the user defined index to the meta blocks
-    std::string block_name = kUserDefinedIndexPrefix + name_;
-    index_blocks->meta_blocks.insert(
-        {block_name, {BlockType::kUserDefinedIndex, user_index_contents}});
-
     index_size_ = internal_index_builder_->IndexSize();
     return status_;
   }
 
   size_t IndexSize() const override { return index_size_; }
 
-  bool seperator_is_key_plus_seq() override {
-    return internal_index_builder_->seperator_is_key_plus_seq();
+  bool separator_is_key_plus_seq() override {
+    return internal_index_builder_->separator_is_key_plus_seq();
   }
 
  private:
@@ -120,6 +164,7 @@ class UserDefinedIndexBuilderWrapper : public IndexBuilder {
   std::unique_ptr<IndexBuilder> internal_index_builder_;
   std::unique_ptr<UserDefinedIndexBuilder> user_defined_index_builder_;
   Status status_;
+  bool udi_finished_ = false;
 };
 
 class UserDefinedIndexIteratorWrapper
@@ -144,23 +189,41 @@ class UserDefinedIndexIteratorWrapper
     status_ = ParseInternalKey(target, &pkey, /*log_err_key=*/false);
     if (status_.ok()) {
       status_ = udi_iter_->SeekAndGetResult(pkey.user_key, &result_);
-      valid_ = status_.ok() &&
-               result_.bound_check_result == IterBoundCheck::kInbound;
+    }
+    if (status_.ok()) {
+      valid_ = result_.bound_check_result == IterBoundCheck::kInbound;
+      if (valid_) {
+        ikey_.Set(result_.key, 0, ValueType::kTypeValue);
+      }
+    } else {
+      valid_ = false;
     }
   }
 
   void Next() override {
     status_ = udi_iter_->NextAndGetResult(&result_);
-    valid_ =
-        status_.ok() && result_.bound_check_result == IterBoundCheck::kInbound;
+    if (status_.ok()) {
+      valid_ = result_.bound_check_result == IterBoundCheck::kInbound;
+      if (valid_) {
+        ikey_.Set(result_.key, 0, ValueType::kTypeValue);
+      }
+    } else {
+      valid_ = false;
+    }
   }
 
   bool NextAndGetResult(IterateResult* result) override {
     status_ = udi_iter_->NextAndGetResult(&result_);
-    valid_ =
-        status_.ok() && result_.bound_check_result == IterBoundCheck::kInbound;
     if (status_.ok()) {
-      *result = result_;
+      valid_ = result_.bound_check_result == IterBoundCheck::kInbound;
+      if (valid_) {
+        ikey_.Set(result_.key, 0, ValueType::kTypeValue);
+      }
+      if (status_.ok()) {
+        *result = result_;
+      }
+    } else {
+      valid_ = false;
     }
     return valid_;
   }
@@ -171,7 +234,7 @@ class UserDefinedIndexIteratorWrapper
 
   void Prev() override { status_ = Status::NotSupported("Prev not supported"); }
 
-  Slice key() const override { return result_.key; }
+  Slice key() const override { return Slice(*ikey_.const_rep()); }
 
   IndexValue value() const override {
     auto handle = udi_iter_->value();
@@ -181,13 +244,21 @@ class UserDefinedIndexIteratorWrapper
 
   Status status() const override { return status_; }
 
-  void Prepare(const std::vector<ScanOptions>* scan_opts) override {
-    udi_iter_->Prepare(scan_opts->data(), scan_opts->size());
+  void Prepare(const MultiScanArgs* scan_opts) override {
+    if (scan_opts) {
+      udi_iter_->Prepare(scan_opts->GetScanRanges().data(),
+                         scan_opts->GetScanRanges().size());
+    }
+  }
+
+  IterBoundCheck UpperBoundCheckResult() override {
+    return result_.bound_check_result;
   }
 
  private:
   std::unique_ptr<UserDefinedIndexIterator> udi_iter_;
   IterateResult result_;
+  InternalKey ikey_;
   Status status_;
   bool valid_;
 };
@@ -218,7 +289,13 @@ class UserDefinedIndexReaderWrapper : public BlockBasedTable::IndexReader {
     }
     std::unique_ptr<UserDefinedIndexIterator> udi_iter =
         udi_reader_->NewIterator(read_options);
-    return new UserDefinedIndexIteratorWrapper(std::move(udi_iter));
+    if (udi_iter) {
+      InternalIteratorBase<IndexValue>* wrap_iter =
+          new UserDefinedIndexIteratorWrapper(std::move(udi_iter));
+      return wrap_iter;
+    }
+    return NewErrorInternalIterator<IndexValue>(
+        Status::NotFound("COuld not create UDI iterator"));
   }
 
   virtual Status CacheDependencies(

package/deps/rocksdb/rocksdb/table/external_table.cc

@@ -131,9 +131,11 @@ class ExternalTableIteratorAdapter : public InternalIterator {
 
   Status status() const override { return status_; }
 
-  void Prepare(const std::vector<ScanOptions>* scan_opts) override {
-    if (iterator_) {
-      iterator_->Prepare(scan_opts->data(), scan_opts->size());
+  void Prepare(const MultiScanArgs* scan_opts) override {
+    if (iterator_ && scan_opts) {
+      iterator_->Prepare(scan_opts->GetScanRanges().data(), scan_opts->size());
+    } else if (iterator_) {
+      iterator_->Prepare(nullptr, 0);
     }
   }
 
@@ -224,6 +226,7 @@ class ExternalTableReaderAdapter : public TableReader {
       // external table reader
       props = std::make_shared<TableProperties>(*reader_->GetTableProperties());
       props->key_largest_seqno = 0;
+      props->key_smallest_seqno = 0;
     }
     return props;
   }
@@ -260,6 +263,7 @@ class ExternalTableBuilderAdapter : public TableBuilder {
     properties_.filter_size = 0;
     properties_.format_version = 0;
     properties_.key_largest_seqno = 0;
+    properties_.key_smallest_seqno = 0;
     properties_.column_family_id = topts.column_family_id;
     properties_.column_family_name = topts.column_family_name;
     properties_.db_id = topts.db_id;