@nxtedition/rocksdb 9.0.0 → 9.0.1

package/deps/rocksdb/rocksdb/util/slice_test.cc

@@ -243,6 +243,36 @@ TEST_F(SmallEnumSetTest, SmallEnumSetTest2) {
   }
 }
 
+// ***************************************************************** //
+// Unit test for Status
+TEST(StatusTest, Update) {
+  const Status ok = Status::OK();
+  const Status inc = Status::Incomplete("blah");
+  const Status notf = Status::NotFound("meow");
+
+  Status s = ok;
+  ASSERT_TRUE(s.UpdateIfOk(Status::Corruption("bad")).IsCorruption());
+  ASSERT_TRUE(s.IsCorruption());
+
+  s = ok;
+  ASSERT_TRUE(s.UpdateIfOk(Status::OK()).ok());
+  ASSERT_TRUE(s.UpdateIfOk(ok).ok());
+  ASSERT_TRUE(s.ok());
+
+  ASSERT_TRUE(s.UpdateIfOk(inc).IsIncomplete());
+  ASSERT_TRUE(s.IsIncomplete());
+
+  ASSERT_TRUE(s.UpdateIfOk(notf).IsIncomplete());
+  ASSERT_TRUE(s.UpdateIfOk(ok).IsIncomplete());
+  ASSERT_TRUE(s.IsIncomplete());
+
+  // Keeps left-most non-OK status
+  s = ok;
+  ASSERT_TRUE(
+      s.UpdateIfOk(Status()).UpdateIfOk(notf).UpdateIfOk(inc).IsNotFound());
+  ASSERT_TRUE(s.IsNotFound());
+}
+
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

package/deps/rocksdb/rocksdb/util/status.cc

@@ -45,6 +45,7 @@ static const char* msgs[static_cast<int>(Status::kMaxSubCode)] = {
     "Txn not prepared",       // kTxnNotPrepared
     "IO fenced off",          // kIOFenced
     "Merge operator failed",  // kMergeOperatorFailed
+    "Number of operands merged exceeded threshold",  // kMergeOperandThresholdExceeded
 };
 
 Status::Status(Code _code, SubCode _subcode, const Slice& msg,

package/deps/rocksdb/rocksdb/util/string_util.cc

@@ -437,6 +437,45 @@ bool SerializeIntVector(const std::vector<int>& vec, std::string* value) {
   return true;
 }
 
+int ParseTimeStringToSeconds(const std::string& value) {
+  int hours, minutes;
+  char colon;
+
+  std::istringstream stream(value);
+  stream >> hours >> colon >> minutes;
+
+  if (stream.fail() || !stream.eof() || colon != ':') {
+    return -1;
+  }
+
+  if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59) {
+    return -1;
+  }
+  return hours * 3600 + minutes * 60;
+}
+
+bool TryParseTimeRangeString(const std::string& value, int& start_time,
+                             int& end_time) {
+  if (value.empty()) {
+    start_time = 0;
+    end_time = 0;
+    return true;
+  }
+  auto split = StringSplit(value, '-');
+  if (split.size() != 2) {
+    return false;
+  }
+  start_time = ParseTimeStringToSeconds(split[0]);
+  if (start_time < 0) {
+    return false;
+  }
+  end_time = ParseTimeStringToSeconds(split[1]);
+  if (end_time < 0) {
+    return false;
+  }
+  return true;
+}
+
 // Copied from folly/string.cpp:
 // https://github.com/facebook/folly/blob/0deef031cb8aab76dc7e736f8b7c22d701d5f36b/folly/String.cpp#L457
 // There are two variants of `strerror_r` function, one returns

package/deps/rocksdb/rocksdb/util/string_util.h

@@ -166,6 +166,16 @@ std::vector<int> ParseVectorInt(const std::string& value);
 
 bool SerializeIntVector(const std::vector<int>& vec, std::string* value);
 
+// Expects HH:mm format for the input value
+// Returns -1 if invalid input. Otherwise returns seconds since midnight
+int ParseTimeStringToSeconds(const std::string& value);
+
+// Expects HH:mm-HH:mm format for the input value
+// Returns false, if invalid format.
+// Otherwise, returns true and start_time and end_time are set
+bool TryParseTimeRangeString(const std::string& value, int& start_time,
+                             int& end_time);
+
 extern const std::string kNullptrString;
 
 // errnoStr() function returns a string that describes the error code passed in

package/deps/rocksdb/rocksdb/util/thread_operation.h

@@ -45,6 +45,8 @@ static OperationInfo global_operation_table[] = {
     {ThreadStatus::OP_DBITERATOR, "DBIterator"},
     {ThreadStatus::OP_VERIFY_DB_CHECKSUM, "VerifyDBChecksum"},
     {ThreadStatus::OP_VERIFY_FILE_CHECKSUMS, "VerifyFileChecksums"},
+    {ThreadStatus::OP_GETENTITY, "GetEntity"},
+    {ThreadStatus::OP_MULTIGETENTITY, "MultiGetEntity"},
 
 };
 

package/deps/rocksdb/rocksdb/util/udt_util.cc

@@ -8,6 +8,7 @@
 
 #include "db/dbformat.h"
 #include "rocksdb/types.h"
+#include "util/coding.h"
 #include "util/write_batch_util.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -340,4 +341,45 @@ Status ValidateUserDefinedTimestampsOptions(
   return Status::InvalidArgument(
       "Unsupported user defined timestamps settings change.");
 }
+
+void GetFullHistoryTsLowFromU64CutoffTs(Slice* cutoff_ts,
+                                        std::string* full_history_ts_low) {
+  uint64_t cutoff_udt_ts = 0;
+  [[maybe_unused]] bool format_res = GetFixed64(cutoff_ts, &cutoff_udt_ts);
+  assert(format_res);
+  PutFixed64(full_history_ts_low, cutoff_udt_ts + 1);
+}
+
+std::tuple<std::optional<Slice>, std::optional<Slice>>
+MaybeAddTimestampsToRange(const Slice* start, const Slice* end, size_t ts_sz,
+                          std::string* start_with_ts, std::string* end_with_ts,
+                          bool exclusive_end) {
+  std::optional<Slice> ret_start, ret_end;
+  if (start) {
+    if (ts_sz == 0) {
+      ret_start = *start;
+    } else {
+      // Maximum timestamp means including all keys with any timestamp for start
+      AppendKeyWithMaxTimestamp(start_with_ts, *start, ts_sz);
+      ret_start = Slice(*start_with_ts);
+    }
+  }
+  if (end) {
+    if (ts_sz == 0) {
+      ret_end = *end;
+    } else {
+      if (exclusive_end) {
+        // Append a maximum timestamp as the range limit is exclusive:
+        // [start, end)
+        AppendKeyWithMaxTimestamp(end_with_ts, *end, ts_sz);
+      } else {
+        // Append a minimum timestamp to end so the range limit is inclusive:
+        // [start, end]
+        AppendKeyWithMinTimestamp(end_with_ts, *end, ts_sz);
+      }
+      ret_end = Slice(*end_with_ts);
+    }
+  }
+  return std::make_tuple(ret_start, ret_end);
+}
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/util/udt_util.h

@@ -246,4 +246,23 @@ Status ValidateUserDefinedTimestampsOptions(
     const Comparator* new_comparator, const std::string& old_comparator_name,
     bool new_persist_udt, bool old_persist_udt,
     bool* mark_sst_files_has_no_udt);
+
+// Given a cutoff user-defined timestamp formatted as uint64_t, get the
+// effective `full_history_ts_low` timestamp, which is the next immediately
+// bigger timestamp. Used by the UDT in memtable only feature when flushing
+// memtables and remove timestamps. This process collapses history and increase
+// the effective `full_history_ts_low`.
+void GetFullHistoryTsLowFromU64CutoffTs(Slice* cutoff_ts,
+                                        std::string* full_history_ts_low);
+
+// `start` is the inclusive lower user key bound without user-defined timestamp.
+// `end` is the upper user key bound without user-defined timestamp.
+// By default, `end` is treated as being exclusive. If `exclusive_end` is set to
+// false, it's treated as an inclusive upper bound.
+// If any of these two bounds is nullptr, an empty std::optional<Slice> is
+// returned for that bound.
+std::tuple<std::optional<Slice>, std::optional<Slice>>
+MaybeAddTimestampsToRange(const Slice* start, const Slice* end, size_t ts_sz,
+                          std::string* start_with_ts, std::string* end_with_ts,
+                          bool exclusive_end = true);
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/util/udt_util_test.cc

@@ -438,6 +438,20 @@ TEST(ValidateUserDefinedTimestampsOptionsTest, InvalidUserComparatorChange) {
                   &mark_sst_files)
                   .IsInvalidArgument());
 }
+
+TEST(GetFullHistoryTsLowFromU64CutoffTsTest, Success) {
+  std::string cutoff_ts;
+  uint64_t cutoff_ts_int = 3;
+  PutFixed64(&cutoff_ts, 3);
+  Slice cutoff_ts_slice = cutoff_ts;
+  std::string actual_full_history_ts_low;
+  GetFullHistoryTsLowFromU64CutoffTs(&cutoff_ts_slice,
+                                     &actual_full_history_ts_low);
+
+  std::string expected_ts_low;
+  PutFixed64(&expected_ts_low, cutoff_ts_int + 1);
+  ASSERT_EQ(expected_ts_low, actual_full_history_ts_low);
+}
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

package/deps/rocksdb/rocksdb/util/xxhash.h

@@ -11,9 +11,6 @@
 #ifndef XXH_NAMESPACE
 #define XXH_NAMESPACE ROCKSDB_
 #endif  // !defined(XXH_NAMESPACE)
-
-// for FALLTHROUGH_INTENDED, inserted as appropriate
-#include "port/lang.h"
 /* END RocksDB customizations */
 
 // clang-format off

package/deps/rocksdb/rocksdb/util/xxph3.h

@@ -386,10 +386,6 @@ typedef struct {
 #define XXPH_STATIC_LINKING_ONLY
 #endif
 
-/* BEGIN RocksDB customizations */
-#include "port/lang.h" /* for FALLTHROUGH_INTENDED, inserted as appropriate */
-/* END RocksDB customizations */
-
 /* *************************************
 *  Compiler Specific Options
 ***************************************/

package/deps/rocksdb/rocksdb/utilities/blob_db/blob_db_impl.cc

@@ -2101,8 +2101,9 @@ Iterator* BlobDBImpl::NewIterator(const ReadOptions& _read_options) {
     own_snapshot = new ManagedSnapshot(db_);
     snapshot = own_snapshot->snapshot();
   }
+  SuperVersion* sv = cfd->GetReferencedSuperVersion(db_impl_);
   auto* iter = db_impl_->NewIteratorImpl(
-      read_options, cfd, snapshot->GetSequenceNumber(),
+      read_options, cfd, sv, snapshot->GetSequenceNumber(),
       nullptr /*read_callback*/, true /*expose_blob_index*/);
   return new BlobDBIterator(own_snapshot, iter, this, clock_, statistics_);
 }

package/deps/rocksdb/rocksdb/utilities/fault_injection_env.h

@@ -96,6 +96,7 @@ class TestWritableFile : public WritableFile {
   virtual bool use_direct_io() const override {
     return target_->use_direct_io();
   };
+  uint64_t GetFileSize() final { return target_->GetFileSize(); }
 
  private:
   FileState state_;

package/deps/rocksdb/rocksdb/utilities/fault_injection_fs.cc

@@ -408,7 +408,7 @@ IOStatus TestFSRandomAccessFile::Read(uint64_t offset, size_t n,
         scratch, /*need_count_increase=*/true, /*fault_injected=*/nullptr);
   }
   if (s.ok() && fs_->ShouldInjectRandomReadError()) {
-    return IOStatus::IOError("Injected read error");
+    return IOStatus::IOError("injected read error");
   }
   return s;
 }
@@ -430,7 +430,7 @@ IOStatus TestFSRandomAccessFile::ReadAsync(
   }
   if (ret.ok()) {
     if (fs_->ShouldInjectRandomReadError()) {
-      ret = IOStatus::IOError("Injected read error");
+      ret = IOStatus::IOError("injected read error");
     } else {
       s = target_->ReadAsync(req, opts, cb, cb_arg, io_handle, del_fn, nullptr);
     }
@@ -470,7 +470,7 @@ IOStatus TestFSRandomAccessFile::MultiRead(FSReadRequest* reqs, size_t num_reqs,
         /*fault_injected=*/nullptr);
   }
   if (s.ok() && fs_->ShouldInjectRandomReadError()) {
-    return IOStatus::IOError("Injected read error");
+    return IOStatus::IOError("injected read error");
   }
   return s;
 }
@@ -487,7 +487,7 @@ IOStatus TestFSSequentialFile::Read(size_t n, const IOOptions& options,
                                     IODebugContext* dbg) {
   IOStatus s = target()->Read(n, options, result, scratch, dbg);
   if (s.ok() && fs_->ShouldInjectRandomReadError()) {
-    return IOStatus::IOError("Injected seq read error");
+    return IOStatus::IOError("injected seq read error");
   }
   return s;
 }
@@ -499,7 +499,7 @@ IOStatus TestFSSequentialFile::PositionedRead(uint64_t offset, size_t n,
   IOStatus s =
       target()->PositionedRead(offset, n, options, result, scratch, dbg);
   if (s.ok() && fs_->ShouldInjectRandomReadError()) {
-    return IOStatus::IOError("Injected seq positioned read error");
+    return IOStatus::IOError("injected seq positioned read error");
   }
   return s;
 }
@@ -678,7 +678,7 @@ IOStatus FaultInjectionTestFS::NewRandomAccessFile(
     return GetError();
   }
   if (ShouldInjectRandomReadError()) {
-    return IOStatus::IOError("Injected error when open random access file");
+    return IOStatus::IOError("injected error when open random access file");
   }
   IOStatus io_s = InjectThreadSpecificReadError(ErrorOperation::kOpen, nullptr,
                                                 false, nullptr,
@@ -701,7 +701,7 @@ IOStatus FaultInjectionTestFS::NewSequentialFile(
   }
 
   if (ShouldInjectRandomReadError()) {
-    return IOStatus::IOError("Injected read error when creating seq file");
+    return IOStatus::IOError("injected read error when creating seq file");
   }
   IOStatus io_s = target()->NewSequentialFile(fname, file_opts, result, dbg);
   if (io_s.ok()) {
@@ -956,6 +956,7 @@ IOStatus FaultInjectionTestFS::InjectThreadSpecificReadError(
     return IOStatus::OK();
   }
 
+  IOStatus ret;
   if (ctx->rand.OneIn(ctx->one_in)) {
     if (ctx->count == 0) {
       ctx->message = "";
@@ -970,15 +971,15 @@ IOStatus FaultInjectionTestFS::InjectThreadSpecificReadError(
 
     if (op != ErrorOperation::kMultiReadSingleReq) {
       // Likely non-per read status code for MultiRead
-      ctx->message += "error; ";
+      ctx->message += "injected read error; ";
       ret_fault_injected = true;
-      return IOStatus::IOError();
+      ret = IOStatus::IOError(ctx->message);
     } else if (Random::GetTLSInstance()->OneIn(8)) {
       assert(result);
       // For a small chance, set the failure to status but turn the
       // result to be empty, which is supposed to be caught for a check.
       *result = Slice();
-      ctx->message += "inject empty result; ";
+      ctx->message += "injected empty result; ";
       ret_fault_injected = true;
     } else if (!direct_io && Random::GetTLSInstance()->OneIn(7) &&
                scratch != nullptr && result->data() == scratch) {
@@ -995,15 +996,18 @@ IOStatus FaultInjectionTestFS::InjectThreadSpecificReadError(
       // It would work for CRC. Not 100% sure for xxhash and will adjust
       // if it is not the case.
       const_cast<char*>(result->data())[result->size() - 1]++;
-      ctx->message += "corrupt last byte; ";
+      ctx->message += "injected corrupt last byte; ";
       ret_fault_injected = true;
     } else {
-      ctx->message += "error result multiget single; ";
+      ctx->message += "injected error result multiget single; ";
       ret_fault_injected = true;
-      return IOStatus::IOError();
+      ret = IOStatus::IOError(ctx->message);
     }
   }
-  return IOStatus::OK();
+  if (ctx->retryable) {
+    ret.SetRetryable(true);
+  }
+  return ret;
 }
 
 bool FaultInjectionTestFS::TryParseFileName(const std::string& file_name,
@@ -1052,7 +1056,7 @@ IOStatus FaultInjectionTestFS::InjectMetadataWriteError() {
     }
   }
   TEST_SYNC_POINT("FaultInjectionTestFS::InjectMetadataWriteError:Injected");
-  return IOStatus::IOError();
+  return IOStatus::IOError("injected metadata write error");
 }
 
 void FaultInjectionTestFS::PrintFaultBacktrace() {

package/deps/rocksdb/rocksdb/utilities/fault_injection_fs.h

@@ -323,8 +323,8 @@ class FaultInjectionTestFS : public FileSystemWrapper {
     if (!TryParseFileName(file_name, &file_number, &file_type)) {
       return false;
     }
-    return skip_direct_writable_types_.find(file_type) !=
-           skip_direct_writable_types_.end();
+    return direct_writable_types_.find(file_type) !=
+           direct_writable_types_.end();
   }
   void SetFilesystemActiveNoLock(
       bool active, IOStatus error = IOStatus::Corruption("Not active")) {
@@ -402,7 +402,8 @@ class FaultInjectionTestFS : public FileSystemWrapper {
   // seed is the seed for the random number generator, and one_in determines
   // the probability of injecting error (i.e an error is injected with
   // 1/one_in probability)
-  void SetThreadLocalReadErrorContext(uint32_t seed, int one_in) {
+  void SetThreadLocalReadErrorContext(uint32_t seed, int one_in,
+                                      bool retryable) {
     struct ErrorContext* ctx =
         static_cast<struct ErrorContext*>(thread_local_error_->Get());
     if (ctx == nullptr) {
@@ -411,6 +412,7 @@ class FaultInjectionTestFS : public FileSystemWrapper {
     }
     ctx->one_in = one_in;
     ctx->count = 0;
+    ctx->retryable = retryable;
   }
 
   static void DeleteThreadLocalErrorContext(void* p) {
@@ -437,9 +439,9 @@ class FaultInjectionTestFS : public FileSystemWrapper {
     write_error_allowed_types_ = types;
   }
 
-  void SetSkipDirectWritableTypes(const std::set<FileType>& types) {
+  void SetDirectWritableTypes(const std::set<FileType>& types) {
     MutexLock l(&mutex_);
-    skip_direct_writable_types_ = types;
+    direct_writable_types_ = types;
   }
 
   void SetRandomMetadataWriteError(int one_in) {
@@ -556,12 +558,14 @@ class FaultInjectionTestFS : public FileSystemWrapper {
     std::string message;
     int frames;
     ErrorType type;
+    bool retryable;
 
     explicit ErrorContext(uint32_t seed)
         : rand(seed),
           enable_error_injection(false),
           callstack(nullptr),
-          frames(0) {}
+          frames(0),
+          retryable(false) {}
     ~ErrorContext() {
       if (callstack) {
         free(callstack);
@@ -579,7 +583,7 @@ class FaultInjectionTestFS : public FileSystemWrapper {
   bool inject_for_all_file_types_;
   std::vector<FileType> write_error_allowed_types_;
   // File types where direct writable is skipped.
-  std::set<FileType> skip_direct_writable_types_;
+  std::set<FileType> direct_writable_types_;
   bool ingest_data_corruption_before_write_;
   ChecksumType checksum_handoff_func_tpye_;
   bool fail_get_file_unique_id_;

package/deps/rocksdb/rocksdb/utilities/fault_injection_secondary_cache.h

@@ -35,6 +35,11 @@ class FaultInjectionSecondaryCache : public SecondaryCache {
                 const Cache::CacheItemHelper* helper,
                 bool force_insert) override;
 
+  Status InsertSaved(const Slice& /*key*/, const Slice& /*saved*/,
+                     CompressionType /*type*/, CacheTier /*source*/) override {
+    return Status::OK();
+  }
+
   std::unique_ptr<SecondaryCacheResultHandle> Lookup(
       const Slice& key, const Cache::CacheItemHelper* helper,
       Cache::CreateContext* create_context, bool wait, bool advise_erase,

package/deps/rocksdb/rocksdb/utilities/merge_operators/string_append/stringappend_test.cc

@@ -193,6 +193,7 @@ TEST_P(StringAppendOperatorTest, IteratorTest) {
       ASSERT_EQ(res, "a1,a2,a3");
     }
   }
+  ASSERT_OK(it->status());
 
   // Should release the snapshot and be aware of the new stuff now
   it.reset(db_->NewIterator(ReadOptions()));
@@ -217,6 +218,7 @@ TEST_P(StringAppendOperatorTest, IteratorTest) {
       ASSERT_EQ(res, "a1,a2,a3,a4");
     }
   }
+  ASSERT_OK(it->status());
 
   slists.Append("k3", "g1");
 
@@ -242,6 +244,7 @@ TEST_P(StringAppendOperatorTest, IteratorTest) {
       ASSERT_EQ(res, "g1");
     }
   }
+  ASSERT_OK(it->status());
 }
 
 TEST_P(StringAppendOperatorTest, SimpleTest) {

package/deps/rocksdb/rocksdb/utilities/option_change_migration/option_change_migration_test.cc

@@ -87,6 +87,7 @@ TEST_P(DBOptionChangeMigrationTests, Migrate1) {
     for (; it->Valid(); it->Next()) {
       keys.insert(it->key().ToString());
     }
+    ASSERT_OK(it->status());
   }
   Close();
 
@@ -124,6 +125,7 @@ TEST_P(DBOptionChangeMigrationTests, Migrate1) {
       it->Next();
     }
     ASSERT_TRUE(!it->Valid());
+    ASSERT_OK(it->status());
   }
 }
 
@@ -165,6 +167,7 @@ TEST_P(DBOptionChangeMigrationTests, Migrate2) {
     for (; it->Valid(); it->Next()) {
       keys.insert(it->key().ToString());
     }
+    ASSERT_OK(it->status());
   }
 
   Close();
@@ -202,6 +205,7 @@ TEST_P(DBOptionChangeMigrationTests, Migrate2) {
       it->Next();
     }
     ASSERT_TRUE(!it->Valid());
+    ASSERT_OK(it->status());
   }
 }
 
@@ -249,6 +253,7 @@ TEST_P(DBOptionChangeMigrationTests, Migrate3) {
     for (; it->Valid(); it->Next()) {
       keys.insert(it->key().ToString());
     }
+    ASSERT_OK(it->status());
   }
   Close();
 
@@ -286,6 +291,7 @@ TEST_P(DBOptionChangeMigrationTests, Migrate3) {
       it->Next();
     }
     ASSERT_TRUE(!it->Valid());
+    ASSERT_OK(it->status());
   }
 }
 
@@ -333,6 +339,7 @@ TEST_P(DBOptionChangeMigrationTests, Migrate4) {
     for (; it->Valid(); it->Next()) {
       keys.insert(it->key().ToString());
     }
+    ASSERT_OK(it->status());
   }
 
   Close();
@@ -370,6 +377,7 @@ TEST_P(DBOptionChangeMigrationTests, Migrate4) {
       it->Next();
     }
     ASSERT_TRUE(!it->Valid());
+    ASSERT_OK(it->status());
   }
 }
 
@@ -509,6 +517,7 @@ TEST_F(DBOptionChangeMigrationTest, CompactedSrcToUniversal) {
     for (; it->Valid(); it->Next()) {
       keys.insert(it->key().ToString());
     }
+    ASSERT_OK(it->status());
   }
 
   Close();

package/deps/rocksdb/rocksdb/utilities/simulator_cache/sim_cache.cc

@@ -169,7 +169,8 @@ class SimCacheImpl : public SimCache {
 
   Status Insert(const Slice& key, Cache::ObjectPtr value,
                 const CacheItemHelper* helper, size_t charge, Handle** handle,
-                Priority priority) override {
+                Priority priority, const Slice& compressed = {},
+                CompressionType type = kNoCompression) override {
     // The handle and value passed in are for real cache, so we pass nullptr
     // to key_only_cache_ for both instead. Also, the deleter function pointer
     // will be called by user to perform some external operation which should
@@ -178,8 +179,9 @@ class SimCacheImpl : public SimCache {
     Handle* h = key_only_cache_->Lookup(key);
     if (h == nullptr) {
       // TODO: Check for error here?
-      auto s = key_only_cache_->Insert(key, nullptr, &kNoopCacheItemHelper,
-                                       charge, nullptr, priority);
+      auto s =
+          key_only_cache_->Insert(key, nullptr, &kNoopCacheItemHelper, charge,
+                                  nullptr, priority, compressed, type);
       s.PermitUncheckedError();
     } else {
       key_only_cache_->Release(h);
@@ -189,7 +191,8 @@ class SimCacheImpl : public SimCache {
     if (!target_) {
       return Status::OK();
     }
-    return target_->Insert(key, value, helper, charge, handle, priority);
+    return target_->Insert(key, value, helper, charge, handle, priority,
+                           compressed, type);
   }
 
   Handle* Lookup(const Slice& key, const CacheItemHelper* helper,

package/deps/rocksdb/rocksdb/utilities/transactions/lock/range/range_tree/lib/README

@@ -0,0 +1,13 @@
+The files in this directory originally come from
+https://github.com/percona/PerconaFT/.
+
+This directory only includes the "locktree" part of PerconaFT, and its
+dependencies.
+
+The following modifications were made:
+- Make locktree usable outside of PerconaFT library
+- Add shared read-only lock support
+
+The files named *_subst.* are substitutes of the PerconaFT's files, they
+contain replacements of PerconaFT's functionality.
+

package/deps/rocksdb/rocksdb/utilities/transactions/optimistic_transaction_test.cc

@@ -1635,6 +1635,47 @@ TEST_P(OptimisticTransactionTest, SequenceNumberAfterRecoverTest) {
   delete transaction;
 }
 
+#ifdef __SANITIZE_THREAD__
+// Skip OptimisticTransactionTest.SequenceNumberAfterRecoverLargeTest under TSAN
+// to avoid false positive because of TSAN lock limit of 64.
+#else
+TEST_P(OptimisticTransactionTest, SequenceNumberAfterRecoverLargeTest) {
+  WriteOptions write_options;
+  OptimisticTransactionOptions transaction_options;
+
+  Transaction* transaction(
+      txn_db->BeginTransaction(write_options, transaction_options));
+
+  std::string value(1024 * 1024, 'X');
+  const size_t n_zero = 2;
+  std::string s_i;
+  Status s;
+  for (int i = 1; i <= 64; i++) {
+    s_i = std::to_string(i);
+    auto key = std::string(n_zero - std::min(n_zero, s_i.length()), '0') + s_i;
+    s = transaction->Put(key, value);
+    ASSERT_OK(s);
+  }
+
+  s = transaction->Commit();
+  ASSERT_OK(s);
+  delete transaction;
+
+  Reopen();
+  transaction = txn_db->BeginTransaction(write_options, transaction_options);
+  s = transaction->Put("bar", "val");
+  ASSERT_OK(s);
+  s = transaction->Commit();
+  if (!s.ok()) {
+    std::cerr << "Failed to commit records. Error: " << s.ToString()
+              << std::endl;
+  }
+  ASSERT_OK(s);
+
+  delete transaction;
+}
+#endif  // __SANITIZE_THREAD__
+
 TEST_P(OptimisticTransactionTest, TimestampedSnapshotMissingCommitTs) {
   std::unique_ptr<Transaction> txn(txn_db->BeginTransaction(WriteOptions()));
   ASSERT_OK(txn->Put("a", "v"));