@nxtedition/rocksdb 12.1.3 → 12.1.5

package/deps/rocksdb/rocksdb/db/db_iter.cc

@@ -65,9 +65,8 @@ DBIter::DBIter(Env* _env, const ReadOptions& read_options,
       valid_(false),
       current_entry_is_merged_(false),
       is_key_seqnum_zero_(false),
-      prefix_same_as_start_(mutable_cf_options.prefix_extractor
-                                ? read_options.prefix_same_as_start
-                                : false),
+      prefix_same_as_start_(
+          prefix_extractor_ ? read_options.prefix_same_as_start : false),
       pin_thru_lifetime_(read_options.pin_data),
       expect_total_order_inner_iter_(prefix_extractor_ == nullptr ||
                                      read_options.total_order_seek ||
@@ -93,6 +92,9 @@ DBIter::DBIter(Env* _env, const ReadOptions& read_options,
   status_.PermitUncheckedError();
   assert(timestamp_size_ ==
          user_comparator_.user_comparator()->timestamp_size());
+  // prefix_seek_opt_in_only should force total_order_seek whereever the caller
+  // is duplicating the original ReadOptions
+  assert(!ioptions.prefix_seek_opt_in_only || read_options.total_order_seek);
 }
 
 Status DBIter::GetProperty(std::string prop_name, std::string* prop) {
@@ -538,6 +540,8 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
     } else {
       iter_.Next();
     }
+    // This could be a long-running operation due to tombstones, etc.
+    ROCKSDB_THREAD_YIELD_HOOK();
   } while (iter_.Valid());
 
   valid_ = false;

package/deps/rocksdb/rocksdb/db/db_secondary_test.cc

@@ -244,7 +244,7 @@ TEST_F(DBSecondaryTest, SimpleInternalCompaction) {
   ASSERT_EQ(largest.user_key().ToString(), "foo");
   ASSERT_EQ(result.output_level, 1);
   ASSERT_EQ(result.output_path, this->secondary_path_);
-  ASSERT_EQ(result.num_output_records, 2);
+  ASSERT_EQ(result.stats.num_output_records, 2);
   ASSERT_GT(result.bytes_written, 0);
   ASSERT_OK(result.status);
 }

package/deps/rocksdb/rocksdb/db/db_sst_test.cc

@@ -383,12 +383,16 @@ TEST_F(DBSSTTest, DBWithSstFileManager) {
   ASSERT_EQ(files_moved, 0);
 
   Close();
+  ASSERT_EQ(sfm->GetTrackedFiles().size(), 0) << "sfm should be empty";
+  ASSERT_EQ(sfm->GetTotalSize(), 0) << "sfm should be empty";
   Reopen(options);
   ASSERT_EQ(sfm->GetTrackedFiles(), files_in_db);
   ASSERT_EQ(sfm->GetTotalSize(), total_files_size);
 
   // Verify that we track all the files again after the DB is closed and opened
   Close();
+  ASSERT_EQ(sfm->GetTrackedFiles().size(), 0) << "sfm should be empty";
+  ASSERT_EQ(sfm->GetTotalSize(), 0) << "sfm should be empty";
   sst_file_manager.reset(NewSstFileManager(env_));
   options.sst_file_manager = sst_file_manager;
   sfm = static_cast<SstFileManagerImpl*>(sst_file_manager.get());
@@ -439,6 +443,11 @@ TEST_F(DBSSTTest, DBWithSstFileManagerForBlobFiles) {
 
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
       "SstFileManagerImpl::OnMoveFile", [&](void* /*arg*/) { files_moved++; });
+
+  int64_t untracked_files = 0;
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
+      "SstFileManagerImpl::OnUntrackFile",
+      [&](void* /*arg*/) { ++untracked_files; });
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
 
   Options options = CurrentOptions();
@@ -485,6 +494,10 @@ TEST_F(DBSSTTest, DBWithSstFileManagerForBlobFiles) {
   }
   ASSERT_EQ(sfm->GetTotalSize(), total_files_size);
   Close();
+  ASSERT_EQ(untracked_files, files_in_db.size());
+  untracked_files = 0;
+  ASSERT_EQ(sfm->GetTrackedFiles().size(), 0) << "sfm should be empty";
+  ASSERT_EQ(sfm->GetTotalSize(), 0) << "sfm should be empty";
 
   Reopen(options);
   ASSERT_EQ(sfm->GetTrackedFiles(), files_in_db);
@@ -492,6 +505,10 @@ TEST_F(DBSSTTest, DBWithSstFileManagerForBlobFiles) {
 
   // Verify that we track all the files again after the DB is closed and opened.
   Close();
+  ASSERT_EQ(untracked_files, files_in_db.size());
+  untracked_files = 0;
+  ASSERT_EQ(sfm->GetTrackedFiles().size(), 0) << "sfm should be empty";
+  ASSERT_EQ(sfm->GetTotalSize(), 0) << "sfm should be empty";
 
   sst_file_manager.reset(NewSstFileManager(env_));
   options.sst_file_manager = sst_file_manager;
@@ -507,6 +524,10 @@ TEST_F(DBSSTTest, DBWithSstFileManagerForBlobFiles) {
   ASSERT_EQ(files_deleted, 0);
   ASSERT_EQ(files_scheduled_to_delete, 0);
   Close();
+  ASSERT_EQ(untracked_files, files_in_db.size());
+  untracked_files = 0;
+  ASSERT_EQ(sfm->GetTrackedFiles().size(), 0) << "sfm should be empty";
+  ASSERT_EQ(sfm->GetTotalSize(), 0) << "sfm should be empty";
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
       "SstFileManagerImpl::ScheduleUnaccountedFileDeletion", [&](void* arg) {
         assert(arg);
@@ -666,6 +687,9 @@ TEST_F(DBSSTTest, DBWithSstFileManagerForBlobFilesWithGC) {
   }
 
   Close();
+  ASSERT_EQ(sfm->GetTrackedFiles().size(), 0) << "sfm should be empty";
+  ASSERT_EQ(sfm->GetTotalSize(), 0) << "sfm should be empty";
+
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
       "SstFileManagerImpl::ScheduleUnaccountedFileDeletion", [&](void* arg) {
         assert(arg);

package/deps/rocksdb/rocksdb/db/db_test2.cc

@@ -5597,32 +5597,45 @@ TEST_F(DBTest2, PrefixBloomFilteredOut) {
   bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
   bbto.whole_key_filtering = false;
   options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-  DestroyAndReopen(options);
 
-  // Construct two L1 files with keys:
-  // f1:[aaa1 ccc1] f2:[ddd0]
-  ASSERT_OK(Put("aaa1", ""));
-  ASSERT_OK(Put("ccc1", ""));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put("ddd0", ""));
-  ASSERT_OK(Flush());
-  CompactRangeOptions cro;
-  cro.bottommost_level_compaction = BottommostLevelCompaction::kSkip;
-  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
+  // This test is also the primary test for prefix_seek_opt_in_only
+  for (bool opt_in : {false, true}) {
+    options.prefix_seek_opt_in_only = opt_in;
+    DestroyAndReopen(options);
 
-  Iterator* iter = db_->NewIterator(ReadOptions());
-  ASSERT_OK(iter->status());
+    // Construct two L1 files with keys:
+    // f1:[aaa1 ccc1] f2:[ddd0]
+    ASSERT_OK(Put("aaa1", ""));
+    ASSERT_OK(Put("ccc1", ""));
+    ASSERT_OK(Flush());
+    ASSERT_OK(Put("ddd0", ""));
+    ASSERT_OK(Flush());
+    CompactRangeOptions cro;
+    cro.bottommost_level_compaction = BottommostLevelCompaction::kSkip;
+    ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
 
-  // Bloom filter is filterd out by f1.
-  // This is just one of several valid position following the contract.
-  // Postioning to ccc1 or ddd0 is also valid. This is just to validate
-  // the behavior of the current implementation. If underlying implementation
-  // changes, the test might fail here.
-  iter->Seek("bbb1");
-  ASSERT_OK(iter->status());
-  ASSERT_FALSE(iter->Valid());
+    ReadOptions ropts;
+    for (bool same : {false, true}) {
+      ropts.prefix_same_as_start = same;
+      std::unique_ptr<Iterator> iter(db_->NewIterator(ropts));
+      ASSERT_OK(iter->status());
 
-  delete iter;
+      iter->Seek("bbb1");
+      ASSERT_OK(iter->status());
+      if (opt_in && !same) {
+        // Unbounded total order seek
+        ASSERT_TRUE(iter->Valid());
+        ASSERT_EQ(iter->key(), "ccc1");
+      } else {
+        // Bloom filter is filterd out by f1. When same == false, this is just
+        // one valid position following the contract. Postioning to ccc1 or ddd0
+        // is also valid. This is just to validate the behavior of the current
+        // implementation. If underlying implementation changes, the test might
+        // fail here.
+        ASSERT_FALSE(iter->Valid());
+      }
+    }
+  }
 }
 
 TEST_F(DBTest2, RowCacheSnapshot) {
@@ -5987,6 +6000,7 @@ TEST_F(DBTest2, ChangePrefixExtractor) {
     // create a DB with block prefix index
     BlockBasedTableOptions table_options;
     Options options = CurrentOptions();
+    options.prefix_seek_opt_in_only = false;  // Use legacy prefix seek
 
     // Sometimes filter is checked based on upper bound. Assert counters
     // for that case. Otherwise, only check data correctness.

package/deps/rocksdb/rocksdb/db/db_wal_test.cc

@@ -2931,6 +2931,29 @@ TEST_F(DBWALTest, RecoveryFlushSwitchWALOnEmptyMemtable) {
   ASSERT_EQ("new_v", Get("k"));
   Destroy(options);
 }
+
+TEST_F(DBWALTest, WALWriteErrorNoRecovery) {
+  Options options = CurrentOptions();
+  auto fault_fs = std::make_shared<FaultInjectionTestFS>(FileSystem::Default());
+  std::unique_ptr<Env> fault_fs_env(NewCompositeEnv(fault_fs));
+  options.env = fault_fs_env.get();
+  options.manual_wal_flush = true;
+  DestroyAndReopen(options);
+  fault_fs->SetThreadLocalErrorContext(
+      FaultInjectionIOType::kWrite, 7 /* seed*/, 1 /* one_in */,
+      true /* retryable */, false /* has_data_loss*/);
+  fault_fs->EnableThreadLocalErrorInjection(FaultInjectionIOType::kWrite);
+
+  ASSERT_OK(Put("k", "v"));
+  Status s;
+  s = db_->FlushWAL(false);
+  ASSERT_TRUE(s.IsIOError());
+  s = dbfull()->TEST_GetBGError();
+  ASSERT_EQ(s.severity(), Status::Severity::kFatalError);
+  ASSERT_FALSE(dbfull()->TEST_IsRecoveryInProgress());
+  fault_fs->DisableThreadLocalErrorInjection(FaultInjectionIOType::kWrite);
+  Destroy(options);
+}
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

package/deps/rocksdb/rocksdb/db/db_with_timestamp_basic_test.cc

@@ -832,6 +832,7 @@ TEST_P(DBBasicTestWithTimestampTableOptions, GetAndMultiGet) {
 
 TEST_P(DBBasicTestWithTimestampTableOptions, SeekWithPrefixLessThanKey) {
   Options options = CurrentOptions();
+  options.prefix_seek_opt_in_only = false;  // Use legacy prefix seek
   options.env = env_;
   options.create_if_missing = true;
   options.prefix_extractor.reset(NewFixedPrefixTransform(3));
@@ -1009,6 +1010,7 @@ TEST_F(DBBasicTestWithTimestamp, ChangeIterationDirection) {
   TestComparator test_cmp(kTimestampSize);
   options.comparator = &test_cmp;
   options.prefix_extractor.reset(NewFixedPrefixTransform(1));
+  options.prefix_seek_opt_in_only = false;  // Use legacy prefix seek
   options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
   DestroyAndReopen(options);
   const std::vector<std::string> timestamps = {Timestamp(1, 1), Timestamp(0, 2),

package/deps/rocksdb/rocksdb/db/error_handler.cc

@@ -381,7 +381,7 @@ void ErrorHandler::HandleKnownErrors(const Status& bg_err,
 //    BackgroundErrorReason reason) will be called to handle other error cases
 //    such as delegating to SstFileManager to handle no space error.
 void ErrorHandler::SetBGError(const Status& bg_status,
-                              BackgroundErrorReason reason) {
+                              BackgroundErrorReason reason, bool wal_related) {
   db_mutex_->AssertHeld();
   Status tmp_status = bg_status;
   IOStatus bg_io_err = status_to_io_status(std::move(tmp_status));
@@ -389,8 +389,8 @@ void ErrorHandler::SetBGError(const Status& bg_status,
   if (bg_io_err.ok()) {
     return;
   }
-  ROCKS_LOG_WARN(db_options_.info_log, "Background IO error %s",
-                 bg_io_err.ToString().c_str());
+  ROCKS_LOG_WARN(db_options_.info_log, "Background IO error %s, reason %d",
+                 bg_io_err.ToString().c_str(), static_cast<int>(reason));
 
   RecordStats({ERROR_HANDLER_BG_ERROR_COUNT, ERROR_HANDLER_BG_IO_ERROR_COUNT},
               {} /* int_histograms */);
@@ -412,6 +412,31 @@ void ErrorHandler::SetBGError(const Status& bg_status,
     recover_context_ = context;
     return;
   }
+  if (wal_related) {
+    assert(reason == BackgroundErrorReason::kWriteCallback ||
+           reason == BackgroundErrorReason::kMemTable ||
+           reason == BackgroundErrorReason::kFlush);
+  }
+  if (db_options_.manual_wal_flush && wal_related && bg_io_err.IsIOError()) {
+    // With manual_wal_flush, a WAL write failure can drop buffered WAL writes.
+    // Memtables and WAL then become inconsistent. A successful memtable flush
+    // on one CF can cause CFs to be inconsistent upon restart. Before we fix
+    // the bug in auto recovery from WAL write failures that can flush one CF
+    // at a time, we set the error severity to fatal to disallow auto recovery.
+    // TODO: remove parameter `wal_related` once we can automatically recover
+    //  from WAL write failures.
+    bool auto_recovery = false;
+    Status bg_err(new_bg_io_err, Status::Severity::kFatalError);
+    CheckAndSetRecoveryAndBGError(bg_err);
+    ROCKS_LOG_WARN(db_options_.info_log,
+                   "ErrorHandler: A potentially WAL error happened, set "
+                   "background IO error as fatal error\n");
+    EventHelpers::NotifyOnBackgroundError(db_options_.listeners, reason,
+                                          &bg_err, db_mutex_, &auto_recovery);
+    recover_context_ = context;
+    return;
+  }
+
   if (bg_io_err.subcode() != IOStatus::SubCode::kNoSpace &&
       (bg_io_err.GetScope() == IOStatus::IOErrorScope::kIOErrorScopeFile ||
        bg_io_err.GetRetryable())) {

package/deps/rocksdb/rocksdb/db/error_handler.h

@@ -56,7 +56,8 @@ class ErrorHandler {
   Status::Severity GetErrorSeverity(BackgroundErrorReason reason,
                                     Status::Code code, Status::SubCode subcode);
 
-  void SetBGError(const Status& bg_err, BackgroundErrorReason reason);
+  void SetBGError(const Status& bg_err, BackgroundErrorReason reason,
+                  bool wal_related = false);
 
   Status GetBGError() const { return bg_error_; }
 

package/deps/rocksdb/rocksdb/db/event_helpers.cc

@@ -124,6 +124,7 @@ void EventHelpers::LogAndNotifyTableFileCreationFinished(
               << "comparator" << table_properties.comparator_name
               << "user_defined_timestamps_persisted"
               << table_properties.user_defined_timestamps_persisted
+              << "key_largest_seqno" << table_properties.key_largest_seqno
               << "merge_operator" << table_properties.merge_operator_name
               << "prefix_extractor_name"
               << table_properties.prefix_extractor_name << "property_collectors"

package/deps/rocksdb/rocksdb/db/experimental.cc

@@ -152,6 +152,85 @@ Status UpdateManifestForFilesState(
 // EXPERIMENTAL new filtering features
 
 namespace {
+template <size_t N>
+class SemiStaticCappedKeySegmentsExtractor : public KeySegmentsExtractor {
+ public:
+  SemiStaticCappedKeySegmentsExtractor(const uint32_t* byte_widths) {
+    id_ = kName();
+    uint32_t prev_end = 0;
+    if constexpr (N > 0) {  // Suppress a compiler warning
+      for (size_t i = 0; i < N; ++i) {
+        prev_end = prev_end + byte_widths[i];
+        ideal_ends_[i] = prev_end;
+        id_ += std::to_string(byte_widths[i]) + "b";
+      }
+    }
+  }
+
+  static const char* kName() { return "CappedKeySegmentsExtractor"; }
+
+  const char* Name() const override { return kName(); }
+
+  std::string GetId() const override { return id_; }
+
+  void Extract(const Slice& key_or_bound, KeyKind /*kind*/,
+               Result* result) const override {
+    // Optimistic assignment
+    result->segment_ends.assign(ideal_ends_.begin(), ideal_ends_.end());
+    if constexpr (N > 0) {  // Suppress a compiler warning
+      uint32_t key_size = static_cast<uint32_t>(key_or_bound.size());
+      if (key_size < ideal_ends_.back()) {
+        // Need to fix up (should be rare)
+        for (size_t i = 0; i < N; ++i) {
+          result->segment_ends[i] = std::min(key_size, result->segment_ends[i]);
+        }
+      }
+    }
+  }
+
+ private:
+  std::array<uint32_t, N> ideal_ends_;
+  std::string id_;
+};
+
+class DynamicCappedKeySegmentsExtractor : public KeySegmentsExtractor {
+ public:
+  DynamicCappedKeySegmentsExtractor(const std::vector<uint32_t>& byte_widths) {
+    id_ = kName();
+    uint32_t prev_end = 0;
+    for (size_t i = 0; i < byte_widths.size(); ++i) {
+      prev_end = prev_end + byte_widths[i];
+      ideal_ends_[i] = prev_end;
+      id_ += std::to_string(byte_widths[i]) + "b";
+    }
+    final_ideal_end_ = prev_end;
+  }
+
+  static const char* kName() { return "CappedKeySegmentsExtractor"; }
+
+  const char* Name() const override { return kName(); }
+
+  std::string GetId() const override { return id_; }
+
+  void Extract(const Slice& key_or_bound, KeyKind /*kind*/,
+               Result* result) const override {
+    // Optimistic assignment
+    result->segment_ends = ideal_ends_;
+    uint32_t key_size = static_cast<uint32_t>(key_or_bound.size());
+    if (key_size < final_ideal_end_) {
+      // Need to fix up (should be rare)
+      for (size_t i = 0; i < ideal_ends_.size(); ++i) {
+        result->segment_ends[i] = std::min(key_size, result->segment_ends[i]);
+      }
+    }
+  }
+
+ private:
+  std::vector<uint32_t> ideal_ends_;
+  uint32_t final_ideal_end_;
+  std::string id_;
+};
+
 void GetFilterInput(FilterInput select, const Slice& key,
                     const KeySegmentsExtractor::Result& extracted,
                     Slice* out_input, Slice* out_leadup) {
@@ -211,12 +290,6 @@ void GetFilterInput(FilterInput select, const Slice& key,
       assert(false);
       return Slice();
     }
-
-    Slice operator()(SelectValue) {
-      // TODO
-      assert(false);
-      return Slice();
-    }
   };
 
   Slice input = std::visit(FilterInputGetter(key, extracted), select);
@@ -256,9 +329,6 @@ const char* DeserializeFilterInput(const char* p, const char* limit,
         case 3:
           *out = SelectColumnName{};
           return p;
-        case 4:
-          *out = SelectValue{};
-          return p;
         default:
           // Reserved for future use
           return nullptr;
@@ -315,7 +385,6 @@ void SerializeFilterInput(std::string* out, const FilterInput& select) {
     void operator()(SelectLegacyKeyPrefix) { out->push_back(1); }
     void operator()(SelectUserTimestamp) { out->push_back(2); }
     void operator()(SelectColumnName) { out->push_back(3); }
-    void operator()(SelectValue) { out->push_back(4); }
     void operator()(SelectKeySegment select) {
       // TODO: expand supported cases
       assert(select.segment_index < 16);
@@ -372,6 +441,7 @@ enum BuiltinSstQueryFilters : char {
   // and filtered independently because it might be a special case that is
   // not representative of the minimum in a spread of values.
   kBytewiseMinMaxFilter = 0x10,
+  kRevBytewiseMinMaxFilter = 0x11,
 };
 
 class SstQueryFilterBuilder {
@@ -459,7 +529,10 @@ class CategoryScopeFilterWrapperBuilder : public SstQueryFilterBuilder {
 
 class BytewiseMinMaxSstQueryFilterConfig : public SstQueryFilterConfigImpl {
  public:
-  using SstQueryFilterConfigImpl::SstQueryFilterConfigImpl;
+  explicit BytewiseMinMaxSstQueryFilterConfig(
+      const FilterInput& input,
+      const KeySegmentsExtractor::KeyCategorySet& categories, bool reverse)
+      : SstQueryFilterConfigImpl(input, categories), reverse_(reverse) {}
 
   std::unique_ptr<SstQueryFilterBuilder> NewBuilder(
       bool sanity_checks) const override {
@@ -477,11 +550,13 @@ class BytewiseMinMaxSstQueryFilterConfig : public SstQueryFilterConfigImpl {
       const KeySegmentsExtractor::Result& lower_bound_extracted,
       const Slice& upper_bound_excl,
       const KeySegmentsExtractor::Result& upper_bound_extracted) {
-    assert(!filter.empty() && filter[0] == kBytewiseMinMaxFilter);
+    assert(!filter.empty() && (filter[0] == kBytewiseMinMaxFilter ||
+                               filter[0] == kRevBytewiseMinMaxFilter));
     if (filter.size() <= 4) {
       // Missing some data
       return true;
     }
+    bool reverse = (filter[0] == kRevBytewiseMinMaxFilter);
     bool empty_included = (filter[1] & kEmptySeenFlag) != 0;
     const char* p = filter.data() + 2;
     const char* limit = filter.data() + filter.size();
@@ -528,8 +603,13 @@ class BytewiseMinMaxSstQueryFilterConfig : public SstQueryFilterConfigImpl {
 
     // May match if both the upper bound and lower bound indicate there could
     // be overlap
-    return upper_bound_input.compare(smallest) >= 0 &&
-           lower_bound_input.compare(largest) <= 0;
+    if (reverse) {
+      return upper_bound_input.compare(smallest) <= 0 &&
+             lower_bound_input.compare(largest) >= 0;
+    } else {
+      return upper_bound_input.compare(smallest) >= 0 &&
+             lower_bound_input.compare(largest) <= 0;
+    }
   }
 
  protected:
@@ -551,19 +631,11 @@ class BytewiseMinMaxSstQueryFilterConfig : public SstQueryFilterConfigImpl {
                        &prev_leadup);
 
         int compare = prev_leadup.compare(leadup);
-        if (compare > 0) {
-          status = Status::Corruption(
-              "Ordering invariant violated from 0x" +
-              prev_key->ToString(/*hex=*/true) + " with prefix 0x" +
-              prev_leadup.ToString(/*hex=*/true) + " to 0x" +
-              key.ToString(/*hex=*/true) + " with prefix 0x" +
-              leadup.ToString(/*hex=*/true));
-          return;
-        } else if (compare == 0) {
+        if (compare == 0) {
           // On the same prefix leading up to the segment, the segments must
           // not be out of order.
           compare = prev_input.compare(input);
-          if (compare > 0) {
+          if (parent.reverse_ ? compare < 0 : compare > 0) {
             status = Status::Corruption(
                 "Ordering invariant violated from 0x" +
                 prev_key->ToString(/*hex=*/true) + " with segment 0x" +
@@ -573,6 +645,9 @@ class BytewiseMinMaxSstQueryFilterConfig : public SstQueryFilterConfigImpl {
             return;
           }
         }
+        // NOTE: it is not strictly required that the leadup be ordered, just
+        // satisfy the "common segment prefix property" which would be
+        // expensive to check
       }
 
       // Now actually update state for the filter inputs
@@ -598,7 +673,8 @@ class BytewiseMinMaxSstQueryFilterConfig : public SstQueryFilterConfigImpl {
         return 0;
       }
       return 2 + GetFilterInputSerializedLength(parent.input_) +
-             VarintLength(smallest.size()) + smallest.size() + largest.size();
+             VarintLength(parent.reverse_ ? largest.size() : smallest.size()) +
+             smallest.size() + largest.size();
     }
 
     void Finish(std::string& append_to) override {
@@ -610,23 +686,27 @@ class BytewiseMinMaxSstQueryFilterConfig : public SstQueryFilterConfigImpl {
       }
       size_t old_append_to_size = append_to.size();
       append_to.reserve(old_append_to_size + encoded_length);
-      append_to.push_back(kBytewiseMinMaxFilter);
+      append_to.push_back(parent.reverse_ ? kRevBytewiseMinMaxFilter
+                                          : kBytewiseMinMaxFilter);
 
       append_to.push_back(empty_seen ? kEmptySeenFlag : 0);
 
       SerializeFilterInput(&append_to, parent.input_);
 
-      PutVarint32(&append_to, static_cast<uint32_t>(smallest.size()));
-      append_to.append(smallest);
-      // The end of `largest` is given by the end of the filter
-      append_to.append(largest);
+      auto& minv = parent.reverse_ ? largest : smallest;
+      auto& maxv = parent.reverse_ ? smallest : largest;
+      PutVarint32(&append_to, static_cast<uint32_t>(minv.size()));
+      append_to.append(minv);
+      // The end of `maxv` is given by the end of the filter
+      append_to.append(maxv);
       assert(append_to.size() == old_append_to_size + encoded_length);
     }
 
     const BytewiseMinMaxSstQueryFilterConfig& parent;
     const bool sanity_checks;
     // Smallest and largest segment seen, excluding the empty segment which
-    // is tracked separately
+    // is tracked separately. "Reverse" from parent is only applied at
+    // serialization time, for efficiency.
     std::string smallest;
     std::string largest;
     bool empty_seen = false;
@@ -635,6 +715,8 @@ class BytewiseMinMaxSstQueryFilterConfig : public SstQueryFilterConfigImpl {
     Status status;
   };
 
+  bool reverse_;
+
  private:
   static constexpr char kEmptySeenFlag = 0x1;
 };
@@ -1036,6 +1118,7 @@ class SstQueryFilterConfigsManagerImpl : public SstQueryFilterConfigsManager {
             may_match = MayMatch_CategoryScopeFilterWrapper(filter, *state);
             break;
           case kBytewiseMinMaxFilter:
+          case kRevBytewiseMinMaxFilter:
             if (state == nullptr) {
               // TODO? Report problem
               // No filtering
@@ -1189,14 +1272,63 @@ const std::string SstQueryFilterConfigsManagerImpl::kTablePropertyName =
     "rocksdb.sqfc";
 }  // namespace
 
+std::shared_ptr<const KeySegmentsExtractor>
+MakeSharedCappedKeySegmentsExtractor(const std::vector<size_t>& byte_widths) {
+  std::vector<uint32_t> byte_widths_checked;
+  byte_widths_checked.resize(byte_widths.size());
+  size_t final_end = 0;
+  for (size_t i = 0; i < byte_widths.size(); ++i) {
+    final_end += byte_widths[i];
+    if (byte_widths[i] > UINT32_MAX / 2 || final_end > UINT32_MAX) {
+      // Better to crash than to proceed unsafely
+      return nullptr;
+    }
+    byte_widths_checked[i] = static_cast<uint32_t>(byte_widths[i]);
+  }
+
+  switch (byte_widths_checked.size()) {
+    case 0:
+      return std::make_shared<SemiStaticCappedKeySegmentsExtractor<0>>(
+          byte_widths_checked.data());
+    case 1:
+      return std::make_shared<SemiStaticCappedKeySegmentsExtractor<1>>(
+          byte_widths_checked.data());
+    case 2:
+      return std::make_shared<SemiStaticCappedKeySegmentsExtractor<2>>(
+          byte_widths_checked.data());
+    case 3:
+      return std::make_shared<SemiStaticCappedKeySegmentsExtractor<3>>(
+          byte_widths_checked.data());
+    case 4:
+      return std::make_shared<SemiStaticCappedKeySegmentsExtractor<4>>(
+          byte_widths_checked.data());
+    case 5:
+      return std::make_shared<SemiStaticCappedKeySegmentsExtractor<5>>(
+          byte_widths_checked.data());
+    case 6:
+      return std::make_shared<SemiStaticCappedKeySegmentsExtractor<6>>(
+          byte_widths_checked.data());
+    default:
+      return std::make_shared<DynamicCappedKeySegmentsExtractor>(
+          byte_widths_checked);
+  }
+}
+
 bool SstQueryFilterConfigs::IsEmptyNotFound() const {
   return this == &kEmptyNotFoundSQFC;
 }
 
 std::shared_ptr<SstQueryFilterConfig> MakeSharedBytewiseMinMaxSQFC(
     FilterInput input, KeySegmentsExtractor::KeyCategorySet categories) {
-  return std::make_shared<BytewiseMinMaxSstQueryFilterConfig>(input,
-                                                              categories);
+  return std::make_shared<BytewiseMinMaxSstQueryFilterConfig>(
+      input, categories,
+      /*reverse=*/false);
+}
+
+std::shared_ptr<SstQueryFilterConfig> MakeSharedReverseBytewiseMinMaxSQFC(
+    FilterInput input, KeySegmentsExtractor::KeyCategorySet categories) {
+  return std::make_shared<BytewiseMinMaxSstQueryFilterConfig>(input, categories,
+                                                              /*reverse=*/true);
 }
 
 Status SstQueryFilterConfigsManager::MakeShared(

package/deps/rocksdb/rocksdb/db/external_sst_file_ingestion_job.cc

@@ -113,8 +113,7 @@ Status ExternalSstFileIngestionJob::Prepare(
     const std::string path_outside_db = f.external_file_path;
     const std::string path_inside_db = TableFileName(
         cfd_->ioptions()->cf_paths, f.fd.GetNumber(), f.fd.GetPathId());
-    if (ingestion_options_.move_files) {
-      assert(!ingestion_options_.allow_db_generated_files);
+    if (ingestion_options_.move_files || ingestion_options_.link_files) {
       status =
           fs_->LinkFile(path_outside_db, path_inside_db, IOOptions(), nullptr);
       if (status.ok()) {
@@ -914,9 +913,18 @@ Status ExternalSstFileIngestionJob::GetIngestedFileInfo(
   } else if (!iter->status().ok()) {
     return iter->status();
   }
-  if (ingestion_options_.allow_db_generated_files) {
-    // Verify that all keys have seqno zero.
-    // TODO: store largest seqno in table property and validate it instead.
+  SequenceNumber largest_seqno =
+      table_reader.get()->GetTableProperties()->key_largest_seqno;
+  // UINT64_MAX means unknown and the file is generated before table property
+  // `key_largest_seqno` is introduced.
+  if (largest_seqno != UINT64_MAX && largest_seqno > 0) {
+    return Status::Corruption(
+        "External file has non zero largest sequence number " +
+        std::to_string(largest_seqno));
+  }
+  if (ingestion_options_.allow_db_generated_files &&
+      largest_seqno == UINT64_MAX) {
+    // Need to verify that all keys have seqno zero.
     for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
       Status pik_status =
           ParseInternalKey(iter->key(), &key, allow_data_in_errors);