@nxtedition/rocksdb 5.2.21 → 5.2.28

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

@@ -126,10 +126,24 @@ struct DecodeKeyV4 {
   }
 };
 
-void DataBlockIter::NextImpl() { ParseNextDataKey<DecodeEntry>(); }
+struct DecodeEntryV4 {
+  inline const char* operator()(const char* p, const char* limit,
+                                uint32_t* shared, uint32_t* non_shared,
+                                uint32_t* value_length) {
+    assert(value_length);
+
+    *value_length = 0;
+    return DecodeKeyV4()(p, limit, shared, non_shared);
+  }
+};
+void DataBlockIter::NextImpl() {
+  bool is_shared = false;
+  ParseNextDataKey(&is_shared);
+}
 
-void DataBlockIter::NextOrReportImpl() {
-  ParseNextDataKey<CheckAndDecodeEntry>();
+void MetaBlockIter::NextImpl() {
+  bool is_shared = false;
+  ParseNextKey<CheckAndDecodeEntry>(&is_shared);
 }
 
 void IndexBlockIter::NextImpl() { ParseNextIndexKey(); }
@@ -153,6 +167,27 @@ void IndexBlockIter::PrevImpl() {
   }
 }
 
+void MetaBlockIter::PrevImpl() {
+  assert(Valid());
+  // Scan backwards to a restart point before current_
+  const uint32_t original = current_;
+  while (GetRestartPoint(restart_index_) >= original) {
+    if (restart_index_ == 0) {
+      // No more entries
+      current_ = restarts_;
+      restart_index_ = num_restarts_;
+      return;
+    }
+    restart_index_--;
+  }
+  SeekToRestartPoint(restart_index_);
+  bool is_shared = false;
+  // Loop until end of current entry hits the start of original entry
+  while (ParseNextKey<CheckAndDecodeEntry>(&is_shared) &&
+         NextEntryOffset() < original) {
+  }
+}
+
 // Similar to IndexBlockIter::PrevImpl but also caches the prev entries
 void DataBlockIter::PrevImpl() {
   assert(Valid());
@@ -212,7 +247,8 @@ void DataBlockIter::PrevImpl() {
   SeekToRestartPoint(restart_index_);
 
   do {
-    if (!ParseNextDataKey<DecodeEntry>()) {
+    bool is_shared = false;
+    if (!ParseNextDataKey(&is_shared)) {
       break;
     }
     Slice current_key = raw_key_.GetKey();
@@ -250,6 +286,22 @@ void DataBlockIter::SeekImpl(const Slice& target) {
   FindKeyAfterBinarySeek(seek_key, index, skip_linear_scan);
 }
 
+void MetaBlockIter::SeekImpl(const Slice& target) {
+  Slice seek_key = target;
+  PERF_TIMER_GUARD(block_seek_nanos);
+  if (data_ == nullptr) {  // Not init yet
+    return;
+  }
+  uint32_t index = 0;
+  bool skip_linear_scan = false;
+  bool ok = BinarySeek<DecodeKey>(seek_key, &index, &skip_linear_scan);
+
+  if (!ok) {
+    return;
+  }
+  FindKeyAfterBinarySeek(seek_key, index, skip_linear_scan);
+}
+
 // Optimized Seek for point lookup for an internal key `target`
 // target = "seek_user_key @ type | seqno".
 //
@@ -309,23 +361,21 @@ bool DataBlockIter::SeekForGetImpl(const Slice& target) {
   // check if the key is in the restart_interval
   assert(restart_index < num_restarts_);
   SeekToRestartPoint(restart_index);
+  current_ = GetRestartPoint(restart_index);
 
-  const char* limit = nullptr;
-  if (restart_index_ + 1 < num_restarts_) {
-    limit = data_ + GetRestartPoint(restart_index_ + 1);
-  } else {
-    limit = data_ + restarts_;
+  uint32_t limit = restarts_;
+  if (restart_index + 1 < num_restarts_) {
+    limit = GetRestartPoint(restart_index + 1);
   }
-
-  while (true) {
+  while (current_ < limit) {
+    bool shared;
     // Here we only linear seek the target key inside the restart interval.
     // If a key does not exist inside a restart interval, we avoid
-    // further searching the block content accross restart interval boundary.
+    // further searching the block content across restart interval boundary.
     //
-    // TODO(fwu): check the left and write boundary of the restart interval
+    // TODO(fwu): check the left and right boundary of the restart interval
     // to avoid linear seek a target key that is out of range.
-    if (!ParseNextDataKey<DecodeEntry>(limit) ||
-        CompareCurrentKey(target) >= 0) {
+    if (!ParseNextDataKey(&shared) || CompareCurrentKey(target) >= 0) {
       // we stop at the first potential matching user key.
       break;
     }
@@ -336,7 +386,7 @@ bool DataBlockIter::SeekForGetImpl(const Slice& target) {
     // 1) there is only one user_key match in the block (otherwise collsion).
     //    the matching user_key resides in the last restart interval, and it
     //    is the last key of the restart interval and of the block as well.
-    //    ParseNextDataKey() skiped it as its [ type | seqno ] is smaller.
+    //    ParseNextKey() skiped it as its [ type | seqno ] is smaller.
     //
     // 2) The seek_key is not found in the HashIndex Lookup(), i.e. kNoEntry,
     //    AND all existing user_keys in the restart interval are smaller than
@@ -432,20 +482,46 @@ void DataBlockIter::SeekForPrevImpl(const Slice& target) {
   }
 }
 
+void MetaBlockIter::SeekForPrevImpl(const Slice& target) {
+  PERF_TIMER_GUARD(block_seek_nanos);
+  Slice seek_key = target;
+  if (data_ == nullptr) {  // Not init yet
+    return;
+  }
+  uint32_t index = 0;
+  bool skip_linear_scan = false;
+  bool ok = BinarySeek<DecodeKey>(seek_key, &index, &skip_linear_scan);
+
+  if (!ok) {
+    return;
+  }
+  FindKeyAfterBinarySeek(seek_key, index, skip_linear_scan);
+
+  if (!Valid()) {
+    SeekToLastImpl();
+  } else {
+    while (Valid() && CompareCurrentKey(seek_key) > 0) {
+      PrevImpl();
+    }
+  }
+}
+
 void DataBlockIter::SeekToFirstImpl() {
   if (data_ == nullptr) {  // Not init yet
     return;
   }
   SeekToRestartPoint(0);
-  ParseNextDataKey<DecodeEntry>();
+  bool is_shared = false;
+  ParseNextDataKey(&is_shared);
 }
 
-void DataBlockIter::SeekToFirstOrReportImpl() {
+void MetaBlockIter::SeekToFirstImpl() {
   if (data_ == nullptr) {  // Not init yet
     return;
   }
   SeekToRestartPoint(0);
-  ParseNextDataKey<CheckAndDecodeEntry>();
+  bool is_shared = false;
+  ParseNextKey<CheckAndDecodeEntry>(&is_shared);
 }
 
 void IndexBlockIter::SeekToFirstImpl() {
@@ -462,7 +538,20 @@ void DataBlockIter::SeekToLastImpl() {
     return;
   }
   SeekToRestartPoint(num_restarts_ - 1);
-  while (ParseNextDataKey<DecodeEntry>() && NextEntryOffset() < restarts_) {
+  bool is_shared = false;
+  while (ParseNextDataKey(&is_shared) && NextEntryOffset() < restarts_) {
+    // Keep skipping
+  }
+}
+
+void MetaBlockIter::SeekToLastImpl() {
+  if (data_ == nullptr) {  // Not init yet
+    return;
+  }
+  SeekToRestartPoint(num_restarts_ - 1);
+  bool is_shared = false;
+  while (ParseNextKey<CheckAndDecodeEntry>(&is_shared) &&
+         NextEntryOffset() < restarts_) {
     // Keep skipping
   }
 }
@@ -487,13 +576,12 @@ void BlockIter<TValue>::CorruptionError() {
   value_.clear();
 }
 
+template <class TValue>
 template <typename DecodeEntryFunc>
-bool DataBlockIter::ParseNextDataKey(const char* limit) {
+bool BlockIter<TValue>::ParseNextKey(bool* is_shared) {
   current_ = NextEntryOffset();
   const char* p = data_ + current_;
-  if (!limit) {
-    limit = data_ + restarts_;  // Restarts come right after data
-  }
+  const char* limit = data_ + restarts_;  // Restarts come right after data
 
   if (p >= limit) {
     // No more entries to return.  Mark as invalid.
@@ -501,7 +589,6 @@ bool DataBlockIter::ParseNextDataKey(const char* limit) {
     restart_index_ = num_restarts_;
     return false;
   }
-
   // Decode next entry
   uint32_t shared, non_shared, value_length;
   p = DecodeEntryFunc()(p, limit, &shared, &non_shared, &value_length);
@@ -510,19 +597,36 @@ bool DataBlockIter::ParseNextDataKey(const char* limit) {
     return false;
   } else {
     if (shared == 0) {
+      *is_shared = false;
       // If this key doesn't share any bytes with prev key then we don't need
       // to decode it and can use its address in the block directly.
       raw_key_.SetKey(Slice(p, non_shared), false /* copy */);
     } else {
       // This key share `shared` bytes with prev key, we need to decode it
+      *is_shared = true;
       raw_key_.TrimAppend(shared, p, non_shared);
     }
+    value_ = Slice(p + non_shared, value_length);
+    if (shared == 0) {
+      while (restart_index_ + 1 < num_restarts_ &&
+             GetRestartPoint(restart_index_ + 1) < current_) {
+        ++restart_index_;
+      }
+    }
+    // else we are in the middle of a restart interval and the restart_index_
+    // thus has not changed
+    return true;
+  }
+}
 
+bool DataBlockIter::ParseNextDataKey(bool* is_shared) {
+  if (ParseNextKey<DecodeEntry>(is_shared)) {
 #ifndef NDEBUG
     if (global_seqno_ != kDisableGlobalSequenceNumber) {
       // If we are reading a file with a global sequence number we should
       // expect that all encoded sequence numbers are zeros and any value
-      // type is kTypeValue, kTypeMerge, kTypeDeletion, or kTypeRangeDeletion.
+      // type is kTypeValue, kTypeMerge, kTypeDeletion,
+      // kTypeDeletionWithTimestamp, or kTypeRangeDeletion.
       uint64_t packed = ExtractInternalKeyFooter(raw_key_.GetKey());
       SequenceNumber seqno;
       ValueType value_type;
@@ -530,68 +634,27 @@ bool DataBlockIter::ParseNextDataKey(const char* limit) {
       assert(value_type == ValueType::kTypeValue ||
              value_type == ValueType::kTypeMerge ||
              value_type == ValueType::kTypeDeletion ||
+             value_type == ValueType::kTypeDeletionWithTimestamp ||
              value_type == ValueType::kTypeRangeDeletion);
       assert(seqno == 0);
     }
 #endif  // NDEBUG
-
-    value_ = Slice(p + non_shared, value_length);
-    if (shared == 0) {
-      while (restart_index_ + 1 < num_restarts_ &&
-             GetRestartPoint(restart_index_ + 1) < current_) {
-        ++restart_index_;
-      }
-    }
-    // else we are in the middle of a restart interval and the restart_index_
-    // thus has not changed
     return true;
+  } else {
+    return false;
   }
 }
 
 bool IndexBlockIter::ParseNextIndexKey() {
-  current_ = NextEntryOffset();
-  const char* p = data_ + current_;
-  const char* limit = data_ + restarts_;  // Restarts come right after data
-  if (p >= limit) {
-    // No more entries to return.  Mark as invalid.
-    current_ = restarts_;
-    restart_index_ = num_restarts_;
-    return false;
-  }
-
-  // Decode next entry
-  uint32_t shared, non_shared, value_length;
-  if (value_delta_encoded_) {
-    p = DecodeKeyV4()(p, limit, &shared, &non_shared);
-    value_length = 0;
-  } else {
-    p = DecodeEntry()(p, limit, &shared, &non_shared, &value_length);
-  }
-  if (p == nullptr || raw_key_.Size() < shared) {
-    CorruptionError();
-    return false;
-  }
-  if (shared == 0) {
-    // If this key doesn't share any bytes with prev key then we don't need
-    // to decode it and can use its address in the block directly.
-    raw_key_.SetKey(Slice(p, non_shared), false /* copy */);
-  } else {
-    // This key share `shared` bytes with prev key, we need to decode it
-    raw_key_.TrimAppend(shared, p, non_shared);
-  }
-  value_ = Slice(p + non_shared, value_length);
-  if (shared == 0) {
-    while (restart_index_ + 1 < num_restarts_ &&
-           GetRestartPoint(restart_index_ + 1) < current_) {
-      ++restart_index_;
+  bool is_shared = false;
+  bool ok = (value_delta_encoded_) ? ParseNextKey<DecodeEntryV4>(&is_shared)
+                                   : ParseNextKey<DecodeEntry>(&is_shared);
+  if (ok) {
+    if (value_delta_encoded_ || global_seqno_state_ != nullptr) {
+      DecodeCurrentValue(is_shared);
     }
   }
-  // else we are in the middle of a restart interval and the restart_index_
-  // thus has not changed
-  if (value_delta_encoded_ || global_seqno_state_ != nullptr) {
-    DecodeCurrentValue(shared);
-  }
-  return true;
+  return ok;
 }
 
 // The format:
@@ -602,15 +665,15 @@ bool IndexBlockIter::ParseNextIndexKey() {
 // where, k is key, v is value, and its encoding is in parenthesis.
 // The format of each key is (shared_size, non_shared_size, shared, non_shared)
 // The format of each value, i.e., block handle, is (offset, size) whenever the
-// shared_size is 0, which included the first entry in each restart point.
+// is_shared is false, which included the first entry in each restart point.
 // Otherwise the format is delta-size = block handle size - size of last block
 // handle.
-void IndexBlockIter::DecodeCurrentValue(uint32_t shared) {
+void IndexBlockIter::DecodeCurrentValue(bool is_shared) {
   Slice v(value_.data(), data_ + restarts_ - value_.data());
   // Delta encoding is used if `shared` != 0.
   Status decode_s __attribute__((__unused__)) = decoded_value_.DecodeFrom(
       &v, have_first_key_,
-      (value_delta_encoded_ && shared) ? &decoded_value_.handle : nullptr);
+      (value_delta_encoded_ && is_shared) ? &decoded_value_.handle : nullptr);
   assert(decode_s.ok());
   value_ = Slice(value_.data(), v.data() - value_.data());
 
@@ -968,6 +1031,21 @@ Block::Block(BlockContents&& contents, size_t read_amp_bytes_per_bit,
   }
 }
 
+MetaBlockIter* Block::NewMetaIterator(bool block_contents_pinned) {
+  MetaBlockIter* iter = new MetaBlockIter();
+  if (size_ < 2 * sizeof(uint32_t)) {
+    iter->Invalidate(Status::Corruption("bad block contents"));
+    return iter;
+  } else if (num_restarts_ == 0) {
+    // Empty block.
+    iter->Invalidate(Status::OK());
+  } else {
+    iter->Initialize(data_, restart_offset_, num_restarts_,
+                     block_contents_pinned);
+  }
+  return iter;
+}
+
 DataBlockIter* Block::NewDataIterator(const Comparator* raw_ucmp,
                                       SequenceNumber global_seqno,
                                       DataBlockIter* iter, Statistics* stats,

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

@@ -13,7 +13,6 @@
 #include <string>
 #include <vector>
 
-#include "db/dbformat.h"
 #include "db/pinned_iterators_manager.h"
 #include "port/malloc.h"
 #include "rocksdb/iterator.h"
@@ -35,6 +34,7 @@ template <class TValue>
 class BlockIter;
 class DataBlockIter;
 class IndexBlockIter;
+class MetaBlockIter;
 class BlockPrefixIndex;
 
 // BlockReadAmpBitmap is a bitmap that map the ROCKSDB_NAMESPACE::Block data
@@ -193,6 +193,21 @@ class Block {
                                  Statistics* stats = nullptr,
                                  bool block_contents_pinned = false);
 
+  // Returns an MetaBlockIter for iterating over blocks containing metadata
+  // (like Properties blocks).  Unlike data blocks, the keys for these blocks
+  // do not contain sequence numbers, do not use a user-define comparator, and
+  // do not track read amplification/statistics.  Additionally, MetaBlocks will
+  // not assert if the block is formatted improperly.
+  //
+  // If `block_contents_pinned` is true, the caller will guarantee that when
+  // the cleanup functions are transferred from the iterator to other
+  // classes, e.g. PinnableSlice, the pointer to the bytes will still be
+  // valid. Either the iterator holds cache handle or ownership of some resource
+  // and release them in a release function, or caller is sure that the data
+  // will not go away (for example, it's from mmapped file which will not be
+  // closed).
+  MetaBlockIter* NewMetaIterator(bool block_contents_pinned = false);
+
   // raw_ucmp is a raw (i.e., not wrapped by `UserComparatorWrapper`) user key
   // comparator.
   //
@@ -270,10 +285,9 @@ class BlockIter : public InternalIteratorBase<TValue> {
 
   // Makes Valid() return false, status() return `s`, and Seek()/Prev()/etc do
   // nothing. Calls cleanup functions.
-  void InvalidateBase(Status s) {
+  virtual void Invalidate(const Status& s) {
     // Assert that the BlockIter is never deleted while Pinning is Enabled.
-    assert(!pinned_iters_mgr_ ||
-           (pinned_iters_mgr_ && !pinned_iters_mgr_->PinningEnabled()));
+    assert(!pinned_iters_mgr_ || !pinned_iters_mgr_->PinningEnabled());
 
     data_ = nullptr;
     current_ = restarts_;
@@ -385,8 +399,12 @@ class BlockIter : public InternalIteratorBase<TValue> {
   virtual void SeekImpl(const Slice& target) = 0;
   virtual void SeekForPrevImpl(const Slice& target) = 0;
   virtual void NextImpl() = 0;
+
   virtual void PrevImpl() = 0;
 
+  template <typename DecodeEntryFunc>
+  inline bool ParseNextKey(bool* is_shared);
+
   InternalKeyComparator icmp() {
     return InternalKeyComparator(raw_ucmp_, false /* named */);
   }
@@ -520,24 +538,8 @@ class DataBlockIter final : public BlockIter<Slice> {
     return res;
   }
 
-  // Try to advance to the next entry in the block. If there is data corruption
-  // or error, report it to the caller instead of aborting the process. May
-  // incur higher CPU overhead because we need to perform check on every entry.
-  void NextOrReport() {
-    NextOrReportImpl();
-    UpdateKey();
-  }
-
-  // Try to seek to the first entry in the block. If there is data corruption
-  // or error, report it to caller instead of aborting the process. May incur
-  // higher CPU overhead because we need to perform check on every entry.
-  void SeekToFirstOrReport() {
-    SeekToFirstOrReportImpl();
-    UpdateKey();
-  }
-
-  void Invalidate(Status s) {
-    InvalidateBase(s);
+  void Invalidate(const Status& s) override {
+    BlockIter::Invalidate(s);
     // Clear prev entries cache.
     prev_entries_keys_buff_.clear();
     prev_entries_.clear();
@@ -545,12 +547,14 @@ class DataBlockIter final : public BlockIter<Slice> {
   }
 
  protected:
-  virtual void SeekToFirstImpl() override;
-  virtual void SeekToLastImpl() override;
-  virtual void SeekImpl(const Slice& target) override;
-  virtual void SeekForPrevImpl(const Slice& target) override;
-  virtual void NextImpl() override;
-  virtual void PrevImpl() override;
+  friend Block;
+  inline bool ParseNextDataKey(bool* is_shared);
+  void SeekToFirstImpl() override;
+  void SeekToLastImpl() override;
+  void SeekImpl(const Slice& target) override;
+  void SeekForPrevImpl(const Slice& target) override;
+  void NextImpl() override;
+  void PrevImpl() override;
 
  private:
   // read-amp bitmap
@@ -583,12 +587,38 @@ class DataBlockIter final : public BlockIter<Slice> {
 
   DataBlockHashIndex* data_block_hash_index_;
 
-  template <typename DecodeEntryFunc>
-  inline bool ParseNextDataKey(const char* limit = nullptr);
-
   bool SeekForGetImpl(const Slice& target);
-  void NextOrReportImpl();
-  void SeekToFirstOrReportImpl();
+};
+
+// Iterator over MetaBlocks.  MetaBlocks are similar to Data Blocks and
+// are used to store Properties associated with table.
+// Meta blocks always store user keys (no sequence number) and always
+// use the BytewiseComparator.  Additionally, MetaBlock accesses are
+// not recorded in the Statistics or for Read-Amplification.
+class MetaBlockIter final : public BlockIter<Slice> {
+ public:
+  MetaBlockIter() : BlockIter() { raw_key_.SetIsUserKey(true); }
+  void Initialize(const char* data, uint32_t restarts, uint32_t num_restarts,
+                  bool block_contents_pinned) {
+    // Initializes the iterator with a BytewiseComparator and
+    // the raw key being a user key.
+    InitializeBase(BytewiseComparator(), data, restarts, num_restarts,
+                   kDisableGlobalSequenceNumber, block_contents_pinned);
+    raw_key_.SetIsUserKey(true);
+  }
+
+  Slice value() const override {
+    assert(Valid());
+    return value_;
+  }
+
+ protected:
+  void SeekToFirstImpl() override;
+  void SeekToLastImpl() override;
+  void SeekImpl(const Slice& target) override;
+  void SeekForPrevImpl(const Slice& target) override;
+  void NextImpl() override;
+  void PrevImpl() override;
 };
 
 class IndexBlockIter final : public BlockIter<IndexValue> {
@@ -636,8 +666,6 @@ class IndexBlockIter final : public BlockIter<IndexValue> {
     }
   }
 
-  void Invalidate(Status s) { InvalidateBase(s); }
-
   bool IsValuePinned() const override {
     return global_seqno_state_ != nullptr ? false : BlockIter::IsValuePinned();
   }
@@ -714,7 +742,7 @@ class IndexBlockIter final : public BlockIter<IndexValue> {
 
   // When value_delta_encoded_ is enabled it decodes the value which is assumed
   // to be BlockHandle and put it to decoded_value_
-  inline void DecodeCurrentValue(uint32_t shared);
+  inline void DecodeCurrentValue(bool is_shared);
 };
 
 }  // namespace ROCKSDB_NAMESPACE

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

@@ -8,12 +8,14 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #include "table/block_based/block_based_filter_block.h"
+
 #include <algorithm>
 
 #include "db/dbformat.h"
 #include "monitoring/perf_context_imp.h"
 #include "rocksdb/filter_policy.h"
 #include "table/block_based/block_based_table_reader.h"
+#include "util/cast_util.h"
 #include "util/coding.h"
 #include "util/string_util.h"
 
@@ -62,15 +64,13 @@ static const size_t kFilterBase = 1 << kFilterBaseLg;
 
 BlockBasedFilterBlockBuilder::BlockBasedFilterBlockBuilder(
     const SliceTransform* prefix_extractor,
-    const BlockBasedTableOptions& table_opt)
-    : policy_(table_opt.filter_policy.get()),
-      prefix_extractor_(prefix_extractor),
+    const BlockBasedTableOptions& table_opt, int bits_per_key)
+    : prefix_extractor_(prefix_extractor),
       whole_key_filtering_(table_opt.whole_key_filtering),
+      bits_per_key_(bits_per_key),
       prev_prefix_start_(0),
       prev_prefix_size_(0),
-      num_added_(0) {
-  assert(policy_);
-}
+      total_added_in_built_(0) {}
 
 void BlockBasedFilterBlockBuilder::StartBlock(uint64_t block_offset) {
   uint64_t filter_index = (block_offset / kFilterBase);
@@ -80,6 +80,10 @@ void BlockBasedFilterBlockBuilder::StartBlock(uint64_t block_offset) {
   }
 }
 
+size_t BlockBasedFilterBlockBuilder::EstimateEntriesAdded() {
+  return total_added_in_built_ + start_.size();
+}
+
 void BlockBasedFilterBlockBuilder::Add(const Slice& key_without_ts) {
   if (prefix_extractor_ && prefix_extractor_->InDomain(key_without_ts)) {
     AddPrefix(key_without_ts);
@@ -92,7 +96,6 @@ void BlockBasedFilterBlockBuilder::Add(const Slice& key_without_ts) {
 
 // Add key to filter if needed
 inline void BlockBasedFilterBlockBuilder::AddKey(const Slice& key) {
-  num_added_++;
   start_.push_back(entries_.size());
   entries_.append(key.data(), key.size());
 }
@@ -114,10 +117,12 @@ inline void BlockBasedFilterBlockBuilder::AddPrefix(const Slice& key) {
   }
 }
 
-Slice BlockBasedFilterBlockBuilder::Finish(const BlockHandle& /*tmp*/,
-                                           Status* status) {
-  // In this impl we ignore BlockHandle
+Slice BlockBasedFilterBlockBuilder::Finish(
+    const BlockHandle& /*tmp*/, Status* status,
+    std::unique_ptr<const char[]>* /* filter_data */) {
+  // In this impl we ignore BlockHandle and filter_data
   *status = Status::OK();
+
   if (!start_.empty()) {
     GenerateFilter();
   }
@@ -140,6 +145,7 @@ void BlockBasedFilterBlockBuilder::GenerateFilter() {
     filter_offsets_.push_back(static_cast<uint32_t>(result_.size()));
     return;
   }
+  total_added_in_built_ += num_entries;
 
   // Make list of keys from flattened key structure
   start_.push_back(entries_.size());  // Simplify length computation
@@ -152,8 +158,9 @@ void BlockBasedFilterBlockBuilder::GenerateFilter() {
 
   // Generate filter for current set of keys and append to result_.
   filter_offsets_.push_back(static_cast<uint32_t>(result_.size()));
-  policy_->CreateFilter(&tmp_entries_[0], static_cast<int>(num_entries),
-                        &result_);
+  DeprecatedBlockBasedBloomFilterPolicy::CreateFilter(
+      tmp_entries_.data(), static_cast<int>(num_entries), bits_per_key_,
+      &result_);
 
   tmp_entries_.clear();
   entries_.clear();
@@ -252,6 +259,7 @@ bool BlockBasedFilterBlockReader::MayMatch(
   const Status s =
       GetOrReadFilterBlock(no_io, get_context, lookup_context, &filter_block);
   if (!s.ok()) {
+    IGNORE_STATUS_IF_ERROR(s);
     return true;
   }
 
@@ -275,9 +283,9 @@ bool BlockBasedFilterBlockReader::MayMatch(
 
       assert(table());
       assert(table()->get_rep());
-      const FilterPolicy* const policy = table()->get_rep()->filter_policy;
 
-      const bool may_match = policy->KeyMayMatch(entry, filter);
+      const bool may_match =
+          DeprecatedBlockBasedBloomFilterPolicy::KeyMayMatch(entry, filter);
       if (may_match) {
         PERF_COUNTER_ADD(bloom_sst_hit_count, 1);
         return true;
@@ -310,6 +318,7 @@ std::string BlockBasedFilterBlockReader::ToString() const {
       GetOrReadFilterBlock(false /* no_io */, nullptr /* get_context */,
                            nullptr /* lookup_context */, &filter_block);
   if (!s.ok()) {
+    IGNORE_STATUS_IF_ERROR(s);
     return std::string("Unable to retrieve filter block");
   }