@nxtedition/rocksdb 7.0.5 → 7.0.8

package/deps/rocksdb/rocksdb/table/block_based/filter_block_reader_common.cc

@@ -112,9 +112,8 @@ bool FilterBlockReaderCommon<TBlocklike>::RangeMayExist(
     return true;
   } else {
     *filter_checked = true;
-    return PrefixMayMatch(prefix, prefix_extractor, kNotValid, no_io,
-                          const_ikey_ptr, /* get_context */ nullptr,
-                          lookup_context);
+    return PrefixMayMatch(prefix, no_io, const_ikey_ptr,
+                          /* get_context */ nullptr, lookup_context);
   }
 }
 

package/deps/rocksdb/rocksdb/table/block_based/filter_policy.cc

@@ -24,7 +24,6 @@
 #include "rocksdb/rocksdb_namespace.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/utilities/object_registry.h"
-#include "table/block_based/block_based_filter_block.h"
 #include "table/block_based/block_based_table_reader.h"
 #include "table/block_based/filter_policy_internal.h"
 #include "table/block_based/full_filter_block.h"
@@ -1375,87 +1374,10 @@ const char* ReadOnlyBuiltinFilterPolicy::kClassName() {
   return kBuiltinFilterMetadataName;
 }
 
-const char* DeprecatedBlockBasedBloomFilterPolicy::kClassName() {
-  return "rocksdb.internal.DeprecatedBlockBasedBloomFilter";
-}
-
 std::string BloomLikeFilterPolicy::GetId() const {
   return Name() + GetBitsPerKeySuffix();
 }
 
-DeprecatedBlockBasedBloomFilterPolicy::DeprecatedBlockBasedBloomFilterPolicy(
-    double bits_per_key)
-    : BloomLikeFilterPolicy(bits_per_key) {}
-
-FilterBitsBuilder* DeprecatedBlockBasedBloomFilterPolicy::GetBuilderWithContext(
-    const FilterBuildingContext&) const {
-  if (GetWholeBitsPerKey() == 0) {
-    // "No filter" special case
-    return nullptr;
-  }
-  // Internal contract: returns a new fake builder that encodes bits per key
-  // into a special value from EstimateEntriesAdded()
-  struct B : public FilterBitsBuilder {
-    explicit B(int bits_per_key) : est(kSecretBitsPerKeyStart + bits_per_key) {}
-    size_t est;
-    size_t EstimateEntriesAdded() override { return est; }
-    void AddKey(const Slice&) override {}
-    using FilterBitsBuilder::Finish;  // FIXME
-    Slice Finish(std::unique_ptr<const char[]>*) override { return Slice(); }
-    size_t ApproximateNumEntries(size_t) override { return 0; }
-  };
-  return new B(GetWholeBitsPerKey());
-}
-
-void DeprecatedBlockBasedBloomFilterPolicy::CreateFilter(const Slice* keys,
-                                                         int n,
-                                                         int bits_per_key,
-                                                         std::string* dst) {
-  // Compute bloom filter size (in both bits and bytes)
-  uint32_t bits = static_cast<uint32_t>(n * bits_per_key);
-
-  // For small n, we can see a very high false positive rate.  Fix it
-  // by enforcing a minimum bloom filter length.
-  if (bits < 64) bits = 64;
-
-  uint32_t bytes = (bits + 7) / 8;
-  bits = bytes * 8;
-
-  int num_probes = LegacyNoLocalityBloomImpl::ChooseNumProbes(bits_per_key);
-
-  const size_t init_size = dst->size();
-  dst->resize(init_size + bytes, 0);
-  dst->push_back(static_cast<char>(num_probes));  // Remember # of probes
-  char* array = &(*dst)[init_size];
-  for (int i = 0; i < n; i++) {
-    LegacyNoLocalityBloomImpl::AddHash(BloomHash(keys[i]), bits, num_probes,
-                                       array);
-  }
-}
-
-bool DeprecatedBlockBasedBloomFilterPolicy::KeyMayMatch(
-    const Slice& key, const Slice& bloom_filter) {
-  const size_t len = bloom_filter.size();
-  if (len < 2 || len > 0xffffffffU) {
-    return false;
-  }
-
-  const char* array = bloom_filter.data();
-  const uint32_t bits = static_cast<uint32_t>(len - 1) * 8;
-
-  // Use the encoded k so that we can read filters generated by
-  // bloom filters created using different parameters.
-  const int k = static_cast<uint8_t>(array[len - 1]);
-  if (k > 30) {
-    // Reserved for potentially new encodings for short bloom filters.
-    // Consider it a match.
-    return true;
-  }
-  // NB: using stored k not num_probes for whole_bits_per_key_
-  return LegacyNoLocalityBloomImpl::HashMayMatch(BloomHash(key), bits, k,
-                                                 array);
-}
-
 BloomFilterPolicy::BloomFilterPolicy(double bits_per_key)
     : BloomLikeFilterPolicy(bits_per_key) {}
 
@@ -1876,9 +1798,6 @@ std::shared_ptr<const FilterPolicy> BloomLikeFilterPolicy::Create(
     return std::make_shared<test::FastLocalBloomFilterPolicy>(bits_per_key);
   } else if (name == test::Standard128RibbonFilterPolicy::kClassName()) {
     return std::make_shared<test::Standard128RibbonFilterPolicy>(bits_per_key);
-  } else if (name == DeprecatedBlockBasedBloomFilterPolicy::kClassName()) {
-    return std::make_shared<DeprecatedBlockBasedBloomFilterPolicy>(
-        bits_per_key);
   } else if (name == BloomFilterPolicy::kClassName()) {
     // For testing
     return std::make_shared<BloomFilterPolicy>(bits_per_key);
@@ -1996,15 +1915,6 @@ static int RegisterBuiltinFilterPolicies(ObjectLibrary& library,
                 uri));
         return guard->get();
       });
-  library.AddFactory<const FilterPolicy>(
-      FilterPatternEntryWithBits(
-          DeprecatedBlockBasedBloomFilterPolicy::kClassName()),
-      [](const std::string& uri, std::unique_ptr<const FilterPolicy>* guard,
-         std::string* /* errmsg */) {
-        guard->reset(NewBuiltinFilterPolicyWithBits<
-                     DeprecatedBlockBasedBloomFilterPolicy>(uri));
-        return guard->get();
-      });
   size_t num_types;
   return static_cast<int>(library.GetFactoryCount(&num_types));
 }
@@ -2055,7 +1965,6 @@ const std::vector<std::string>& BloomLikeFilterPolicy::GetAllFixedImpls() {
   STATIC_AVOID_DESTRUCTION(std::vector<std::string>, impls){
       // Match filter_bench -impl=x ordering
       test::LegacyBloomFilterPolicy::kClassName(),
-      DeprecatedBlockBasedBloomFilterPolicy::kClassName(),
       test::FastLocalBloomFilterPolicy::kClassName(),
       test::Standard128RibbonFilterPolicy::kClassName(),
   };

package/deps/rocksdb/rocksdb/table/block_based/filter_policy_internal.h

@@ -131,7 +131,7 @@ class BuiltinFilterPolicy : public FilterPolicy {
   // Read metadata to determine what kind of FilterBitsReader is needed
   // and return a new one. This must successfully process any filter data
   // generated by a built-in FilterBitsBuilder, regardless of the impl
-  // chosen for this BloomFilterPolicy. Not compatible with CreateFilter.
+  // chosen for this BloomFilterPolicy.
   FilterBitsReader* GetFilterBitsReader(const Slice& contents) const override;
   static const char* kClassName();
   bool IsInstanceOf(const std::string& id) const override;
@@ -151,12 +151,8 @@ class BuiltinFilterPolicy : public FilterPolicy {
   // (An internal convenience function to save boilerplate.)
   static FilterBitsBuilder* GetBuilderFromContext(const FilterBuildingContext&);
 
- protected:
-  // Deprecated block-based filter only (no longer in public API)
-  bool KeyMayMatch(const Slice& key, const Slice& bloom_filter) const;
-
  private:
-  // For Bloom filter implementation(s) (except deprecated block-based filter)
+  // For Bloom filter implementation(s)
   static BuiltinFilterBitsReader* GetBloomBitsReader(const Slice& contents);
 
   // For Ribbon filter implementation(s)
@@ -300,30 +296,6 @@ class RibbonFilterPolicy : public BloomLikeFilterPolicy {
   const int bloom_before_level_;
 };
 
-// Deprecated block-based filter only. We still support reading old
-// block-based filters from any BuiltinFilterPolicy, but there is no public
-// option to build them. However, this class is used to build them for testing
-// and for a public backdoor to building them by constructing this policy from
-// a string.
-class DeprecatedBlockBasedBloomFilterPolicy : public BloomLikeFilterPolicy {
- public:
-  explicit DeprecatedBlockBasedBloomFilterPolicy(double bits_per_key);
-
-  // Internal contract: returns a new fake builder that encodes bits per key
-  // into a special value from EstimateEntriesAdded(), using
-  // kSecretBitsPerKeyStart
-  FilterBitsBuilder* GetBuilderWithContext(
-      const FilterBuildingContext&) const override;
-  static constexpr size_t kSecretBitsPerKeyStart = 1234567890U;
-
-  static const char* kClassName();
-  const char* Name() const override { return kClassName(); }
-
-  static void CreateFilter(const Slice* keys, int n, int bits_per_key,
-                           std::string* dst);
-  static bool KeyMayMatch(const Slice& key, const Slice& bloom_filter);
-};
-
 // For testing only, but always constructable with internal names
 namespace test {
 

package/deps/rocksdb/rocksdb/table/block_based/full_filter_block.cc

@@ -125,14 +125,8 @@ FullFilterBlockReader::FullFilterBlockReader(
 }
 
 bool FullFilterBlockReader::KeyMayMatch(
-    const Slice& key, const SliceTransform* /*prefix_extractor*/,
-    uint64_t block_offset, const bool no_io,
-    const Slice* const /*const_ikey_ptr*/, GetContext* get_context,
-    BlockCacheLookupContext* lookup_context) {
-#ifdef NDEBUG
-  (void)block_offset;
-#endif
-  assert(block_offset == kNotValid);
+    const Slice& key, const bool no_io, const Slice* const /*const_ikey_ptr*/,
+    GetContext* get_context, BlockCacheLookupContext* lookup_context) {
   if (!whole_key_filtering()) {
     return true;
   }
@@ -167,14 +161,9 @@ std::unique_ptr<FilterBlockReader> FullFilterBlockReader::Create(
 }
 
 bool FullFilterBlockReader::PrefixMayMatch(
-    const Slice& prefix, const SliceTransform* /* prefix_extractor */,
-    uint64_t block_offset, const bool no_io,
+    const Slice& prefix, const bool no_io,
     const Slice* const /*const_ikey_ptr*/, GetContext* get_context,
     BlockCacheLookupContext* lookup_context) {
-#ifdef NDEBUG
-  (void)block_offset;
-#endif
-  assert(block_offset == kNotValid);
   return MayMatch(prefix, no_io, get_context, lookup_context);
 }
 
@@ -204,17 +193,12 @@ bool FullFilterBlockReader::MayMatch(
       return false;
     }
   }
-  return true;  // remain the same with block_based filter
+  return true;
 }
 
 void FullFilterBlockReader::KeysMayMatch(
-    MultiGetRange* range, const SliceTransform* /*prefix_extractor*/,
-    uint64_t block_offset, const bool no_io,
+    MultiGetRange* range, const bool no_io,
     BlockCacheLookupContext* lookup_context) {
-#ifdef NDEBUG
-  (void)block_offset;
-#endif
-  assert(block_offset == kNotValid);
   if (!whole_key_filtering()) {
     // Simply return. Don't skip any key - consider all keys as likely to be
     // present
@@ -225,12 +209,7 @@ void FullFilterBlockReader::KeysMayMatch(
 
 void FullFilterBlockReader::PrefixesMayMatch(
     MultiGetRange* range, const SliceTransform* prefix_extractor,
-    uint64_t block_offset, const bool no_io,
-    BlockCacheLookupContext* lookup_context) {
-#ifdef NDEBUG
-  (void)block_offset;
-#endif
-  assert(block_offset == kNotValid);
+    const bool no_io, BlockCacheLookupContext* lookup_context) {
   MayMatch(range, no_io, prefix_extractor, lookup_context);
 }
 

package/deps/rocksdb/rocksdb/table/block_based/full_filter_block.h

@@ -49,8 +49,6 @@ class FullFilterBlockBuilder : public FilterBlockBuilder {
   // directly. and be deleted here
   ~FullFilterBlockBuilder() {}
 
-  virtual bool IsBlockBased() override { return false; }
-  virtual void StartBlock(uint64_t /*block_offset*/) override {}
   virtual void Add(const Slice& key_without_ts) override;
   virtual bool IsEmpty() const override { return !any_added_; }
   virtual size_t EstimateEntriesAdded() override;
@@ -107,28 +105,28 @@ class FullFilterBlockReader
       FilePrefetchBuffer* prefetch_buffer, bool use_cache, bool prefetch,
       bool pin, BlockCacheLookupContext* lookup_context);
 
-  bool IsBlockBased() override { return false; }
-
-  bool KeyMayMatch(const Slice& key, const SliceTransform* prefix_extractor,
-                   uint64_t block_offset, const bool no_io,
+  bool KeyMayMatch(const Slice& key, const bool no_io,
                    const Slice* const const_ikey_ptr, GetContext* get_context,
                    BlockCacheLookupContext* lookup_context) override;
 
-  bool PrefixMayMatch(const Slice& prefix,
-                      const SliceTransform* prefix_extractor,
-                      uint64_t block_offset, const bool no_io,
+  bool PrefixMayMatch(const Slice& prefix, const bool no_io,
                       const Slice* const const_ikey_ptr,
                       GetContext* get_context,
                       BlockCacheLookupContext* lookup_context) override;
 
-  void KeysMayMatch(MultiGetRange* range,
-                    const SliceTransform* prefix_extractor,
-                    uint64_t block_offset, const bool no_io,
+  void KeysMayMatch(MultiGetRange* range, const bool no_io,
                     BlockCacheLookupContext* lookup_context) override;
+  // Used in partitioned filter code
+  void KeysMayMatch2(MultiGetRange* range,
+                     const SliceTransform* /*prefix_extractor*/,
+                     const bool no_io,
+                     BlockCacheLookupContext* lookup_context) {
+    KeysMayMatch(range, no_io, lookup_context);
+  }
 
   void PrefixesMayMatch(MultiGetRange* range,
                         const SliceTransform* prefix_extractor,
-                        uint64_t block_offset, const bool no_io,
+                        const bool no_io,
                         BlockCacheLookupContext* lookup_context) override;
   size_t ApproximateMemoryUsage() const override;
  private:

package/deps/rocksdb/rocksdb/table/block_based/full_filter_block_test.cc

@@ -115,8 +115,7 @@ TEST_F(PluginFullFilterBlockTest, PluginEmptyBuilder) {
 
   FullFilterBlockReader reader(table_.get(), std::move(block));
   // Remain same symantic with blockbased filter
-  ASSERT_TRUE(reader.KeyMayMatch("foo", /*prefix_extractor=*/nullptr,
-                                 /*block_offset=*/kNotValid,
+  ASSERT_TRUE(reader.KeyMayMatch("foo",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr));
@@ -137,39 +136,34 @@ TEST_F(PluginFullFilterBlockTest, PluginSingleChunk) {
       nullptr /* cache */, nullptr /* cache_handle */, true /* own_value */);
 
   FullFilterBlockReader reader(table_.get(), std::move(block));
-  ASSERT_TRUE(reader.KeyMayMatch("foo", /*prefix_extractor=*/nullptr,
-                                 /*block_offset=*/kNotValid,
+  ASSERT_TRUE(reader.KeyMayMatch("foo",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr));
-  ASSERT_TRUE(reader.KeyMayMatch("bar", /*prefix_extractor=*/nullptr,
-                                 /*block_offset=*/kNotValid,
+  ASSERT_TRUE(reader.KeyMayMatch("bar",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr));
-  ASSERT_TRUE(reader.KeyMayMatch("box", /*prefix_extractor=*/nullptr,
-                                 /*block_offset=*/kNotValid,
+  ASSERT_TRUE(reader.KeyMayMatch("box",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr));
-  ASSERT_TRUE(reader.KeyMayMatch("hello", /*prefix_extractor=*/nullptr,
-                                 /*block_offset=*/kNotValid,
+  ASSERT_TRUE(reader.KeyMayMatch("hello",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr));
-  ASSERT_TRUE(reader.KeyMayMatch("foo", /*prefix_extractor=*/nullptr,
-                                 /*block_offset=*/kNotValid,
+  ASSERT_TRUE(reader.KeyMayMatch("foo",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr));
-  ASSERT_TRUE(!reader.KeyMayMatch(
-      "missing", /*prefix_extractor=*/nullptr, /*block_offset=*/kNotValid,
-      /*no_io=*/false, /*const_ikey_ptr=*/nullptr, /*get_context=*/nullptr,
-      /*lookup_context=*/nullptr));
-  ASSERT_TRUE(!reader.KeyMayMatch(
-      "other", /*prefix_extractor=*/nullptr, /*block_offset=*/kNotValid,
-      /*no_io=*/false, /*const_ikey_ptr=*/nullptr, /*get_context=*/nullptr,
-      /*lookup_context=*/nullptr));
+  ASSERT_TRUE(!reader.KeyMayMatch("missing",
+                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                  /*get_context=*/nullptr,
+                                  /*lookup_context=*/nullptr));
+  ASSERT_TRUE(!reader.KeyMayMatch("other",
+                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                  /*get_context=*/nullptr,
+                                  /*lookup_context=*/nullptr));
 }
 
 class FullFilterBlockTest : public mock::MockBlockBasedTableTester,
@@ -191,8 +185,7 @@ TEST_F(FullFilterBlockTest, EmptyBuilder) {
 
   FullFilterBlockReader reader(table_.get(), std::move(block));
   // Remain same symantic with blockbased filter
-  ASSERT_TRUE(reader.KeyMayMatch("foo", /*prefix_extractor=*/nullptr,
-                                 /*block_offset=*/kNotValid,
+  ASSERT_TRUE(reader.KeyMayMatch("foo",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr));
@@ -292,39 +285,34 @@ TEST_F(FullFilterBlockTest, SingleChunk) {
       nullptr /* cache */, nullptr /* cache_handle */, true /* own_value */);
 
   FullFilterBlockReader reader(table_.get(), std::move(block));
-  ASSERT_TRUE(reader.KeyMayMatch("foo", /*prefix_extractor=*/nullptr,
-                                 /*block_offset=*/kNotValid,
+  ASSERT_TRUE(reader.KeyMayMatch("foo",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr));
-  ASSERT_TRUE(reader.KeyMayMatch("bar", /*prefix_extractor=*/nullptr,
-                                 /*block_offset=*/kNotValid,
+  ASSERT_TRUE(reader.KeyMayMatch("bar",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr));
-  ASSERT_TRUE(reader.KeyMayMatch("box", /*prefix_extractor=*/nullptr,
-                                 /*block_offset=*/kNotValid,
+  ASSERT_TRUE(reader.KeyMayMatch("box",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr));
-  ASSERT_TRUE(reader.KeyMayMatch("hello", /*prefix_extractor=*/nullptr,
-                                 /*block_offset=*/kNotValid,
+  ASSERT_TRUE(reader.KeyMayMatch("hello",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr));
-  ASSERT_TRUE(reader.KeyMayMatch("foo", /*prefix_extractor=*/nullptr,
-                                 /*block_offset=*/kNotValid,
+  ASSERT_TRUE(reader.KeyMayMatch("foo",
                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr));
-  ASSERT_TRUE(!reader.KeyMayMatch(
-      "missing", /*prefix_extractor=*/nullptr, /*block_offset=*/kNotValid,
-      /*no_io=*/false, /*const_ikey_ptr=*/nullptr, /*get_context=*/nullptr,
-      /*lookup_context=*/nullptr));
-  ASSERT_TRUE(!reader.KeyMayMatch(
-      "other", /*prefix_extractor=*/nullptr, /*block_offset=*/kNotValid,
-      /*no_io=*/false, /*const_ikey_ptr=*/nullptr, /*get_context=*/nullptr,
-      /*lookup_context=*/nullptr));
+  ASSERT_TRUE(!reader.KeyMayMatch("missing",
+                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                  /*get_context=*/nullptr,
+                                  /*lookup_context=*/nullptr));
+  ASSERT_TRUE(!reader.KeyMayMatch("other",
+                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                  /*get_context=*/nullptr,
+                                  /*lookup_context=*/nullptr));
 }
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/table/block_based/mock_block_based_table.h

@@ -7,7 +7,6 @@
 #include <memory>
 
 #include "rocksdb/filter_policy.h"
-#include "table/block_based/block_based_filter_block.h"
 #include "table/block_based/block_based_table_reader.h"
 #include "table/block_based/filter_policy_internal.h"
 

package/deps/rocksdb/rocksdb/table/block_based/partitioned_filter_block.cc

@@ -216,58 +216,41 @@ std::unique_ptr<FilterBlockReader> PartitionedFilterBlockReader::Create(
 }
 
 bool PartitionedFilterBlockReader::KeyMayMatch(
-    const Slice& key, const SliceTransform* prefix_extractor,
-    uint64_t block_offset, const bool no_io, const Slice* const const_ikey_ptr,
+    const Slice& key, const bool no_io, const Slice* const const_ikey_ptr,
     GetContext* get_context, BlockCacheLookupContext* lookup_context) {
   assert(const_ikey_ptr != nullptr);
-  assert(block_offset == kNotValid);
   if (!whole_key_filtering()) {
     return true;
   }
 
-  return MayMatch(key, prefix_extractor, block_offset, no_io, const_ikey_ptr,
-                  get_context, lookup_context,
+  return MayMatch(key, no_io, const_ikey_ptr, get_context, lookup_context,
                   &FullFilterBlockReader::KeyMayMatch);
 }
 
 void PartitionedFilterBlockReader::KeysMayMatch(
-    MultiGetRange* range, const SliceTransform* prefix_extractor,
-    uint64_t block_offset, const bool no_io,
+    MultiGetRange* range, const bool no_io,
     BlockCacheLookupContext* lookup_context) {
-  assert(block_offset == kNotValid);
   if (!whole_key_filtering()) {
     return;  // Any/all may match
   }
 
-  MayMatch(range, prefix_extractor, block_offset, no_io, lookup_context,
-           &FullFilterBlockReader::KeysMayMatch);
+  MayMatch(range, nullptr, no_io, lookup_context,
+           &FullFilterBlockReader::KeysMayMatch2);
 }
 
 bool PartitionedFilterBlockReader::PrefixMayMatch(
-    const Slice& prefix, const SliceTransform* prefix_extractor,
-    uint64_t block_offset, const bool no_io, const Slice* const const_ikey_ptr,
+    const Slice& prefix, const bool no_io, const Slice* const const_ikey_ptr,
     GetContext* get_context, BlockCacheLookupContext* lookup_context) {
   assert(const_ikey_ptr != nullptr);
-  assert(block_offset == kNotValid);
-  if (!table_prefix_extractor() && !prefix_extractor) {
-    return true;
-  }
-
-  return MayMatch(prefix, prefix_extractor, block_offset, no_io, const_ikey_ptr,
-                  get_context, lookup_context,
+  return MayMatch(prefix, no_io, const_ikey_ptr, get_context, lookup_context,
                   &FullFilterBlockReader::PrefixMayMatch);
 }
 
 void PartitionedFilterBlockReader::PrefixesMayMatch(
     MultiGetRange* range, const SliceTransform* prefix_extractor,
-    uint64_t block_offset, const bool no_io,
-    BlockCacheLookupContext* lookup_context) {
-  assert(block_offset == kNotValid);
-  if (!table_prefix_extractor() && !prefix_extractor) {
-    return;  // Any/all may match
-  }
-
-  MayMatch(range, prefix_extractor, block_offset, no_io, lookup_context,
+    const bool no_io, BlockCacheLookupContext* lookup_context) {
+  assert(prefix_extractor);
+  MayMatch(range, prefix_extractor, no_io, lookup_context,
            &FullFilterBlockReader::PrefixesMayMatch);
 }
 
@@ -331,8 +314,7 @@ Status PartitionedFilterBlockReader::GetFilterPartitionBlock(
 }
 
 bool PartitionedFilterBlockReader::MayMatch(
-    const Slice& slice, const SliceTransform* prefix_extractor,
-    uint64_t block_offset, bool no_io, const Slice* const_ikey_ptr,
+    const Slice& slice, bool no_io, const Slice* const_ikey_ptr,
     GetContext* get_context, BlockCacheLookupContext* lookup_context,
     FilterFunction filter_function) const {
   CachableEntry<Block> filter_block;
@@ -364,14 +346,13 @@ bool PartitionedFilterBlockReader::MayMatch(
 
   FullFilterBlockReader filter_partition(table(),
                                          std::move(filter_partition_block));
-  return (filter_partition.*filter_function)(
-      slice, prefix_extractor, block_offset, no_io, const_ikey_ptr, get_context,
-      lookup_context);
+  return (filter_partition.*filter_function)(slice, no_io, const_ikey_ptr,
+                                             get_context, lookup_context);
 }
 
 void PartitionedFilterBlockReader::MayMatch(
-    MultiGetRange* range, const SliceTransform* prefix_extractor,
-    uint64_t block_offset, bool no_io, BlockCacheLookupContext* lookup_context,
+    MultiGetRange* range, const SliceTransform* prefix_extractor, bool no_io,
+    BlockCacheLookupContext* lookup_context,
     FilterManyFunction filter_function) const {
   CachableEntry<Block> filter_block;
   Status s =
@@ -399,9 +380,8 @@ void PartitionedFilterBlockReader::MayMatch(
     if (!prev_filter_handle.IsNull() &&
         this_filter_handle != prev_filter_handle) {
       MultiGetRange subrange(*range, start_iter_same_handle, iter);
-      MayMatchPartition(&subrange, prefix_extractor, block_offset,
-                        prev_filter_handle, no_io, lookup_context,
-                        filter_function);
+      MayMatchPartition(&subrange, prefix_extractor, prev_filter_handle, no_io,
+                        lookup_context, filter_function);
       range->AddSkipsFrom(subrange);
       start_iter_same_handle = iter;
     }
@@ -416,16 +396,15 @@ void PartitionedFilterBlockReader::MayMatch(
   }
   if (!prev_filter_handle.IsNull()) {
     MultiGetRange subrange(*range, start_iter_same_handle, range->end());
-    MayMatchPartition(&subrange, prefix_extractor, block_offset,
-                      prev_filter_handle, no_io, lookup_context,
-                      filter_function);
+    MayMatchPartition(&subrange, prefix_extractor, prev_filter_handle, no_io,
+                      lookup_context, filter_function);
     range->AddSkipsFrom(subrange);
   }
 }
 
 void PartitionedFilterBlockReader::MayMatchPartition(
     MultiGetRange* range, const SliceTransform* prefix_extractor,
-    uint64_t block_offset, BlockHandle filter_handle, bool no_io,
+    BlockHandle filter_handle, bool no_io,
     BlockCacheLookupContext* lookup_context,
     FilterManyFunction filter_function) const {
   CachableEntry<ParsedFullFilterBlock> filter_partition_block;
@@ -439,8 +418,8 @@ void PartitionedFilterBlockReader::MayMatchPartition(
 
   FullFilterBlockReader filter_partition(table(),
                                          std::move(filter_partition_block));
-  (filter_partition.*filter_function)(range, prefix_extractor, block_offset,
-                                      no_io, lookup_context);
+  (filter_partition.*filter_function)(range, prefix_extractor, no_io,
+                                      lookup_context);
 }
 
 size_t PartitionedFilterBlockReader::ApproximateMemoryUsage() const {

package/deps/rocksdb/rocksdb/table/block_based/partitioned_filter_block.h

@@ -109,25 +109,19 @@ class PartitionedFilterBlockReader : public FilterBlockReaderCommon<Block> {
       FilePrefetchBuffer* prefetch_buffer, bool use_cache, bool prefetch,
       bool pin, BlockCacheLookupContext* lookup_context);
 
-  bool IsBlockBased() override { return false; }
-  bool KeyMayMatch(const Slice& key, const SliceTransform* prefix_extractor,
-                   uint64_t block_offset, const bool no_io,
+  bool KeyMayMatch(const Slice& key, const bool no_io,
                    const Slice* const const_ikey_ptr, GetContext* get_context,
                    BlockCacheLookupContext* lookup_context) override;
-  void KeysMayMatch(MultiGetRange* range,
-                    const SliceTransform* prefix_extractor,
-                    uint64_t block_offset, const bool no_io,
+  void KeysMayMatch(MultiGetRange* range, const bool no_io,
                     BlockCacheLookupContext* lookup_context) override;
 
-  bool PrefixMayMatch(const Slice& prefix,
-                      const SliceTransform* prefix_extractor,
-                      uint64_t block_offset, const bool no_io,
+  bool PrefixMayMatch(const Slice& prefix, const bool no_io,
                       const Slice* const const_ikey_ptr,
                       GetContext* get_context,
                       BlockCacheLookupContext* lookup_context) override;
   void PrefixesMayMatch(MultiGetRange* range,
                         const SliceTransform* prefix_extractor,
-                        uint64_t block_offset, const bool no_io,
+                        const bool no_io,
                         BlockCacheLookupContext* lookup_context) override;
 
   size_t ApproximateMemoryUsage() const override;
@@ -142,27 +136,22 @@ class PartitionedFilterBlockReader : public FilterBlockReaderCommon<Block> {
       CachableEntry<ParsedFullFilterBlock>* filter_block) const;
 
   using FilterFunction = bool (FullFilterBlockReader::*)(
-      const Slice& slice, const SliceTransform* prefix_extractor,
-      uint64_t block_offset, const bool no_io,
-      const Slice* const const_ikey_ptr, GetContext* get_context,
-      BlockCacheLookupContext* lookup_context);
-  bool MayMatch(const Slice& slice, const SliceTransform* prefix_extractor,
-                uint64_t block_offset, bool no_io, const Slice* const_ikey_ptr,
+      const Slice& slice, const bool no_io, const Slice* const const_ikey_ptr,
+      GetContext* get_context, BlockCacheLookupContext* lookup_context);
+  bool MayMatch(const Slice& slice, bool no_io, const Slice* const_ikey_ptr,
                 GetContext* get_context,
                 BlockCacheLookupContext* lookup_context,
                 FilterFunction filter_function) const;
   using FilterManyFunction = void (FullFilterBlockReader::*)(
       MultiGetRange* range, const SliceTransform* prefix_extractor,
-      uint64_t block_offset, const bool no_io,
-      BlockCacheLookupContext* lookup_context);
+      const bool no_io, BlockCacheLookupContext* lookup_context);
   void MayMatch(MultiGetRange* range, const SliceTransform* prefix_extractor,
-                uint64_t block_offset, bool no_io,
-                BlockCacheLookupContext* lookup_context,
+                bool no_io, BlockCacheLookupContext* lookup_context,
                 FilterManyFunction filter_function) const;
   void MayMatchPartition(MultiGetRange* range,
                          const SliceTransform* prefix_extractor,
-                         uint64_t block_offset, BlockHandle filter_handle,
-                         bool no_io, BlockCacheLookupContext* lookup_context,
+                         BlockHandle filter_handle, bool no_io,
+                         BlockCacheLookupContext* lookup_context,
                          FilterManyFunction filter_function) const;
   Status CacheDependencies(const ReadOptions& ro, bool pin) override;