@nxtedition/rocksdb 7.1.32 → 7.1.34

package/deps/rocksdb/rocksdb/db/c.cc

@@ -125,28 +125,48 @@ using ROCKSDB_NAMESPACE::WriteBatch;
 using ROCKSDB_NAMESPACE::WriteBatchWithIndex;
 using ROCKSDB_NAMESPACE::WriteOptions;
 
-using std::vector;
 using std::unordered_set;
+using std::vector;
 
 extern "C" {
 
-struct rocksdb_t                 { DB*               rep; };
-struct rocksdb_backup_engine_t   { BackupEngine*     rep; };
-struct rocksdb_backup_engine_info_t { std::vector<BackupInfo> rep; };
-struct rocksdb_restore_options_t { RestoreOptions rep; };
-struct rocksdb_iterator_t        { Iterator*         rep; };
-struct rocksdb_writebatch_t      { WriteBatch        rep; };
-struct rocksdb_writebatch_wi_t   { WriteBatchWithIndex* rep; };
-struct rocksdb_snapshot_t        { const Snapshot*   rep; };
-struct rocksdb_flushoptions_t    { FlushOptions      rep; };
-struct rocksdb_fifo_compaction_options_t { CompactionOptionsFIFO rep; };
+struct rocksdb_t {
+  DB* rep;
+};
+struct rocksdb_backup_engine_t {
+  BackupEngine* rep;
+};
+struct rocksdb_backup_engine_info_t {
+  std::vector<BackupInfo> rep;
+};
+struct rocksdb_restore_options_t {
+  RestoreOptions rep;
+};
+struct rocksdb_iterator_t {
+  Iterator* rep;
+};
+struct rocksdb_writebatch_t {
+  WriteBatch rep;
+};
+struct rocksdb_writebatch_wi_t {
+  WriteBatchWithIndex* rep;
+};
+struct rocksdb_snapshot_t {
+  const Snapshot* rep;
+};
+struct rocksdb_flushoptions_t {
+  FlushOptions rep;
+};
+struct rocksdb_fifo_compaction_options_t {
+  CompactionOptionsFIFO rep;
+};
 struct rocksdb_readoptions_t {
-   ReadOptions rep;
-   // stack variables to set pointers to in ReadOptions
-   Slice upper_bound;
-   Slice lower_bound;
-   Slice timestamp;
-   Slice iter_start_ts;
+  ReadOptions rep;
+  // stack variables to set pointers to in ReadOptions
+  Slice upper_bound;
+  Slice lower_bound;
+  Slice timestamp;
+  Slice iter_start_ts;
 };
 struct rocksdb_writeoptions_t {
   WriteOptions rep;
@@ -164,12 +184,24 @@ struct rocksdb_block_based_table_options_t {
 struct rocksdb_cuckoo_table_options_t {
   CuckooTableOptions rep;
 };
-struct rocksdb_seqfile_t         { SequentialFile*   rep; };
-struct rocksdb_randomfile_t      { RandomAccessFile* rep; };
-struct rocksdb_writablefile_t    { WritableFile*     rep; };
-struct rocksdb_wal_iterator_t { TransactionLogIterator* rep; };
-struct rocksdb_wal_readoptions_t { TransactionLogIterator::ReadOptions rep; };
-struct rocksdb_filelock_t        { FileLock*         rep; };
+struct rocksdb_seqfile_t {
+  SequentialFile* rep;
+};
+struct rocksdb_randomfile_t {
+  RandomAccessFile* rep;
+};
+struct rocksdb_writablefile_t {
+  WritableFile* rep;
+};
+struct rocksdb_wal_iterator_t {
+  TransactionLogIterator* rep;
+};
+struct rocksdb_wal_readoptions_t {
+  TransactionLogIterator::ReadOptions rep;
+};
+struct rocksdb_filelock_t {
+  FileLock* rep;
+};
 struct rocksdb_logger_t {
   std::shared_ptr<Logger> rep;
 };
@@ -182,8 +214,12 @@ struct rocksdb_memory_allocator_t {
 struct rocksdb_cache_t {
   std::shared_ptr<Cache> rep;
 };
-struct rocksdb_livefiles_t       { std::vector<LiveFileMetaData> rep; };
-struct rocksdb_column_family_handle_t  { ColumnFamilyHandle* rep; };
+struct rocksdb_livefiles_t {
+  std::vector<LiveFileMetaData> rep;
+};
+struct rocksdb_column_family_handle_t {
+  ColumnFamilyHandle* rep;
+};
 struct rocksdb_column_family_metadata_t {
   ColumnFamilyMetaData rep;
 };
@@ -193,13 +229,21 @@ struct rocksdb_level_metadata_t {
 struct rocksdb_sst_file_metadata_t {
   const SstFileMetaData* rep;
 };
-struct rocksdb_envoptions_t      { EnvOptions        rep; };
-struct rocksdb_ingestexternalfileoptions_t  { IngestExternalFileOptions rep; };
-struct rocksdb_sstfilewriter_t   { SstFileWriter*    rep; };
+struct rocksdb_envoptions_t {
+  EnvOptions rep;
+};
+struct rocksdb_ingestexternalfileoptions_t {
+  IngestExternalFileOptions rep;
+};
+struct rocksdb_sstfilewriter_t {
+  SstFileWriter* rep;
+};
 struct rocksdb_ratelimiter_t {
   std::shared_ptr<RateLimiter> rep;
 };
-struct rocksdb_perfcontext_t     { PerfContext*      rep; };
+struct rocksdb_perfcontext_t {
+  PerfContext* rep;
+};
 struct rocksdb_pinnableslice_t {
   PinnableSlice rep;
 };
@@ -235,13 +279,10 @@ struct rocksdb_compactionfiltercontext_t {
 struct rocksdb_compactionfilter_t : public CompactionFilter {
   void* state_;
   void (*destructor_)(void*);
-  unsigned char (*filter_)(
-      void*,
-      int level,
-      const char* key, size_t key_length,
-      const char* existing_value, size_t value_length,
-      char** new_value, size_t *new_value_length,
-      unsigned char* value_changed);
+  unsigned char (*filter_)(void*, int level, const char* key, size_t key_length,
+                           const char* existing_value, size_t value_length,
+                           char** new_value, size_t* new_value_length,
+                           unsigned char* value_changed);
   const char* (*name_)(void*);
   unsigned char ignore_snapshots_;
 
@@ -252,12 +293,10 @@ struct rocksdb_compactionfilter_t : public CompactionFilter {
     char* c_new_value = nullptr;
     size_t new_value_length = 0;
     unsigned char c_value_changed = 0;
-    unsigned char result = (*filter_)(
-        state_,
-        level,
-        key.data(), key.size(),
-        existing_value.data(), existing_value.size(),
-        &c_new_value, &new_value_length, &c_value_changed);
+    unsigned char result =
+        (*filter_)(state_, level, key.data(), key.size(), existing_value.data(),
+                   existing_value.size(), &c_new_value, &new_value_length,
+                   &c_value_changed);
     if (c_value_changed) {
       new_value->assign(c_new_value, new_value_length);
       *value_changed = true;
@@ -350,20 +389,16 @@ struct rocksdb_mergeoperator_t : public MergeOperator {
   void* state_;
   void (*destructor_)(void*);
   const char* (*name_)(void*);
-  char* (*full_merge_)(
-      void*,
-      const char* key, size_t key_length,
-      const char* existing_value, size_t existing_value_length,
-      const char* const* operands_list, const size_t* operands_list_length,
-      int num_operands,
-      unsigned char* success, size_t* new_value_length);
+  char* (*full_merge_)(void*, const char* key, size_t key_length,
+                       const char* existing_value, size_t existing_value_length,
+                       const char* const* operands_list,
+                       const size_t* operands_list_length, int num_operands,
+                       unsigned char* success, size_t* new_value_length);
   char* (*partial_merge_)(void*, const char* key, size_t key_length,
                           const char* const* operands_list,
                           const size_t* operands_list_length, int num_operands,
                           unsigned char* success, size_t* new_value_length);
-  void (*delete_value_)(
-      void*,
-      const char* value, size_t value_length);
+  void (*delete_value_)(void*, const char* value, size_t value_length);
 
   ~rocksdb_mergeoperator_t() override { (*destructor_)(state_); }
 
@@ -447,16 +482,10 @@ struct rocksdb_slicetransform_t : public SliceTransform {
   void* state_;
   void (*destructor_)(void*);
   const char* (*name_)(void*);
-  char* (*transform_)(
-      void*,
-      const char* key, size_t length,
-      size_t* dst_length);
-  unsigned char (*in_domain_)(
-      void*,
-      const char* key, size_t length);
-  unsigned char (*in_range_)(
-      void*,
-      const char* key, size_t length);
+  char* (*transform_)(void*, const char* key, size_t length,
+                      size_t* dst_length);
+  unsigned char (*in_domain_)(void*, const char* key, size_t length);
+  unsigned char (*in_range_)(void*, const char* key, size_t length);
 
   ~rocksdb_slicetransform_t() override { (*destructor_)(state_); }
 
@@ -502,10 +531,8 @@ static char* CopyString(const std::string& str) {
   return result;
 }
 
-rocksdb_t* rocksdb_open(
-    const rocksdb_options_t* options,
-    const char* name,
-    char** errptr) {
+rocksdb_t* rocksdb_open(const rocksdb_options_t* options, const char* name,
+                        char** errptr) {
   DB* db;
   if (SaveError(errptr, DB::Open(options->rep, std::string(name), &db))) {
     return nullptr;
@@ -515,11 +542,8 @@ rocksdb_t* rocksdb_open(
   return result;
 }
 
-rocksdb_t* rocksdb_open_with_ttl(
-    const rocksdb_options_t* options,
-    const char* name,
-    int ttl,
-    char** errptr) {
+rocksdb_t* rocksdb_open_with_ttl(const rocksdb_options_t* options,
+                                 const char* name, int ttl, char** errptr) {
   ROCKSDB_NAMESPACE::DBWithTTL* db;
   if (SaveError(errptr, ROCKSDB_NAMESPACE::DBWithTTL::Open(
                             options->rep, std::string(name), &db, ttl))) {
@@ -587,15 +611,13 @@ rocksdb_backup_engine_t* rocksdb_backup_engine_open_opts(
 }
 
 void rocksdb_backup_engine_create_new_backup(rocksdb_backup_engine_t* be,
-                                             rocksdb_t* db,
-                                             char** errptr) {
+                                             rocksdb_t* db, char** errptr) {
   SaveError(errptr, be->rep->CreateNewBackup(db->rep));
 }
 
-void rocksdb_backup_engine_create_new_backup_flush(rocksdb_backup_engine_t* be,
-                                                   rocksdb_t* db,
-                                                   unsigned char flush_before_backup,
-                                                   char** errptr) {
+void rocksdb_backup_engine_create_new_backup_flush(
+    rocksdb_backup_engine_t* be, rocksdb_t* db,
+    unsigned char flush_before_backup, char** errptr) {
   SaveError(errptr, be->rep->CreateNewBackup(db->rep, flush_before_backup));
 }
 
@@ -618,9 +640,8 @@ void rocksdb_restore_options_set_keep_log_files(rocksdb_restore_options_t* opt,
   opt->rep.keep_log_files = v;
 }
 
-
 void rocksdb_backup_engine_verify_backup(rocksdb_backup_engine_t* be,
-    uint32_t backup_id, char** errptr) {
+                                         uint32_t backup_id, char** errptr) {
   SaveError(errptr, be->rep->VerifyBackup(static_cast<BackupID>(backup_id)));
 }
 
@@ -885,13 +906,14 @@ rocksdb_t* rocksdb_open_column_families(
 
   DB* db;
   std::vector<ColumnFamilyHandle*> handles;
-  if (SaveError(errptr, DB::Open(DBOptions(db_options->rep),
-          std::string(name), column_families, &handles, &db))) {
+  if (SaveError(errptr, DB::Open(DBOptions(db_options->rep), std::string(name),
+                                 column_families, &handles, &db))) {
     return nullptr;
   }
 
   for (size_t i = 0; i < handles.size(); i++) {
-    rocksdb_column_family_handle_t* c_handle = new rocksdb_column_family_handle_t;
+    rocksdb_column_family_handle_t* c_handle =
+        new rocksdb_column_family_handle_t;
     c_handle->rep = handles[i];
     column_family_handles[i] = c_handle;
   }
@@ -958,7 +980,8 @@ rocksdb_t* rocksdb_open_for_read_only_column_families(
   }
 
   for (size_t i = 0; i < handles.size(); i++) {
-    rocksdb_column_family_handle_t* c_handle = new rocksdb_column_family_handle_t;
+    rocksdb_column_family_handle_t* c_handle =
+        new rocksdb_column_family_handle_t;
     c_handle->rep = handles[i];
     column_family_handles[i] = c_handle;
   }
@@ -998,18 +1021,16 @@ rocksdb_t* rocksdb_open_as_secondary_column_families(
   return result;
 }
 
-char** rocksdb_list_column_families(
-    const rocksdb_options_t* options,
-    const char* name,
-    size_t* lencfs,
-    char** errptr) {
+char** rocksdb_list_column_families(const rocksdb_options_t* options,
+                                    const char* name, size_t* lencfs,
+                                    char** errptr) {
   std::vector<std::string> fams;
-  SaveError(errptr,
-      DB::ListColumnFamilies(DBOptions(options->rep),
-        std::string(name), &fams));
+  SaveError(errptr, DB::ListColumnFamilies(DBOptions(options->rep),
+                                           std::string(name), &fams));
 
   *lencfs = fams.size();
-  char** column_families = static_cast<char**>(malloc(sizeof(char*) * fams.size()));
+  char** column_families =
+      static_cast<char**>(malloc(sizeof(char*) * fams.size()));
   for (size_t i = 0; i < fams.size(); i++) {
     column_families[i] = strdup(fams[i].c_str());
   }
@@ -1024,14 +1045,12 @@ void rocksdb_list_column_families_destroy(char** list, size_t len) {
 }
 
 rocksdb_column_family_handle_t* rocksdb_create_column_family(
-    rocksdb_t* db,
-    const rocksdb_options_t* column_family_options,
-    const char* column_family_name,
-    char** errptr) {
+    rocksdb_t* db, const rocksdb_options_t* column_family_options,
+    const char* column_family_name, char** errptr) {
   rocksdb_column_family_handle_t* handle = new rocksdb_column_family_handle_t;
-  SaveError(errptr,
-      db->rep->CreateColumnFamily(ColumnFamilyOptions(column_family_options->rep),
-        std::string(column_family_name), &(handle->rep)));
+  SaveError(errptr, db->rep->CreateColumnFamily(
+                        ColumnFamilyOptions(column_family_options->rep),
+                        std::string(column_family_name), &(handle->rep)));
   return handle;
 }
 
@@ -1047,10 +1066,9 @@ rocksdb_column_family_handle_t* rocksdb_create_column_family_with_ttl(
   return handle;
 }
 
-void rocksdb_drop_column_family(
-    rocksdb_t* db,
-    rocksdb_column_family_handle_t* handle,
-    char** errptr) {
+void rocksdb_drop_column_family(rocksdb_t* db,
+                                rocksdb_column_family_handle_t* handle,
+                                char** errptr) {
   SaveError(errptr, db->rep->DropColumnFamily(handle->rep));
 }
 
@@ -1066,17 +1084,15 @@ char* rocksdb_column_family_handle_get_name(
   return CopyString(name);
 }
 
-void rocksdb_column_family_handle_destroy(rocksdb_column_family_handle_t* handle) {
+void rocksdb_column_family_handle_destroy(
+    rocksdb_column_family_handle_t* handle) {
   delete handle->rep;
   delete handle;
 }
 
-void rocksdb_put(
-    rocksdb_t* db,
-    const rocksdb_writeoptions_t* options,
-    const char* key, size_t keylen,
-    const char* val, size_t vallen,
-    char** errptr) {
+void rocksdb_put(rocksdb_t* db, const rocksdb_writeoptions_t* options,
+                 const char* key, size_t keylen, const char* val, size_t vallen,
+                 char** errptr) {
   SaveError(errptr,
             db->rep->Put(options->rep, Slice(key, keylen), Slice(val, vallen)));
 }
@@ -1113,12 +1129,9 @@ void rocksdb_delete(rocksdb_t* db, const rocksdb_writeoptions_t* options,
   SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen)));
 }
 
-void rocksdb_delete_cf(
-    rocksdb_t* db,
-    const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family,
-    const char* key, size_t keylen,
-    char** errptr) {
+void rocksdb_delete_cf(rocksdb_t* db, const rocksdb_writeoptions_t* options,
+                       rocksdb_column_family_handle_t* column_family,
+                       const char* key, size_t keylen, char** errptr) {
   SaveError(errptr, db->rep->Delete(options->rep, column_family->rep,
                                     Slice(key, keylen)));
 }
@@ -1215,25 +1228,18 @@ void rocksdb_merge_cf(rocksdb_t* db, const rocksdb_writeoptions_t* options,
                       rocksdb_column_family_handle_t* column_family,
                       const char* key, size_t keylen, const char* val,
                       size_t vallen, char** errptr) {
-  SaveError(errptr,
-            db->rep->Merge(options->rep, column_family->rep,
-              Slice(key, keylen), Slice(val, vallen)));
+  SaveError(errptr, db->rep->Merge(options->rep, column_family->rep,
+                                   Slice(key, keylen), Slice(val, vallen)));
 }
 
-void rocksdb_write(
-    rocksdb_t* db,
-    const rocksdb_writeoptions_t* options,
-    rocksdb_writebatch_t* batch,
-    char** errptr) {
+void rocksdb_write(rocksdb_t* db, const rocksdb_writeoptions_t* options,
+                   rocksdb_writebatch_t* batch, char** errptr) {
   SaveError(errptr, db->rep->Write(options->rep, &batch->rep));
 }
 
-char* rocksdb_get(
-    rocksdb_t* db,
-    const rocksdb_readoptions_t* options,
-    const char* key, size_t keylen,
-    size_t* vallen,
-    char** errptr) {
+char* rocksdb_get(rocksdb_t* db, const rocksdb_readoptions_t* options,
+                  const char* key, size_t keylen, size_t* vallen,
+                  char** errptr) {
   char* result = nullptr;
   std::string tmp;
   Status s = db->rep->Get(options->rep, Slice(key, keylen), &tmp);
@@ -1249,17 +1255,14 @@ char* rocksdb_get(
   return result;
 }
 
-char* rocksdb_get_cf(
-    rocksdb_t* db,
-    const rocksdb_readoptions_t* options,
-    rocksdb_column_family_handle_t* column_family,
-    const char* key, size_t keylen,
-    size_t* vallen,
-    char** errptr) {
+char* rocksdb_get_cf(rocksdb_t* db, const rocksdb_readoptions_t* options,
+                     rocksdb_column_family_handle_t* column_family,
+                     const char* key, size_t keylen, size_t* vallen,
+                     char** errptr) {
   char* result = nullptr;
   std::string tmp;
-  Status s = db->rep->Get(options->rep, column_family->rep,
-      Slice(key, keylen), &tmp);
+  Status s =
+      db->rep->Get(options->rep, column_family->rep, Slice(key, keylen), &tmp);
   if (s.ok()) {
     *vallen = tmp.size();
     result = CopyString(tmp);
@@ -1539,21 +1542,19 @@ unsigned char rocksdb_key_may_exist_cf(
 }
 
 rocksdb_iterator_t* rocksdb_create_iterator(
-    rocksdb_t* db,
-    const rocksdb_readoptions_t* options) {
+    rocksdb_t* db, const rocksdb_readoptions_t* options) {
   rocksdb_iterator_t* result = new rocksdb_iterator_t;
   result->rep = db->rep->NewIterator(options->rep);
   return result;
 }
 
 rocksdb_wal_iterator_t* rocksdb_get_updates_since(
-        rocksdb_t* db, uint64_t seq_number,
-        const rocksdb_wal_readoptions_t* options,
-        char** errptr) {
+    rocksdb_t* db, uint64_t seq_number,
+    const rocksdb_wal_readoptions_t* options, char** errptr) {
   std::unique_ptr<TransactionLogIterator> iter;
   TransactionLogIterator::ReadOptions ro;
-  if (options!=nullptr) {
-      ro = options->rep;
+  if (options != nullptr) {
+    ro = options->rep;
   }
   if (SaveError(errptr, db->rep->GetUpdatesSince(seq_number, &iter, ro))) {
     return nullptr;
@@ -1563,24 +1564,24 @@ rocksdb_wal_iterator_t* rocksdb_get_updates_since(
   return result;
 }
 
-void rocksdb_wal_iter_next(rocksdb_wal_iterator_t* iter) {
-    iter->rep->Next();
-}
+void rocksdb_wal_iter_next(rocksdb_wal_iterator_t* iter) { iter->rep->Next(); }
 
 unsigned char rocksdb_wal_iter_valid(const rocksdb_wal_iterator_t* iter) {
-    return iter->rep->Valid();
+  return iter->rep->Valid();
 }
 
-void rocksdb_wal_iter_status (const rocksdb_wal_iterator_t* iter, char** errptr) {
-    SaveError(errptr, iter->rep->status());
+void rocksdb_wal_iter_status(const rocksdb_wal_iterator_t* iter,
+                             char** errptr) {
+  SaveError(errptr, iter->rep->status());
 }
 
-void rocksdb_wal_iter_destroy (const rocksdb_wal_iterator_t* iter) {
+void rocksdb_wal_iter_destroy(const rocksdb_wal_iterator_t* iter) {
   delete iter->rep;
   delete iter;
 }
 
-rocksdb_writebatch_t* rocksdb_wal_iter_get_batch (const rocksdb_wal_iterator_t* iter, uint64_t* seq) {
+rocksdb_writebatch_t* rocksdb_wal_iter_get_batch(
+    const rocksdb_wal_iterator_t* iter, uint64_t* seq) {
   rocksdb_writebatch_t* result = rocksdb_writebatch_create();
   BatchResult wal_batch = iter->rep->GetBatch();
   result->rep = std::move(*wal_batch.writeBatchPtr);
@@ -1590,26 +1591,22 @@ rocksdb_writebatch_t* rocksdb_wal_iter_get_batch (const rocksdb_wal_iterator_t*
   return result;
 }
 
-uint64_t rocksdb_get_latest_sequence_number (rocksdb_t *db) {
-    return db->rep->GetLatestSequenceNumber();
+uint64_t rocksdb_get_latest_sequence_number(rocksdb_t* db) {
+  return db->rep->GetLatestSequenceNumber();
 }
 
 rocksdb_iterator_t* rocksdb_create_iterator_cf(
-    rocksdb_t* db,
-    const rocksdb_readoptions_t* options,
+    rocksdb_t* db, const rocksdb_readoptions_t* options,
     rocksdb_column_family_handle_t* column_family) {
   rocksdb_iterator_t* result = new rocksdb_iterator_t;
   result->rep = db->rep->NewIterator(options->rep, column_family->rep);
   return result;
 }
 
-void rocksdb_create_iterators(
-    rocksdb_t *db,
-    rocksdb_readoptions_t* opts,
-    rocksdb_column_family_handle_t** column_families,
-    rocksdb_iterator_t** iterators,
-    size_t size,
-    char** errptr) {
+void rocksdb_create_iterators(rocksdb_t* db, rocksdb_readoptions_t* opts,
+                              rocksdb_column_family_handle_t** column_families,
+                              rocksdb_iterator_t** iterators, size_t size,
+                              char** errptr) {
   std::vector<ColumnFamilyHandle*> column_families_vec;
   for (size_t i = 0; i < size; i++) {
     column_families_vec.push_back(column_families[i]->rep);
@@ -1628,23 +1625,19 @@ void rocksdb_create_iterators(
   }
 }
 
-const rocksdb_snapshot_t* rocksdb_create_snapshot(
-    rocksdb_t* db) {
+const rocksdb_snapshot_t* rocksdb_create_snapshot(rocksdb_t* db) {
   rocksdb_snapshot_t* result = new rocksdb_snapshot_t;
   result->rep = db->rep->GetSnapshot();
   return result;
 }
 
-void rocksdb_release_snapshot(
-    rocksdb_t* db,
-    const rocksdb_snapshot_t* snapshot) {
+void rocksdb_release_snapshot(rocksdb_t* db,
+                              const rocksdb_snapshot_t* snapshot) {
   db->rep->ReleaseSnapshot(snapshot->rep);
   delete snapshot;
 }
 
-char* rocksdb_property_value(
-    rocksdb_t* db,
-    const char* propname) {
+char* rocksdb_property_value(rocksdb_t* db, const char* propname) {
   std::string tmp;
   if (db->rep->GetProperty(Slice(propname), &tmp)) {
     // We use strdup() since we expect human readable output.
@@ -1654,10 +1647,8 @@ char* rocksdb_property_value(
   }
 }
 
-int rocksdb_property_int(
-    rocksdb_t* db,
-    const char* propname,
-    uint64_t *out_val) {
+int rocksdb_property_int(rocksdb_t* db, const char* propname,
+                         uint64_t* out_val) {
   if (db->rep->GetIntProperty(Slice(propname), out_val)) {
     return 0;
   } else {
@@ -1665,11 +1656,9 @@ int rocksdb_property_int(
   }
 }
 
-int rocksdb_property_int_cf(
-    rocksdb_t* db,
-    rocksdb_column_family_handle_t* column_family,
-    const char* propname,
-    uint64_t *out_val) {
+int rocksdb_property_int_cf(rocksdb_t* db,
+                            rocksdb_column_family_handle_t* column_family,
+                            const char* propname, uint64_t* out_val) {
   if (db->rep->GetIntProperty(column_family->rep, Slice(propname), out_val)) {
     return 0;
   } else {
@@ -1677,10 +1666,9 @@ int rocksdb_property_int_cf(
   }
 }
 
-char* rocksdb_property_value_cf(
-    rocksdb_t* db,
-    rocksdb_column_family_handle_t* column_family,
-    const char* propname) {
+char* rocksdb_property_value_cf(rocksdb_t* db,
+                                rocksdb_column_family_handle_t* column_family,
+                                const char* propname) {
   std::string tmp;
   if (db->rep->GetProperty(column_family->rep, Slice(propname), &tmp)) {
     // We use strdup() since we expect human readable output.
@@ -1726,23 +1714,19 @@ void rocksdb_approximate_sizes_cf(
   delete[] ranges;
 }
 
-void rocksdb_delete_file(
-    rocksdb_t* db,
-    const char* name) {
+void rocksdb_delete_file(rocksdb_t* db, const char* name) {
   db->rep->DeleteFile(name);
 }
 
-const rocksdb_livefiles_t* rocksdb_livefiles(
-    rocksdb_t* db) {
+const rocksdb_livefiles_t* rocksdb_livefiles(rocksdb_t* db) {
   rocksdb_livefiles_t* result = new rocksdb_livefiles_t;
   db->rep->GetLiveFilesMetaData(&result->rep);
   return result;
 }
 
-void rocksdb_compact_range(
-    rocksdb_t* db,
-    const char* start_key, size_t start_key_len,
-    const char* limit_key, size_t limit_key_len) {
+void rocksdb_compact_range(rocksdb_t* db, const char* start_key,
+                           size_t start_key_len, const char* limit_key,
+                           size_t limit_key_len) {
   Slice a, b;
   db->rep->CompactRange(
       CompactRangeOptions(),
@@ -1751,11 +1735,10 @@ void rocksdb_compact_range(
       (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
 }
 
-void rocksdb_compact_range_cf(
-    rocksdb_t* db,
-    rocksdb_column_family_handle_t* column_family,
-    const char* start_key, size_t start_key_len,
-    const char* limit_key, size_t limit_key_len) {
+void rocksdb_compact_range_cf(rocksdb_t* db,
+                              rocksdb_column_family_handle_t* column_family,
+                              const char* start_key, size_t start_key_len,
+                              const char* limit_key, size_t limit_key_len) {
   Slice a, b;
   db->rep->CompactRange(
       CompactRangeOptions(), column_family->rep,
@@ -1811,18 +1794,14 @@ void rocksdb_compact_range_cf_opt(rocksdb_t* db,
       (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
 }
 
-void rocksdb_flush(
-    rocksdb_t* db,
-    const rocksdb_flushoptions_t* options,
-    char** errptr) {
+void rocksdb_flush(rocksdb_t* db, const rocksdb_flushoptions_t* options,
+                   char** errptr) {
   SaveError(errptr, db->rep->Flush(options->rep));
 }
 
-void rocksdb_flush_cf(
-    rocksdb_t* db,
-    const rocksdb_flushoptions_t* options,
-    rocksdb_column_family_handle_t* column_family,
-    char** errptr) {
+void rocksdb_flush_cf(rocksdb_t* db, const rocksdb_flushoptions_t* options,
+                      rocksdb_column_family_handle_t* column_family,
+                      char** errptr) {
   SaveError(errptr, db->rep->Flush(options->rep, column_family->rep));
 }
 
@@ -1830,30 +1809,22 @@ void rocksdb_flush_wal(rocksdb_t* db, unsigned char sync, char** errptr) {
   SaveError(errptr, db->rep->FlushWAL(sync));
 }
 
-void rocksdb_disable_file_deletions(
-    rocksdb_t* db,
-    char** errptr) {
+void rocksdb_disable_file_deletions(rocksdb_t* db, char** errptr) {
   SaveError(errptr, db->rep->DisableFileDeletions());
 }
 
-void rocksdb_enable_file_deletions(
-    rocksdb_t* db,
-    unsigned char force,
-    char** errptr) {
+void rocksdb_enable_file_deletions(rocksdb_t* db, unsigned char force,
+                                   char** errptr) {
   SaveError(errptr, db->rep->EnableFileDeletions(force));
 }
 
-void rocksdb_destroy_db(
-    const rocksdb_options_t* options,
-    const char* name,
-    char** errptr) {
+void rocksdb_destroy_db(const rocksdb_options_t* options, const char* name,
+                        char** errptr) {
   SaveError(errptr, DestroyDB(name, options->rep));
 }
 
-void rocksdb_repair_db(
-    const rocksdb_options_t* options,
-    const char* name,
-    char** errptr) {
+void rocksdb_repair_db(const rocksdb_options_t* options, const char* name,
+                       char** errptr) {
   SaveError(errptr, RepairDB(name, options->rep));
 }
 
@@ -1883,13 +1854,9 @@ void rocksdb_iter_seek_for_prev(rocksdb_iterator_t* iter, const char* k,
   iter->rep->SeekForPrev(Slice(k, klen));
 }
 
-void rocksdb_iter_next(rocksdb_iterator_t* iter) {
-  iter->rep->Next();
-}
+void rocksdb_iter_next(rocksdb_iterator_t* iter) { iter->rep->Next(); }
 
-void rocksdb_iter_prev(rocksdb_iterator_t* iter) {
-  iter->rep->Prev();
-}
+void rocksdb_iter_prev(rocksdb_iterator_t* iter) { iter->rep->Prev(); }
 
 const char* rocksdb_iter_key(const rocksdb_iterator_t* iter, size_t* klen) {
   Slice s = iter->rep->key();
@@ -1991,20 +1958,18 @@ void rocksdb_writebatch_merge(rocksdb_writebatch_t* b, const char* key,
   b->rep.Merge(Slice(key, klen), Slice(val, vlen));
 }
 
-void rocksdb_writebatch_merge_cf(
-    rocksdb_writebatch_t* b,
-    rocksdb_column_family_handle_t* column_family,
-    const char* key, size_t klen,
-    const char* val, size_t vlen) {
+void rocksdb_writebatch_merge_cf(rocksdb_writebatch_t* b,
+                                 rocksdb_column_family_handle_t* column_family,
+                                 const char* key, size_t klen, const char* val,
+                                 size_t vlen) {
   b->rep.Merge(column_family->rep, Slice(key, klen), Slice(val, vlen));
 }
 
-void rocksdb_writebatch_mergev(
-    rocksdb_writebatch_t* b,
-    int num_keys, const char* const* keys_list,
-    const size_t* keys_list_sizes,
-    int num_values, const char* const* values_list,
-    const size_t* values_list_sizes) {
+void rocksdb_writebatch_mergev(rocksdb_writebatch_t* b, int num_keys,
+                               const char* const* keys_list,
+                               const size_t* keys_list_sizes, int num_values,
+                               const char* const* values_list,
+                               const size_t* values_list_sizes) {
   std::vector<Slice> key_slices(num_keys);
   for (int i = 0; i < num_keys; i++) {
     key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
@@ -2017,13 +1982,12 @@ void rocksdb_writebatch_mergev(
                SliceParts(value_slices.data(), num_values));
 }
 
-void rocksdb_writebatch_mergev_cf(
-    rocksdb_writebatch_t* b,
-    rocksdb_column_family_handle_t* column_family,
-    int num_keys, const char* const* keys_list,
-    const size_t* keys_list_sizes,
-    int num_values, const char* const* values_list,
-    const size_t* values_list_sizes) {
+void rocksdb_writebatch_mergev_cf(rocksdb_writebatch_t* b,
+                                  rocksdb_column_family_handle_t* column_family,
+                                  int num_keys, const char* const* keys_list,
+                                  const size_t* keys_list_sizes, int num_values,
+                                  const char* const* values_list,
+                                  const size_t* values_list_sizes) {
   std::vector<Slice> key_slices(num_keys);
   for (int i = 0; i < num_keys; i++) {
     key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
@@ -2036,9 +2000,8 @@ void rocksdb_writebatch_mergev_cf(
                SliceParts(value_slices.data(), num_values));
 }
 
-void rocksdb_writebatch_delete(
-    rocksdb_writebatch_t* b,
-    const char* key, size_t klen) {
+void rocksdb_writebatch_delete(rocksdb_writebatch_t* b, const char* key,
+                               size_t klen) {
   b->rep.Delete(Slice(key, klen));
 }
 
@@ -2047,10 +2010,9 @@ void rocksdb_writebatch_singledelete(rocksdb_writebatch_t* b, const char* key,
   b->rep.SingleDelete(Slice(key, klen));
 }
 
-void rocksdb_writebatch_delete_cf(
-    rocksdb_writebatch_t* b,
-    rocksdb_column_family_handle_t* column_family,
-    const char* key, size_t klen) {
+void rocksdb_writebatch_delete_cf(rocksdb_writebatch_t* b,
+                                  rocksdb_column_family_handle_t* column_family,
+                                  const char* key, size_t klen) {
   b->rep.Delete(column_family->rep, Slice(key, klen));
 }
 
@@ -2139,9 +2101,8 @@ void rocksdb_writebatch_delete_rangev_cf(
                      SliceParts(end_key_slices.data(), num_keys));
 }
 
-void rocksdb_writebatch_put_log_data(
-    rocksdb_writebatch_t* b,
-    const char* blob, size_t len) {
+void rocksdb_writebatch_put_log_data(rocksdb_writebatch_t* b, const char* blob,
+                                     size_t len) {
   b->rep.PutLogData(Slice(blob, len));
 }
 
@@ -2158,11 +2119,11 @@ class H : public WriteBatch::Handler {
   }
 };
 
-void rocksdb_writebatch_iterate(
-    rocksdb_writebatch_t* b,
-    void* state,
-    void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen),
-    void (*deleted)(void*, const char* k, size_t klen)) {
+void rocksdb_writebatch_iterate(rocksdb_writebatch_t* b, void* state,
+                                void (*put)(void*, const char* k, size_t klen,
+                                            const char* v, size_t vlen),
+                                void (*deleted)(void*, const char* k,
+                                                size_t klen)) {
   H handler;
   handler.state_ = state;
   handler.put_ = put;
@@ -2188,9 +2149,11 @@ void rocksdb_writebatch_pop_save_point(rocksdb_writebatch_t* b, char** errptr) {
   SaveError(errptr, b->rep.PopSavePoint());
 }
 
-rocksdb_writebatch_wi_t* rocksdb_writebatch_wi_create(size_t reserved_bytes, unsigned char overwrite_key) {
+rocksdb_writebatch_wi_t* rocksdb_writebatch_wi_create(
+    size_t reserved_bytes, unsigned char overwrite_key) {
   rocksdb_writebatch_wi_t* b = new rocksdb_writebatch_wi_t;
-  b->rep = new WriteBatchWithIndex(BytewiseComparator(), reserved_bytes, overwrite_key);
+  b->rep = new WriteBatchWithIndex(BytewiseComparator(), reserved_bytes,
+                                   overwrite_key);
   return b;
 }
 
@@ -2209,27 +2172,23 @@ int rocksdb_writebatch_wi_count(rocksdb_writebatch_wi_t* b) {
   return b->rep->GetWriteBatch()->Count();
 }
 
-void rocksdb_writebatch_wi_put(
-    rocksdb_writebatch_wi_t* b,
-    const char* key, size_t klen,
-    const char* val, size_t vlen) {
+void rocksdb_writebatch_wi_put(rocksdb_writebatch_wi_t* b, const char* key,
+                               size_t klen, const char* val, size_t vlen) {
   b->rep->Put(Slice(key, klen), Slice(val, vlen));
 }
 
-void rocksdb_writebatch_wi_put_cf(
-    rocksdb_writebatch_wi_t* b,
-    rocksdb_column_family_handle_t* column_family,
-    const char* key, size_t klen,
-    const char* val, size_t vlen) {
+void rocksdb_writebatch_wi_put_cf(rocksdb_writebatch_wi_t* b,
+                                  rocksdb_column_family_handle_t* column_family,
+                                  const char* key, size_t klen, const char* val,
+                                  size_t vlen) {
   b->rep->Put(column_family->rep, Slice(key, klen), Slice(val, vlen));
 }
 
-void rocksdb_writebatch_wi_putv(
-    rocksdb_writebatch_wi_t* b,
-    int num_keys, const char* const* keys_list,
-    const size_t* keys_list_sizes,
-    int num_values, const char* const* values_list,
-    const size_t* values_list_sizes) {
+void rocksdb_writebatch_wi_putv(rocksdb_writebatch_wi_t* b, int num_keys,
+                                const char* const* keys_list,
+                                const size_t* keys_list_sizes, int num_values,
+                                const char* const* values_list,
+                                const size_t* values_list_sizes) {
   std::vector<Slice> key_slices(num_keys);
   for (int i = 0; i < num_keys; i++) {
     key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
@@ -2239,14 +2198,12 @@ void rocksdb_writebatch_wi_putv(
     value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
   }
   b->rep->Put(SliceParts(key_slices.data(), num_keys),
-             SliceParts(value_slices.data(), num_values));
+              SliceParts(value_slices.data(), num_values));
 }
 
 void rocksdb_writebatch_wi_putv_cf(
-    rocksdb_writebatch_wi_t* b,
-    rocksdb_column_family_handle_t* column_family,
-    int num_keys, const char* const* keys_list,
-    const size_t* keys_list_sizes,
+    rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family,
+    int num_keys, const char* const* keys_list, const size_t* keys_list_sizes,
     int num_values, const char* const* values_list,
     const size_t* values_list_sizes) {
   std::vector<Slice> key_slices(num_keys);
@@ -2258,30 +2215,25 @@ void rocksdb_writebatch_wi_putv_cf(
     value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
   }
   b->rep->Put(column_family->rep, SliceParts(key_slices.data(), num_keys),
-             SliceParts(value_slices.data(), num_values));
+              SliceParts(value_slices.data(), num_values));
 }
 
-void rocksdb_writebatch_wi_merge(
-    rocksdb_writebatch_wi_t* b,
-    const char* key, size_t klen,
-    const char* val, size_t vlen) {
+void rocksdb_writebatch_wi_merge(rocksdb_writebatch_wi_t* b, const char* key,
+                                 size_t klen, const char* val, size_t vlen) {
   b->rep->Merge(Slice(key, klen), Slice(val, vlen));
 }
 
 void rocksdb_writebatch_wi_merge_cf(
-    rocksdb_writebatch_wi_t* b,
-    rocksdb_column_family_handle_t* column_family,
-    const char* key, size_t klen,
-    const char* val, size_t vlen) {
+    rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family,
+    const char* key, size_t klen, const char* val, size_t vlen) {
   b->rep->Merge(column_family->rep, Slice(key, klen), Slice(val, vlen));
 }
 
-void rocksdb_writebatch_wi_mergev(
-    rocksdb_writebatch_wi_t* b,
-    int num_keys, const char* const* keys_list,
-    const size_t* keys_list_sizes,
-    int num_values, const char* const* values_list,
-    const size_t* values_list_sizes) {
+void rocksdb_writebatch_wi_mergev(rocksdb_writebatch_wi_t* b, int num_keys,
+                                  const char* const* keys_list,
+                                  const size_t* keys_list_sizes, int num_values,
+                                  const char* const* values_list,
+                                  const size_t* values_list_sizes) {
   std::vector<Slice> key_slices(num_keys);
   for (int i = 0; i < num_keys; i++) {
     key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
@@ -2291,14 +2243,12 @@ void rocksdb_writebatch_wi_mergev(
     value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
   }
   b->rep->Merge(SliceParts(key_slices.data(), num_keys),
-               SliceParts(value_slices.data(), num_values));
+                SliceParts(value_slices.data(), num_values));
 }
 
 void rocksdb_writebatch_wi_mergev_cf(
-    rocksdb_writebatch_wi_t* b,
-    rocksdb_column_family_handle_t* column_family,
-    int num_keys, const char* const* keys_list,
-    const size_t* keys_list_sizes,
+    rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family,
+    int num_keys, const char* const* keys_list, const size_t* keys_list_sizes,
     int num_values, const char* const* values_list,
     const size_t* values_list_sizes) {
   std::vector<Slice> key_slices(num_keys);
@@ -2310,12 +2260,11 @@ void rocksdb_writebatch_wi_mergev_cf(
     value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
   }
   b->rep->Merge(column_family->rep, SliceParts(key_slices.data(), num_keys),
-               SliceParts(value_slices.data(), num_values));
+                SliceParts(value_slices.data(), num_values));
 }
 
-void rocksdb_writebatch_wi_delete(
-    rocksdb_writebatch_wi_t* b,
-    const char* key, size_t klen) {
+void rocksdb_writebatch_wi_delete(rocksdb_writebatch_wi_t* b, const char* key,
+                                  size_t klen) {
   b->rep->Delete(Slice(key, klen));
 }
 
@@ -2325,8 +2274,7 @@ void rocksdb_writebatch_wi_singledelete(rocksdb_writebatch_wi_t* b,
 }
 
 void rocksdb_writebatch_wi_delete_cf(
-    rocksdb_writebatch_wi_t* b,
-    rocksdb_column_family_handle_t* column_family,
+    rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family,
     const char* key, size_t klen) {
   b->rep->Delete(column_family->rep, Slice(key, klen));
 }
@@ -2337,10 +2285,9 @@ void rocksdb_writebatch_wi_singledelete_cf(
   b->rep->SingleDelete(column_family->rep, Slice(key, klen));
 }
 
-void rocksdb_writebatch_wi_deletev(
-    rocksdb_writebatch_wi_t* b,
-    int num_keys, const char* const* keys_list,
-    const size_t* keys_list_sizes) {
+void rocksdb_writebatch_wi_deletev(rocksdb_writebatch_wi_t* b, int num_keys,
+                                   const char* const* keys_list,
+                                   const size_t* keys_list_sizes) {
   std::vector<Slice> key_slices(num_keys);
   for (int i = 0; i < num_keys; i++) {
     key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
@@ -2349,10 +2296,8 @@ void rocksdb_writebatch_wi_deletev(
 }
 
 void rocksdb_writebatch_wi_deletev_cf(
-    rocksdb_writebatch_wi_t* b,
-    rocksdb_column_family_handle_t* column_family,
-    int num_keys, const char* const* keys_list,
-    const size_t* keys_list_sizes) {
+    rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family,
+    int num_keys, const char* const* keys_list, const size_t* keys_list_sizes) {
   std::vector<Slice> key_slices(num_keys);
   for (int i = 0; i < num_keys; i++) {
     key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
@@ -2361,11 +2306,12 @@ void rocksdb_writebatch_wi_deletev_cf(
 }
 
 void rocksdb_writebatch_wi_delete_range(rocksdb_writebatch_wi_t* b,
-                                     const char* start_key,
-                                     size_t start_key_len, const char* end_key,
-                                     size_t end_key_len) {
+                                        const char* start_key,
+                                        size_t start_key_len,
+                                        const char* end_key,
+                                        size_t end_key_len) {
   b->rep->DeleteRange(Slice(start_key, start_key_len),
-                     Slice(end_key, end_key_len));
+                      Slice(end_key, end_key_len));
 }
 
 void rocksdb_writebatch_wi_delete_range_cf(
@@ -2373,14 +2319,15 @@ void rocksdb_writebatch_wi_delete_range_cf(
     const char* start_key, size_t start_key_len, const char* end_key,
     size_t end_key_len) {
   b->rep->DeleteRange(column_family->rep, Slice(start_key, start_key_len),
-                     Slice(end_key, end_key_len));
+                      Slice(end_key, end_key_len));
 }
 
-void rocksdb_writebatch_wi_delete_rangev(rocksdb_writebatch_wi_t* b, int num_keys,
-                                      const char* const* start_keys_list,
-                                      const size_t* start_keys_list_sizes,
-                                      const char* const* end_keys_list,
-                                      const size_t* end_keys_list_sizes) {
+void rocksdb_writebatch_wi_delete_rangev(rocksdb_writebatch_wi_t* b,
+                                         int num_keys,
+                                         const char* const* start_keys_list,
+                                         const size_t* start_keys_list_sizes,
+                                         const char* const* end_keys_list,
+                                         const size_t* end_keys_list_sizes) {
   std::vector<Slice> start_key_slices(num_keys);
   std::vector<Slice> end_key_slices(num_keys);
   for (int i = 0; i < num_keys; i++) {
@@ -2388,7 +2335,7 @@ void rocksdb_writebatch_wi_delete_rangev(rocksdb_writebatch_wi_t* b, int num_key
     end_key_slices[i] = Slice(end_keys_list[i], end_keys_list_sizes[i]);
   }
   b->rep->DeleteRange(SliceParts(start_key_slices.data(), num_keys),
-                     SliceParts(end_key_slices.data(), num_keys));
+                      SliceParts(end_key_slices.data(), num_keys));
 }
 
 void rocksdb_writebatch_wi_delete_rangev_cf(
@@ -2403,19 +2350,17 @@ void rocksdb_writebatch_wi_delete_rangev_cf(
     end_key_slices[i] = Slice(end_keys_list[i], end_keys_list_sizes[i]);
   }
   b->rep->DeleteRange(column_family->rep,
-                     SliceParts(start_key_slices.data(), num_keys),
-                     SliceParts(end_key_slices.data(), num_keys));
+                      SliceParts(start_key_slices.data(), num_keys),
+                      SliceParts(end_key_slices.data(), num_keys));
 }
 
-void rocksdb_writebatch_wi_put_log_data(
-    rocksdb_writebatch_wi_t* b,
-    const char* blob, size_t len) {
+void rocksdb_writebatch_wi_put_log_data(rocksdb_writebatch_wi_t* b,
+                                        const char* blob, size_t len) {
   b->rep->PutLogData(Slice(blob, len));
 }
 
 void rocksdb_writebatch_wi_iterate(
-    rocksdb_writebatch_wi_t* b,
-    void* state,
+    rocksdb_writebatch_wi_t* b, void* state,
     void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen),
     void (*deleted)(void*, const char* k, size_t klen)) {
   H handler;
@@ -2425,7 +2370,8 @@ void rocksdb_writebatch_wi_iterate(
   b->rep->GetWriteBatch()->Iterate(&handler);
 }
 
-const char* rocksdb_writebatch_wi_data(rocksdb_writebatch_wi_t* b, size_t* size) {
+const char* rocksdb_writebatch_wi_data(rocksdb_writebatch_wi_t* b,
+                                       size_t* size) {
   WriteBatch* wb = b->rep->GetWriteBatch();
   *size = wb->GetDataSize();
   return wb->Data().c_str();
@@ -2436,13 +2382,12 @@ void rocksdb_writebatch_wi_set_save_point(rocksdb_writebatch_wi_t* b) {
 }
 
 void rocksdb_writebatch_wi_rollback_to_save_point(rocksdb_writebatch_wi_t* b,
-                                               char** errptr) {
+                                                  char** errptr) {
   SaveError(errptr, b->rep->RollbackToSavePoint());
 }
 
 rocksdb_iterator_t* rocksdb_writebatch_wi_create_iterator_with_base(
-    rocksdb_writebatch_wi_t* wbwi,
-    rocksdb_iterator_t* base_iterator) {
+    rocksdb_writebatch_wi_t* wbwi, rocksdb_iterator_t* base_iterator) {
   rocksdb_iterator_t* result = new rocksdb_iterator_t;
   result->rep = wbwi->rep->NewIteratorWithBase(base_iterator->rep);
   delete base_iterator;
@@ -2459,12 +2404,10 @@ rocksdb_iterator_t* rocksdb_writebatch_wi_create_iterator_with_base_cf(
   return result;
 }
 
-char* rocksdb_writebatch_wi_get_from_batch(
-    rocksdb_writebatch_wi_t* wbwi,
-    const rocksdb_options_t* options,
-    const char* key, size_t keylen,
-    size_t* vallen,
-    char** errptr) {
+char* rocksdb_writebatch_wi_get_from_batch(rocksdb_writebatch_wi_t* wbwi,
+                                           const rocksdb_options_t* options,
+                                           const char* key, size_t keylen,
+                                           size_t* vallen, char** errptr) {
   char* result = nullptr;
   std::string tmp;
   Status s = wbwi->rep->GetFromBatch(options->rep, Slice(key, keylen), &tmp);
@@ -2481,16 +2424,13 @@ char* rocksdb_writebatch_wi_get_from_batch(
 }
 
 char* rocksdb_writebatch_wi_get_from_batch_cf(
-    rocksdb_writebatch_wi_t* wbwi,
-    const rocksdb_options_t* options,
-    rocksdb_column_family_handle_t* column_family,
-    const char* key, size_t keylen,
-    size_t* vallen,
-    char** errptr) {
+    rocksdb_writebatch_wi_t* wbwi, const rocksdb_options_t* options,
+    rocksdb_column_family_handle_t* column_family, const char* key,
+    size_t keylen, size_t* vallen, char** errptr) {
   char* result = nullptr;
   std::string tmp;
   Status s = wbwi->rep->GetFromBatch(column_family->rep, options->rep,
-      Slice(key, keylen), &tmp);
+                                     Slice(key, keylen), &tmp);
   if (s.ok()) {
     *vallen = tmp.size();
     result = CopyString(tmp);
@@ -2504,15 +2444,13 @@ char* rocksdb_writebatch_wi_get_from_batch_cf(
 }
 
 char* rocksdb_writebatch_wi_get_from_batch_and_db(
-    rocksdb_writebatch_wi_t* wbwi,
-    rocksdb_t* db,
-    const rocksdb_readoptions_t* options,
-    const char* key, size_t keylen,
-    size_t* vallen,
-    char** errptr) {
+    rocksdb_writebatch_wi_t* wbwi, rocksdb_t* db,
+    const rocksdb_readoptions_t* options, const char* key, size_t keylen,
+    size_t* vallen, char** errptr) {
   char* result = nullptr;
   std::string tmp;
-  Status s = wbwi->rep->GetFromBatchAndDB(db->rep, options->rep, Slice(key, keylen), &tmp);
+  Status s = wbwi->rep->GetFromBatchAndDB(db->rep, options->rep,
+                                          Slice(key, keylen), &tmp);
   if (s.ok()) {
     *vallen = tmp.size();
     result = CopyString(tmp);
@@ -2526,17 +2464,14 @@ char* rocksdb_writebatch_wi_get_from_batch_and_db(
 }
 
 char* rocksdb_writebatch_wi_get_from_batch_and_db_cf(
-    rocksdb_writebatch_wi_t* wbwi,
-    rocksdb_t* db,
+    rocksdb_writebatch_wi_t* wbwi, rocksdb_t* db,
     const rocksdb_readoptions_t* options,
-    rocksdb_column_family_handle_t* column_family,
-    const char* key, size_t keylen,
-    size_t* vallen,
-    char** errptr) {
+    rocksdb_column_family_handle_t* column_family, const char* key,
+    size_t keylen, size_t* vallen, char** errptr) {
   char* result = nullptr;
   std::string tmp;
-  Status s = wbwi->rep->GetFromBatchAndDB(db->rep, options->rep, column_family->rep,
-      Slice(key, keylen), &tmp);
+  Status s = wbwi->rep->GetFromBatchAndDB(
+      db->rep, options->rep, column_family->rep, Slice(key, keylen), &tmp);
   if (s.ok()) {
     *vallen = tmp.size();
     result = CopyString(tmp);
@@ -2549,11 +2484,9 @@ char* rocksdb_writebatch_wi_get_from_batch_and_db_cf(
   return result;
 }
 
-void rocksdb_write_writebatch_wi(
-    rocksdb_t* db,
-    const rocksdb_writeoptions_t* options,
-    rocksdb_writebatch_wi_t* wbwi,
-    char** errptr) {
+void rocksdb_write_writebatch_wi(rocksdb_t* db,
+                                 const rocksdb_writeoptions_t* options,
+                                 rocksdb_writebatch_wi_t* wbwi, char** errptr) {
   WriteBatch* wb = wbwi->rep->GetWriteBatch();
   SaveError(errptr, db->rep->Write(options->rep, wb));
 }
@@ -2608,8 +2541,7 @@ void rocksdb_load_latest_options_destroy(
   }
 }
 
-rocksdb_block_based_table_options_t*
-rocksdb_block_based_options_create() {
+rocksdb_block_based_table_options_t* rocksdb_block_based_options_create() {
   return new rocksdb_block_based_table_options_t;
 }
 
@@ -2639,22 +2571,26 @@ void rocksdb_block_based_options_set_block_restart_interval(
 }
 
 void rocksdb_block_based_options_set_index_block_restart_interval(
-    rocksdb_block_based_table_options_t* options, int index_block_restart_interval) {
+    rocksdb_block_based_table_options_t* options,
+    int index_block_restart_interval) {
   options->rep.index_block_restart_interval = index_block_restart_interval;
 }
 
 void rocksdb_block_based_options_set_metadata_block_size(
-    rocksdb_block_based_table_options_t* options, uint64_t metadata_block_size) {
+    rocksdb_block_based_table_options_t* options,
+    uint64_t metadata_block_size) {
   options->rep.metadata_block_size = metadata_block_size;
 }
 
 void rocksdb_block_based_options_set_partition_filters(
-    rocksdb_block_based_table_options_t* options, unsigned char partition_filters) {
+    rocksdb_block_based_table_options_t* options,
+    unsigned char partition_filters) {
   options->rep.partition_filters = partition_filters;
 }
 
 void rocksdb_block_based_options_set_use_delta_encoding(
-    rocksdb_block_based_table_options_t* options, unsigned char use_delta_encoding) {
+    rocksdb_block_based_table_options_t* options,
+    unsigned char use_delta_encoding) {
   options->rep.use_delta_encoding = use_delta_encoding;
 }
 
@@ -2704,7 +2640,7 @@ void rocksdb_block_based_options_set_index_type(
 void rocksdb_block_based_options_set_data_block_index_type(
     rocksdb_block_based_table_options_t* options, int v) {
   options->rep.data_block_index_type =
-          static_cast<BlockBasedTableOptions::DataBlockIndexType>(v);
+      static_cast<BlockBasedTableOptions::DataBlockIndexType>(v);
 }
 
 void rocksdb_block_based_options_set_data_block_hash_ratio(
@@ -2733,7 +2669,7 @@ void rocksdb_block_based_options_set_pin_top_level_index_and_filter(
 }
 
 void rocksdb_options_set_block_based_table_factory(
-    rocksdb_options_t *opt,
+    rocksdb_options_t* opt,
     rocksdb_block_based_table_options_t* table_options) {
   if (table_options) {
     opt->rep.table_factory.reset(
@@ -2741,13 +2677,11 @@ void rocksdb_options_set_block_based_table_factory(
   }
 }
 
-rocksdb_cuckoo_table_options_t*
-rocksdb_cuckoo_options_create() {
+rocksdb_cuckoo_table_options_t* rocksdb_cuckoo_options_create() {
   return new rocksdb_cuckoo_table_options_t;
 }
 
-void rocksdb_cuckoo_options_destroy(
-    rocksdb_cuckoo_table_options_t* options) {
+void rocksdb_cuckoo_options_destroy(rocksdb_cuckoo_table_options_t* options) {
   delete options;
 }
 
@@ -2777,51 +2711,44 @@ void rocksdb_cuckoo_options_set_use_module_hash(
 }
 
 void rocksdb_options_set_cuckoo_table_factory(
-    rocksdb_options_t *opt,
-    rocksdb_cuckoo_table_options_t* table_options) {
+    rocksdb_options_t* opt, rocksdb_cuckoo_table_options_t* table_options) {
   if (table_options) {
     opt->rep.table_factory.reset(
         ROCKSDB_NAMESPACE::NewCuckooTableFactory(table_options->rep));
   }
 }
 
-void rocksdb_set_options(
-    rocksdb_t* db, int count, const char* const keys[], const char* const values[], char** errptr) {
-        std::unordered_map<std::string, std::string> options_map;
-        for (int i=0; i<count; i++)
-            options_map[keys[i]] = values[i];
-        SaveError(errptr,
-            db->rep->SetOptions(options_map));
-    }
-
-void rocksdb_set_options_cf(
-    rocksdb_t* db, rocksdb_column_family_handle_t* handle, int count, const char* const keys[], const char* const values[], char** errptr) {
-        std::unordered_map<std::string, std::string> options_map;
-        for (int i=0; i<count; i++)
-            options_map[keys[i]] = values[i];
-        SaveError(errptr,
-            db->rep->SetOptions(handle->rep, options_map));
-    }
-
-rocksdb_options_t* rocksdb_options_create() {
-  return new rocksdb_options_t;
+void rocksdb_set_options(rocksdb_t* db, int count, const char* const keys[],
+                         const char* const values[], char** errptr) {
+  std::unordered_map<std::string, std::string> options_map;
+  for (int i = 0; i < count; i++) options_map[keys[i]] = values[i];
+  SaveError(errptr, db->rep->SetOptions(options_map));
 }
 
-void rocksdb_options_destroy(rocksdb_options_t* options) {
-  delete options;
+void rocksdb_set_options_cf(rocksdb_t* db,
+                            rocksdb_column_family_handle_t* handle, int count,
+                            const char* const keys[],
+                            const char* const values[], char** errptr) {
+  std::unordered_map<std::string, std::string> options_map;
+  for (int i = 0; i < count; i++) options_map[keys[i]] = values[i];
+  SaveError(errptr, db->rep->SetOptions(handle->rep, options_map));
 }
 
+rocksdb_options_t* rocksdb_options_create() { return new rocksdb_options_t; }
+
+void rocksdb_options_destroy(rocksdb_options_t* options) { delete options; }
+
 rocksdb_options_t* rocksdb_options_create_copy(rocksdb_options_t* options) {
   return new rocksdb_options_t(*options);
 }
 
-void rocksdb_options_increase_parallelism(
-    rocksdb_options_t* opt, int total_threads) {
+void rocksdb_options_increase_parallelism(rocksdb_options_t* opt,
+                                          int total_threads) {
   opt->rep.IncreaseParallelism(total_threads);
 }
 
-void rocksdb_options_optimize_for_point_lookup(
-    rocksdb_options_t* opt, uint64_t block_cache_size_mb) {
+void rocksdb_options_optimize_for_point_lookup(rocksdb_options_t* opt,
+                                               uint64_t block_cache_size_mb) {
   opt->rep.OptimizeForPointLookup(block_cache_size_mb);
 }
 
@@ -2835,8 +2762,8 @@ void rocksdb_options_optimize_universal_style_compaction(
   opt->rep.OptimizeUniversalStyleCompaction(memtable_memory_budget);
 }
 
-void rocksdb_options_set_allow_ingest_behind(
-    rocksdb_options_t* opt, unsigned char v) {
+void rocksdb_options_set_allow_ingest_behind(rocksdb_options_t* opt,
+                                             unsigned char v) {
   opt->rep.allow_ingest_behind = v;
 }
 
@@ -2844,9 +2771,8 @@ unsigned char rocksdb_options_get_allow_ingest_behind(rocksdb_options_t* opt) {
   return opt->rep.allow_ingest_behind;
 }
 
-void rocksdb_options_set_compaction_filter(
-    rocksdb_options_t* opt,
-    rocksdb_compactionfilter_t* filter) {
+void rocksdb_options_set_compaction_filter(rocksdb_options_t* opt,
+                                           rocksdb_compactionfilter_t* filter) {
   opt->rep.compaction_filter = filter;
 }
 
@@ -2856,8 +2782,8 @@ void rocksdb_options_set_compaction_filter_factory(
       std::shared_ptr<CompactionFilterFactory>(factory);
 }
 
-void rocksdb_options_compaction_readahead_size(
-    rocksdb_options_t* opt, size_t s) {
+void rocksdb_options_compaction_readahead_size(rocksdb_options_t* opt,
+                                               size_t s) {
   opt->rep.compaction_readahead_size = s;
 }
 
@@ -2865,20 +2791,18 @@ size_t rocksdb_options_get_compaction_readahead_size(rocksdb_options_t* opt) {
   return opt->rep.compaction_readahead_size;
 }
 
-void rocksdb_options_set_comparator(
-    rocksdb_options_t* opt,
-    rocksdb_comparator_t* cmp) {
+void rocksdb_options_set_comparator(rocksdb_options_t* opt,
+                                    rocksdb_comparator_t* cmp) {
   opt->rep.comparator = cmp;
 }
 
 void rocksdb_options_set_merge_operator(
-    rocksdb_options_t* opt,
-    rocksdb_mergeoperator_t* merge_operator) {
+    rocksdb_options_t* opt, rocksdb_mergeoperator_t* merge_operator) {
   opt->rep.merge_operator = std::shared_ptr<MergeOperator>(merge_operator);
 }
 
-void rocksdb_options_set_create_if_missing(
-    rocksdb_options_t* opt, unsigned char v) {
+void rocksdb_options_set_create_if_missing(rocksdb_options_t* opt,
+                                           unsigned char v) {
   opt->rep.create_if_missing = v;
 }
 
@@ -2886,8 +2810,8 @@ unsigned char rocksdb_options_get_create_if_missing(rocksdb_options_t* opt) {
   return opt->rep.create_if_missing;
 }
 
-void rocksdb_options_set_create_missing_column_families(
-    rocksdb_options_t* opt, unsigned char v) {
+void rocksdb_options_set_create_missing_column_families(rocksdb_options_t* opt,
+                                                        unsigned char v) {
   opt->rep.create_missing_column_families = v;
 }
 
@@ -2896,8 +2820,8 @@ unsigned char rocksdb_options_get_create_missing_column_families(
   return opt->rep.create_missing_column_families;
 }
 
-void rocksdb_options_set_error_if_exists(
-    rocksdb_options_t* opt, unsigned char v) {
+void rocksdb_options_set_error_if_exists(rocksdb_options_t* opt,
+                                         unsigned char v) {
   opt->rep.error_if_exists = v;
 }
 
@@ -2905,8 +2829,8 @@ unsigned char rocksdb_options_get_error_if_exists(rocksdb_options_t* opt) {
   return opt->rep.error_if_exists;
 }
 
-void rocksdb_options_set_paranoid_checks(
-    rocksdb_options_t* opt, unsigned char v) {
+void rocksdb_options_set_paranoid_checks(rocksdb_options_t* opt,
+                                         unsigned char v) {
   opt->rep.paranoid_checks = v;
 }
 
@@ -2934,8 +2858,7 @@ void rocksdb_options_set_info_log(rocksdb_options_t* opt, rocksdb_logger_t* l) {
   }
 }
 
-void rocksdb_options_set_info_log_level(
-    rocksdb_options_t* opt, int v) {
+void rocksdb_options_set_info_log_level(rocksdb_options_t* opt, int v) {
   opt->rep.info_log_level = static_cast<InfoLogLevel>(v);
 }
 
@@ -2968,7 +2891,8 @@ int rocksdb_options_get_max_open_files(rocksdb_options_t* opt) {
   return opt->rep.max_open_files;
 }
 
-void rocksdb_options_set_max_file_opening_threads(rocksdb_options_t* opt, int n) {
+void rocksdb_options_set_max_file_opening_threads(rocksdb_options_t* opt,
+                                                  int n) {
   opt->rep.max_file_opening_threads = n;
 }
 
@@ -2976,7 +2900,8 @@ int rocksdb_options_get_max_file_opening_threads(rocksdb_options_t* opt) {
   return opt->rep.max_file_opening_threads;
 }
 
-void rocksdb_options_set_max_total_wal_size(rocksdb_options_t* opt, uint64_t n) {
+void rocksdb_options_set_max_total_wal_size(rocksdb_options_t* opt,
+                                            uint64_t n) {
   opt->rep.max_total_wal_size = n;
 }
 
@@ -2984,8 +2909,8 @@ uint64_t rocksdb_options_get_max_total_wal_size(rocksdb_options_t* opt) {
   return opt->rep.max_total_wal_size;
 }
 
-void rocksdb_options_set_target_file_size_base(
-    rocksdb_options_t* opt, uint64_t n) {
+void rocksdb_options_set_target_file_size_base(rocksdb_options_t* opt,
+                                               uint64_t n) {
   opt->rep.target_file_size_base = n;
 }
 
@@ -2993,8 +2918,8 @@ uint64_t rocksdb_options_get_target_file_size_base(rocksdb_options_t* opt) {
   return opt->rep.target_file_size_base;
 }
 
-void rocksdb_options_set_target_file_size_multiplier(
-    rocksdb_options_t* opt, int n) {
+void rocksdb_options_set_target_file_size_multiplier(rocksdb_options_t* opt,
+                                                     int n) {
   opt->rep.target_file_size_multiplier = n;
 }
 
@@ -3002,8 +2927,8 @@ int rocksdb_options_get_target_file_size_multiplier(rocksdb_options_t* opt) {
   return opt->rep.target_file_size_multiplier;
 }
 
-void rocksdb_options_set_max_bytes_for_level_base(
-    rocksdb_options_t* opt, uint64_t n) {
+void rocksdb_options_set_max_bytes_for_level_base(rocksdb_options_t* opt,
+                                                  uint64_t n) {
   opt->rep.max_bytes_for_level_base = n;
 }
 
@@ -3184,8 +3109,8 @@ int rocksdb_options_get_level0_file_num_compaction_trigger(
   return opt->rep.level0_file_num_compaction_trigger;
 }
 
-void rocksdb_options_set_level0_slowdown_writes_trigger(
-    rocksdb_options_t* opt, int n) {
+void rocksdb_options_set_level0_slowdown_writes_trigger(rocksdb_options_t* opt,
+                                                        int n) {
   opt->rep.level0_slowdown_writes_trigger = n;
 }
 
@@ -3193,8 +3118,8 @@ int rocksdb_options_get_level0_slowdown_writes_trigger(rocksdb_options_t* opt) {
   return opt->rep.level0_slowdown_writes_trigger;
 }
 
-void rocksdb_options_set_level0_stop_writes_trigger(
-    rocksdb_options_t* opt, int n) {
+void rocksdb_options_set_level0_stop_writes_trigger(rocksdb_options_t* opt,
+                                                    int n) {
   opt->rep.level0_stop_writes_trigger = n;
 }
 
@@ -3202,7 +3127,7 @@ int rocksdb_options_get_level0_stop_writes_trigger(rocksdb_options_t* opt) {
   return opt->rep.level0_stop_writes_trigger;
 }
 
-void rocksdb_options_set_wal_recovery_mode(rocksdb_options_t* opt,int mode) {
+void rocksdb_options_set_wal_recovery_mode(rocksdb_options_t* opt, int mode) {
   opt->rep.wal_recovery_mode = static_cast<WALRecoveryMode>(mode);
 }
 
@@ -3232,7 +3157,7 @@ void rocksdb_options_set_compression_per_level(rocksdb_options_t* opt,
   opt->rep.compression_per_level.resize(num_levels);
   for (size_t i = 0; i < num_levels; ++i) {
     opt->rep.compression_per_level[i] =
-      static_cast<CompressionType>(level_values[i]);
+        static_cast<CompressionType>(level_values[i]);
   }
 }
 
@@ -3331,8 +3256,7 @@ void rocksdb_options_set_prefix_extractor(
   opt->rep.prefix_extractor.reset(prefix_extractor);
 }
 
-void rocksdb_options_set_use_fsync(
-    rocksdb_options_t* opt, int use_fsync) {
+void rocksdb_options_set_use_fsync(rocksdb_options_t* opt, int use_fsync) {
   opt->rep.use_fsync = use_fsync;
 }
 
@@ -3340,13 +3264,12 @@ int rocksdb_options_get_use_fsync(rocksdb_options_t* opt) {
   return opt->rep.use_fsync;
 }
 
-void rocksdb_options_set_db_log_dir(
-    rocksdb_options_t* opt, const char* db_log_dir) {
+void rocksdb_options_set_db_log_dir(rocksdb_options_t* opt,
+                                    const char* db_log_dir) {
   opt->rep.db_log_dir = db_log_dir;
 }
 
-void rocksdb_options_set_wal_dir(
-    rocksdb_options_t* opt, const char* v) {
+void rocksdb_options_set_wal_dir(rocksdb_options_t* opt, const char* v) {
   opt->rep.wal_dir = v;
 }
 
@@ -3358,8 +3281,8 @@ uint64_t rocksdb_options_get_WAL_ttl_seconds(rocksdb_options_t* opt) {
   return opt->rep.WAL_ttl_seconds;
 }
 
-void rocksdb_options_set_WAL_size_limit_MB(
-    rocksdb_options_t* opt, uint64_t limit) {
+void rocksdb_options_set_WAL_size_limit_MB(rocksdb_options_t* opt,
+                                           uint64_t limit) {
   opt->rep.WAL_size_limit_MB = limit;
 }
 
@@ -3367,8 +3290,8 @@ uint64_t rocksdb_options_get_WAL_size_limit_MB(rocksdb_options_t* opt) {
   return opt->rep.WAL_size_limit_MB;
 }
 
-void rocksdb_options_set_manifest_preallocation_size(
-    rocksdb_options_t* opt, size_t v) {
+void rocksdb_options_set_manifest_preallocation_size(rocksdb_options_t* opt,
+                                                     size_t v) {
   opt->rep.manifest_preallocation_size = v;
 }
 
@@ -3395,8 +3318,8 @@ unsigned char rocksdb_options_get_use_direct_io_for_flush_and_compaction(
   return opt->rep.use_direct_io_for_flush_and_compaction;
 }
 
-void rocksdb_options_set_allow_mmap_reads(
-    rocksdb_options_t* opt, unsigned char v) {
+void rocksdb_options_set_allow_mmap_reads(rocksdb_options_t* opt,
+                                          unsigned char v) {
   opt->rep.allow_mmap_reads = v;
 }
 
@@ -3404,8 +3327,8 @@ unsigned char rocksdb_options_get_allow_mmap_reads(rocksdb_options_t* opt) {
   return opt->rep.allow_mmap_reads;
 }
 
-void rocksdb_options_set_allow_mmap_writes(
-    rocksdb_options_t* opt, unsigned char v) {
+void rocksdb_options_set_allow_mmap_writes(rocksdb_options_t* opt,
+                                           unsigned char v) {
   opt->rep.allow_mmap_writes = v;
 }
 
@@ -3413,8 +3336,8 @@ unsigned char rocksdb_options_get_allow_mmap_writes(rocksdb_options_t* opt) {
   return opt->rep.allow_mmap_writes;
 }
 
-void rocksdb_options_set_is_fd_close_on_exec(
-    rocksdb_options_t* opt, unsigned char v) {
+void rocksdb_options_set_is_fd_close_on_exec(rocksdb_options_t* opt,
+                                             unsigned char v) {
   opt->rep.is_fd_close_on_exec = v;
 }
 
@@ -3422,8 +3345,8 @@ unsigned char rocksdb_options_get_is_fd_close_on_exec(rocksdb_options_t* opt) {
   return opt->rep.is_fd_close_on_exec;
 }
 
-void rocksdb_options_set_stats_dump_period_sec(
-    rocksdb_options_t* opt, unsigned int v) {
+void rocksdb_options_set_stats_dump_period_sec(rocksdb_options_t* opt,
+                                               unsigned int v) {
   opt->rep.stats_dump_period_sec = v;
 }
 
@@ -3441,8 +3364,8 @@ unsigned int rocksdb_options_get_stats_persist_period_sec(
   return opt->rep.stats_persist_period_sec;
 }
 
-void rocksdb_options_set_advise_random_on_open(
-    rocksdb_options_t* opt, unsigned char v) {
+void rocksdb_options_set_advise_random_on_open(rocksdb_options_t* opt,
+                                               unsigned char v) {
   opt->rep.advise_random_on_open = v;
 }
 
@@ -3451,9 +3374,9 @@ unsigned char rocksdb_options_get_advise_random_on_open(
   return opt->rep.advise_random_on_open;
 }
 
-void rocksdb_options_set_access_hint_on_compaction_start(
-    rocksdb_options_t* opt, int v) {
-  switch(v) {
+void rocksdb_options_set_access_hint_on_compaction_start(rocksdb_options_t* opt,
+                                                         int v) {
+  switch (v) {
     case 0:
       opt->rep.access_hint_on_compaction_start =
           ROCKSDB_NAMESPACE::Options::NONE;
@@ -3480,8 +3403,8 @@ int rocksdb_options_get_access_hint_on_compaction_start(
   return opt->rep.access_hint_on_compaction_start;
 }
 
-void rocksdb_options_set_use_adaptive_mutex(
-    rocksdb_options_t* opt, unsigned char v) {
+void rocksdb_options_set_use_adaptive_mutex(rocksdb_options_t* opt,
+                                            unsigned char v) {
   opt->rep.use_adaptive_mutex = v;
 }
 
@@ -3489,8 +3412,8 @@ unsigned char rocksdb_options_get_use_adaptive_mutex(rocksdb_options_t* opt) {
   return opt->rep.use_adaptive_mutex;
 }
 
-void rocksdb_options_set_wal_bytes_per_sync(
-    rocksdb_options_t* opt, uint64_t v) {
+void rocksdb_options_set_wal_bytes_per_sync(rocksdb_options_t* opt,
+                                            uint64_t v) {
   opt->rep.wal_bytes_per_sync = v;
 }
 
@@ -3498,8 +3421,7 @@ uint64_t rocksdb_options_get_wal_bytes_per_sync(rocksdb_options_t* opt) {
   return opt->rep.wal_bytes_per_sync;
 }
 
-void rocksdb_options_set_bytes_per_sync(
-    rocksdb_options_t* opt, uint64_t v) {
+void rocksdb_options_set_bytes_per_sync(rocksdb_options_t* opt, uint64_t v) {
   opt->rep.bytes_per_sync = v;
 }
 
@@ -3547,7 +3469,8 @@ uint64_t rocksdb_options_get_max_sequential_skip_in_iterations(
   return opt->rep.max_sequential_skip_in_iterations;
 }
 
-void rocksdb_options_set_max_write_buffer_number(rocksdb_options_t* opt, int n) {
+void rocksdb_options_set_max_write_buffer_number(rocksdb_options_t* opt,
+                                                 int n) {
   opt->rep.max_write_buffer_number = n;
 }
 
@@ -3555,7 +3478,8 @@ int rocksdb_options_get_max_write_buffer_number(rocksdb_options_t* opt) {
   return opt->rep.max_write_buffer_number;
 }
 
-void rocksdb_options_set_min_write_buffer_number_to_merge(rocksdb_options_t* opt, int n) {
+void rocksdb_options_set_min_write_buffer_number_to_merge(
+    rocksdb_options_t* opt, int n) {
   opt->rep.min_write_buffer_number_to_merge = n;
 }
 
@@ -3620,7 +3544,8 @@ int rocksdb_options_get_max_background_jobs(rocksdb_options_t* opt) {
   return opt->rep.max_background_jobs;
 }
 
-void rocksdb_options_set_max_background_compactions(rocksdb_options_t* opt, int n) {
+void rocksdb_options_set_max_background_compactions(rocksdb_options_t* opt,
+                                                    int n) {
   opt->rep.max_background_compactions = n;
 }
 
@@ -3654,7 +3579,8 @@ size_t rocksdb_options_get_max_log_file_size(rocksdb_options_t* opt) {
   return opt->rep.max_log_file_size;
 }
 
-void rocksdb_options_set_log_file_time_to_roll(rocksdb_options_t* opt, size_t v) {
+void rocksdb_options_set_log_file_time_to_roll(rocksdb_options_t* opt,
+                                               size_t v) {
   opt->rep.log_file_time_to_roll = v;
 }
 
@@ -3679,7 +3605,8 @@ size_t rocksdb_options_get_recycle_log_file_num(rocksdb_options_t* opt) {
   return opt->rep.recycle_log_file_num;
 }
 
-void rocksdb_options_set_soft_pending_compaction_bytes_limit(rocksdb_options_t* opt, size_t v) {
+void rocksdb_options_set_soft_pending_compaction_bytes_limit(
+    rocksdb_options_t* opt, size_t v) {
   opt->rep.soft_pending_compaction_bytes_limit = v;
 }
 
@@ -3688,7 +3615,8 @@ size_t rocksdb_options_get_soft_pending_compaction_bytes_limit(
   return opt->rep.soft_pending_compaction_bytes_limit;
 }
 
-void rocksdb_options_set_hard_pending_compaction_bytes_limit(rocksdb_options_t* opt, size_t v) {
+void rocksdb_options_set_hard_pending_compaction_bytes_limit(
+    rocksdb_options_t* opt, size_t v) {
   opt->rep.hard_pending_compaction_bytes_limit = v;
 }
 
@@ -3697,8 +3625,8 @@ size_t rocksdb_options_get_hard_pending_compaction_bytes_limit(
   return opt->rep.hard_pending_compaction_bytes_limit;
 }
 
-void rocksdb_options_set_max_manifest_file_size(
-    rocksdb_options_t* opt, size_t v) {
+void rocksdb_options_set_max_manifest_file_size(rocksdb_options_t* opt,
+                                                size_t v) {
   opt->rep.max_manifest_file_size = v;
 }
 
@@ -3706,8 +3634,8 @@ size_t rocksdb_options_get_max_manifest_file_size(rocksdb_options_t* opt) {
   return opt->rep.max_manifest_file_size;
 }
 
-void rocksdb_options_set_table_cache_numshardbits(
-    rocksdb_options_t* opt, int v) {
+void rocksdb_options_set_table_cache_numshardbits(rocksdb_options_t* opt,
+                                                  int v) {
   opt->rep.table_cache_numshardbits = v;
 }
 
@@ -3715,8 +3643,7 @@ int rocksdb_options_get_table_cache_numshardbits(rocksdb_options_t* opt) {
   return opt->rep.table_cache_numshardbits;
 }
 
-void rocksdb_options_set_arena_block_size(
-    rocksdb_options_t* opt, size_t v) {
+void rocksdb_options_set_arena_block_size(rocksdb_options_t* opt, size_t v) {
   opt->rep.arena_block_size = v;
 }
 
@@ -3724,7 +3651,8 @@ size_t rocksdb_options_get_arena_block_size(rocksdb_options_t* opt) {
   return opt->rep.arena_block_size;
 }
 
-void rocksdb_options_set_disable_auto_compactions(rocksdb_options_t* opt, int disable) {
+void rocksdb_options_set_disable_auto_compactions(rocksdb_options_t* opt,
+                                                  int disable) {
   opt->rep.disable_auto_compactions = disable;
 }
 
@@ -3733,7 +3661,8 @@ unsigned char rocksdb_options_get_disable_auto_compactions(
   return opt->rep.disable_auto_compactions;
 }
 
-void rocksdb_options_set_optimize_filters_for_hits(rocksdb_options_t* opt, int v) {
+void rocksdb_options_set_optimize_filters_for_hits(rocksdb_options_t* opt,
+                                                   int v) {
   opt->rep.optimize_filters_for_hits = v;
 }
 
@@ -3756,7 +3685,7 @@ void rocksdb_options_prepare_for_bulk_load(rocksdb_options_t* opt) {
   opt->rep.PrepareForBulkLoad();
 }
 
-void rocksdb_options_set_memtable_vector_rep(rocksdb_options_t *opt) {
+void rocksdb_options_set_memtable_vector_rep(rocksdb_options_t* opt) {
   opt->rep.memtable_factory.reset(new ROCKSDB_NAMESPACE::VectorRepFactory);
 }
 
@@ -3779,24 +3708,27 @@ size_t rocksdb_options_get_memtable_huge_page_size(rocksdb_options_t* opt) {
   return opt->rep.memtable_huge_page_size;
 }
 
-void rocksdb_options_set_hash_skip_list_rep(
-    rocksdb_options_t *opt, size_t bucket_count,
-    int32_t skiplist_height, int32_t skiplist_branching_factor) {
+void rocksdb_options_set_hash_skip_list_rep(rocksdb_options_t* opt,
+                                            size_t bucket_count,
+                                            int32_t skiplist_height,
+                                            int32_t skiplist_branching_factor) {
   ROCKSDB_NAMESPACE::MemTableRepFactory* factory =
       ROCKSDB_NAMESPACE::NewHashSkipListRepFactory(
           bucket_count, skiplist_height, skiplist_branching_factor);
   opt->rep.memtable_factory.reset(factory);
 }
 
-void rocksdb_options_set_hash_link_list_rep(
-    rocksdb_options_t *opt, size_t bucket_count) {
+void rocksdb_options_set_hash_link_list_rep(rocksdb_options_t* opt,
+                                            size_t bucket_count) {
   opt->rep.memtable_factory.reset(
       ROCKSDB_NAMESPACE::NewHashLinkListRepFactory(bucket_count));
 }
 
-void rocksdb_options_set_plain_table_factory(
-    rocksdb_options_t *opt, uint32_t user_key_len, int bloom_bits_per_key,
-    double hash_table_ratio, size_t index_sparseness) {
+void rocksdb_options_set_plain_table_factory(rocksdb_options_t* opt,
+                                             uint32_t user_key_len,
+                                             int bloom_bits_per_key,
+                                             double hash_table_ratio,
+                                             size_t index_sparseness) {
   ROCKSDB_NAMESPACE::PlainTableOptions options;
   options.user_key_len = user_key_len;
   options.bloom_bits_per_key = bloom_bits_per_key;
@@ -3808,8 +3740,8 @@ void rocksdb_options_set_plain_table_factory(
   opt->rep.table_factory.reset(factory);
 }
 
-void rocksdb_options_set_max_successive_merges(
-    rocksdb_options_t* opt, size_t v) {
+void rocksdb_options_set_max_successive_merges(rocksdb_options_t* opt,
+                                               size_t v) {
   opt->rep.max_successive_merges = v;
 }
 
@@ -3817,8 +3749,7 @@ size_t rocksdb_options_get_max_successive_merges(rocksdb_options_t* opt) {
   return opt->rep.max_successive_merges;
 }
 
-void rocksdb_options_set_bloom_locality(
-    rocksdb_options_t* opt, uint32_t v) {
+void rocksdb_options_set_bloom_locality(rocksdb_options_t* opt, uint32_t v) {
   opt->rep.bloom_locality = v;
 }
 
@@ -3826,8 +3757,8 @@ uint32_t rocksdb_options_get_bloom_locality(rocksdb_options_t* opt) {
   return opt->rep.bloom_locality;
 }
 
-void rocksdb_options_set_inplace_update_support(
-    rocksdb_options_t* opt, unsigned char v) {
+void rocksdb_options_set_inplace_update_support(rocksdb_options_t* opt,
+                                                unsigned char v) {
   opt->rep.inplace_update_support = v;
 }
 
@@ -3836,8 +3767,8 @@ unsigned char rocksdb_options_get_inplace_update_support(
   return opt->rep.inplace_update_support;
 }
 
-void rocksdb_options_set_inplace_update_num_locks(
-    rocksdb_options_t* opt, size_t v) {
+void rocksdb_options_set_inplace_update_num_locks(rocksdb_options_t* opt,
+                                                  size_t v) {
   opt->rep.inplace_update_num_locks = v;
 }
 
@@ -3845,8 +3776,7 @@ size_t rocksdb_options_get_inplace_update_num_locks(rocksdb_options_t* opt) {
   return opt->rep.inplace_update_num_locks;
 }
 
-void rocksdb_options_set_report_bg_io_stats(
-    rocksdb_options_t* opt, int v) {
+void rocksdb_options_set_report_bg_io_stats(rocksdb_options_t* opt, int v) {
   opt->rep.report_bg_io_stats = v;
 }
 
@@ -3854,7 +3784,7 @@ unsigned char rocksdb_options_get_report_bg_io_stats(rocksdb_options_t* opt) {
   return opt->rep.report_bg_io_stats;
 }
 
-void rocksdb_options_set_compaction_style(rocksdb_options_t *opt, int style) {
+void rocksdb_options_set_compaction_style(rocksdb_options_t* opt, int style) {
   opt->rep.compaction_style =
       static_cast<ROCKSDB_NAMESPACE::CompactionStyle>(style);
 }
@@ -3863,17 +3793,17 @@ int rocksdb_options_get_compaction_style(rocksdb_options_t* opt) {
   return opt->rep.compaction_style;
 }
 
-void rocksdb_options_set_universal_compaction_options(rocksdb_options_t *opt, rocksdb_universal_compaction_options_t *uco) {
+void rocksdb_options_set_universal_compaction_options(
+    rocksdb_options_t* opt, rocksdb_universal_compaction_options_t* uco) {
   opt->rep.compaction_options_universal = *(uco->rep);
 }
 
 void rocksdb_options_set_fifo_compaction_options(
-    rocksdb_options_t* opt,
-    rocksdb_fifo_compaction_options_t* fifo) {
+    rocksdb_options_t* opt, rocksdb_fifo_compaction_options_t* fifo) {
   opt->rep.compaction_options_fifo = fifo->rep;
 }
 
-char *rocksdb_options_statistics_get_string(rocksdb_options_t *opt) {
+char* rocksdb_options_statistics_get_string(rocksdb_options_t* opt) {
   ROCKSDB_NAMESPACE::Statistics* statistics = opt->rep.statistics.get();
   if (statistics) {
     return strdup(statistics->ToString().c_str());
@@ -3881,7 +3811,8 @@ char *rocksdb_options_statistics_get_string(rocksdb_options_t *opt) {
   return nullptr;
 }
 
-void rocksdb_options_set_ratelimiter(rocksdb_options_t *opt, rocksdb_ratelimiter_t *limiter) {
+void rocksdb_options_set_ratelimiter(rocksdb_options_t* opt,
+                                     rocksdb_ratelimiter_t* limiter) {
   if (limiter) {
     opt->rep.rate_limiter = limiter->rep;
   }
@@ -3913,23 +3844,22 @@ int rocksdb_options_get_wal_compression(rocksdb_options_t* opt) {
   return opt->rep.wal_compression;
 }
 
-rocksdb_ratelimiter_t* rocksdb_ratelimiter_create(
-    int64_t rate_bytes_per_sec,
-    int64_t refill_period_us,
-    int32_t fairness) {
+rocksdb_ratelimiter_t* rocksdb_ratelimiter_create(int64_t rate_bytes_per_sec,
+                                                  int64_t refill_period_us,
+                                                  int32_t fairness) {
   rocksdb_ratelimiter_t* rate_limiter = new rocksdb_ratelimiter_t;
   rate_limiter->rep.reset(
-               NewGenericRateLimiter(rate_bytes_per_sec,
-                                     refill_period_us, fairness));
+      NewGenericRateLimiter(rate_bytes_per_sec, refill_period_us, fairness));
   return rate_limiter;
 }
 
-void rocksdb_ratelimiter_destroy(rocksdb_ratelimiter_t *limiter) {
+void rocksdb_ratelimiter_destroy(rocksdb_ratelimiter_t* limiter) {
   delete limiter;
 }
 
-void rocksdb_options_set_row_cache(rocksdb_options_t* opt, rocksdb_cache_t* cache) {
-  if(cache) {
+void rocksdb_options_set_row_cache(rocksdb_options_t* opt,
+                                   rocksdb_cache_t* cache) {
+  if (cache) {
     opt->rep.row_cache = cache->rep;
   }
 }
@@ -3958,12 +3888,12 @@ void rocksdb_perfcontext_reset(rocksdb_perfcontext_t* context) {
 }
 
 char* rocksdb_perfcontext_report(rocksdb_perfcontext_t* context,
-    unsigned char exclude_zero_counters) {
+                                 unsigned char exclude_zero_counters) {
   return strdup(context->rep->ToString(exclude_zero_counters).c_str());
 }
 
 uint64_t rocksdb_perfcontext_metric(rocksdb_perfcontext_t* context,
-    int metric) {
+                                    int metric) {
   PerfContext* rep = context->rep;
   switch (metric) {
     case rocksdb_user_key_comparison_count:
@@ -4143,15 +4073,12 @@ table_properties_collectors
 */
 
 rocksdb_compactionfilter_t* rocksdb_compactionfilter_create(
-    void* state,
-    void (*destructor)(void*),
-    unsigned char (*filter)(
-        void*,
-        int level,
-        const char* key, size_t key_length,
-        const char* existing_value, size_t value_length,
-        char** new_value, size_t *new_value_length,
-        unsigned char* value_changed),
+    void* state, void (*destructor)(void*),
+    unsigned char (*filter)(void*, int level, const char* key,
+                            size_t key_length, const char* existing_value,
+                            size_t value_length, char** new_value,
+                            size_t* new_value_length,
+                            unsigned char* value_changed),
     const char* (*name)(void*)) {
   rocksdb_compactionfilter_t* result = new rocksdb_compactionfilter_t;
   result->state_ = state;
@@ -4163,8 +4090,7 @@ rocksdb_compactionfilter_t* rocksdb_compactionfilter_create(
 }
 
 void rocksdb_compactionfilter_set_ignore_snapshots(
-  rocksdb_compactionfilter_t* filter,
-  unsigned char whether_ignore) {
+    rocksdb_compactionfilter_t* filter, unsigned char whether_ignore) {
   filter->ignore_snapshots_ = whether_ignore;
 }
 
@@ -4202,12 +4128,9 @@ void rocksdb_compactionfilterfactory_destroy(
 }
 
 rocksdb_comparator_t* rocksdb_comparator_create(
-    void* state,
-    void (*destructor)(void*),
-    int (*compare)(
-        void*,
-        const char* a, size_t alen,
-        const char* b, size_t blen),
+    void* state, void (*destructor)(void*),
+    int (*compare)(void*, const char* a, size_t alen, const char* b,
+                   size_t blen),
     const char* (*name)(void*)) {
   rocksdb_comparator_t* result = new rocksdb_comparator_t;
   result->state_ = state;
@@ -4360,13 +4283,10 @@ rocksdb_readoptions_t* rocksdb_readoptions_create() {
   return new rocksdb_readoptions_t;
 }
 
-void rocksdb_readoptions_destroy(rocksdb_readoptions_t* opt) {
-  delete opt;
-}
+void rocksdb_readoptions_destroy(rocksdb_readoptions_t* opt) { delete opt; }
 
-void rocksdb_readoptions_set_verify_checksums(
-    rocksdb_readoptions_t* opt,
-    unsigned char v) {
+void rocksdb_readoptions_set_verify_checksums(rocksdb_readoptions_t* opt,
+                                              unsigned char v) {
   opt->rep.verify_checksums = v;
 }
 
@@ -4375,8 +4295,8 @@ unsigned char rocksdb_readoptions_get_verify_checksums(
   return opt->rep.verify_checksums;
 }
 
-void rocksdb_readoptions_set_fill_cache(
-    rocksdb_readoptions_t* opt, unsigned char v) {
+void rocksdb_readoptions_set_fill_cache(rocksdb_readoptions_t* opt,
+                                        unsigned char v) {
   opt->rep.fill_cache = v;
 }
 
@@ -4384,15 +4304,14 @@ unsigned char rocksdb_readoptions_get_fill_cache(rocksdb_readoptions_t* opt) {
   return opt->rep.fill_cache;
 }
 
-void rocksdb_readoptions_set_snapshot(
-    rocksdb_readoptions_t* opt,
-    const rocksdb_snapshot_t* snap) {
+void rocksdb_readoptions_set_snapshot(rocksdb_readoptions_t* opt,
+                                      const rocksdb_snapshot_t* snap) {
   opt->rep.snapshot = (snap ? snap->rep : nullptr);
 }
 
-void rocksdb_readoptions_set_iterate_upper_bound(
-    rocksdb_readoptions_t* opt,
-    const char* key, size_t keylen) {
+void rocksdb_readoptions_set_iterate_upper_bound(rocksdb_readoptions_t* opt,
+                                                 const char* key,
+                                                 size_t keylen) {
   if (key == nullptr) {
     opt->upper_bound = Slice();
     opt->rep.iterate_upper_bound = nullptr;
@@ -4403,9 +4322,9 @@ void rocksdb_readoptions_set_iterate_upper_bound(
   }
 }
 
-void rocksdb_readoptions_set_iterate_lower_bound(
-    rocksdb_readoptions_t *opt,
-    const char* key, size_t keylen) {
+void rocksdb_readoptions_set_iterate_lower_bound(rocksdb_readoptions_t* opt,
+                                                 const char* key,
+                                                 size_t keylen) {
   if (key == nullptr) {
     opt->lower_bound = Slice();
     opt->rep.iterate_lower_bound = nullptr;
@@ -4415,8 +4334,7 @@ void rocksdb_readoptions_set_iterate_lower_bound(
   }
 }
 
-void rocksdb_readoptions_set_read_tier(
-    rocksdb_readoptions_t* opt, int v) {
+void rocksdb_readoptions_set_read_tier(rocksdb_readoptions_t* opt, int v) {
   opt->rep.read_tier = static_cast<ROCKSDB_NAMESPACE::ReadTier>(v);
 }
 
@@ -4424,8 +4342,8 @@ int rocksdb_readoptions_get_read_tier(rocksdb_readoptions_t* opt) {
   return static_cast<int>(opt->rep.read_tier);
 }
 
-void rocksdb_readoptions_set_tailing(
-    rocksdb_readoptions_t* opt, unsigned char v) {
+void rocksdb_readoptions_set_tailing(rocksdb_readoptions_t* opt,
+                                     unsigned char v) {
   opt->rep.tailing = v;
 }
 
@@ -4433,13 +4351,13 @@ unsigned char rocksdb_readoptions_get_tailing(rocksdb_readoptions_t* opt) {
   return opt->rep.tailing;
 }
 
-void rocksdb_readoptions_set_managed(
-    rocksdb_readoptions_t* opt, unsigned char v) {
+void rocksdb_readoptions_set_managed(rocksdb_readoptions_t* opt,
+                                     unsigned char v) {
   opt->rep.managed = v;
 }
 
-void rocksdb_readoptions_set_readahead_size(
-    rocksdb_readoptions_t* opt, size_t v) {
+void rocksdb_readoptions_set_readahead_size(rocksdb_readoptions_t* opt,
+                                            size_t v) {
   opt->rep.readahead_size = v;
 }
 
@@ -4447,8 +4365,8 @@ size_t rocksdb_readoptions_get_readahead_size(rocksdb_readoptions_t* opt) {
   return opt->rep.readahead_size;
 }
 
-void rocksdb_readoptions_set_prefix_same_as_start(
-    rocksdb_readoptions_t* opt, unsigned char v) {
+void rocksdb_readoptions_set_prefix_same_as_start(rocksdb_readoptions_t* opt,
+                                                  unsigned char v) {
   opt->rep.prefix_same_as_start = v;
 }
 
@@ -4477,8 +4395,7 @@ unsigned char rocksdb_readoptions_get_total_order_seek(
 }
 
 void rocksdb_readoptions_set_max_skippable_internal_keys(
-    rocksdb_readoptions_t* opt,
-    uint64_t v) {
+    rocksdb_readoptions_t* opt, uint64_t v) {
   opt->rep.max_skippable_internal_keys = v;
 }
 
@@ -4497,8 +4414,8 @@ unsigned char rocksdb_readoptions_get_background_purge_on_iterator_cleanup(
   return opt->rep.background_purge_on_iterator_cleanup;
 }
 
-void rocksdb_readoptions_set_ignore_range_deletions(
-    rocksdb_readoptions_t* opt, unsigned char v) {
+void rocksdb_readoptions_set_ignore_range_deletions(rocksdb_readoptions_t* opt,
+                                                    unsigned char v) {
   opt->rep.ignore_range_deletions = v;
 }
 
@@ -4552,12 +4469,10 @@ rocksdb_writeoptions_t* rocksdb_writeoptions_create() {
   return new rocksdb_writeoptions_t;
 }
 
-void rocksdb_writeoptions_destroy(rocksdb_writeoptions_t* opt) {
-  delete opt;
-}
+void rocksdb_writeoptions_destroy(rocksdb_writeoptions_t* opt) { delete opt; }
 
-void rocksdb_writeoptions_set_sync(
-    rocksdb_writeoptions_t* opt, unsigned char v) {
+void rocksdb_writeoptions_set_sync(rocksdb_writeoptions_t* opt,
+                                   unsigned char v) {
   opt->rep.sync = v;
 }
 
@@ -4624,7 +4539,8 @@ void rocksdb_compactoptions_destroy(rocksdb_compactoptions_t* opt) {
 
 void rocksdb_compactoptions_set_bottommost_level_compaction(
     rocksdb_compactoptions_t* opt, unsigned char v) {
-  opt->rep.bottommost_level_compaction = static_cast<BottommostLevelCompaction>(v);
+  opt->rep.bottommost_level_compaction =
+      static_cast<BottommostLevelCompaction>(v);
 }
 
 unsigned char rocksdb_compactoptions_get_bottommost_level_compaction(
@@ -4676,12 +4592,10 @@ rocksdb_flushoptions_t* rocksdb_flushoptions_create() {
   return new rocksdb_flushoptions_t;
 }
 
-void rocksdb_flushoptions_destroy(rocksdb_flushoptions_t* opt) {
-  delete opt;
-}
+void rocksdb_flushoptions_destroy(rocksdb_flushoptions_t* opt) { delete opt; }
 
-void rocksdb_flushoptions_set_wait(
-    rocksdb_flushoptions_t* opt, unsigned char v) {
+void rocksdb_flushoptions_set_wait(rocksdb_flushoptions_t* opt,
+                                   unsigned char v) {
   opt->rep.wait = v;
 }
 
@@ -4746,9 +4660,7 @@ rocksdb_cache_t* rocksdb_cache_create_lru_opts(
   return c;
 }
 
-void rocksdb_cache_destroy(rocksdb_cache_t* cache) {
-  delete cache;
-}
+void rocksdb_cache_destroy(rocksdb_cache_t* cache) { delete cache; }
 
 void rocksdb_cache_disown_data(rocksdb_cache_t* cache) {
   cache->rep->DisownData();
@@ -4770,16 +4682,15 @@ size_t rocksdb_cache_get_pinned_usage(rocksdb_cache_t* cache) {
   return cache->rep->GetPinnedUsage();
 }
 
-rocksdb_dbpath_t* rocksdb_dbpath_create(const char* path, uint64_t target_size) {
+rocksdb_dbpath_t* rocksdb_dbpath_create(const char* path,
+                                        uint64_t target_size) {
   rocksdb_dbpath_t* result = new rocksdb_dbpath_t;
   result->rep.path = std::string(path);
   result->rep.target_size = target_size;
   return result;
 }
 
-void rocksdb_dbpath_destroy(rocksdb_dbpath_t* dbpath) {
-  delete dbpath;
-}
+void rocksdb_dbpath_destroy(rocksdb_dbpath_t* dbpath) { delete dbpath; }
 
 rocksdb_env_t* rocksdb_create_default_env() {
   rocksdb_env_t* result = new rocksdb_env_t;
@@ -4812,7 +4723,8 @@ int rocksdb_env_get_bottom_priority_background_threads(rocksdb_env_t* env) {
   return env->rep->GetBackgroundThreads(Env::BOTTOM);
 }
 
-void rocksdb_env_set_high_priority_background_threads(rocksdb_env_t* env, int n) {
+void rocksdb_env_set_high_priority_background_threads(rocksdb_env_t* env,
+                                                      int n) {
   env->rep->SetBackgroundThreads(n, Env::HIGH);
 }
 
@@ -4837,7 +4749,8 @@ void rocksdb_env_lower_thread_pool_io_priority(rocksdb_env_t* env) {
   env->rep->LowerThreadPoolIOPriority();
 }
 
-void rocksdb_env_lower_high_priority_thread_pool_io_priority(rocksdb_env_t* env) {
+void rocksdb_env_lower_high_priority_thread_pool_io_priority(
+    rocksdb_env_t* env) {
   env->rep->LowerThreadPoolIOPriority(Env::HIGH);
 }
 
@@ -4845,7 +4758,8 @@ void rocksdb_env_lower_thread_pool_cpu_priority(rocksdb_env_t* env) {
   env->rep->LowerThreadPoolCPUPriority();
 }
 
-void rocksdb_env_lower_high_priority_thread_pool_cpu_priority(rocksdb_env_t* env) {
+void rocksdb_env_lower_high_priority_thread_pool_cpu_priority(
+    rocksdb_env_t* env) {
   env->rep->LowerThreadPoolCPUPriority(Env::HIGH);
 }
 
@@ -5017,18 +4931,11 @@ void rocksdb_try_catch_up_with_primary(rocksdb_t* db, char** errptr) {
 }
 
 rocksdb_slicetransform_t* rocksdb_slicetransform_create(
-    void* state,
-    void (*destructor)(void*),
-    char* (*transform)(
-        void*,
-        const char* key, size_t length,
-        size_t* dst_length),
-    unsigned char (*in_domain)(
-        void*,
-        const char* key, size_t length),
-    unsigned char (*in_range)(
-        void*,
-        const char* key, size_t length),
+    void* state, void (*destructor)(void*),
+    char* (*transform)(void*, const char* key, size_t length,
+                       size_t* dst_length),
+    unsigned char (*in_domain)(void*, const char* key, size_t length),
+    unsigned char (*in_range)(void*, const char* key, size_t length),
     const char* (*name)(void*)) {
   rocksdb_slicetransform_t* result = new rocksdb_slicetransform_t;
   result->state_ = state;
@@ -5040,9 +4947,7 @@ rocksdb_slicetransform_t* rocksdb_slicetransform_create(
   return result;
 }
 
-void rocksdb_slicetransform_destroy(rocksdb_slicetransform_t* st) {
-  delete st;
-}
+void rocksdb_slicetransform_destroy(rocksdb_slicetransform_t* st) { delete st; }
 
 struct SliceTransformWrapper : public rocksdb_slicetransform_t {
   const SliceTransform* rep_;
@@ -5052,14 +4957,13 @@ struct SliceTransformWrapper : public rocksdb_slicetransform_t {
   Slice Transform(const Slice& src) const override {
     return rep_->Transform(src);
   }
-  bool InDomain(const Slice& src) const override {
-    return rep_->InDomain(src);
-  }
+  bool InDomain(const Slice& src) const override { return rep_->InDomain(src); }
   bool InRange(const Slice& src) const override { return rep_->InRange(src); }
-  static void DoNothing(void*) { }
+  static void DoNothing(void*) {}
 };
 
-rocksdb_slicetransform_t* rocksdb_slicetransform_create_fixed_prefix(size_t prefixLen) {
+rocksdb_slicetransform_t* rocksdb_slicetransform_create_fixed_prefix(
+    size_t prefixLen) {
   SliceTransformWrapper* wrapper = new SliceTransformWrapper;
   wrapper->rep_ = ROCKSDB_NAMESPACE::NewFixedPrefixTransform(prefixLen);
   wrapper->state_ = nullptr;
@@ -5075,14 +4979,16 @@ rocksdb_slicetransform_t* rocksdb_slicetransform_create_noop() {
   return wrapper;
 }
 
-rocksdb_universal_compaction_options_t* rocksdb_universal_compaction_options_create() {
-  rocksdb_universal_compaction_options_t* result = new rocksdb_universal_compaction_options_t;
+rocksdb_universal_compaction_options_t*
+rocksdb_universal_compaction_options_create() {
+  rocksdb_universal_compaction_options_t* result =
+      new rocksdb_universal_compaction_options_t;
   result->rep = new ROCKSDB_NAMESPACE::CompactionOptionsUniversal;
   return result;
 }
 
 void rocksdb_universal_compaction_options_set_size_ratio(
-  rocksdb_universal_compaction_options_t* uco, int ratio) {
+    rocksdb_universal_compaction_options_t* uco, int ratio) {
   uco->rep->size_ratio = ratio;
 }
 
@@ -5092,7 +4998,7 @@ int rocksdb_universal_compaction_options_get_size_ratio(
 }
 
 void rocksdb_universal_compaction_options_set_min_merge_width(
-  rocksdb_universal_compaction_options_t* uco, int w) {
+    rocksdb_universal_compaction_options_t* uco, int w) {
   uco->rep->min_merge_width = w;
 }
 
@@ -5102,7 +5008,7 @@ int rocksdb_universal_compaction_options_get_min_merge_width(
 }
 
 void rocksdb_universal_compaction_options_set_max_merge_width(
-  rocksdb_universal_compaction_options_t* uco, int w) {
+    rocksdb_universal_compaction_options_t* uco, int w) {
   uco->rep->max_merge_width = w;
 }
 
@@ -5112,7 +5018,7 @@ int rocksdb_universal_compaction_options_get_max_merge_width(
 }
 
 void rocksdb_universal_compaction_options_set_max_size_amplification_percent(
-  rocksdb_universal_compaction_options_t* uco, int p) {
+    rocksdb_universal_compaction_options_t* uco, int p) {
   uco->rep->max_size_amplification_percent = p;
 }
 
@@ -5122,7 +5028,7 @@ int rocksdb_universal_compaction_options_get_max_size_amplification_percent(
 }
 
 void rocksdb_universal_compaction_options_set_compression_size_percent(
-  rocksdb_universal_compaction_options_t* uco, int p) {
+    rocksdb_universal_compaction_options_t* uco, int p) {
   uco->rep->compression_size_percent = p;
 }
 
@@ -5132,7 +5038,7 @@ int rocksdb_universal_compaction_options_get_compression_size_percent(
 }
 
 void rocksdb_universal_compaction_options_set_stop_style(
-  rocksdb_universal_compaction_options_t* uco, int style) {
+    rocksdb_universal_compaction_options_t* uco, int style) {
   uco->rep->stop_style =
       static_cast<ROCKSDB_NAMESPACE::CompactionStopStyle>(style);
 }
@@ -5143,14 +5049,15 @@ int rocksdb_universal_compaction_options_get_stop_style(
 }
 
 void rocksdb_universal_compaction_options_destroy(
-  rocksdb_universal_compaction_options_t* uco) {
+    rocksdb_universal_compaction_options_t* uco) {
   delete uco->rep;
   delete uco;
 }
 
 rocksdb_fifo_compaction_options_t* rocksdb_fifo_compaction_options_create() {
-  rocksdb_fifo_compaction_options_t* result = new rocksdb_fifo_compaction_options_t;
-  result->rep =  CompactionOptionsFIFO();
+  rocksdb_fifo_compaction_options_t* result =
+      new rocksdb_fifo_compaction_options_t;
+  result->rep = CompactionOptionsFIFO();
   return result;
 }
 
@@ -5169,7 +5076,8 @@ void rocksdb_fifo_compaction_options_destroy(
   delete fifo_opts;
 }
 
-void rocksdb_options_set_min_level_to_compress(rocksdb_options_t* opt, int level) {
+void rocksdb_options_set_min_level_to_compress(rocksdb_options_t* opt,
+                                               int level) {
   if (level >= 0) {
     assert(level <= opt->rep.num_levels);
     opt->rep.compression_per_level.resize(opt->rep.num_levels);
@@ -5182,8 +5090,7 @@ void rocksdb_options_set_min_level_to_compress(rocksdb_options_t* opt, int level
   }
 }
 
-int rocksdb_livefiles_count(
-  const rocksdb_livefiles_t* lf) {
+int rocksdb_livefiles_count(const rocksdb_livefiles_t* lf) {
   return static_cast<int>(lf->rep.size());
 }
 
@@ -5192,54 +5099,39 @@ const char* rocksdb_livefiles_column_family_name(const rocksdb_livefiles_t* lf,
   return lf->rep[index].column_family_name.c_str();
 }
 
-const char* rocksdb_livefiles_name(
-  const rocksdb_livefiles_t* lf,
-  int index) {
+const char* rocksdb_livefiles_name(const rocksdb_livefiles_t* lf, int index) {
   return lf->rep[index].name.c_str();
 }
 
-int rocksdb_livefiles_level(
-  const rocksdb_livefiles_t* lf,
-  int index) {
+int rocksdb_livefiles_level(const rocksdb_livefiles_t* lf, int index) {
   return lf->rep[index].level;
 }
 
-size_t rocksdb_livefiles_size(
-  const rocksdb_livefiles_t* lf,
-  int index) {
+size_t rocksdb_livefiles_size(const rocksdb_livefiles_t* lf, int index) {
   return lf->rep[index].size;
 }
 
-const char* rocksdb_livefiles_smallestkey(
-  const rocksdb_livefiles_t* lf,
-  int index,
-  size_t* size) {
+const char* rocksdb_livefiles_smallestkey(const rocksdb_livefiles_t* lf,
+                                          int index, size_t* size) {
   *size = lf->rep[index].smallestkey.size();
   return lf->rep[index].smallestkey.data();
 }
 
-const char* rocksdb_livefiles_largestkey(
-  const rocksdb_livefiles_t* lf,
-  int index,
-  size_t* size) {
+const char* rocksdb_livefiles_largestkey(const rocksdb_livefiles_t* lf,
+                                         int index, size_t* size) {
   *size = lf->rep[index].largestkey.size();
   return lf->rep[index].largestkey.data();
 }
 
-uint64_t rocksdb_livefiles_entries(
-    const rocksdb_livefiles_t* lf,
-    int index) {
+uint64_t rocksdb_livefiles_entries(const rocksdb_livefiles_t* lf, int index) {
   return lf->rep[index].num_entries;
 }
 
-uint64_t rocksdb_livefiles_deletions(
-    const rocksdb_livefiles_t* lf,
-    int index) {
+uint64_t rocksdb_livefiles_deletions(const rocksdb_livefiles_t* lf, int index) {
   return lf->rep[index].num_deletions;
 }
 
-extern void rocksdb_livefiles_destroy(
-  const rocksdb_livefiles_t* lf) {
+extern void rocksdb_livefiles_destroy(const rocksdb_livefiles_t* lf) {
   delete lf;
 }
 
@@ -5394,7 +5286,8 @@ rocksdb_transactiondb_options_t* rocksdb_transactiondb_options_create() {
   return new rocksdb_transactiondb_options_t;
 }
 
-void rocksdb_transactiondb_options_destroy(rocksdb_transactiondb_options_t* opt){
+void rocksdb_transactiondb_options_destroy(
+    rocksdb_transactiondb_options_t* opt) {
   delete opt;
 }
 
@@ -5600,7 +5493,7 @@ rocksdb_transaction_t* rocksdb_transaction_begin(
     return result;
   }
   old_txn->rep = txn_db->rep->BeginTransaction(write_options->rep,
-                                                txn_options->rep, old_txn->rep);
+                                               txn_options->rep, old_txn->rep);
   return old_txn;
 }
 
@@ -5672,7 +5565,8 @@ void rocksdb_transaction_set_savepoint(rocksdb_transaction_t* txn) {
   txn->rep->SetSavePoint();
 }
 
-void rocksdb_transaction_rollback_to_savepoint(rocksdb_transaction_t* txn, char** errptr) {
+void rocksdb_transaction_rollback_to_savepoint(rocksdb_transaction_t* txn,
+                                               char** errptr) {
   SaveError(errptr, txn->rep->RollbackToSavePoint());
 }
 
@@ -5904,12 +5798,10 @@ void rocksdb_transaction_multi_get_cf(
 }
 
 // Read a key outside a transaction
-char* rocksdb_transactiondb_get(
-    rocksdb_transactiondb_t* txn_db,
-    const rocksdb_readoptions_t* options,
-    const char* key, size_t klen,
-    size_t* vlen,
-    char** errptr){
+char* rocksdb_transactiondb_get(rocksdb_transactiondb_t* txn_db,
+                                const rocksdb_readoptions_t* options,
+                                const char* key, size_t klen, size_t* vlen,
+                                char** errptr) {
   char* result = nullptr;
   std::string tmp;
   Status s = txn_db->rep->Get(options->rep, Slice(key, klen), &tmp);
@@ -6086,11 +5978,9 @@ void rocksdb_transactiondb_put_cf(rocksdb_transactiondb_t* txn_db,
 }
 
 // Write batch into transaction db
-void rocksdb_transactiondb_write(
-        rocksdb_transactiondb_t* db,
-        const rocksdb_writeoptions_t* options,
-        rocksdb_writebatch_t* batch,
-        char** errptr) {
+void rocksdb_transactiondb_write(rocksdb_transactiondb_t* db,
+                                 const rocksdb_writeoptions_t* options,
+                                 rocksdb_writebatch_t* batch, char** errptr) {
   SaveError(errptr, db->rep->Write(options->rep, &batch->rep));
 }
 
@@ -6411,7 +6301,6 @@ struct rocksdb_memory_usage_t {
 // estimates amount of memory occupied by consumers (dbs and caches)
 rocksdb_memory_usage_t* rocksdb_approximate_memory_usage_create(
     rocksdb_memory_consumers_t* consumers, char** errptr) {
-
   vector<DB*> dbs;
   for (auto db : consumers->dbs) {
     dbs.push_back(db->rep);
@@ -6433,7 +6322,8 @@ rocksdb_memory_usage_t* rocksdb_approximate_memory_usage_create(
   auto result = new rocksdb_memory_usage_t;
   result->mem_table_total = usage_by_type[MemoryUtil::kMemTableTotal];
   result->mem_table_unflushed = usage_by_type[MemoryUtil::kMemTableUnFlushed];
-  result->mem_table_readers_total = usage_by_type[MemoryUtil::kTableReadersTotal];
+  result->mem_table_readers_total =
+      usage_by_type[MemoryUtil::kTableReadersTotal];
   result->cache_total = usage_by_type[MemoryUtil::kCacheTotal];
   return result;
 }