@nxtedition/rocksdb 15.4.1 → 15.5.0

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

@@ -32,4 +32,34 @@ enum class BlockType : uint8_t {
   kInvalid
 };
 
+inline const char* BlockTypeToString(BlockType block_type) {
+  switch (block_type) {
+    case BlockType::kData:
+      return "Data";
+    case BlockType::kFilter:
+      return "Filter";
+    case BlockType::kFilterPartitionIndex:
+      return "FilterPartitionIndex";
+    case BlockType::kProperties:
+      return "Properties";
+    case BlockType::kCompressionDictionary:
+      return "CompressionDictionary";
+    case BlockType::kRangeDeletion:
+      return "RangeDeletion";
+    case BlockType::kHashIndexPrefixes:
+      return "HashIndexPrefixes";
+    case BlockType::kHashIndexMetadata:
+      return "HashIndexMetadata";
+    case BlockType::kMetaIndex:
+      return "MetaIndex";
+    case BlockType::kIndex:
+      return "Index";
+    case BlockType::kUserDefinedIndex:
+      return "UserDefinedIndex";
+    case BlockType::kInvalid:
+      return "Invalid";
+  }
+  return "Unknown";
+}
+
 }  // namespace ROCKSDB_NAMESPACE

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

@@ -0,0 +1,156 @@
+//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
+//  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 <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <cstring>
+
+#include "db/dbformat.h"
+#include "port/port.h"
+#include "rocksdb/slice.h"
+#include "util/coding.h"
+#include "util/math.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+// Decode the next block entry starting at "p", storing the number of shared key
+// bytes, non_shared key bytes, and the length of the value in "*shared",
+// "*non_shared", and "*value_length", respectively.  Will not dereference past
+// "limit".
+//
+// If any errors are detected, returns nullptr.  Otherwise, returns a
+// pointer to the key delta (just past the three decoded values).
+struct DecodeEntry {
+  inline const char* operator()(const char* p, const char* limit,
+                                uint32_t* shared, uint32_t* non_shared,
+                                uint32_t* value_length,
+                                uint32_t* value_offset) {
+    // We need 2 bytes for shared and non_shared size. We also need one more
+    // byte either for value size or the actual value in case of value delta
+    // encoding.
+    assert(limit - p >= 3);
+    *shared = reinterpret_cast<const unsigned char*>(p)[0];
+    *non_shared = reinterpret_cast<const unsigned char*>(p)[1];
+    *value_length = reinterpret_cast<const unsigned char*>(p)[2];
+    if ((*shared | *non_shared | *value_length) < 128) {
+      // Fast path: all three values are encoded in one byte each
+      p += 3;
+    } else {
+      if ((p = GetVarint32Ptr(p, limit, shared)) == nullptr) {
+        return nullptr;
+      }
+      if ((p = GetVarint32Ptr(p, limit, non_shared)) == nullptr) {
+        return nullptr;
+      }
+      if ((p = GetVarint32Ptr(p, limit, value_length)) == nullptr) {
+        return nullptr;
+      }
+    }
+
+    if (value_offset) {
+      if ((p = GetVarint32Ptr(p, limit, value_offset)) == nullptr) {
+        return nullptr;
+      }
+    }
+
+    return p;
+  }
+};
+
+struct DecodeKey {
+  inline const char* operator()(const char* p, const char* limit,
+                                uint32_t* shared, uint32_t* non_shared,
+                                uint32_t* value_offset) {
+    uint32_t value_length;
+    return DecodeEntry()(p, limit, shared, non_shared, &value_length,
+                         value_offset);
+  }
+};
+
+// In format_version 4, which is used by index blocks, the value size is not
+// encoded before the entry, as the value is known to be the handle with the
+// known size.
+struct DecodeKeyV4 {
+  inline const char* operator()(const char* p, const char* limit,
+                                uint32_t* shared, uint32_t* non_shared,
+                                uint32_t* value_offset) {
+    // We need 2 bytes for shared and non_shared size. We also need one more
+    // byte either for value size or the actual value in case of value delta
+    // encoding.
+    if (limit - p < 3) {
+      return nullptr;
+    }
+    *shared = reinterpret_cast<const unsigned char*>(p)[0];
+    *non_shared = reinterpret_cast<const unsigned char*>(p)[1];
+    if ((*shared | *non_shared) < 128) {
+      // Fast path: all three values are encoded in one byte each
+      p += 2;
+    } else {
+      if ((p = GetVarint32Ptr(p, limit, shared)) == nullptr) {
+        return nullptr;
+      }
+      if ((p = GetVarint32Ptr(p, limit, non_shared)) == nullptr) {
+        return nullptr;
+      }
+    }
+
+    if (value_offset) {
+      if ((p = GetVarint32Ptr(p, limit, value_offset)) == nullptr) {
+        return nullptr;
+      }
+    }
+    return p;
+  }
+};
+
+struct DecodeEntryV4 {
+  inline const char* operator()(const char* p, const char* limit,
+                                uint32_t* shared, uint32_t* non_shared,
+                                uint32_t* value_length,
+                                uint32_t* value_offset) {
+    assert(value_length);
+
+    *value_length = 0;
+    return DecodeKeyV4()(p, limit, shared, non_shared, value_offset);
+  }
+};
+
+// Read first 8 bytes (starting at offset) as big-endian uint64_t, padding
+// with zeros on the right if the key is shorter. This preserves
+// lexicographic ordering.
+//
+// If s.size() <= offset, then returns 0.
+inline uint64_t ReadBe64FromKey(Slice s, bool is_user_key, size_t offset) {
+  if (!is_user_key) {
+    assert(s.size() >= kNumInternalBytes);
+    s = Slice(s.data(), s.size() - kNumInternalBytes);
+  }
+  offset = std::min(offset, s.size());
+  size_t remaining = s.size() - offset;
+
+  // fast path
+  if (remaining >= 8) {
+    uint64_t val;
+    memcpy(&val, s.data() + offset, sizeof(val));
+    if (port::kLittleEndian) {
+      return EndianSwapValue(val);
+    }
+    return val;
+  }
+
+  uint64_t val = 0;
+  for (size_t i = 0; i < remaining; i++) {
+    val = (val << 8) | static_cast<uint8_t>(s.data()[offset + i]);
+  }
+  if (remaining > 0) {
+    val <<= (8 - remaining) * 8;  // Pad zeros on the right
+  }
+  return val;
+}
+
+}  // namespace ROCKSDB_NAMESPACE

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

@@ -9,51 +9,94 @@
 
 #include "table/block_based/data_block_footer.h"
 
-#include "rocksdb/table.h"
+#include "util/coding.h"
 
 namespace ROCKSDB_NAMESPACE {
 
-const int kDataBlockIndexTypeBitShift = 31;
+// Hash index bit (bit 31)
+constexpr uint32_t kHashIndexBit = 1u << 31;
+// Uniform keys bit (bit 29) - indicates keys are uniformly distributed
+constexpr uint32_t kUniformKeysBit = 1u << 29;
+// Separated KV storage bit (bit 28)
+constexpr uint32_t kSeparatedKVBit = 1u << 28;
 
-// 0x7FFFFFFF
-const uint32_t kMaxNumRestarts = (1u << kDataBlockIndexTypeBitShift) - 1u;
+void DataBlockFooter::EncodeTo(std::string* dst) const {
+  assert(num_restarts <= kMaxNumRestarts);
 
-// 0x7FFFFFFF
-const uint32_t kNumRestartsMask = (1u << kDataBlockIndexTypeBitShift) - 1u;
-
-uint32_t PackIndexTypeAndNumRestarts(
-    BlockBasedTableOptions::DataBlockIndexType index_type,
-    uint32_t num_restarts) {
-  if (num_restarts > kMaxNumRestarts) {
-    assert(0);  // mute travis "unused" warning
+  // If separated KV, write the values_section_offset before the packed footer
+  if (separated_kv) {
+    PutFixed32(dst, values_section_offset);
   }
 
-  uint32_t block_footer = num_restarts;
+  uint32_t packed = num_restarts;
   if (index_type == BlockBasedTableOptions::kDataBlockBinaryAndHash) {
-    block_footer |= 1u << kDataBlockIndexTypeBitShift;
-  } else if (index_type != BlockBasedTableOptions::kDataBlockBinarySearch) {
-    assert(0);
+    packed |= kHashIndexBit;
+  } else {
+    assert(index_type == BlockBasedTableOptions::kDataBlockBinarySearch);
+  }
+  if (separated_kv) {
+    packed |= kSeparatedKVBit;
+  }
+  if (is_uniform) {
+    packed |= kUniformKeysBit;
   }
 
-  return block_footer;
+  PutFixed32(dst, packed);
 }
 
-void UnPackIndexTypeAndNumRestarts(
-    uint32_t block_footer,
-    BlockBasedTableOptions::DataBlockIndexType* index_type,
-    uint32_t* num_restarts) {
-  if (index_type) {
-    if (block_footer & 1u << kDataBlockIndexTypeBitShift) {
-      *index_type = BlockBasedTableOptions::kDataBlockBinaryAndHash;
-    } else {
-      *index_type = BlockBasedTableOptions::kDataBlockBinarySearch;
-    }
+Status DataBlockFooter::DecodeFrom(Slice* input) {
+  if (input->size() < kMinEncodedLength) {
+    return Status::Corruption("Block too small for footer");
+  }
+
+  // Decode from the end of the input
+  const char* footer_ptr = input->data() + input->size() - sizeof(uint32_t);
+  uint32_t packed = DecodeFixed32(footer_ptr);
+
+  if (packed & kHashIndexBit) {
+    index_type = BlockBasedTableOptions::kDataBlockBinaryAndHash;
+    packed &= ~kHashIndexBit;
+  } else {
+    index_type = BlockBasedTableOptions::kDataBlockBinarySearch;
+  }
+
+  if (packed & kSeparatedKVBit) {
+    separated_kv = true;
+    packed &= ~kSeparatedKVBit;
+  } else {
+    separated_kv = false;
   }
 
-  if (num_restarts) {
-    *num_restarts = block_footer & kNumRestartsMask;
-    assert(*num_restarts <= kMaxNumRestarts);
+  if (packed & kUniformKeysBit) {
+    is_uniform = true;
+    packed &= ~kUniformKeysBit;
+  } else {
+    is_uniform = false;
   }
+
+  // Check for reserved/unrecognized feature bits (anything beyond
+  // kMaxNumRestarts)
+  if (packed > kMaxNumRestarts) {
+    return Status::Corruption(
+        "Unrecognized feature in block footer (reserved bits set)");
+  }
+
+  num_restarts = packed;
+
+  input->remove_suffix(sizeof(uint32_t));
+
+  // If separated KV, read values_section_offset from before the packed footer
+  if (separated_kv) {
+    if (input->size() < sizeof(uint32_t)) {
+      return Status::Corruption(
+          "Block too small for separated KV values section offset");
+    }
+    values_section_offset =
+        DecodeFixed32(input->data() + input->size() - sizeof(uint32_t));
+    input->remove_suffix(sizeof(uint32_t));
+  }
+
+  return Status::OK();
 }
 
 }  // namespace ROCKSDB_NAMESPACE

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

@@ -9,17 +9,84 @@
 
 #pragma once
 
+#include <cstdint>
+#include <string>
+
+#include "rocksdb/slice.h"
+#include "rocksdb/status.h"
 #include "rocksdb/table.h"
 
 namespace ROCKSDB_NAMESPACE {
 
-uint32_t PackIndexTypeAndNumRestarts(
-    BlockBasedTableOptions::DataBlockIndexType index_type,
-    uint32_t num_restarts);
+// DataBlockFooter represents the footer of a data block, containing metadata
+// about the block's structure and features.
+//
+// Current encoding (may expand in future format versions):
+// - A single uint32_t where:
+//   - The low 28 bits store the number of restart points (num_restarts)
+//   - The high 4 bits are reserved for metadata/features:
+//     - Bit 31: Hash index present (kDataBlockBinaryAndHash)
+//     - Bit 30: IMPORTANT: Cannot be used without format version bump.
+//     - Bit 29: Uniform keys flag (for kAuto index block search)
+//     - Bit 28: Separated KV storage (keys and values stored in separate
+//       sections within the block)
+//
+// Note on forward compatibility: Bits 28-29 can be read by older versions of
+// RocksDB and interpreted as an extremely large, which will be caught as a
+// corruption. Bit 30 is special because num_restarts is multipled by 4, causing
+// overflow and the corruption check to be silently ignored
+// (https://github.com/facebook/rocksdb/blob/10.11.fb/table/block_based/block.cc#L1070-L1103)
+//
+// When separated KV is enabled, an additional uint32_t is prepended before the
+// packed footer, storing the offset to the values section within the block.
+//
+// When any unrecognized reserved bit is set, DecodeFrom() returns an error,
+// allowing older versions to fail gracefully on newer formats.
+//
+// The encoding size is not fixed - future format versions may expand it.
+// Use kMaxEncodedLength for buffer sizing.
+struct DataBlockFooter {
+  // Maximum number of restarts that can be stored (2^28 - 1 = 268,435,455).
+  // This reserves the top 4 bits for metadata (bit 31 for hash index, bits
+  // 28-30 for future features). For historical compatibility purposes, the
+  // limit is adequate because a 4GiB block (maximum due to 32-bit block size)
+  // with restart_interval=1 and minimum entries (12 bytes: 3 varint bytes +
+  // 9-byte internal key + empty value) plus 4-byte restart offsets = 16 bytes
+  // per restart, fits at most (2^32 - 4) / 16 ≈ 268 million restarts.
+  static constexpr uint32_t kMaxNumRestarts = (1u << 28) - 1;
+
+  // Maximum encoded length of a DataBlockFooter (for buffer sizing).
+  // 8 bytes when separated KV is enabled (values_section_offset + packed),
+  // 4 bytes otherwise.
+  static constexpr uint32_t kMaxEncodedLength = 2 * sizeof(uint32_t);
+
+  // Minimum encoded length (for current format version)
+  static constexpr uint32_t kMinEncodedLength = sizeof(uint32_t);
+
+  BlockBasedTableOptions::DataBlockIndexType index_type =
+      BlockBasedTableOptions::kDataBlockBinarySearch;
+
+  // Whether the block uses separated KV storage (keys and values in separate
+  // sections). When true, values_section_offset indicates where the values
+  // section begins within the block data.
+  bool separated_kv = false;
+  uint32_t values_section_offset = 0;
+
+  uint32_t num_restarts = 0;
+  bool is_uniform = false;
+
+  DataBlockFooter() = default;
+  DataBlockFooter(BlockBasedTableOptions::DataBlockIndexType _index_type,
+                  uint32_t _num_restarts)
+      : index_type(_index_type), num_restarts(_num_restarts) {}
+
+  // Appends the encoded footer to dst.
+  void EncodeTo(std::string* dst) const;
 
-void UnPackIndexTypeAndNumRestarts(
-    uint32_t block_footer,
-    BlockBasedTableOptions::DataBlockIndexType* index_type,
-    uint32_t* num_restarts);
+  // Decodes a footer from the end of input (consumes bytes from the end).
+  // Returns an error if reserved/unrecognized feature bits are set.
+  // On success, advances input to exclude the consumed footer bytes.
+  Status DecodeFrom(Slice* input);
+};
 
 }  // namespace ROCKSDB_NAMESPACE

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

@@ -122,7 +122,7 @@ class DataBlockHashIndex {
 
   uint8_t Lookup(const char* data, uint32_t map_offset, const Slice& key) const;
 
-  inline bool Valid() { return num_buckets_ != 0; }
+  inline bool Valid() const { return num_buckets_ != 0; }
 
  private:
   // To make the serialized hash index compact and to save the space overhead,

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

@@ -29,7 +29,7 @@ IndexBuilder* IndexBuilder::CreateIndexBuilder(
     const InternalKeySliceTransform* int_key_slice_transform,
     const bool use_value_delta_encoding,
     const BlockBasedTableOptions& table_opt, size_t ts_sz,
-    const bool persist_user_defined_timestamps) {
+    const bool persist_user_defined_timestamps, Statistics* statistics) {
   IndexBuilder* result = nullptr;
   switch (index_type) {
     case BlockBasedTableOptions::kBinarySearch: {
@@ -37,7 +37,8 @@ IndexBuilder* IndexBuilder::CreateIndexBuilder(
           comparator, table_opt.index_block_restart_interval,
           table_opt.format_version, use_value_delta_encoding,
           table_opt.index_shortening, /* include_first_key */ false, ts_sz,
-          persist_user_defined_timestamps);
+          persist_user_defined_timestamps, statistics,
+          table_opt.uniform_cv_threshold);
       break;
     }
     case BlockBasedTableOptions::kHashSearch: {
@@ -48,7 +49,7 @@ IndexBuilder* IndexBuilder::CreateIndexBuilder(
           comparator, int_key_slice_transform,
           table_opt.index_block_restart_interval, table_opt.format_version,
           use_value_delta_encoding, table_opt.index_shortening, ts_sz,
-          persist_user_defined_timestamps);
+          persist_user_defined_timestamps, table_opt.uniform_cv_threshold);
       break;
     }
     case BlockBasedTableOptions::kTwoLevelIndexSearch: {
@@ -62,11 +63,12 @@ IndexBuilder* IndexBuilder::CreateIndexBuilder(
           comparator, table_opt.index_block_restart_interval,
           table_opt.format_version, use_value_delta_encoding,
           table_opt.index_shortening, /* include_first_key */ true, ts_sz,
-          persist_user_defined_timestamps);
+          persist_user_defined_timestamps, statistics,
+          table_opt.uniform_cv_threshold);
       break;
     }
     default: {
-      assert(!"Do not recognize the index type ");
+      assert(false && "Do not recognize the index type ");
       break;
     }
   }
@@ -135,30 +137,32 @@ PartitionedIndexBuilder* PartitionedIndexBuilder::CreateIndexBuilder(
     const InternalKeyComparator* comparator,
     const bool use_value_delta_encoding,
     const BlockBasedTableOptions& table_opt, size_t ts_sz,
-    const bool persist_user_defined_timestamps) {
-  return new PartitionedIndexBuilder(comparator, table_opt,
-                                     use_value_delta_encoding, ts_sz,
-                                     persist_user_defined_timestamps);
+    const bool persist_user_defined_timestamps, Statistics* statistics) {
+  return new PartitionedIndexBuilder(
+      comparator, table_opt, use_value_delta_encoding, ts_sz,
+      persist_user_defined_timestamps, statistics);
 }
 
 PartitionedIndexBuilder::PartitionedIndexBuilder(
     const InternalKeyComparator* comparator,
     const BlockBasedTableOptions& table_opt,
     const bool use_value_delta_encoding, size_t ts_sz,
-    const bool persist_user_defined_timestamps)
+    const bool persist_user_defined_timestamps, Statistics* statistics)
     : IndexBuilder(comparator, ts_sz, persist_user_defined_timestamps),
       index_block_builder_(
           table_opt.index_block_restart_interval, true /*use_delta_encoding*/,
           use_value_delta_encoding,
           BlockBasedTableOptions::kDataBlockBinarySearch /* index_type */,
           0.75 /* data_block_hash_table_util_ratio */, ts_sz,
-          persist_user_defined_timestamps, false /* is_user_key */),
+          persist_user_defined_timestamps, false /* is_user_key */,
+          /*use_separated_kv_storage=*/false),
       index_block_builder_without_seq_(
           table_opt.index_block_restart_interval, true /*use_delta_encoding*/,
           use_value_delta_encoding,
           BlockBasedTableOptions::kDataBlockBinarySearch /* index_type */,
           0.75 /* data_block_hash_table_util_ratio */, ts_sz,
-          persist_user_defined_timestamps, true /* is_user_key */),
+          persist_user_defined_timestamps, true /* is_user_key */,
+          /*use_separated_kv_storage=*/false),
       table_opt_(table_opt),
       // We start by false. After each partition we revise the value based on
       // what the sub_index_builder has decided. If the feature is disabled
@@ -167,7 +171,8 @@ PartitionedIndexBuilder::PartitionedIndexBuilder(
       // sub_index_builders could not safely exclude seq from the keys, then it
       // wil be enforced on all sub_index_builders on ::Finish.
       must_use_separator_with_seq_(false),
-      use_value_delta_encoding_(use_value_delta_encoding) {
+      use_value_delta_encoding_(use_value_delta_encoding),
+      statistics_(statistics) {
   MakeNewSubIndexBuilder();
 }
 
@@ -176,7 +181,8 @@ void PartitionedIndexBuilder::MakeNewSubIndexBuilder() {
       comparator_, table_opt_.index_block_restart_interval,
       table_opt_.format_version, use_value_delta_encoding_,
       table_opt_.index_shortening, /* include_first_key */ false, ts_sz_,
-      persist_user_defined_timestamps_);
+      persist_user_defined_timestamps_, statistics_,
+      table_opt_.uniform_cv_threshold);
   sub_index_builder_ = new_builder.get();
   // Start next partition entry, where we will modify the key
   entries_.push_back({{}, std::move(new_builder)});

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

@@ -20,6 +20,7 @@
 #include "table/block_based/block_builder.h"
 #include "table/block_based/flush_block_policy_impl.h"
 #include "table/format.h"
+#include "util/atomic.h"
 
 namespace ROCKSDB_NAMESPACE {
 // The interface for building index.
@@ -39,7 +40,8 @@ class IndexBuilder {
       const InternalKeyComparator* comparator,
       const InternalKeySliceTransform* int_key_slice_transform,
       bool use_value_delta_encoding, const BlockBasedTableOptions& table_opt,
-      size_t ts_sz, bool persist_user_defined_timestamps);
+      size_t ts_sz, bool persist_user_defined_timestamps,
+      Statistics* statistics = nullptr);
 
   // Index builder will construct a set of blocks which contain:
   //  1. One primary index block.
@@ -226,20 +228,25 @@ class ShortenedIndexBuilder : public IndexBuilder {
       const bool use_value_delta_encoding,
       BlockBasedTableOptions::IndexShorteningMode shortening_mode,
       bool include_first_key, size_t ts_sz,
-      const bool persist_user_defined_timestamps)
+      const bool persist_user_defined_timestamps, Statistics* statistics,
+      double uniform_cv_threshold)
       : IndexBuilder(comparator, ts_sz, persist_user_defined_timestamps),
         index_block_builder_(
             index_block_restart_interval, true /*use_delta_encoding*/,
             use_value_delta_encoding,
             BlockBasedTableOptions::kDataBlockBinarySearch /* index_type */,
             0.75 /* data_block_hash_table_util_ratio */, ts_sz,
-            persist_user_defined_timestamps, false /* is_user_key */),
+            persist_user_defined_timestamps, false /* is_user_key */,
+            false /* use_separated_kv_storage */, statistics,
+            uniform_cv_threshold),
         index_block_builder_without_seq_(
             index_block_restart_interval, true /*use_delta_encoding*/,
             use_value_delta_encoding,
             BlockBasedTableOptions::kDataBlockBinarySearch /* index_type */,
             0.75 /* data_block_hash_table_util_ratio */, ts_sz,
-            persist_user_defined_timestamps, true /* is_user_key */),
+            persist_user_defined_timestamps, true /* is_user_key */,
+            false /* use_separated_kv_storage */, statistics,
+            uniform_cv_threshold),
         use_value_delta_encoding_(use_value_delta_encoding),
         include_first_key_(include_first_key),
         shortening_mode_(shortening_mode) {
@@ -513,12 +520,14 @@ class HashIndexBuilder : public IndexBuilder {
                    int index_block_restart_interval, int format_version,
                    bool use_value_delta_encoding,
                    BlockBasedTableOptions::IndexShorteningMode shortening_mode,
-                   size_t ts_sz, const bool persist_user_defined_timestamps)
+                   size_t ts_sz, const bool persist_user_defined_timestamps,
+                   double uniform_cv_threshold)
       : IndexBuilder(comparator, ts_sz, persist_user_defined_timestamps),
         primary_index_builder_(comparator, index_block_restart_interval,
                                format_version, use_value_delta_encoding,
                                shortening_mode, /* include_first_key */ false,
-                               ts_sz, persist_user_defined_timestamps),
+                               ts_sz, persist_user_defined_timestamps,
+                               nullptr /* statistics */, uniform_cv_threshold),
         hash_key_extractor_(hash_key_extractor) {}
 
   Slice AddIndexEntry(const Slice& last_key_in_current_block,
@@ -608,10 +617,9 @@ class HashIndexBuilder : public IndexBuilder {
   void FlushPendingPrefix() {
     prefix_block_.append(pending_entry_prefix_.data(),
                          pending_entry_prefix_.size());
-    PutVarint32Varint32Varint32(
-        &prefix_meta_block_,
-        static_cast<uint32_t>(pending_entry_prefix_.size()),
-        pending_entry_index_, pending_block_num_);
+    PutVarint32(&prefix_meta_block_,
+                static_cast<uint32_t>(pending_entry_prefix_.size()),
+                pending_entry_index_, pending_block_num_);
   }
 
   ShortenedIndexBuilder primary_index_builder_;
@@ -647,12 +655,13 @@ class PartitionedIndexBuilder : public IndexBuilder {
   static PartitionedIndexBuilder* CreateIndexBuilder(
       const InternalKeyComparator* comparator, bool use_value_delta_encoding,
       const BlockBasedTableOptions& table_opt, size_t ts_sz,
-      bool persist_user_defined_timestamps);
+      bool persist_user_defined_timestamps, Statistics* statistics = nullptr);
 
   PartitionedIndexBuilder(const InternalKeyComparator* comparator,
                           const BlockBasedTableOptions& table_opt,
                           bool use_value_delta_encoding, size_t ts_sz,
-                          bool persist_user_defined_timestamps);
+                          bool persist_user_defined_timestamps,
+                          Statistics* statistics = nullptr);
 
   Slice AddIndexEntry(const Slice& last_key_in_current_block,
                       const Slice* first_key_in_next_block,
@@ -745,6 +754,7 @@ class PartitionedIndexBuilder : public IndexBuilder {
   // true if it should cut the next filter partition block
   bool cut_filter_block = false;
   BlockHandle last_encoded_handle_;
+  Statistics* statistics_;
   // Cached estimate of current index size, updated when data blocks are added
   RelaxedAtomic<uint64_t> estimated_index_size_{0};
   // Running estimate of completed partitions total size

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

@@ -32,7 +32,7 @@ class MockBlockBasedTableTester {
 
   explicit MockBlockBasedTableTester(const FilterPolicy* filter_policy)
       : MockBlockBasedTableTester(
-            std::shared_ptr<const FilterPolicy>(filter_policy)){};
+            std::shared_ptr<const FilterPolicy>(filter_policy)) {};
 
   explicit MockBlockBasedTableTester(
       std::shared_ptr<const FilterPolicy> filter_policy)