@nxtedition/rocksdb 8.2.8 → 9.0.1

package/deps/rocksdb/rocksdb/db/merge_helper.h

@@ -41,30 +41,94 @@ class MergeHelper {
               Statistics* stats = nullptr,
               const std::atomic<bool>* shutting_down = nullptr);
 
-  // Wrapper around MergeOperator::FullMergeV2() that records perf statistics.
-  // Result of merge will be written to result if status returned is OK.
-  // If operands is empty, the value will simply be copied to result.
-  // Set `update_num_ops_stats` to true if it is from a user read, so that
-  // the latency is sensitive.
+  // Wrappers around MergeOperator::FullMergeV3() that record perf statistics.
+  // Set `update_num_ops_stats` to true if it is from a user read so that
+  // the corresponding statistics are updated.
   // Returns one of the following statuses:
   // - OK: Entries were successfully merged.
   // - Corruption: Merge operator reported unsuccessful merge. The scope of the
   //   damage will be stored in `*op_failure_scope` when `op_failure_scope` is
   //   not nullptr
+
+  // Empty tag types to disambiguate overloads
+  struct NoBaseValueTag {};
+  static constexpr NoBaseValueTag kNoBaseValue{};
+
+  struct PlainBaseValueTag {};
+  static constexpr PlainBaseValueTag kPlainBaseValue{};
+
+  struct WideBaseValueTag {};
+  static constexpr WideBaseValueTag kWideBaseValue{};
+
+  // Variants that expose the merge result directly (in serialized form for wide
+  // columns) as well as its value type. Used by iterator and compaction.
+  static Status TimedFullMerge(const MergeOperator* merge_operator,
+                               const Slice& key, NoBaseValueTag,
+                               const std::vector<Slice>& operands,
+                               Logger* logger, Statistics* statistics,
+                               SystemClock* clock, bool update_num_ops_stats,
+                               std::string* result, Slice* result_operand,
+                               ValueType* result_type,
+                               MergeOperator::OpFailureScope* op_failure_scope);
+
+  static Status TimedFullMerge(
+      const MergeOperator* merge_operator, const Slice& key, PlainBaseValueTag,
+      const Slice& value, const std::vector<Slice>& operands, Logger* logger,
+      Statistics* statistics, SystemClock* clock, bool update_num_ops_stats,
+      std::string* result, Slice* result_operand, ValueType* result_type,
+      MergeOperator::OpFailureScope* op_failure_scope);
+
+  static Status TimedFullMerge(
+      const MergeOperator* merge_operator, const Slice& key, WideBaseValueTag,
+      const Slice& entity, const std::vector<Slice>& operands, Logger* logger,
+      Statistics* statistics, SystemClock* clock, bool update_num_ops_stats,
+      std::string* result, Slice* result_operand, ValueType* result_type,
+      MergeOperator::OpFailureScope* op_failure_scope);
+
+  static Status TimedFullMerge(
+      const MergeOperator* merge_operator, const Slice& key, WideBaseValueTag,
+      const WideColumns& columns, const std::vector<Slice>& operands,
+      Logger* logger, Statistics* statistics, SystemClock* clock,
+      bool update_num_ops_stats, std::string* result, Slice* result_operand,
+      ValueType* result_type, MergeOperator::OpFailureScope* op_failure_scope);
+
+  // Variants that expose the merge result translated to the form requested by
+  // the client. (For example, if the result is a wide-column structure but the
+  // client requested the results in plain-value form, the value of the default
+  // column is returned.) Used by point lookups.
   static Status TimedFullMerge(const MergeOperator* merge_operator,
-                               const Slice& key, const Slice* value,
+                               const Slice& key, NoBaseValueTag,
                                const std::vector<Slice>& operands,
-                               std::string* result, Logger* logger,
-                               Statistics* statistics, SystemClock* clock,
-                               Slice* result_operand, bool update_num_ops_stats,
+                               Logger* logger, Statistics* statistics,
+                               SystemClock* clock, bool update_num_ops_stats,
+                               std::string* result_value,
+                               PinnableWideColumns* result_entity,
                                MergeOperator::OpFailureScope* op_failure_scope);
 
-  static Status TimedFullMergeWithEntity(
-      const MergeOperator* merge_operator, const Slice& key, Slice base_entity,
-      const std::vector<Slice>& operands, std::string* result, Logger* logger,
+  static Status TimedFullMerge(
+      const MergeOperator* merge_operator, const Slice& key, PlainBaseValueTag,
+      const Slice& value, const std::vector<Slice>& operands, Logger* logger,
       Statistics* statistics, SystemClock* clock, bool update_num_ops_stats,
+      std::string* result_value, PinnableWideColumns* result_entity,
       MergeOperator::OpFailureScope* op_failure_scope);
 
+  static Status TimedFullMerge(
+      const MergeOperator* merge_operator, const Slice& key, WideBaseValueTag,
+      const Slice& entity, const std::vector<Slice>& operands, Logger* logger,
+      Statistics* statistics, SystemClock* clock, bool update_num_ops_stats,
+      std::string* result_value, PinnableWideColumns* result_entity,
+      MergeOperator::OpFailureScope* op_failure_scope);
+
+  static Status TimedFullMerge(const MergeOperator* merge_operator,
+                               const Slice& key, WideBaseValueTag,
+                               const WideColumns& columns,
+                               const std::vector<Slice>& operands,
+                               Logger* logger, Statistics* statistics,
+                               SystemClock* clock, bool update_num_ops_stats,
+                               std::string* result_value,
+                               PinnableWideColumns* result_entity,
+                               MergeOperator::OpFailureScope* op_failure_scope);
+
   // During compaction, merge entries until we hit
   //     - a corrupted key
   //     - a Put/Delete,
@@ -198,6 +262,30 @@ class MergeHelper {
     // This is a best-effort facility, so memory_order_relaxed is sufficient.
     return shutting_down_ && shutting_down_->load(std::memory_order_relaxed);
   }
+
+  template <typename Visitor>
+  static Status TimedFullMergeCommonImpl(
+      const MergeOperator* merge_operator, const Slice& key,
+      MergeOperator::MergeOperationInputV3::ExistingValue&& existing_value,
+      const std::vector<Slice>& operands, Logger* logger,
+      Statistics* statistics, SystemClock* clock, bool update_num_ops_stats,
+      MergeOperator::OpFailureScope* op_failure_scope, Visitor&& visitor);
+
+  static Status TimedFullMergeImpl(
+      const MergeOperator* merge_operator, const Slice& key,
+      MergeOperator::MergeOperationInputV3::ExistingValue&& existing_value,
+      const std::vector<Slice>& operands, Logger* logger,
+      Statistics* statistics, SystemClock* clock, bool update_num_ops_stats,
+      std::string* result, Slice* result_operand, ValueType* result_type,
+      MergeOperator::OpFailureScope* op_failure_scope);
+
+  static Status TimedFullMergeImpl(
+      const MergeOperator* merge_operator, const Slice& key,
+      MergeOperator::MergeOperationInputV3::ExistingValue&& existing_value,
+      const std::vector<Slice>& operands, Logger* logger,
+      Statistics* statistics, SystemClock* clock, bool update_num_ops_stats,
+      std::string* result_value, PinnableWideColumns* result_entity,
+      MergeOperator::OpFailureScope* op_failure_scope);
 };
 
 // MergeOutputIterator can be used to iterate over the result of a merge.

package/deps/rocksdb/rocksdb/db/merge_operator.cc

@@ -9,6 +9,11 @@
 
 #include "rocksdb/merge_operator.h"
 
+#include <type_traits>
+
+#include "db/wide/wide_columns_helper.h"
+#include "util/overload.h"
+
 namespace ROCKSDB_NAMESPACE {
 
 bool MergeOperator::FullMergeV2(const MergeOperationInput& merge_in,
@@ -23,6 +28,83 @@ bool MergeOperator::FullMergeV2(const MergeOperationInput& merge_in,
                    &merge_out->new_value, merge_in.logger);
 }
 
+bool MergeOperator::FullMergeV3(const MergeOperationInputV3& merge_in,
+                                MergeOperationOutputV3* merge_out) const {
+  assert(merge_out);
+
+  MergeOperationInput in_v2(merge_in.key, nullptr, merge_in.operand_list,
+                            merge_in.logger);
+
+  std::string new_value;
+  Slice existing_operand(nullptr, 0);
+  MergeOperationOutput out_v2(new_value, existing_operand);
+
+  return std::visit(
+      overload{
+          [&](const auto& existing) -> bool {
+            using T = std::decay_t<decltype(existing)>;
+
+            if constexpr (std::is_same_v<T, Slice>) {
+              in_v2.existing_value = &existing;
+            }
+
+            const bool result = FullMergeV2(in_v2, &out_v2);
+            if (!result) {
+              merge_out->op_failure_scope = out_v2.op_failure_scope;
+              return false;
+            }
+
+            if (existing_operand.data()) {
+              merge_out->new_value = existing_operand;
+            } else {
+              merge_out->new_value = std::move(new_value);
+            }
+
+            return true;
+          },
+          [&](const WideColumns& existing_columns) -> bool {
+            const bool has_default_column =
+                WideColumnsHelper::HasDefaultColumn(existing_columns);
+
+            Slice value_of_default;
+            if (has_default_column) {
+              value_of_default = existing_columns.front().value();
+            }
+
+            in_v2.existing_value = &value_of_default;
+
+            const bool result = FullMergeV2(in_v2, &out_v2);
+            if (!result) {
+              merge_out->op_failure_scope = out_v2.op_failure_scope;
+              return false;
+            }
+
+            merge_out->new_value = MergeOperationOutputV3::NewColumns();
+            auto& new_columns = std::get<MergeOperationOutputV3::NewColumns>(
+                merge_out->new_value);
+            new_columns.reserve(has_default_column
+                                    ? existing_columns.size()
+                                    : (existing_columns.size() + 1));
+
+            if (existing_operand.data()) {
+              new_columns.emplace_back(kDefaultWideColumnName.ToString(),
+                                       existing_operand.ToString());
+            } else {
+              new_columns.emplace_back(kDefaultWideColumnName.ToString(),
+                                       std::move(new_value));
+            }
+
+            for (size_t i = has_default_column ? 1 : 0;
+                 i < existing_columns.size(); ++i) {
+              new_columns.emplace_back(existing_columns[i].name().ToString(),
+                                       existing_columns[i].value().ToString());
+            }
+
+            return true;
+          }},
+      merge_in.existing_value);
+}
+
 // The default implementation of PartialMergeMulti, which invokes
 // PartialMerge multiple times internally and merges two operands at
 // a time.

package/deps/rocksdb/rocksdb/db/merge_test.cc

@@ -18,6 +18,7 @@
 #include "rocksdb/env.h"
 #include "rocksdb/merge_operator.h"
 #include "rocksdb/utilities/db_ttl.h"
+#include "rocksdb/wide_columns.h"
 #include "test_util/testharness.h"
 #include "util/coding.h"
 #include "utilities/merge_operators.h"
@@ -607,6 +608,272 @@ TEST_F(MergeTest, MergeWithCompactionAndFlush) {
   ASSERT_OK(DestroyDB(dbname, Options()));
 }
 
+TEST_F(MergeTest, FullMergeV3FallbackNewValue) {
+  // Test that the default FullMergeV3 implementation correctly handles the case
+  // when FullMergeV2 results in a new value.
+
+  const Slice key("foo");
+  const MergeOperator::MergeOperationInputV3::OperandList operands{
+      "first", "second", "third"};
+  constexpr Logger* logger = nullptr;
+
+  auto append_operator =
+      MergeOperators::CreateStringAppendOperator(std::string());
+
+  // No existing value
+  {
+    MergeOperator::MergeOperationInputV3::ExistingValue existing_value;
+    const MergeOperator::MergeOperationInputV3 merge_in(
+        key, std::move(existing_value), operands, logger);
+
+    MergeOperator::MergeOperationOutputV3 merge_out;
+
+    ASSERT_TRUE(append_operator->FullMergeV3(merge_in, &merge_out));
+
+    const auto& result = std::get<std::string>(merge_out.new_value);
+    ASSERT_EQ(result, operands[0].ToString() + operands[1].ToString() +
+                          operands[2].ToString());
+  }
+
+  // Plain existing value
+  {
+    const Slice plain("plain");
+    MergeOperator::MergeOperationInputV3::ExistingValue existing_value(plain);
+    const MergeOperator::MergeOperationInputV3 merge_in(
+        key, std::move(existing_value), operands, logger);
+
+    MergeOperator::MergeOperationOutputV3 merge_out;
+
+    ASSERT_TRUE(append_operator->FullMergeV3(merge_in, &merge_out));
+
+    const auto& result = std::get<std::string>(merge_out.new_value);
+    ASSERT_EQ(result, plain.ToString() + operands[0].ToString() +
+                          operands[1].ToString() + operands[2].ToString());
+  }
+
+  // Wide-column existing value with default column
+  {
+    const WideColumns entity{
+        {kDefaultWideColumnName, "default"}, {"one", "1"}, {"two", "2"}};
+    MergeOperator::MergeOperationInputV3::ExistingValue existing_value(entity);
+    const MergeOperator::MergeOperationInputV3 merge_in(
+        key, std::move(existing_value), operands, logger);
+
+    MergeOperator::MergeOperationOutputV3 merge_out;
+
+    ASSERT_TRUE(append_operator->FullMergeV3(merge_in, &merge_out));
+
+    const auto& result =
+        std::get<MergeOperator::MergeOperationOutputV3::NewColumns>(
+            merge_out.new_value);
+    ASSERT_EQ(result.size(), entity.size());
+    ASSERT_EQ(result[0].first, entity[0].name());
+    ASSERT_EQ(result[0].second,
+              entity[0].value().ToString() + operands[0].ToString() +
+                  operands[1].ToString() + operands[2].ToString());
+    ASSERT_EQ(result[1].first, entity[1].name());
+    ASSERT_EQ(result[1].second, entity[1].value());
+    ASSERT_EQ(result[2].first, entity[2].name());
+    ASSERT_EQ(result[2].second, entity[2].value());
+  }
+
+  // Wide-column existing value without default column
+  {
+    const WideColumns entity{{"one", "1"}, {"two", "2"}};
+    MergeOperator::MergeOperationInputV3::ExistingValue existing_value(entity);
+    const MergeOperator::MergeOperationInputV3 merge_in(
+        key, std::move(existing_value), operands, logger);
+
+    MergeOperator::MergeOperationOutputV3 merge_out;
+
+    ASSERT_TRUE(append_operator->FullMergeV3(merge_in, &merge_out));
+
+    const auto& result =
+        std::get<MergeOperator::MergeOperationOutputV3::NewColumns>(
+            merge_out.new_value);
+    ASSERT_EQ(result.size(), entity.size() + 1);
+    ASSERT_EQ(result[0].first, kDefaultWideColumnName);
+    ASSERT_EQ(result[0].second, operands[0].ToString() +
+                                    operands[1].ToString() +
+                                    operands[2].ToString());
+    ASSERT_EQ(result[1].first, entity[0].name());
+    ASSERT_EQ(result[1].second, entity[0].value());
+    ASSERT_EQ(result[2].first, entity[1].name());
+    ASSERT_EQ(result[2].second, entity[1].value());
+  }
+}
+
+TEST_F(MergeTest, FullMergeV3FallbackExistingOperand) {
+  // Test that the default FullMergeV3 implementation correctly handles the case
+  // when FullMergeV2 results in an existing operand.
+
+  const Slice key("foo");
+  const MergeOperator::MergeOperationInputV3::OperandList operands{
+      "first", "second", "third"};
+  constexpr Logger* logger = nullptr;
+
+  auto put_operator = MergeOperators::CreatePutOperator();
+
+  // No existing value
+  {
+    MergeOperator::MergeOperationInputV3::ExistingValue existing_value;
+    const MergeOperator::MergeOperationInputV3 merge_in(
+        key, std::move(existing_value), operands, logger);
+
+    MergeOperator::MergeOperationOutputV3 merge_out;
+
+    ASSERT_TRUE(put_operator->FullMergeV3(merge_in, &merge_out));
+
+    const auto& result = std::get<Slice>(merge_out.new_value);
+    ASSERT_EQ(result.data(), operands.back().data());
+    ASSERT_EQ(result.size(), operands.back().size());
+  }
+
+  // Plain existing value
+  {
+    const Slice plain("plain");
+    MergeOperator::MergeOperationInputV3::ExistingValue existing_value(plain);
+    const MergeOperator::MergeOperationInputV3 merge_in(
+        key, std::move(existing_value), operands, logger);
+
+    MergeOperator::MergeOperationOutputV3 merge_out;
+
+    ASSERT_TRUE(put_operator->FullMergeV3(merge_in, &merge_out));
+
+    const auto& result = std::get<Slice>(merge_out.new_value);
+    ASSERT_EQ(result.data(), operands.back().data());
+    ASSERT_EQ(result.size(), operands.back().size());
+  }
+
+  // Wide-column existing value with default column
+  {
+    const WideColumns entity{
+        {kDefaultWideColumnName, "default"}, {"one", "1"}, {"two", "2"}};
+    MergeOperator::MergeOperationInputV3::ExistingValue existing_value(entity);
+    const MergeOperator::MergeOperationInputV3 merge_in(
+        key, std::move(existing_value), operands, logger);
+
+    MergeOperator::MergeOperationOutputV3 merge_out;
+
+    ASSERT_TRUE(put_operator->FullMergeV3(merge_in, &merge_out));
+
+    const auto& result =
+        std::get<MergeOperator::MergeOperationOutputV3::NewColumns>(
+            merge_out.new_value);
+    ASSERT_EQ(result.size(), entity.size());
+    ASSERT_EQ(result[0].first, entity[0].name());
+    ASSERT_EQ(result[0].second, operands.back());
+    ASSERT_EQ(result[1].first, entity[1].name());
+    ASSERT_EQ(result[1].second, entity[1].value());
+    ASSERT_EQ(result[2].first, entity[2].name());
+    ASSERT_EQ(result[2].second, entity[2].value());
+  }
+
+  // Wide-column existing value without default column
+  {
+    const WideColumns entity{{"one", "1"}, {"two", "2"}};
+    MergeOperator::MergeOperationInputV3::ExistingValue existing_value(entity);
+    const MergeOperator::MergeOperationInputV3 merge_in(
+        key, std::move(existing_value), operands, logger);
+
+    MergeOperator::MergeOperationOutputV3 merge_out;
+
+    ASSERT_TRUE(put_operator->FullMergeV3(merge_in, &merge_out));
+
+    const auto& result =
+        std::get<MergeOperator::MergeOperationOutputV3::NewColumns>(
+            merge_out.new_value);
+    ASSERT_EQ(result.size(), entity.size() + 1);
+    ASSERT_EQ(result[0].first, kDefaultWideColumnName);
+    ASSERT_EQ(result[0].second, operands.back());
+    ASSERT_EQ(result[1].first, entity[0].name());
+    ASSERT_EQ(result[1].second, entity[0].value());
+    ASSERT_EQ(result[2].first, entity[1].name());
+    ASSERT_EQ(result[2].second, entity[1].value());
+  }
+}
+
+TEST_F(MergeTest, FullMergeV3FallbackFailure) {
+  // Test that the default FullMergeV3 implementation correctly handles the case
+  // when FullMergeV2 fails.
+
+  const Slice key("foo");
+  const MergeOperator::MergeOperationInputV3::OperandList operands{
+      "first", "second", "third"};
+  constexpr Logger* logger = nullptr;
+
+  class FailMergeOperator : public MergeOperator {
+   public:
+    bool FullMergeV2(const MergeOperationInput& /* merge_in */,
+                     MergeOperationOutput* merge_out) const override {
+      assert(merge_out);
+      merge_out->op_failure_scope = OpFailureScope::kMustMerge;
+
+      return false;
+    }
+
+    const char* Name() const override { return "FailMergeOperator"; }
+  };
+
+  FailMergeOperator fail_operator;
+
+  // No existing value
+  {
+    MergeOperator::MergeOperationInputV3::ExistingValue existing_value;
+    const MergeOperator::MergeOperationInputV3 merge_in(
+        key, std::move(existing_value), operands, logger);
+
+    MergeOperator::MergeOperationOutputV3 merge_out;
+
+    ASSERT_FALSE(fail_operator.FullMergeV3(merge_in, &merge_out));
+    ASSERT_EQ(merge_out.op_failure_scope,
+              MergeOperator::OpFailureScope::kMustMerge);
+  }
+
+  // Plain existing value
+  {
+    const Slice plain("plain");
+    MergeOperator::MergeOperationInputV3::ExistingValue existing_value(plain);
+    const MergeOperator::MergeOperationInputV3 merge_in(
+        key, std::move(existing_value), operands, logger);
+
+    MergeOperator::MergeOperationOutputV3 merge_out;
+
+    ASSERT_FALSE(fail_operator.FullMergeV3(merge_in, &merge_out));
+    ASSERT_EQ(merge_out.op_failure_scope,
+              MergeOperator::OpFailureScope::kMustMerge);
+  }
+
+  // Wide-column existing value with default column
+  {
+    const WideColumns entity{
+        {kDefaultWideColumnName, "default"}, {"one", "1"}, {"two", "2"}};
+    MergeOperator::MergeOperationInputV3::ExistingValue existing_value(entity);
+    const MergeOperator::MergeOperationInputV3 merge_in(
+        key, std::move(existing_value), operands, logger);
+
+    MergeOperator::MergeOperationOutputV3 merge_out;
+
+    ASSERT_FALSE(fail_operator.FullMergeV3(merge_in, &merge_out));
+    ASSERT_EQ(merge_out.op_failure_scope,
+              MergeOperator::OpFailureScope::kMustMerge);
+  }
+
+  // Wide-column existing value without default column
+  {
+    const WideColumns entity{{"one", "1"}, {"two", "2"}};
+    MergeOperator::MergeOperationInputV3::ExistingValue existing_value(entity);
+    const MergeOperator::MergeOperationInputV3 merge_in(
+        key, std::move(existing_value), operands, logger);
+
+    MergeOperator::MergeOperationOutputV3 merge_out;
+
+    ASSERT_FALSE(fail_operator.FullMergeV3(merge_in, &merge_out));
+    ASSERT_EQ(merge_out.op_failure_scope,
+              MergeOperator::OpFailureScope::kMustMerge);
+  }
+}
+
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

package/deps/rocksdb/rocksdb/db/perf_context_test.cc

@@ -149,6 +149,7 @@ TEST_F(PerfContextTest, SeekIntoDeletion) {
     ASSERT_TRUE(iter->Valid());
     StopWatchNano timer2(SystemClock::Default().get(), true);
     iter->Next();
+    ASSERT_OK(iter->status());
     auto elapsed_nanos2 = timer2.ElapsedNanos();
     if (FLAGS_verbose) {
       std::cout << "next cmp: " << get_perf_context()->user_key_comparison_count
@@ -262,7 +263,7 @@ void ProfileQueries(bool enabled_time = false) {
   for (const int i : keys) {
     if (i == kFlushFlag) {
       FlushOptions fo;
-      db->Flush(fo);
+      ASSERT_OK(db->Flush(fo));
       continue;
     }
 
@@ -1092,6 +1093,7 @@ TEST_F(PerfContextTest, MergeOperandCount) {
 
         get_perf_context()->Reset();
       }
+      ASSERT_OK(it->status());
     }
 
     // Backward iteration
@@ -1104,6 +1106,7 @@ TEST_F(PerfContextTest, MergeOperandCount) {
 
         get_perf_context()->Reset();
       }
+      ASSERT_OK(it->status());
     }
   };
 
@@ -1111,7 +1114,7 @@ TEST_F(PerfContextTest, MergeOperandCount) {
   verify();
 
   // Verify counters when reading from table files
-  db->Flush(FlushOptions());
+  ASSERT_OK(db->Flush(FlushOptions()));
 
   verify();
 }

package/deps/rocksdb/rocksdb/db/periodic_task_scheduler.h

@@ -42,15 +42,16 @@ class PeriodicTaskScheduler {
   PeriodicTaskScheduler& operator=(const PeriodicTaskScheduler&) = delete;
   PeriodicTaskScheduler& operator=(PeriodicTaskScheduler&&) = delete;
 
-  // Register a task with its default repeat period
+  // Register a task with its default repeat period. Thread safe call.
   Status Register(PeriodicTaskType task_type, const PeriodicTaskFunc& fn);
 
   // Register a task with specified repeat period. 0 is an invalid argument
-  // (kInvalidPeriodSec). To stop the task, please use Unregister() specifically
+  // (kInvalidPeriodSec). To stop the task, please use Unregister().
+  // Thread safe call.
   Status Register(PeriodicTaskType task_type, const PeriodicTaskFunc& fn,
                   uint64_t repeat_period_seconds);
 
-  // Unregister the task
+  // Unregister the task. Thread safe call.
   Status Unregister(PeriodicTaskType task_type);
 
 #ifndef NDEBUG
@@ -105,4 +106,3 @@ class PeriodicTaskScheduler {
 };
 
 }  // namespace ROCKSDB_NAMESPACE
-

package/deps/rocksdb/rocksdb/db/plain_table_db_test.cc

@@ -123,6 +123,7 @@ class PlainTableDBTest : public testing::Test,
   // Return the current option configuration.
   Options CurrentOptions() {
     Options options;
+    options.level_compaction_dynamic_level_bytes = false;
 
     PlainTableOptions plain_table_options;
     plain_table_options.user_key_len = 0;
@@ -896,6 +897,7 @@ TEST_P(PlainTableDBTest, IteratorLargeKeys) {
   }
 
   ASSERT_TRUE(!iter->Valid());
+  ASSERT_OK(iter->status());
 
   delete iter;
 }
@@ -944,6 +946,7 @@ TEST_P(PlainTableDBTest, IteratorLargeKeysWithPrefix) {
   }
 
   ASSERT_TRUE(!iter->Valid());
+  ASSERT_OK(iter->status());
 
   delete iter;
 }

package/deps/rocksdb/rocksdb/db/prefix_test.cc

@@ -782,6 +782,7 @@ TEST_F(PrefixTest, PrefixSeekModePrev) {
         }
       }
     }
+    ASSERT_OK(iter->status());
   }
 }
 

package/deps/rocksdb/rocksdb/db/range_del_aggregator.h

@@ -36,6 +36,10 @@ class TruncatedRangeDelIterator {
       const InternalKeyComparator* icmp, const InternalKey* smallest,
       const InternalKey* largest);
 
+  void SetRangeDelReadSeqno(SequenceNumber read_seqno) {
+    iter_->SetRangeDelReadSeqno(read_seqno);
+  }
+
   bool Valid() const;
 
   void Next() { iter_->TopNext(); }

package/deps/rocksdb/rocksdb/db/range_tombstone_fragmenter.h

@@ -148,6 +148,10 @@ class FragmentedRangeTombstoneIterator : public InternalIterator {
       const InternalKeyComparator& icmp, SequenceNumber upper_bound,
       const Slice* ts_upper_bound = nullptr, SequenceNumber lower_bound = 0);
 
+  void SetRangeDelReadSeqno(SequenceNumber read_seqno) override {
+    upper_bound_ = read_seqno;
+  }
+
   void SeekToFirst() override;
   void SeekToLast() override;