@nxtedition/rocksdb 8.1.17 → 8.2.0-alpha.2

package/deps/rocksdb/rocksdb/table/merging_iterator.h

@@ -12,6 +12,7 @@
 #include "db/range_del_aggregator.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/types.h"
+#include "table/iterator_wrapper.h"
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -23,7 +24,7 @@ template <class TValue>
 class InternalIteratorBase;
 using InternalIterator = InternalIteratorBase<Slice>;
 
-// Return an iterator that provided the union of the data in
+// Return an iterator that provides the union of the data in
 // children[0,n-1].  Takes ownership of the child iterators and
 // will delete them when the result iterator is deleted.
 //
@@ -35,11 +36,15 @@ extern InternalIterator* NewMergingIterator(
     const InternalKeyComparator* comparator, InternalIterator** children, int n,
     Arena* arena = nullptr, bool prefix_seek_mode = false);
 
+// The iterator returned by NewMergingIterator() and
+// MergeIteratorBuilder::Finish(). MergingIterator handles the merging of data
+// from different point and/or range tombstone iterators.
 class MergingIterator;
 
-// A builder class to build a merging iterator by adding iterators one by one.
-// User should call only one of AddIterator() or AddPointAndTombstoneIterator()
-// exclusively for the same builder.
+// A builder class to for an iterator that provides the union of data
+// of input iterators. Two APIs are provided to add input iterators. User should
+// only call one of them exclusively depending on if range tombstone should be
+// processed.
 class MergeIteratorBuilder {
  public:
   // comparator: the comparator used in merging comparator
@@ -49,7 +54,7 @@ class MergeIteratorBuilder {
                                 const Slice* iterate_upper_bound = nullptr);
   ~MergeIteratorBuilder();
 
-  // Add iter to the merging iterator.
+  // Add point key iterator `iter` to the merging iterator.
   void AddIterator(InternalIterator* iter);
 
   // Add a point key iterator and a range tombstone iterator.

package/deps/rocksdb/rocksdb/table/table_test.cc

@@ -2253,6 +2253,12 @@ TEST_P(BlockBasedTableTest, BadChecksumType) {
             "Corruption: Corrupt or unsupported checksum type: 123 in test");
 }
 
+class BuiltinChecksumTest : public testing::Test,
+                            public testing::WithParamInterface<ChecksumType> {};
+
+INSTANTIATE_TEST_CASE_P(SupportedChecksums, BuiltinChecksumTest,
+                        testing::ValuesIn(GetSupportedChecksums()));
+
 namespace {
 std::string ChecksumAsString(const std::string& data,
                              ChecksumType checksum_type) {
@@ -2278,7 +2284,11 @@ std::string ChecksumAsString(std::string* data, char new_last_byte,
 
 // Make sure that checksum values don't change in later versions, even if
 // consistent within current version.
-TEST_P(BlockBasedTableTest, ChecksumSchemas) {
+TEST_P(BuiltinChecksumTest, ChecksumSchemas) {
+  // Trailing 'x' chars will be replaced by compression type. Specifically,
+  // the first byte of a block trailer is compression type, which is part of
+  // the checksum input. This test does not deal with storing or parsing
+  // checksums from the trailer (next 4 bytes of trailer).
   std::string b0 = "x";
   std::string b1 = "This is a short block!x";
   std::string b2;
@@ -2286,7 +2296,6 @@ TEST_P(BlockBasedTableTest, ChecksumSchemas) {
     b2.append("This is a long block!");
   }
   b2.append("x");
-  // Trailing 'x' will be replaced by compression type
 
   std::string empty;
 
@@ -2294,74 +2303,108 @@ TEST_P(BlockBasedTableTest, ChecksumSchemas) {
   char ct2 = kSnappyCompression;
   char ct3 = kZSTD;
 
-  // Note: first byte of trailer is compression type, last 4 are checksum
-
-  for (ChecksumType t : GetSupportedChecksums()) {
-    switch (t) {
-      case kNoChecksum:
-        EXPECT_EQ(ChecksumAsString(empty, t), "00000000");
-        EXPECT_EQ(ChecksumAsString(&b0, ct1, t), "00000000");
-        EXPECT_EQ(ChecksumAsString(&b0, ct2, t), "00000000");
-        EXPECT_EQ(ChecksumAsString(&b0, ct3, t), "00000000");
-        EXPECT_EQ(ChecksumAsString(&b1, ct1, t), "00000000");
-        EXPECT_EQ(ChecksumAsString(&b1, ct2, t), "00000000");
-        EXPECT_EQ(ChecksumAsString(&b1, ct3, t), "00000000");
-        EXPECT_EQ(ChecksumAsString(&b2, ct1, t), "00000000");
-        EXPECT_EQ(ChecksumAsString(&b2, ct2, t), "00000000");
-        EXPECT_EQ(ChecksumAsString(&b2, ct3, t), "00000000");
-        break;
-      case kCRC32c:
-        EXPECT_EQ(ChecksumAsString(empty, t), "D8EA82A2");
-        EXPECT_EQ(ChecksumAsString(&b0, ct1, t), "D28F2549");
-        EXPECT_EQ(ChecksumAsString(&b0, ct2, t), "052B2843");
-        EXPECT_EQ(ChecksumAsString(&b0, ct3, t), "46F8F711");
-        EXPECT_EQ(ChecksumAsString(&b1, ct1, t), "583F0355");
-        EXPECT_EQ(ChecksumAsString(&b1, ct2, t), "2F9B0A57");
-        EXPECT_EQ(ChecksumAsString(&b1, ct3, t), "ECE7DA1D");
-        EXPECT_EQ(ChecksumAsString(&b2, ct1, t), "943EF0AB");
-        EXPECT_EQ(ChecksumAsString(&b2, ct2, t), "43A2EDB1");
-        EXPECT_EQ(ChecksumAsString(&b2, ct3, t), "00E53D63");
-        break;
-      case kxxHash:
-        EXPECT_EQ(ChecksumAsString(empty, t), "055DCC02");
-        EXPECT_EQ(ChecksumAsString(&b0, ct1, t), "3EB065CF");
-        EXPECT_EQ(ChecksumAsString(&b0, ct2, t), "31F79238");
-        EXPECT_EQ(ChecksumAsString(&b0, ct3, t), "320D2E00");
-        EXPECT_EQ(ChecksumAsString(&b1, ct1, t), "4A2E5FB0");
-        EXPECT_EQ(ChecksumAsString(&b1, ct2, t), "0BD9F652");
-        EXPECT_EQ(ChecksumAsString(&b1, ct3, t), "B4107E50");
-        EXPECT_EQ(ChecksumAsString(&b2, ct1, t), "20F4D4BA");
-        EXPECT_EQ(ChecksumAsString(&b2, ct2, t), "8F1A1F99");
-        EXPECT_EQ(ChecksumAsString(&b2, ct3, t), "A191A338");
-        break;
-      case kxxHash64:
-        EXPECT_EQ(ChecksumAsString(empty, t), "99E9D851");
-        EXPECT_EQ(ChecksumAsString(&b0, ct1, t), "682705DB");
-        EXPECT_EQ(ChecksumAsString(&b0, ct2, t), "30E7211B");
-        EXPECT_EQ(ChecksumAsString(&b0, ct3, t), "B7BB58E8");
-        EXPECT_EQ(ChecksumAsString(&b1, ct1, t), "B74655EF");
-        EXPECT_EQ(ChecksumAsString(&b1, ct2, t), "B6C8BBBE");
-        EXPECT_EQ(ChecksumAsString(&b1, ct3, t), "AED9E3B4");
-        EXPECT_EQ(ChecksumAsString(&b2, ct1, t), "0D4999FE");
-        EXPECT_EQ(ChecksumAsString(&b2, ct2, t), "F5932423");
-        EXPECT_EQ(ChecksumAsString(&b2, ct3, t), "6B31BAB1");
-        break;
-      case kXXH3:
-        EXPECT_EQ(ChecksumAsString(empty, t), "00000000");
-        EXPECT_EQ(ChecksumAsString(&b0, ct1, t), "C294D338");
-        EXPECT_EQ(ChecksumAsString(&b0, ct2, t), "1B174353");
-        EXPECT_EQ(ChecksumAsString(&b0, ct3, t), "2D0E20C8");
-        EXPECT_EQ(ChecksumAsString(&b1, ct1, t), "B37FB5E6");
-        EXPECT_EQ(ChecksumAsString(&b1, ct2, t), "6AFC258D");
-        EXPECT_EQ(ChecksumAsString(&b1, ct3, t), "5CE54616");
-        EXPECT_EQ(ChecksumAsString(&b2, ct1, t), "FA2D482E");
-        EXPECT_EQ(ChecksumAsString(&b2, ct2, t), "23AED845");
-        EXPECT_EQ(ChecksumAsString(&b2, ct3, t), "15B7BBDE");
-        break;
-      default:
-        // Force this test to be updated on new ChecksumTypes
-        assert(false);
-        break;
+  ChecksumType t = GetParam();
+  switch (t) {
+    case kNoChecksum:
+      EXPECT_EQ(ChecksumAsString(empty, t), "00000000");
+      EXPECT_EQ(ChecksumAsString(&b0, ct1, t), "00000000");
+      EXPECT_EQ(ChecksumAsString(&b0, ct2, t), "00000000");
+      EXPECT_EQ(ChecksumAsString(&b0, ct3, t), "00000000");
+      EXPECT_EQ(ChecksumAsString(&b1, ct1, t), "00000000");
+      EXPECT_EQ(ChecksumAsString(&b1, ct2, t), "00000000");
+      EXPECT_EQ(ChecksumAsString(&b1, ct3, t), "00000000");
+      EXPECT_EQ(ChecksumAsString(&b2, ct1, t), "00000000");
+      EXPECT_EQ(ChecksumAsString(&b2, ct2, t), "00000000");
+      EXPECT_EQ(ChecksumAsString(&b2, ct3, t), "00000000");
+      break;
+    case kCRC32c:
+      EXPECT_EQ(ChecksumAsString(empty, t), "D8EA82A2");
+      EXPECT_EQ(ChecksumAsString(&b0, ct1, t), "D28F2549");
+      EXPECT_EQ(ChecksumAsString(&b0, ct2, t), "052B2843");
+      EXPECT_EQ(ChecksumAsString(&b0, ct3, t), "46F8F711");
+      EXPECT_EQ(ChecksumAsString(&b1, ct1, t), "583F0355");
+      EXPECT_EQ(ChecksumAsString(&b1, ct2, t), "2F9B0A57");
+      EXPECT_EQ(ChecksumAsString(&b1, ct3, t), "ECE7DA1D");
+      EXPECT_EQ(ChecksumAsString(&b2, ct1, t), "943EF0AB");
+      EXPECT_EQ(ChecksumAsString(&b2, ct2, t), "43A2EDB1");
+      EXPECT_EQ(ChecksumAsString(&b2, ct3, t), "00E53D63");
+      break;
+    case kxxHash:
+      EXPECT_EQ(ChecksumAsString(empty, t), "055DCC02");
+      EXPECT_EQ(ChecksumAsString(&b0, ct1, t), "3EB065CF");
+      EXPECT_EQ(ChecksumAsString(&b0, ct2, t), "31F79238");
+      EXPECT_EQ(ChecksumAsString(&b0, ct3, t), "320D2E00");
+      EXPECT_EQ(ChecksumAsString(&b1, ct1, t), "4A2E5FB0");
+      EXPECT_EQ(ChecksumAsString(&b1, ct2, t), "0BD9F652");
+      EXPECT_EQ(ChecksumAsString(&b1, ct3, t), "B4107E50");
+      EXPECT_EQ(ChecksumAsString(&b2, ct1, t), "20F4D4BA");
+      EXPECT_EQ(ChecksumAsString(&b2, ct2, t), "8F1A1F99");
+      EXPECT_EQ(ChecksumAsString(&b2, ct3, t), "A191A338");
+      break;
+    case kxxHash64:
+      EXPECT_EQ(ChecksumAsString(empty, t), "99E9D851");
+      EXPECT_EQ(ChecksumAsString(&b0, ct1, t), "682705DB");
+      EXPECT_EQ(ChecksumAsString(&b0, ct2, t), "30E7211B");
+      EXPECT_EQ(ChecksumAsString(&b0, ct3, t), "B7BB58E8");
+      EXPECT_EQ(ChecksumAsString(&b1, ct1, t), "B74655EF");
+      EXPECT_EQ(ChecksumAsString(&b1, ct2, t), "B6C8BBBE");
+      EXPECT_EQ(ChecksumAsString(&b1, ct3, t), "AED9E3B4");
+      EXPECT_EQ(ChecksumAsString(&b2, ct1, t), "0D4999FE");
+      EXPECT_EQ(ChecksumAsString(&b2, ct2, t), "F5932423");
+      EXPECT_EQ(ChecksumAsString(&b2, ct3, t), "6B31BAB1");
+      break;
+    case kXXH3:
+      EXPECT_EQ(ChecksumAsString(empty, t), "00000000");
+      EXPECT_EQ(ChecksumAsString(&b0, ct1, t), "C294D338");
+      EXPECT_EQ(ChecksumAsString(&b0, ct2, t), "1B174353");
+      EXPECT_EQ(ChecksumAsString(&b0, ct3, t), "2D0E20C8");
+      EXPECT_EQ(ChecksumAsString(&b1, ct1, t), "B37FB5E6");
+      EXPECT_EQ(ChecksumAsString(&b1, ct2, t), "6AFC258D");
+      EXPECT_EQ(ChecksumAsString(&b1, ct3, t), "5CE54616");
+      EXPECT_EQ(ChecksumAsString(&b2, ct1, t), "FA2D482E");
+      EXPECT_EQ(ChecksumAsString(&b2, ct2, t), "23AED845");
+      EXPECT_EQ(ChecksumAsString(&b2, ct3, t), "15B7BBDE");
+      break;
+    default:
+      // Force this test to be updated on new ChecksumTypes
+      assert(false);
+      break;
+  }
+}
+
+TEST_P(BuiltinChecksumTest, ChecksumZeroInputs) {
+  // Verify that no reasonably sized "all zeros" inputs produce "all zeros"
+  // output. Otherwise, "wiped" data could appear to be well-formed.
+  // Assuming essentially random assignment of output values, the likelihood
+  // of encountering checksum == 0 for an input not specifically crafted is
+  // 1 in 4 billion.
+  if (GetParam() == kNoChecksum) {
+    return;
+  }
+  // "Thorough" case is too slow for continouous testing
+  bool thorough = getenv("ROCKSDB_THOROUGH_CHECKSUM_TEST") != nullptr;
+  // Verified through 10M
+  size_t kMaxZerosLen = thorough ? 10000000 : 20000;
+  std::string zeros(kMaxZerosLen, '\0');
+
+  for (size_t len = 0; len < kMaxZerosLen; ++len) {
+    if (thorough && (len & 0xffffU) == 0) {
+      fprintf(stderr, "t=%u len=%u\n", (unsigned)GetParam(), (unsigned)len);
+    }
+    uint32_t v = ComputeBuiltinChecksum(GetParam(), zeros.data(), len);
+    if (v == 0U) {
+      // One exception case:
+      if (GetParam() == kXXH3 && len == 0) {
+        // This is not a big deal because assuming the block length is known
+        // from the block handle, which comes from a checksum-verified block,
+        // there is nothing to corrupt in a zero-length block. And when there
+        // is a block trailer with compression byte (as in block-based table),
+        // zero length checksummed data never arises.
+        continue;
+      }
+      // Only compute this on failure
+      SCOPED_TRACE("len=" + std::to_string(len));
+      ASSERT_NE(v, 0U);
     }
   }
 }

package/deps/rocksdb/rocksdb/test_util/secondary_cache_test_util.cc

@@ -0,0 +1,96 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+
+#include "test_util/secondary_cache_test_util.h"
+
+#include <array>
+
+namespace ROCKSDB_NAMESPACE {
+
+namespace secondary_cache_test_util {
+
+namespace {
+using TestItem = WithCacheType::TestItem;
+
+size_t SizeCallback(Cache::ObjectPtr obj) {
+  return static_cast<TestItem*>(obj)->Size();
+}
+
+Status SaveToCallback(Cache::ObjectPtr from_obj, size_t from_offset,
+                      size_t length, char* out) {
+  auto item = static_cast<TestItem*>(from_obj);
+  const char* buf = item->Buf();
+  EXPECT_EQ(length, item->Size());
+  EXPECT_EQ(from_offset, 0);
+  memcpy(out, buf, length);
+  return Status::OK();
+}
+
+void DeletionCallback(Cache::ObjectPtr obj, MemoryAllocator* /*alloc*/) {
+  delete static_cast<TestItem*>(obj);
+}
+
+Status SaveToCallbackFail(Cache::ObjectPtr /*obj*/, size_t /*offset*/,
+                          size_t /*size*/, char* /*out*/) {
+  return Status::NotSupported();
+}
+
+Status CreateCallback(const Slice& data, Cache::CreateContext* context,
+                      MemoryAllocator* /*allocator*/, Cache::ObjectPtr* out_obj,
+                      size_t* out_charge) {
+  auto t = static_cast<TestCreateContext*>(context);
+  if (t->fail_create_) {
+    return Status::NotSupported();
+  }
+  *out_obj = new TestItem(data.data(), data.size());
+  *out_charge = data.size();
+  return Status::OK();
+}
+
+// If helpers without_secondary are provided, returns helpers with secondary
+// support. If not provided, returns helpers without secondary support.
+auto GenerateHelpersByRole(
+    const std::array<Cache::CacheItemHelper, kNumCacheEntryRoles>*
+        without_secondary,
+    bool fail) {
+  std::array<Cache::CacheItemHelper, kNumCacheEntryRoles> a;
+  for (uint32_t i = 0; i < kNumCacheEntryRoles; ++i) {
+    if (without_secondary) {
+      a[i] =
+          Cache::CacheItemHelper{static_cast<CacheEntryRole>(i),
+                                 &DeletionCallback,
+                                 &SizeCallback,
+                                 fail ? &SaveToCallbackFail : &SaveToCallback,
+                                 &CreateCallback,
+                                 &(*without_secondary)[i]};
+    } else {
+      a[i] = Cache::CacheItemHelper{static_cast<CacheEntryRole>(i),
+                                    &DeletionCallback};
+    }
+  }
+  return a;
+}
+}  // namespace
+
+const Cache::CacheItemHelper* WithCacheType::GetHelper(
+    CacheEntryRole r, bool secondary_compatible, bool fail) {
+  static const std::array<Cache::CacheItemHelper, kNumCacheEntryRoles>
+      without_secondary = GenerateHelpersByRole(nullptr, false);
+  static const std::array<Cache::CacheItemHelper, kNumCacheEntryRoles>
+      with_secondary = GenerateHelpersByRole(&without_secondary, false);
+  static const std::array<Cache::CacheItemHelper, kNumCacheEntryRoles>
+      with_secondary_fail = GenerateHelpersByRole(&without_secondary, true);
+  return &(fail                   ? with_secondary_fail
+           : secondary_compatible ? with_secondary
+                                  : without_secondary)[static_cast<int>(r)];
+}
+
+const Cache::CacheItemHelper* WithCacheType::GetHelperFail(CacheEntryRole r) {
+  return GetHelper(r, true, true);
+}
+
+}  // namespace secondary_cache_test_util
+
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/test_util/secondary_cache_test_util.h

@@ -0,0 +1,117 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+
+#pragma once
+
+#include <gtest/gtest.h>
+
+#include <functional>
+
+#include "rocksdb/advanced_cache.h"
+
+namespace ROCKSDB_NAMESPACE {
+namespace secondary_cache_test_util {
+
+struct TestCreateContext : public Cache::CreateContext {
+  void SetFailCreate(bool fail) { fail_create_ = fail; }
+
+  bool fail_create_ = false;
+};
+
+class WithCacheType : public TestCreateContext {
+ public:
+  WithCacheType() {}
+  virtual ~WithCacheType() {}
+
+  class TestItem {
+   public:
+    TestItem(const char* buf, size_t size) : buf_(new char[size]), size_(size) {
+      memcpy(buf_.get(), buf, size);
+    }
+    ~TestItem() = default;
+
+    char* Buf() { return buf_.get(); }
+    [[nodiscard]] size_t Size() const { return size_; }
+    std::string ToString() { return std::string(Buf(), Size()); }
+
+   private:
+    std::unique_ptr<char[]> buf_;
+    size_t size_;
+  };
+
+  static constexpr auto kLRU = "lru";
+  static constexpr auto kHyperClock = "hyper_clock";
+
+  // For options other than capacity
+  size_t estimated_value_size_ = 1;
+
+  virtual const std::string& Type() = 0;
+
+  std::shared_ptr<Cache> NewCache(
+      size_t capacity,
+      std::function<void(ShardedCacheOptions&)> modify_opts_fn = {}) {
+    const auto& type = Type();
+    if (type == kLRU) {
+      LRUCacheOptions lru_opts;
+      lru_opts.capacity = capacity;
+      if (modify_opts_fn) {
+        modify_opts_fn(lru_opts);
+      }
+      return NewLRUCache(lru_opts);
+    }
+    if (type == kHyperClock) {
+      HyperClockCacheOptions hc_opts{capacity, estimated_value_size_};
+      if (modify_opts_fn) {
+        modify_opts_fn(hc_opts);
+      }
+      return hc_opts.MakeSharedCache();
+    }
+    assert(false);
+    return nullptr;
+  }
+
+  std::shared_ptr<Cache> NewCache(
+      size_t capacity, int num_shard_bits, bool strict_capacity_limit,
+      CacheMetadataChargePolicy charge_policy = kDontChargeCacheMetadata) {
+    return NewCache(capacity, [=](ShardedCacheOptions& opts) {
+      opts.num_shard_bits = num_shard_bits;
+      opts.strict_capacity_limit = strict_capacity_limit;
+      opts.metadata_charge_policy = charge_policy;
+    });
+  }
+
+  std::shared_ptr<Cache> NewCache(
+      size_t capacity, int num_shard_bits, bool strict_capacity_limit,
+      std::shared_ptr<SecondaryCache> secondary_cache) {
+    return NewCache(capacity, [=](ShardedCacheOptions& opts) {
+      opts.num_shard_bits = num_shard_bits;
+      opts.strict_capacity_limit = strict_capacity_limit;
+      opts.metadata_charge_policy = kDontChargeCacheMetadata;
+      opts.secondary_cache = secondary_cache;
+    });
+  }
+
+  static const Cache::CacheItemHelper* GetHelper(
+      CacheEntryRole r = CacheEntryRole::kDataBlock,
+      bool secondary_compatible = true, bool fail = false);
+
+  static const Cache::CacheItemHelper* GetHelperFail(
+      CacheEntryRole r = CacheEntryRole::kDataBlock);
+};
+
+class WithCacheTypeParam : public WithCacheType,
+                           public testing::WithParamInterface<std::string> {
+  const std::string& Type() override { return GetParam(); }
+};
+
+constexpr auto kLRU = WithCacheType::kLRU;
+constexpr auto kHyperClock = WithCacheType::kHyperClock;
+
+inline auto GetTestingCacheTypes() {
+  return testing::Values(std::string(kLRU), std::string(kHyperClock));
+}
+
+}  // namespace secondary_cache_test_util
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/utilities/checkpoint/checkpoint_impl.cc

@@ -372,17 +372,19 @@ Status CheckpointImpl::ExportColumnFamily(
       for (const auto& file_metadata : level_metadata.files) {
         LiveFileMetaData live_file_metadata;
         live_file_metadata.size = file_metadata.size;
-        live_file_metadata.name = std::move(file_metadata.name);
+        live_file_metadata.name = file_metadata.name;
         live_file_metadata.file_number = file_metadata.file_number;
         live_file_metadata.db_path = export_dir;
         live_file_metadata.smallest_seqno = file_metadata.smallest_seqno;
         live_file_metadata.largest_seqno = file_metadata.largest_seqno;
-        live_file_metadata.smallestkey = std::move(file_metadata.smallestkey);
-        live_file_metadata.largestkey = std::move(file_metadata.largestkey);
+        live_file_metadata.smallestkey = file_metadata.smallestkey;
+        live_file_metadata.largestkey = file_metadata.largestkey;
         live_file_metadata.oldest_blob_file_number =
             file_metadata.oldest_blob_file_number;
         live_file_metadata.epoch_number = file_metadata.epoch_number;
         live_file_metadata.level = level_metadata.level;
+        live_file_metadata.smallest = file_metadata.smallest;
+        live_file_metadata.largest = file_metadata.largest;
         result_metadata->files.push_back(live_file_metadata);
       }
       *metadata = result_metadata;

package/deps/rocksdb/rocksdb/utilities/fault_injection_secondary_cache.cc

@@ -92,18 +92,18 @@ FaultInjectionSecondaryCache::Lookup(const Slice& key,
                                      const Cache::CacheItemHelper* helper,
                                      Cache::CreateContext* create_context,
                                      bool wait, bool advise_erase,
-                                     bool& is_in_sec_cache) {
+                                     bool& kept_in_sec_cache) {
   ErrorContext* ctx = GetErrorContext();
   if (base_is_compressed_sec_cache_) {
     if (ctx->rand.OneIn(prob_)) {
       return nullptr;
     } else {
       return base_->Lookup(key, helper, create_context, wait, advise_erase,
-                           is_in_sec_cache);
+                           kept_in_sec_cache);
     }
   } else {
     std::unique_ptr<SecondaryCacheResultHandle> hdl = base_->Lookup(
-        key, helper, create_context, wait, advise_erase, is_in_sec_cache);
+        key, helper, create_context, wait, advise_erase, kept_in_sec_cache);
     if (wait && ctx->rand.OneIn(prob_)) {
       hdl.reset();
     }

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

@@ -37,7 +37,7 @@ class FaultInjectionSecondaryCache : public SecondaryCache {
   std::unique_ptr<SecondaryCacheResultHandle> Lookup(
       const Slice& key, const Cache::CacheItemHelper* helper,
       Cache::CreateContext* create_context, bool wait, bool advise_erase,
-      bool& is_in_sec_cache) override;
+      bool& kept_in_sec_cache) override;
 
   bool SupportForceErase() const override { return base_->SupportForceErase(); }
 

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

@@ -194,13 +194,20 @@ class SimCacheImpl : public SimCache {
 
   Handle* Lookup(const Slice& key, const CacheItemHelper* helper,
                  CreateContext* create_context,
-                 Priority priority = Priority::LOW, bool wait = true,
+                 Priority priority = Priority::LOW,
                  Statistics* stats = nullptr) override {
     HandleLookup(key, stats);
     if (!target_) {
       return nullptr;
     }
-    return target_->Lookup(key, helper, create_context, priority, wait, stats);
+    return target_->Lookup(key, helper, create_context, priority, stats);
+  }
+
+  void StartAsyncLookup(AsyncLookupHandle& async_handle) override {
+    HandleLookup(async_handle.key, async_handle.stats);
+    if (target_) {
+      target_->StartAsyncLookup(async_handle);
+    }
   }
 
   bool Ref(Handle* handle) override { return target_->Ref(handle); }

package/deps/rocksdb/rocksdb/utilities/ttl/db_ttl_impl.cc

@@ -451,7 +451,11 @@ bool DBWithTTLImpl::IsStale(const Slice& value, int32_t ttl,
   if (!clock->GetCurrentTime(&curtime).ok()) {
     return false;  // Treat the data as fresh if could not get current time
   }
-  int32_t timestamp_value =
+  /* int32_t may overflow when timestamp_value + ttl
+   * for example ttl = 86400 * 365 * 15
+   * convert timestamp_value to int64_t
+   */
+  int64_t timestamp_value =
       DecodeFixed32(value.data() + value.size() - kTSLength);
   return (timestamp_value + ttl) < curtime;
 }

package/deps/rocksdb/rocksdb/utilities/ttl/ttl_test.cc

@@ -635,6 +635,17 @@ TEST_F(TtlTest, MultiGetTest) {
   CloseTtl();
 }
 
+TEST_F(TtlTest, TtlFiftenYears) {
+  MakeKVMap(kSampleSize_);
+  // 15 year will lead int32_t overflow from now
+  const int kFifteenYearSeconds = 86400 * 365 * 15;
+  OpenTtl(kFifteenYearSeconds);
+  PutValues(0, kSampleSize_, true);
+  // trigger the compaction
+  SleepCompactCheck(1, 0, kSampleSize_);
+  CloseTtl();
+}
+
 TEST_F(TtlTest, ColumnFamiliesTest) {
   DB* db;
   Options options;

package/deps/rocksdb/rocksdb.gyp

@@ -87,7 +87,7 @@
               "ROCKSDB_PTHREAD_ADAPTIVE_MUTEX=1",
               "ROCKSDB_RANGESYNC_PRESENT=1",
               "ROCKSDB_SCHED_GETCPU_PRESENT=1",
-              # "ROCKSDB_IOURING_PRESENT=1",
+              "ROCKSDB_IOURING_PRESENT=1",
               "USE_FOLLY=1",
               "FOLLY_NO_CONFIG=1"
               "HAVE_SSE42=1",
@@ -115,6 +115,9 @@
               "/usr/lib/include",
               # "/usr/local/Cellar/jemalloc/5.3.0/include"
             ],
+            "dependencies": [
+              "../liburing/liburing.gyp:liburing"
+            ],
             "cflags": [
               "-msse4.2",
               "-mpclmul",
@@ -168,6 +171,7 @@
         "rocksdb/cache/compressed_secondary_cache.cc",
         "rocksdb/cache/lru_cache.cc",
         "rocksdb/cache/secondary_cache.cc",
+        "rocksdb/cache/secondary_cache_adapter.cc",
         "rocksdb/cache/sharded_cache.cc",
         "rocksdb/db/arena_wrapped_db_iter.cc",
         "rocksdb/db/blob/blob_contents.cc",
@@ -254,6 +258,7 @@
         "rocksdb/db/write_batch.cc",
         "rocksdb/db/write_batch_base.cc",
         "rocksdb/db/write_controller.cc",
+        "rocksdb/db/write_stall_stats.cc",
         "rocksdb/db/write_thread.cc",
         "rocksdb/env/composite_env.cc",
         "rocksdb/env/env.cc",
@@ -345,6 +350,7 @@
         "rocksdb/table/get_context.cc",
         "rocksdb/table/iterator.cc",
         "rocksdb/table/merging_iterator.cc",
+        "rocksdb/table/compaction_merging_iterator.cc",
         "rocksdb/table/meta_blocks.cc",
         "rocksdb/table/persistent_cache_helper.cc",
         "rocksdb/table/plain/plain_table_bloom.cc",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/rocksdb",
-  "version": "8.1.17",
+  "version": "8.2.0-alpha.2",
   "description": "A low-level Node.js RocksDB binding",
   "license": "MIT",
   "main": "index.js",