@nxtedition/rocksdb 15.1.2 → 15.1.3

package/deps/rocksdb/rocksdb/tools/sst_dump_tool.cc

@@ -8,6 +8,7 @@
 
 #include <cinttypes>
 #include <iostream>
+#include <regex>
 
 #include "db_stress_tool/db_stress_compression_manager.h"
 #include "options/options_helper.h"
@@ -62,6 +63,9 @@ void print_help(bool to_stderr) {
     --decode_blob_index
       Decode blob indexes and print them in a human-readable format during scans.
 
+    --show_sequence_number_type
+      Show sequence number and value type when executing raw command
+
     --from=<user_key>
       Key to start reading from when executing check|scan
 
@@ -100,6 +104,10 @@ void print_help(bool to_stderr) {
       instead of the built-in compression manager, which may support a
       different set of compression types.
 
+    --enable_index_compression=<bool>
+      Used with --command=recompress to specify whether to compress index
+      blocks (in addition to data blocks).
+
     --parse_internal_key=<0xKEY>
       Convenience option to parse an internal key on the command line. Dumps the
       internal key in hex format {'key' @ SN: type}
@@ -172,6 +180,7 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
   bool verify_checksum = false;
   bool output_hex = false;
   bool decode_blob_index = false;
+  bool show_sequence_number_type = false;
   bool input_key_hex = false;
   bool has_from = false;
   bool has_to = false;
@@ -188,8 +197,15 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
   std::string compression_level_to_str;
   size_t block_size = 16384;  // A popular choice for default
   size_t readahead_size = 2 * 1024 * 1024;
+  // These two options are intentionally secret options because they are
+  // niche ways to select files to get the "recompress" treatment. And even
+  // if std::regex is flawed, it should be good enough for these niche uses.
+  std::unique_ptr<std::regex> require_property_regex;
+  std::unique_ptr<std::regex> exclude_property_regex;
   std::vector<CompressionType> compression_types;
   std::shared_ptr<CompressionManager> compression_manager;
+  bool enable_index_compression =
+      BlockBasedTableOptions{}.enable_index_compression;
   uint64_t total_num_files = 0;
   uint64_t total_num_data_blocks = 0;
   uint64_t total_data_block_size = 0;
@@ -223,6 +239,8 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
       output_hex = true;
     } else if (strcmp(argv[i], "--decode_blob_index") == 0) {
       decode_blob_index = true;
+    } else if (strcmp(argv[i], "--show_sequence_number_type") == 0) {
+      show_sequence_number_type = true;
     } else if (strcmp(argv[i], "--input_key_hex") == 0) {
       input_key_hex = true;
     } else if (sscanf(argv[i], "--read_num=%lu%c", (unsigned long*)&n, &junk) ==
@@ -268,6 +286,12 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
         }
         compression_types.emplace_back(iter->second);
       }
+    } else if (strncmp(argv[i], "--require_property_regex=", 25) == 0) {
+      require_property_regex = std::make_unique<std::regex>(
+          argv[i] + 25, std::regex_constants::egrep);
+    } else if (strncmp(argv[i], "--exclude_property_regex=", 25) == 0) {
+      exclude_property_regex = std::make_unique<std::regex>(
+          argv[i] + 25, std::regex_constants::egrep);
     } else if (strncmp(argv[i], "--compression_manager=", 22) == 0) {
       std::string compression_manager_str = argv[i] + 22;
       ConfigOptions config_options;
@@ -287,6 +311,11 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
       options.compression_manager = compression_manager;
       printf("Using compression manager: %s\n",
              compression_manager->GetId().c_str());
+    } else if (strncmp(argv[i], "--enable_index_compression=", 27) == 0) {
+      if (strlen(argv[i]) > 27) {
+        enable_index_compression =
+            argv[i][27] == '1' || argv[i][27] == 't' || argv[i][27] == 'T';
+      }
     } else if (strncmp(argv[i], "--parse_internal_key=", 21) == 0) {
       std::string in_key(argv[i] + 21);
       try {
@@ -492,6 +521,7 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
         bbto = *options.table_factory->GetOptions<BlockBasedTableOptions>();
       }
       bbto.block_size = block_size;
+      bbto.enable_index_compression = enable_index_compression;
       // Maximize compression features available
       bbto.format_version = kLatestFormatVersion;
       options.table_factory = std::make_shared<BlockBasedTableFactory>(bbto);
@@ -507,24 +537,45 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
 
     ROCKSDB_NAMESPACE::SstFileDumper dumper(
         options, filename, Temperature::kUnknown, readahead_size,
-        verify_checksum, output_hex, decode_blob_index);
+        verify_checksum, output_hex, decode_blob_index, EnvOptions(), false,
+        show_sequence_number_type);
 
     // Not a valid SST
     if (!dumper.getStatus().ok()) {
       fprintf(stderr, "%s: %s\n", filename.c_str(),
               dumper.getStatus().ToString().c_str());
       continue;
-    } else {
-      valid_sst_files.push_back(filename);
-      // Print out from and to key information once
-      // where there is at least one valid SST
-      if (valid_sst_files.size() == 1) {
-        // from_key and to_key are only used for "check", "scan", or ""
-        if (command == "check" || command == "scan" || command == "") {
-          fprintf(stdout, "from [%s] to [%s]\n",
-                  ROCKSDB_NAMESPACE::Slice(from_key).ToString(true).c_str(),
-                  ROCKSDB_NAMESPACE::Slice(to_key).ToString(true).c_str());
-        }
+    }
+    auto props_ptr = dumper.GetInitTableProperties();
+    if (props_ptr && (require_property_regex || exclude_property_regex)) {
+      // Call should match with show_properties below
+      auto props_str = props_ptr->ToString("\n  ", ": ");
+      if (require_property_regex &&
+          !std::regex_search(props_str, *require_property_regex)) {
+        fprintf(stderr,
+                "%s: skipping because properties string doesn't match required "
+                "regex\n",
+                filename.c_str());
+        continue;
+      }
+      if (exclude_property_regex &&
+          std::regex_search(props_str, *exclude_property_regex)) {
+        fprintf(
+            stderr,
+            "%s: skipping because properties string matches excluded regex\n",
+            filename.c_str());
+        continue;
+      }
+    }
+    valid_sst_files.push_back(filename);
+    // Print out from and to key information once
+    // where there is at least one valid SST
+    if (valid_sst_files.size() == 1) {
+      // from_key and to_key are only used for "check", "scan", or ""
+      if (command == "check" || command == "scan" || command == "") {
+        fprintf(stdout, "from [%s] to [%s]\n",
+                ROCKSDB_NAMESPACE::Slice(from_key).ToString(true).c_str(),
+                ROCKSDB_NAMESPACE::Slice(to_key).ToString(true).c_str());
       }
     }
 

package/deps/rocksdb/rocksdb/util/auto_tune_compressor.cc

@@ -59,6 +59,17 @@ const char* AutoSkipCompressorWrapper::Name() const {
   return "AutoSkipCompressorWrapper";
 }
 
+std::unique_ptr<Compressor> AutoSkipCompressorWrapper::Clone() const {
+  return std::make_unique<AutoSkipCompressorWrapper>(wrapped_->Clone(), opts_);
+}
+
+std::unique_ptr<Compressor> AutoSkipCompressorWrapper::MaybeCloneSpecialized(
+    CacheEntryRole block_type, DictSampleArgs&& dict_samples) const {
+  auto clone =
+      wrapped_->CloneMaybeSpecialized(block_type, std::move(dict_samples));
+  return std::make_unique<AutoSkipCompressorWrapper>(std::move(clone), opts_);
+}
+
 Status AutoSkipCompressorWrapper::CompressBlock(
     Slice uncompressed_data, char* compressed_output,
     size_t* compressed_output_size, CompressionType* out_compression_type,
@@ -174,6 +185,10 @@ CostAwareCompressor::CostAwareCompressor(const CompressionOptions& opts)
 }
 
 const char* CostAwareCompressor::Name() const { return "CostAwareCompressor"; }
+
+std::unique_ptr<Compressor> CostAwareCompressor::Clone() const {
+  return std::make_unique<CostAwareCompressor>(opts_);
+}
 size_t CostAwareCompressor::GetMaxSampleSizeIfWantDict(
     CacheEntryRole block_type) const {
   auto idx = allcompressors_index_.back();
@@ -190,7 +205,7 @@ CompressionType CostAwareCompressor::GetPreferredCompressionType() const {
   return kZSTD;
 }
 std::unique_ptr<Compressor> CostAwareCompressor::MaybeCloneSpecialized(
-    CacheEntryRole block_type, DictSampleArgs&& dict_samples) {
+    CacheEntryRole block_type, DictSampleArgs&& dict_samples) const {
   // TODO: full dictionary compression support. Currently this just falls
   // back on a non-multi compressor when asked to use a dictionary.
   auto idx = allcompressors_index_.back();

package/deps/rocksdb/rocksdb/util/auto_tune_compressor.h

@@ -64,6 +64,9 @@ class AutoSkipCompressorWrapper : public CompressorWrapper {
   explicit AutoSkipCompressorWrapper(std::unique_ptr<Compressor> compressor,
                                      const CompressionOptions& opts);
 
+  std::unique_ptr<Compressor> Clone() const override;
+  std::unique_ptr<Compressor> MaybeCloneSpecialized(
+      CacheEntryRole block_type, DictSampleArgs&& dict_samples) const override;
   Status CompressBlock(Slice uncompressed_data, char* compressed_output,
                        size_t* compressed_output_size,
                        CompressionType* out_compression_type,
@@ -149,12 +152,13 @@ class CostAwareCompressor : public Compressor {
  public:
   explicit CostAwareCompressor(const CompressionOptions& opts);
   const char* Name() const override;
+  std::unique_ptr<Compressor> Clone() const override;
   size_t GetMaxSampleSizeIfWantDict(CacheEntryRole block_type) const override;
   Slice GetSerializedDict() const override;
   CompressionType GetPreferredCompressionType() const override;
   ManagedWorkingArea ObtainWorkingArea() override;
   std::unique_ptr<Compressor> MaybeCloneSpecialized(
-      CacheEntryRole block_type, DictSampleArgs&& dict_samples) override;
+      CacheEntryRole block_type, DictSampleArgs&& dict_samples) const override;
 
   Status CompressBlock(Slice uncompressed_data, char* compressed_output,
                        size_t* compressed_output_size,

package/deps/rocksdb/rocksdb/util/bit_fields.h

@@ -6,8 +6,10 @@
 #pragma once
 
 #include <atomic>
+#include <vector>
 
 #include "rocksdb/rocksdb_namespace.h"
+#include "test_util/sync_point.h"
 #include "util/math.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -144,8 +146,44 @@ struct AndTransform {
   }
 };
 
-// TODO: AddTransfrom, which is more complicated due to possible overflow into
-// other fields etc.
+// Can represent a combination of both subtractions and additions, representing
+// subtractions as the addition of a negated value. To ensure we don't create a
+// net overflow or underflow between fields, in debug builds we track the
+// corresponding preconditions. (NOTE that when representing a subtraction, we
+// rely on overflow of the unsigned representation.)
+template <typename BitFieldsT>
+struct AddTransform {
+  using U = typename BitFieldsT::U;
+  U to_add = 0;
+#ifndef NDEBUG
+  struct Precondition {
+    U mask;   // for bits of the target field
+    U piece;  // component of to_add for the target field
+  };
+  std::vector<Precondition> preconditions;
+#endif  // NDEBUG
+  void AssertPreconditions([[maybe_unused]] U from) {
+#ifndef NDEBUG
+    for (auto p : preconditions) {
+      U tmp = (from & p.mask) + p.piece;
+      // Assert no under/overflow (unless the field is at the top bits of the
+      // representation in U, which is allowed because it doesn't lead to
+      // leakage into other fields)
+      testable_assert((tmp & ~p.mask) == 0);
+    }
+#endif  // NDEBUG
+  }
+  // + for general combine
+  AddTransform<BitFieldsT> operator+(AddTransform<BitFieldsT> other) const {
+    AddTransform<BitFieldsT> rv{to_add + other.to_add};
+#ifndef NDEBUG
+    rv.preconditions = preconditions;
+    rv.preconditions.insert(rv.preconditions.end(), other.preconditions.begin(),
+                            other.preconditions.end());
+#endif  // NDEBUG
+    return rv;
+  }
+};
 
 // Placeholder for PrevField for the first field
 struct NoPrevBitField {
@@ -204,6 +242,7 @@ struct UnsignedBitField {
   static_assert(kBitCount >= 1);
   static_assert(kBitCount <= 64);
   static_assert(kBitOffset >= 0 && kEndBit <= BitFieldsT::kBitCount);
+  static constexpr bool kIncludesTopBit = (kEndBit == BitFieldsT::kBitCount);
 
   static constexpr V kMask = (V{1} << (kBitCount - 1) << 1) - 1;
 
@@ -219,9 +258,59 @@ struct UnsignedBitField {
     bf.underlying |= static_cast<U>(value & kMask) << kBitOffset;
   }
 
+  // Create a transfor for clearing this field to zero.
   static AndTransform<BitFieldsT> ClearTransform() {
     return AndTransform<BitFieldsT>{~(static_cast<U>(kMask) << kBitOffset)};
   }
+
+  // Create a transform for adding a particular value, but with the precondition
+  // that adding the value will not overflow the field. This applies for fields
+  // that do not include the top bit of the underlying representation. Can be
+  // combined with other additive transforms for other fields.
+  static AddTransform<BitFieldsT> PlusTransformPromiseNoOverflow(V value) {
+    static_assert(!kIncludesTopBit);
+    AddTransform<BitFieldsT> rv{static_cast<U>(value) << kBitOffset};
+#ifndef NDEBUG
+    rv.preconditions.push_back(
+        {static_cast<U>(kMask) << kBitOffset, rv.to_add});
+#endif  // NDEBUG
+    return rv;
+  }
+
+  // Create a transform for adding a particular value, but ignoring any overflow
+  // in that field. This applies for fields that include the top bit of the
+  // underlying representation. Can be combined with other additive transforms
+  // for other fields.
+  static AddTransform<BitFieldsT> PlusTransformIgnoreOverflow(V value) {
+    static_assert(kIncludesTopBit);
+    AddTransform<BitFieldsT> rv{static_cast<U>(value) << kBitOffset};
+    return rv;
+  }
+
+  // Create a transform for subtracting a particular value, but with the
+  // precondition that subtracting the value will not underflow the field. This
+  // applies for fields that do not include the top bit of the underlying
+  // representation. Can be combined with other additive transforms for other
+  // fields.
+  static AddTransform<BitFieldsT> MinusTransformPromiseNoUnderflow(V value) {
+    static_assert(!kIncludesTopBit);
+    AddTransform<BitFieldsT> rv{U{0} - (static_cast<U>(value) << kBitOffset)};
+#ifndef NDEBUG
+    rv.preconditions.push_back(
+        {static_cast<U>(kMask) << kBitOffset, rv.to_add});
+#endif  // NDEBUG
+    return rv;
+  }
+
+  // Create a transform for subtracting a particular value, but ignoring any
+  // underflow in that field. This applies for fields that include the top bit
+  // of the underlying representation. Can be combined with other additive
+  // transforms for other fields.
+  static AddTransform<BitFieldsT> MinusTransformIgnoreUnderflow(V value) {
+    static_assert(kIncludesTopBit);
+    AddTransform<BitFieldsT> rv{U{0} - (static_cast<U>(value) << kBitOffset)};
+    return rv;
+  }
 };
 
 // A handy wrapper for a relaxed atomic on some BitFields type (unlike
@@ -260,7 +349,22 @@ class RelaxedBitFieldsAtomic {
   }
   void ApplyRelaxed(OrTransform<BitFieldsT> transform,
                     BitFieldsT* before = nullptr, BitFieldsT* after = nullptr) {
-    U before_val = v_.fetch_or(transform.to_or, std::memory_order_relaxed);
+    ApplyImpl<std::memory_order_relaxed>(transform, before, after);
+  }
+  void ApplyRelaxed(AndTransform<BitFieldsT> transform,
+                    BitFieldsT* before = nullptr, BitFieldsT* after = nullptr) {
+    ApplyImpl<std::memory_order_relaxed>(transform, before, after);
+  }
+  void ApplyRelaxed(AddTransform<BitFieldsT> transform,
+                    BitFieldsT* before = nullptr, BitFieldsT* after = nullptr) {
+    ApplyImpl<std::memory_order_relaxed>(transform, before, after);
+  }
+
+ protected:  // fns
+  template <std::memory_order kOrder>
+  void ApplyImpl(OrTransform<BitFieldsT> transform,
+                 BitFieldsT* before = nullptr, BitFieldsT* after = nullptr) {
+    U before_val = v_.fetch_or(transform.to_or, kOrder);
     if (before) {
       before->underlying = before_val;
     }
@@ -268,9 +372,10 @@ class RelaxedBitFieldsAtomic {
       after->underlying = before_val | transform.to_or;
     }
   }
-  void ApplyRelaxed(AndTransform<BitFieldsT> transform,
-                    BitFieldsT* before = nullptr, BitFieldsT* after = nullptr) {
-    U before_val = v_.fetch_and(transform.to_and, std::memory_order_relaxed);
+  template <std::memory_order kOrder>
+  void ApplyImpl(AndTransform<BitFieldsT> transform,
+                 BitFieldsT* before = nullptr, BitFieldsT* after = nullptr) {
+    U before_val = v_.fetch_and(transform.to_and, kOrder);
     if (before) {
       before->underlying = before_val;
     }
@@ -278,8 +383,20 @@ class RelaxedBitFieldsAtomic {
       after->underlying = before_val & transform.to_and;
     }
   }
+  template <std::memory_order kOrder>
+  void ApplyImpl(AddTransform<BitFieldsT> transform,
+                 BitFieldsT* before = nullptr, BitFieldsT* after = nullptr) {
+    U before_val = v_.fetch_add(transform.to_add, kOrder);
+    transform.AssertPreconditions(before_val);
+    if (before) {
+      before->underlying = before_val;
+    }
+    if (after) {
+      after->underlying = before_val + transform.to_add;
+    }
+  }
 
- protected:
+ protected:  // data
   std::atomic<U> v_;
 };
 
@@ -313,25 +430,18 @@ class AcqRelBitFieldsAtomic : public RelaxedBitFieldsAtomic<BitFieldsT> {
   }
   void Apply(OrTransform<BitFieldsT> transform, BitFieldsT* before = nullptr,
              BitFieldsT* after = nullptr) {
-    U before_val =
-        Base::v_.fetch_or(transform.to_or, std::memory_order_acq_rel);
-    if (before) {
-      before->underlying = before_val;
-    }
-    if (after) {
-      after->underlying = before_val | transform.to_or;
-    }
+    Base::template ApplyImpl<std::memory_order_acq_rel>(transform, before,
+                                                        after);
   }
   void Apply(AndTransform<BitFieldsT> transform, BitFieldsT* before = nullptr,
              BitFieldsT* after = nullptr) {
-    U before_val =
-        Base::v_.fetch_and(transform.to_and, std::memory_order_acq_rel);
-    if (before) {
-      before->underlying = before_val;
-    }
-    if (after) {
-      after->underlying = before_val & transform.to_and;
-    }
+    Base::template ApplyImpl<std::memory_order_acq_rel>(transform, before,
+                                                        after);
+  }
+  void Apply(AddTransform<BitFieldsT> transform, BitFieldsT* before = nullptr,
+             BitFieldsT* after = nullptr) {
+    Base::template ApplyImpl<std::memory_order_acq_rel>(transform, before,
+                                                        after);
   }
 };
 

package/deps/rocksdb/rocksdb/util/bloom_test.cc

@@ -86,10 +86,7 @@ class FullBloomTest : public testing::TestWithParam<std::string> {
     ResetPolicy();
   }
 
-  BuiltinFilterBitsBuilder* GetBuiltinFilterBitsBuilder() {
-    // Throws on bad cast
-    return dynamic_cast<BuiltinFilterBitsBuilder*>(bits_builder_.get());
-  }
+  FilterBitsBuilder* GetFilterBitsBuilder() { return bits_builder_.get(); }
 
   const BloomLikeFilterPolicy* GetBloomLikeFilterPolicy() {
     // Throws on bad cast
@@ -239,7 +236,7 @@ TEST_P(FullBloomTest, FilterSize) {
     EXPECT_EQ(bpk.second, bfp->GetMillibitsPerKey());
     EXPECT_EQ((bpk.second + 500) / 1000, bfp->GetWholeBitsPerKey());
 
-    auto bits_builder = GetBuiltinFilterBitsBuilder();
+    auto bits_builder = GetFilterBitsBuilder();
     if (bpk.second == 0) {
       ASSERT_EQ(bits_builder, nullptr);
       continue;