@nxtedition/rocksdb 7.1.30 → 7.1.32

package/deps/rocksdb/rocksdb/table/cuckoo/cuckoo_table_reader_test.cc

@@ -33,11 +33,12 @@ int main() {
 
 using GFLAGS_NAMESPACE::ParseCommandLineFlags;
 
-DEFINE_string(file_dir, "", "Directory where the files will be created"
-    " for benchmark. Added for using tmpfs.");
+DEFINE_string(file_dir, "",
+              "Directory where the files will be created"
+              " for benchmark. Added for using tmpfs.");
 DEFINE_bool(enable_perf, false, "Run Benchmark Tests too.");
 DEFINE_bool(write, false,
-    "Should write new values to file in performance tests?");
+            "Should write new values to file in performance tests?");
 DEFINE_bool(identity_as_first_hash, true, "use identity as first hash");
 
 namespace ROCKSDB_NAMESPACE {
@@ -45,10 +46,10 @@ namespace ROCKSDB_NAMESPACE {
 namespace {
 const uint32_t kNumHashFunc = 10;
 // Methods, variables related to Hash functions.
-std::unordered_map<std::string, std::vector<uint64_t>> hash_map;
+std::unordered_map<std::string, std::vector<uint64_t> > hash_map;
 
 void AddHashLookups(const std::string& s, uint64_t bucket_id,
-        uint32_t num_hash_fun) {
+                    uint32_t num_hash_fun) {
   std::vector<uint64_t> v;
   for (uint32_t i = 0; i < num_hash_fun; i++) {
     v.push_back(bucket_id + i);
@@ -128,8 +129,8 @@ class CuckooReaderTest : public testing::Test {
   }
   void UpdateKeys(bool with_zero_seqno) {
     for (uint32_t i = 0; i < num_items; i++) {
-      ParsedInternalKey ikey(user_keys[i],
-          with_zero_seqno ? 0 : i + 1000, kTypeValue);
+      ParsedInternalKey ikey(user_keys[i], with_zero_seqno ? 0 : i + 1000,
+                             kTypeValue);
       keys[i].clear();
       AppendInternalKey(&keys[i], ikey);
     }
@@ -189,11 +190,11 @@ class CuckooReaderTest : public testing::Test {
                             TableReaderCaller::kUncategorized);
     ASSERT_OK(it->status());
     ASSERT_TRUE(!it->Valid());
-    it->Seek(keys[num_items/2]);
+    it->Seek(keys[num_items / 2]);
     ASSERT_TRUE(it->Valid());
     ASSERT_OK(it->status());
-    ASSERT_TRUE(keys[num_items/2] == it->key());
-    ASSERT_TRUE(values[num_items/2] == it->value());
+    ASSERT_TRUE(keys[num_items / 2] == it->key());
+    ASSERT_TRUE(values[num_items / 2] == it->value());
     ASSERT_OK(it->status());
     it->~InternalIterator();
   }
@@ -273,7 +274,7 @@ TEST_F(CuckooReaderTest, WhenKeyExistsWithUint64Comparator) {
 }
 
 TEST_F(CuckooReaderTest, CheckIterator) {
-  SetUp(2*kNumHashFunc);
+  SetUp(2 * kNumHashFunc);
   fname = test::PerThreadDBPath("CuckooReader_CheckIterator");
   for (uint64_t i = 0; i < num_items; i++) {
     user_keys[i] = "key" + NumToStr(i);
@@ -281,7 +282,7 @@ TEST_F(CuckooReaderTest, CheckIterator) {
     AppendInternalKey(&keys[i], ikey);
     values[i] = "value" + NumToStr(i);
     // Give disjoint hash values, in reverse order.
-    AddHashLookups(user_keys[i], num_items-i-1, kNumHashFunc);
+    AddHashLookups(user_keys[i], num_items - i - 1, kNumHashFunc);
   }
   CreateCuckooFileAndCheckReader();
   CheckIterator();
@@ -292,7 +293,7 @@ TEST_F(CuckooReaderTest, CheckIterator) {
 }
 
 TEST_F(CuckooReaderTest, CheckIteratorUint64) {
-  SetUp(2*kNumHashFunc);
+  SetUp(2 * kNumHashFunc);
   fname = test::PerThreadDBPath("CuckooReader_CheckIterator");
   for (uint64_t i = 0; i < num_items; i++) {
     user_keys[i].resize(8);
@@ -301,7 +302,7 @@ TEST_F(CuckooReaderTest, CheckIteratorUint64) {
     AppendInternalKey(&keys[i], ikey);
     values[i] = "value" + NumToStr(i);
     // Give disjoint hash values, in reverse order.
-    AddHashLookups(user_keys[i], num_items-i-1, kNumHashFunc);
+    AddHashLookups(user_keys[i], num_items - i - 1, kNumHashFunc);
   }
   CreateCuckooFileAndCheckReader(test::Uint64Comparator());
   CheckIterator(test::Uint64Comparator());
@@ -366,11 +367,11 @@ TEST_F(CuckooReaderTest, WhenKeyNotFound) {
 
   // Test read when key is unused key.
   std::string unused_key =
-    reader.GetTableProperties()->user_collected_properties.at(
-    CuckooTablePropertyNames::kEmptyKey);
+      reader.GetTableProperties()->user_collected_properties.at(
+          CuckooTablePropertyNames::kEmptyKey);
   // Add hash values that map to empty buckets.
-  AddHashLookups(ExtractUserKey(unused_key).ToString(),
-      kNumHashFunc, kNumHashFunc);
+  AddHashLookups(ExtractUserKey(unused_key).ToString(), kNumHashFunc,
+                 kNumHashFunc);
   value.Reset();
   GetContext get_context3(
       ucmp, nullptr, nullptr, nullptr, GetContext::kNotFound, Slice(unused_key),
@@ -407,8 +408,8 @@ std::string GetFileName(uint64_t num) {
 
 // Create last level file as we are interested in measuring performance of
 // last level file only.
-void WriteFile(const std::vector<std::string>& keys,
-    const uint64_t num, double hash_ratio) {
+void WriteFile(const std::vector<std::string>& keys, const uint64_t num,
+               double hash_ratio) {
   Options options;
   options.allow_mmap_reads = true;
   const auto& fs = options.env->GetFileSystem();
@@ -478,13 +479,16 @@ void ReadKeys(uint64_t num, uint32_t batch_size) {
                            test::Uint64Comparator(), nullptr);
   ASSERT_OK(reader.status());
   const UserCollectedProperties user_props =
-    reader.GetTableProperties()->user_collected_properties;
+      reader.GetTableProperties()->user_collected_properties;
   const uint32_t num_hash_fun = *reinterpret_cast<const uint32_t*>(
       user_props.at(CuckooTablePropertyNames::kNumHashFunc).data());
   const uint64_t table_size = *reinterpret_cast<const uint64_t*>(
       user_props.at(CuckooTablePropertyNames::kHashTableSize).data());
-  fprintf(stderr, "With %" PRIu64 " items, utilization is %.2f%%, number of"
-      " hash functions: %u.\n", num, num * 100.0 / (table_size), num_hash_fun);
+  fprintf(stderr,
+          "With %" PRIu64
+          " items, utilization is %.2f%%, number of"
+          " hash functions: %u.\n",
+          num, num * 100.0 / (table_size), num_hash_fun);
   ReadOptions r_options;
 
   std::vector<uint64_t> keys;
@@ -502,10 +506,10 @@ void ReadKeys(uint64_t num, uint32_t batch_size) {
   uint64_t start_time = env->NowMicros();
   if (batch_size > 0) {
     for (uint64_t i = 0; i < num; i += batch_size) {
-      for (uint64_t j = i; j < i+batch_size && j < num; ++j) {
+      for (uint64_t j = i; j < i + batch_size && j < num; ++j) {
         reader.Prepare(Slice(reinterpret_cast<char*>(&keys[j]), 16));
       }
-      for (uint64_t j = i; j < i+batch_size && j < num; ++j) {
+      for (uint64_t j = i; j < i + batch_size && j < num; ++j) {
         reader.Get(r_options, Slice(reinterpret_cast<char*>(&keys[j]), 16),
                    &get_context, nullptr);
       }
@@ -518,8 +522,8 @@ void ReadKeys(uint64_t num, uint32_t batch_size) {
   }
   float time_per_op = (env->NowMicros() - start_time) * 1.0f / num;
   fprintf(stderr,
-      "Time taken per op is %.3fus (%.1f Mqps) with batch size of %u\n",
-      time_per_op, 1.0 / time_per_op, batch_size);
+          "Time taken per op is %.3fus (%.1f Mqps) with batch size of %u\n",
+          time_per_op, 1.0 / time_per_op, batch_size);
 }
 }  // namespace.
 
@@ -531,10 +535,11 @@ TEST_F(CuckooReaderTest, TestReadPerformance) {
   // These numbers are chosen to have a hash utilization % close to
   // 0.9, 0.75, 0.6 and 0.5 respectively.
   // They all create 128 M buckets.
-  std::vector<uint64_t> nums = {120*1024*1024, 100*1024*1024, 80*1024*1024,
-    70*1024*1024};
+  std::vector<uint64_t> nums = {120 * 1024 * 1024, 100 * 1024 * 1024,
+                                80 * 1024 * 1024, 70 * 1024 * 1024};
 #ifndef NDEBUG
-  fprintf(stdout,
+  fprintf(
+      stdout,
       "WARNING: Not compiled with DNDEBUG. Performance tests may be slow.\n");
 #endif
   for (uint64_t num : nums) {

package/deps/rocksdb/rocksdb/table/get_context.cc

@@ -407,7 +407,9 @@ bool GetContext::SaveValue(const ParsedInternalKey& parsed_key,
           state_ = kDeleted;
         } else if (kMerge == state_) {
           state_ = kFound;
-          Merge(nullptr);
+          if (do_merge_) {
+            Merge(nullptr);
+          }
           // If do_merge_ = false then the current value shouldn't be part of
           // merge_context_->operand_list
         }
@@ -438,16 +440,20 @@ bool GetContext::SaveValue(const ParsedInternalKey& parsed_key,
 }
 
 void GetContext::Merge(const Slice* value) {
+  assert(do_merge_);
+  assert(!pinnable_val_ || !columns_);
+
+  const Status s = MergeHelper::TimedFullMerge(
+      merge_operator_, user_key_, value, merge_context_->GetOperands(),
+      pinnable_val_ ? pinnable_val_->GetSelf() : nullptr, columns_, logger_,
+      statistics_, clock_);
+  if (!s.ok()) {
+    state_ = kCorrupt;
+    return;
+  }
+
   if (LIKELY(pinnable_val_ != nullptr)) {
-    if (do_merge_) {
-      Status merge_status = MergeHelper::TimedFullMerge(
-          merge_operator_, user_key_, value, merge_context_->GetOperands(),
-          pinnable_val_->GetSelf(), logger_, statistics_, clock_);
-      pinnable_val_->PinSelf();
-      if (!merge_status.ok()) {
-        state_ = kCorrupt;
-      }
-    }
+    pinnable_val_->PinSelf();
   }
 }
 

package/deps/rocksdb/rocksdb/table/iter_heap.h

@@ -21,6 +21,7 @@ class MaxIteratorComparator {
   bool operator()(IteratorWrapper* a, IteratorWrapper* b) const {
     return comparator_->Compare(a->key(), b->key()) < 0;
   }
+
  private:
   const InternalKeyComparator* comparator_;
 };
@@ -35,6 +36,7 @@ class MinIteratorComparator {
   bool operator()(IteratorWrapper* a, IteratorWrapper* b) const {
     return comparator_->Compare(a->key(), b->key()) > 0;
   }
+
  private:
   const InternalKeyComparator* comparator_;
 };

package/deps/rocksdb/rocksdb/table/iterator.cc

@@ -29,7 +29,7 @@ Status Iterator::GetProperty(std::string prop_name, std::string* prop) {
 namespace {
 class EmptyIterator : public Iterator {
  public:
-  explicit EmptyIterator(const Status& s) : status_(s) { }
+  explicit EmptyIterator(const Status& s) : status_(s) {}
   bool Valid() const override { return false; }
   void Seek(const Slice& /*target*/) override {}
   void SeekForPrev(const Slice& /*target*/) override {}

package/deps/rocksdb/rocksdb/table/iterator_wrapper.h

@@ -145,9 +145,7 @@ class IteratorWrapperBase {
     return iter_->IsValuePinned();
   }
 
-  bool IsValuePrepared() const {
-    return result_.value_prepared;
-  }
+  bool IsValuePrepared() const { return result_.value_prepared; }
 
   Slice user_key() const {
     assert(Valid());

package/deps/rocksdb/rocksdb/table/merging_iterator.cc

@@ -197,7 +197,8 @@ class MergingIterator : public InternalIterator {
   // Add range_tombstone_iters_[level] into min heap.
   // Updates active_ if the end key of a range tombstone is inserted.
   // @param start_key specifies which end point of the range tombstone to add.
-  void InsertRangeTombstoneToMinHeap(size_t level, bool start_key = true) {
+  void InsertRangeTombstoneToMinHeap(size_t level, bool start_key = true,
+                                     bool replace_top = false) {
     assert(!range_tombstone_iters_.empty() &&
            range_tombstone_iters_[level]->Valid());
     if (start_key) {
@@ -211,13 +212,18 @@ class MergingIterator : public InternalIterator {
       pinned_heap_item_[level].type = HeapItem::DELETE_RANGE_END;
       active_.insert(level);
     }
-    minHeap_.push(&pinned_heap_item_[level]);
+    if (replace_top) {
+      minHeap_.replace_top(&pinned_heap_item_[level]);
+    } else {
+      minHeap_.push(&pinned_heap_item_[level]);
+    }
   }
 
   // Add range_tombstone_iters_[level] into max heap.
   // Updates active_ if the start key of a range tombstone is inserted.
   // @param end_key specifies which end point of the range tombstone to add.
-  void InsertRangeTombstoneToMaxHeap(size_t level, bool end_key = true) {
+  void InsertRangeTombstoneToMaxHeap(size_t level, bool end_key = true,
+                                     bool replace_top = false) {
     assert(!range_tombstone_iters_.empty() &&
            range_tombstone_iters_[level]->Valid());
     if (end_key) {
@@ -231,7 +237,11 @@ class MergingIterator : public InternalIterator {
       pinned_heap_item_[level].type = HeapItem::DELETE_RANGE_START;
       active_.insert(level);
     }
-    maxHeap_->push(&pinned_heap_item_[level]);
+    if (replace_top) {
+      maxHeap_->replace_top(&pinned_heap_item_[level]);
+    } else {
+      maxHeap_->push(&pinned_heap_item_[level]);
+    }
   }
 
   // Remove HeapItems from top of minHeap_ that are of type DELETE_RANGE_START
@@ -241,10 +251,9 @@ class MergingIterator : public InternalIterator {
   void PopDeleteRangeStart() {
     while (!minHeap_.empty() &&
            minHeap_.top()->type == HeapItem::DELETE_RANGE_START) {
-      auto level = minHeap_.top()->level;
-      minHeap_.pop();
       // insert end key of this range tombstone and updates active_
-      InsertRangeTombstoneToMinHeap(level, false /* start_key */);
+      InsertRangeTombstoneToMinHeap(
+          minHeap_.top()->level, false /* start_key */, true /* replace_top */);
     }
   }
 
@@ -255,10 +264,9 @@ class MergingIterator : public InternalIterator {
   void PopDeleteRangeEnd() {
     while (!maxHeap_->empty() &&
            maxHeap_->top()->type == HeapItem::DELETE_RANGE_END) {
-      auto level = maxHeap_->top()->level;
-      maxHeap_->pop();
       // insert start key of this range tombstone and updates active_
-      InsertRangeTombstoneToMaxHeap(level, false /* end_key */);
+      InsertRangeTombstoneToMaxHeap(maxHeap_->top()->level, false /* end_key */,
+                                    true /* replace_top */);
     }
   }
 
@@ -766,13 +774,15 @@ bool MergingIterator::SkipNextDeleted() {
   // - range deletion end key
   auto current = minHeap_.top();
   if (current->type == HeapItem::DELETE_RANGE_END) {
-    minHeap_.pop();
     active_.erase(current->level);
     assert(range_tombstone_iters_[current->level] &&
            range_tombstone_iters_[current->level]->Valid());
     range_tombstone_iters_[current->level]->Next();
     if (range_tombstone_iters_[current->level]->Valid()) {
-      InsertRangeTombstoneToMinHeap(current->level);
+      InsertRangeTombstoneToMinHeap(current->level, true /* start_key */,
+                                    true /* replace_top */);
+    } else {
+      minHeap_.pop();
     }
     return true /* current key deleted */;
   }
@@ -810,7 +820,8 @@ bool MergingIterator::SkipNextDeleted() {
   // Point key case: check active_ for range tombstone coverage.
   ParsedInternalKey pik;
   ParseInternalKey(current->iter.key(), &pik, false).PermitUncheckedError();
-  for (auto& i : active_) {
+  if (!active_.empty()) {
+    auto i = *active_.begin();
     if (i < current->level) {
       // range tombstone is from a newer level, definitely covers
       assert(comparator_->Compare(range_tombstone_iters_[i]->start_key(),
@@ -981,13 +992,15 @@ bool MergingIterator::SkipPrevDeleted() {
   // - range deletion start key
   auto current = maxHeap_->top();
   if (current->type == HeapItem::DELETE_RANGE_START) {
-    maxHeap_->pop();
     active_.erase(current->level);
     assert(range_tombstone_iters_[current->level] &&
            range_tombstone_iters_[current->level]->Valid());
     range_tombstone_iters_[current->level]->Prev();
     if (range_tombstone_iters_[current->level]->Valid()) {
-      InsertRangeTombstoneToMaxHeap(current->level);
+      InsertRangeTombstoneToMaxHeap(current->level, true /* end_key */,
+                                    true /* replace_top */);
+    } else {
+      maxHeap_->pop();
     }
     return true /* current key deleted */;
   }
@@ -1015,7 +1028,8 @@ bool MergingIterator::SkipPrevDeleted() {
   // Point key case: check active_ for range tombstone coverage.
   ParsedInternalKey pik;
   ParseInternalKey(current->iter.key(), &pik, false).PermitUncheckedError();
-  for (auto& i : active_) {
+  if (!active_.empty()) {
+    auto i = *active_.begin();
     if (i < current->level) {
       // range tombstone is from a newer level, definitely covers
       assert(comparator_->Compare(range_tombstone_iters_[i]->start_key(),
@@ -1054,6 +1068,7 @@ bool MergingIterator::SkipPrevDeleted() {
       return false /* current key not deleted */;
     }
   }
+
   assert(active_.empty());
   assert(maxHeap_->top()->type == HeapItem::ITERATOR);
   return false /* current key not deleted */;

package/deps/rocksdb/rocksdb/table/meta_blocks.cc

@@ -35,8 +35,7 @@ const std::string kRangeDelBlockName = "rocksdb.range_del";
 MetaIndexBuilder::MetaIndexBuilder()
     : meta_index_block_(new BlockBuilder(1 /* restart interval */)) {}
 
-void MetaIndexBuilder::Add(const std::string& key,
-                           const BlockHandle& handle) {
+void MetaIndexBuilder::Add(const std::string& key, const BlockHandle& handle) {
   std::string handle_encoding;
   handle.EncodeTo(&handle_encoding);
   meta_block_handles_.insert({key, handle_encoding});
@@ -173,8 +172,8 @@ void LogPropertiesCollectionError(Logger* info_log, const std::string& method,
   assert(method == "Add" || method == "Finish");
 
   std::string msg =
-    "Encountered error when calling TablePropertiesCollector::" +
-    method + "() with collector name: " + name;
+      "Encountered error when calling TablePropertiesCollector::" + method +
+      "() with collector name: " + name;
   ROCKS_LOG_ERROR(info_log, "%s", msg.c_str());
 }
 
@@ -346,8 +345,9 @@ Status ReadTablePropertiesHelper(
       if (!GetVarint64(&raw_val, &val)) {
         // skip malformed value
         auto error_msg =
-          "Detect malformed value in properties meta-block:"
-          "\tkey: " + key + "\tval: " + raw_val.ToString();
+            "Detect malformed value in properties meta-block:"
+            "\tkey: " +
+            key + "\tval: " + raw_val.ToString();
         ROCKS_LOG_ERROR(ioptions.logger, "%s", error_msg.c_str());
         continue;
       }

package/deps/rocksdb/rocksdb/table/multiget_context.h

@@ -123,8 +123,7 @@ class MultiGetContext {
     assert(num_keys <= MAX_BATCH_SIZE);
     if (num_keys > MAX_LOOKUP_KEYS_ON_STACK) {
       lookup_key_heap_buf.reset(new char[sizeof(LookupKey) * num_keys]);
-      lookup_key_ptr_ = reinterpret_cast<LookupKey*>(
-          lookup_key_heap_buf.get());
+      lookup_key_ptr_ = reinterpret_cast<LookupKey*>(lookup_key_heap_buf.get());
     }
 
     for (size_t iter = 0; iter != num_keys_; ++iter) {
@@ -157,8 +156,9 @@ class MultiGetContext {
 
  private:
   static const int MAX_LOOKUP_KEYS_ON_STACK = 16;
-  alignas(alignof(LookupKey))
-    char lookup_key_stack_buf[sizeof(LookupKey) * MAX_LOOKUP_KEYS_ON_STACK];
+  alignas(
+      alignof(LookupKey)) char lookup_key_stack_buf[sizeof(LookupKey) *
+                                                    MAX_LOOKUP_KEYS_ON_STACK];
   std::array<KeyContext*, MAX_BATCH_SIZE> sorted_keys_;
   size_t num_keys_;
   Mask value_mask_;
@@ -250,8 +250,7 @@ class MultiGetContext {
       size_t index_;
     };
 
-    Range(const Range& mget_range,
-          const Iterator& first,
+    Range(const Range& mget_range, const Iterator& first,
           const Iterator& last) {
       ctx_ = mget_range.ctx_;
       if (first == last) {

package/deps/rocksdb/rocksdb/table/persistent_cache_helper.cc

@@ -4,6 +4,7 @@
 //  (found in the LICENSE.Apache file in the root directory).
 
 #include "table/persistent_cache_helper.h"
+
 #include "table/block_based/block_based_table_reader.h"
 #include "table/format.h"
 

package/deps/rocksdb/rocksdb/table/plain/plain_table_bloom.cc

@@ -7,9 +7,9 @@
 
 #include <algorithm>
 #include <string>
-#include "util/dynamic_bloom.h"
 
 #include "memory/allocator.h"
+#include "util/dynamic_bloom.h"
 
 namespace ROCKSDB_NAMESPACE {
 

package/deps/rocksdb/rocksdb/table/plain/plain_table_builder.cc

@@ -82,8 +82,9 @@ PlainTableBuilder::PlainTableBuilder(
     index_builder_.reset(new PlainTableIndexBuilder(
         &arena_, ioptions, moptions.prefix_extractor.get(), index_sparseness,
         hash_table_ratio, huge_page_tlb_size_));
-    properties_.user_collected_properties
-        [PlainTablePropertyNames::kBloomVersion] = "1";  // For future use
+    properties_
+        .user_collected_properties[PlainTablePropertyNames::kBloomVersion] =
+        "1";  // For future use
   }
 
   properties_.fixed_key_len = user_key_len;
@@ -112,8 +113,8 @@ PlainTableBuilder::PlainTableBuilder(
 
   std::string val;
   PutFixed32(&val, static_cast<uint32_t>(encoder_.GetEncodingType()));
-  properties_.user_collected_properties
-      [PlainTablePropertyNames::kEncodingType] = val;
+  properties_
+      .user_collected_properties[PlainTablePropertyNames::kEncodingType] = val;
 
   assert(int_tbl_prop_collector_factories);
   for (auto& factory : *int_tbl_prop_collector_factories) {
@@ -303,17 +304,13 @@ Status PlainTableBuilder::Finish() {
   return status_;
 }
 
-void PlainTableBuilder::Abandon() {
-  closed_ = true;
-}
+void PlainTableBuilder::Abandon() { closed_ = true; }
 
 uint64_t PlainTableBuilder::NumEntries() const {
   return properties_.num_entries;
 }
 
-uint64_t PlainTableBuilder::FileSize() const {
-  return offset_;
-}
+uint64_t PlainTableBuilder::FileSize() const { return offset_; }
 
 std::string PlainTableBuilder::GetFileChecksum() const {
   if (file_ != nullptr) {

package/deps/rocksdb/rocksdb/table/plain/plain_table_builder.h

@@ -7,8 +7,10 @@
 
 #ifndef ROCKSDB_LITE
 #include <stdint.h>
+
 #include <string>
 #include <vector>
+
 #include "db/version_edit.h"
 #include "rocksdb/options.h"
 #include "rocksdb/status.h"
@@ -29,7 +31,7 @@ class TableBuilder;
 // The builder class of PlainTable. For description of PlainTable format
 // See comments of class PlainTableFactory, where instances of
 // PlainTableReader are created.
-class PlainTableBuilder: public TableBuilder {
+class PlainTableBuilder : public TableBuilder {
  public:
   // Create a builder that will store the contents of the table it is
   // building in *file.  Does not close the file.  It is up to the

package/deps/rocksdb/rocksdb/table/plain/plain_table_factory.h

@@ -6,9 +6,10 @@
 #pragma once
 
 #ifndef ROCKSDB_LITE
+#include <stdint.h>
+
 #include <memory>
 #include <string>
-#include <stdint.h>
 
 #include "rocksdb/table.h"
 
@@ -177,6 +178,5 @@ class PlainTableFactory : public TableFactory {
   PlainTableOptions table_options_;
 };
 
-
 }  // namespace ROCKSDB_NAMESPACE
 #endif  // ROCKSDB_LITE

package/deps/rocksdb/rocksdb/table/plain/plain_table_index.cc

@@ -19,7 +19,7 @@ inline uint32_t GetBucketIdFromHash(uint32_t hash, uint32_t num_buckets) {
   assert(num_buckets > 0);
   return hash % num_buckets;
 }
-}
+}  // namespace
 
 Status PlainTableIndex::InitFromRawData(Slice data) {
   if (!GetVarint32(&data, &index_size_)) {
@@ -114,7 +114,7 @@ void PlainTableIndexBuilder::AllocateIndex() {
   } else {
     double hash_table_size_multipier = 1.0 / hash_table_ratio_;
     index_size_ =
-      static_cast<uint32_t>(num_prefixes_ * hash_table_size_multipier) + 1;
+        static_cast<uint32_t>(num_prefixes_ * hash_table_size_multipier) + 1;
     assert(index_size_ > 0);
   }
 }
@@ -180,7 +180,8 @@ Slice PlainTableIndexBuilder::FillIndexes(
         break;
       default:
         // point to second level indexes.
-        PutUnaligned(index + i, sub_index_offset | PlainTableIndex::kSubIndexMask);
+        PutUnaligned(index + i,
+                     sub_index_offset | PlainTableIndex::kSubIndexMask);
         char* prev_ptr = &sub_index[sub_index_offset];
         char* cur_ptr = EncodeVarint32(prev_ptr, num_keys_for_bucket);
         sub_index_offset += static_cast<uint32_t>(cur_ptr - prev_ptr);

package/deps/rocksdb/rocksdb/table/plain/plain_table_index.h

@@ -188,8 +188,8 @@ class PlainTableIndexBuilder {
              num_records_in_current_group_;
     }
     IndexRecord* At(size_t index) {
-      return &(groups_[index / kNumRecordsPerGroup]
-                      [index % kNumRecordsPerGroup]);
+      return &(
+          groups_[index / kNumRecordsPerGroup][index % kNumRecordsPerGroup]);
     }
 
    private:

package/deps/rocksdb/rocksdb/table/plain/plain_table_key_coding.cc

@@ -8,6 +8,7 @@
 
 #include <algorithm>
 #include <string>
+
 #include "db/dbformat.h"
 #include "file/writable_file_writer.h"
 #include "table/plain/plain_table_factory.h"