rocksdb c wrapper (#67)

librocksdb_sys/Cargo.toml

@@ -14,3 +14,6 @@ static-link = []
 # portable doesn't require static link, though it's meaningless
 # when not using with static-link right now in this crate.
 portable = []
+
+[build-dependencies]
+gcc = "0.3"

librocksdb_sys/build.rs

+
+extern crate gcc;
+
 use std::{env, fs, str};
 use std::path::PathBuf;
 use std::process::Command;
@@ -11,8 +14,20 @@ macro_rules! t {
 
 fn main() {
     if !cfg!(feature = "static-link") {
+        gcc::Config::new()
+        .cpp(true)
+        .file("crocksdb/c.cc")
+        .flag("-std=c++11")
+        .flag("-fPIC")
+        .flag("-O2")
+        .compile("libcrocksdb.a");
+
+        println!("cargo:rustc-link-lib=static=crocksdb");
+        println!("cargo:rustc-link-lib=rocksdb");
+
         return;
     }
+
     if !cfg!(target_os = "linux") && !cfg!(target_os = "macos") {
         // only linux and apple support static link right now
         return;
@@ -24,7 +39,9 @@ fn main() {
     t!(fs::create_dir_all(&build));
 
     let fest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
-    let p = PathBuf::from(fest_dir).join("build.sh");
+    let p = PathBuf::from(fest_dir.clone()).join("build.sh");
+    let crocksdb_path = PathBuf::from(fest_dir).join("crocksdb");
+    env::set_var("CROCKSDB_PATH", crocksdb_path.to_str().unwrap());
     for lib in &["z", "snappy", "bz2", "lz4", "rocksdb"] {
         let lib_name = format!("lib{}.a", lib);
         let src = build.join(&lib_name);

librocksdb_sys/build.sh

@@ -114,10 +114,13 @@ function compile_rocksdb() {
     tar xf rocksdb-$version.tar.gz
     wd=`pwd`
     cd rocksdb-$vernum
+    cp $CROCKSDB_PATH/c.cc ./db/c.cc
+    cp $CROCKSDB_PATH/rocksdb/c.h ./include/rocksdb/c.h
     export EXTRA_CFLAGS="-fPIC -I${wd}/zlib-1.2.8 -I${wd}/bzip2-1.0.6 -I${wd}/snappy-1.1.1 -I${wd}/lz4-r131/lib"
     export EXTRA_CXXFLAGS="-DZLIB -DBZIP2 -DSNAPPY -DLZ4 $EXTRA_CFLAGS"
     make static_lib -j $con
     mv librocksdb.a ../
+    cd ..
 }
 
 function find_library() {

librocksdb_sys/crocksdb/c.cc

+//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
+//  This source code is licensed under the BSD-style license found in the
+//  LICENSE file in the root directory of this source tree. An additional grant
+//  of patent rights can be found in the PATENTS file in the same directory.
+//
+// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file. See the AUTHORS file for names of contributors.
+
+#include "rocksdb/c.h"
+
+#include <stdlib.h>
+#include "rocksdb/cache.h"
+#include "rocksdb/compaction_filter.h"
+#include "rocksdb/comparator.h"
+#include "rocksdb/convenience.h"
+#include "rocksdb/db.h"
+#include "rocksdb/env.h"
+#include "rocksdb/filter_policy.h"
+#include "rocksdb/iterator.h"
+#include "rocksdb/merge_operator.h"
+#include "rocksdb/options.h"
+#include "rocksdb/status.h"
+#include "rocksdb/write_batch.h"
+#include "rocksdb/memtablerep.h"
+#include "rocksdb/universal_compaction.h"
+#include "rocksdb/statistics.h"
+#include "rocksdb/slice_transform.h"
+#include "rocksdb/table.h"
+#include "rocksdb/rate_limiter.h"
+#include "rocksdb/utilities/backupable_db.h"
+
+using rocksdb::Cache;
+using rocksdb::ColumnFamilyDescriptor;
+using rocksdb::ColumnFamilyHandle;
+using rocksdb::ColumnFamilyOptions;
+using rocksdb::CompactionFilter;
+using rocksdb::CompactionFilterFactory;
+using rocksdb::CompactionFilterContext;
+using rocksdb::CompactionOptionsFIFO;
+using rocksdb::Comparator;
+using rocksdb::CompressionType;
+using rocksdb::WALRecoveryMode;
+using rocksdb::DB;
+using rocksdb::DBOptions;
+using rocksdb::Env;
+using rocksdb::EnvOptions;
+using rocksdb::InfoLogLevel;
+using rocksdb::FileLock;
+using rocksdb::FilterPolicy;
+using rocksdb::FlushOptions;
+using rocksdb::IngestExternalFileOptions;
+using rocksdb::Iterator;
+using rocksdb::Logger;
+using rocksdb::MergeOperator;
+using rocksdb::NewBloomFilterPolicy;
+using rocksdb::NewLRUCache;
+using rocksdb::Options;
+using rocksdb::BlockBasedTableOptions;
+using rocksdb::CuckooTableOptions;
+using rocksdb::RandomAccessFile;
+using rocksdb::Range;
+using rocksdb::ReadOptions;
+using rocksdb::SequentialFile;
+using rocksdb::Slice;
+using rocksdb::SliceParts;
+using rocksdb::SliceTransform;
+using rocksdb::Snapshot;
+using rocksdb::SstFileWriter;
+using rocksdb::Status;
+using rocksdb::WritableFile;
+using rocksdb::WriteBatch;
+using rocksdb::WriteOptions;
+using rocksdb::LiveFileMetaData;
+using rocksdb::BackupEngine;
+using rocksdb::BackupableDBOptions;
+using rocksdb::BackupInfo;
+using rocksdb::RestoreOptions;
+using rocksdb::CompactRangeOptions;
+using rocksdb::RateLimiter;
+using rocksdb::NewGenericRateLimiter;
+
+using std::shared_ptr;
+
+extern "C" {
+
+struct crocksdb_t                 { DB*               rep; };
+struct crocksdb_backup_engine_t   { BackupEngine*     rep; };
+struct crocksdb_backup_engine_info_t { std::vector<BackupInfo> rep; };
+struct crocksdb_restore_options_t { RestoreOptions rep; };
+struct crocksdb_iterator_t        { Iterator*         rep; };
+struct crocksdb_writebatch_t      { WriteBatch        rep; };
+struct crocksdb_snapshot_t        { const Snapshot*   rep; };
+struct crocksdb_flushoptions_t    { FlushOptions      rep; };
+struct crocksdb_fifo_compaction_options_t { CompactionOptionsFIFO rep; };
+struct crocksdb_readoptions_t {
+   ReadOptions rep;
+   Slice upper_bound; // stack variable to set pointer to in ReadOptions
+};
+struct crocksdb_writeoptions_t    { WriteOptions      rep; };
+struct crocksdb_options_t         { Options           rep; };
+struct crocksdb_compactoptions_t {
+  CompactRangeOptions rep;
+};
+struct crocksdb_block_based_table_options_t  { BlockBasedTableOptions rep; };
+struct crocksdb_cuckoo_table_options_t  { CuckooTableOptions rep; };
+struct crocksdb_seqfile_t         { SequentialFile*   rep; };
+struct crocksdb_randomfile_t      { RandomAccessFile* rep; };
+struct crocksdb_writablefile_t    { WritableFile*     rep; };
+struct crocksdb_filelock_t        { FileLock*         rep; };
+struct crocksdb_logger_t          { shared_ptr<Logger>  rep; };
+struct crocksdb_cache_t           { shared_ptr<Cache>   rep; };
+struct crocksdb_livefiles_t       { std::vector<LiveFileMetaData> rep; };
+struct crocksdb_column_family_handle_t  { ColumnFamilyHandle* rep; };
+struct crocksdb_envoptions_t      { EnvOptions        rep; };
+struct crocksdb_ingestexternalfileoptions_t  { IngestExternalFileOptions rep; };
+struct crocksdb_sstfilewriter_t   { SstFileWriter*    rep; };
+struct crocksdb_ratelimiter_t     { RateLimiter*      rep; };
+
+struct crocksdb_compactionfiltercontext_t {
+  CompactionFilter::Context rep;
+};
+
+struct crocksdb_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);
+  const char* (*name_)(void*);
+  unsigned char ignore_snapshots_;
+
+  virtual ~crocksdb_compactionfilter_t() {
+    (*destructor_)(state_);
+  }
+
+  virtual bool Filter(int level, const Slice& key, const Slice& existing_value,
+                      std::string* new_value,
+                      bool* value_changed) const override {
+    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);
+    if (c_value_changed) {
+      new_value->assign(c_new_value, new_value_length);
+      *value_changed = true;
+    }
+    return result;
+  }
+
+  virtual const char* Name() const override { return (*name_)(state_); }
+
+  virtual bool IgnoreSnapshots() const override { return ignore_snapshots_; }
+};
+
+struct crocksdb_compactionfilterfactory_t : public CompactionFilterFactory {
+  void* state_;
+  void (*destructor_)(void*);
+  crocksdb_compactionfilter_t* (*create_compaction_filter_)(
+      void*, crocksdb_compactionfiltercontext_t* context);
+  const char* (*name_)(void*);
+
+  virtual ~crocksdb_compactionfilterfactory_t() { (*destructor_)(state_); }
+
+  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
+      const CompactionFilter::Context& context) override {
+    crocksdb_compactionfiltercontext_t ccontext;
+    ccontext.rep = context;
+    CompactionFilter* cf = (*create_compaction_filter_)(state_, &ccontext);
+    return std::unique_ptr<CompactionFilter>(cf);
+  }
+
+  virtual const char* Name() const override { return (*name_)(state_); }
+};
+
+struct crocksdb_comparator_t : public Comparator {
+  void* state_;
+  void (*destructor_)(void*);
+  int (*compare_)(
+      void*,
+      const char* a, size_t alen,
+      const char* b, size_t blen);
+  const char* (*name_)(void*);
+
+  virtual ~crocksdb_comparator_t() {
+    (*destructor_)(state_);
+  }
+
+  virtual int Compare(const Slice& a, const Slice& b) const override {
+    return (*compare_)(state_, a.data(), a.size(), b.data(), b.size());
+  }
+
+  virtual const char* Name() const override { return (*name_)(state_); }
+
+  // No-ops since the C binding does not support key shortening methods.
+  virtual void FindShortestSeparator(std::string*,
+                                     const Slice&) const override {}
+  virtual void FindShortSuccessor(std::string* key) const override {}
+};
+
+struct crocksdb_filterpolicy_t : public FilterPolicy {
+  void* state_;
+  void (*destructor_)(void*);
+  const char* (*name_)(void*);
+  char* (*create_)(
+      void*,
+      const char* const* key_array, const size_t* key_length_array,
+      int num_keys,
+      size_t* filter_length);
+  unsigned char (*key_match_)(
+      void*,
+      const char* key, size_t length,
+      const char* filter, size_t filter_length);
+  void (*delete_filter_)(
+      void*,
+      const char* filter, size_t filter_length);
+
+  virtual ~crocksdb_filterpolicy_t() {
+    (*destructor_)(state_);
+  }
+
+  virtual const char* Name() const override { return (*name_)(state_); }
+
+  virtual void CreateFilter(const Slice* keys, int n,
+                            std::string* dst) const override {
+    std::vector<const char*> key_pointers(n);
+    std::vector<size_t> key_sizes(n);
+    for (int i = 0; i < n; i++) {
+      key_pointers[i] = keys[i].data();
+      key_sizes[i] = keys[i].size();
+    }
+    size_t len;
+    char* filter = (*create_)(state_, &key_pointers[0], &key_sizes[0], n, &len);
+    dst->append(filter, len);
+
+    if (delete_filter_ != nullptr) {
+      (*delete_filter_)(state_, filter, len);
+    } else {
+      free(filter);
+    }
+  }
+
+  virtual bool KeyMayMatch(const Slice& key,
+                           const Slice& filter) const override {
+    return (*key_match_)(state_, key.data(), key.size(),
+                         filter.data(), filter.size());
+  }
+};
+
+struct crocksdb_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* (*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);
+
+  virtual ~crocksdb_mergeoperator_t() {
+    (*destructor_)(state_);
+  }
+
+  virtual const char* Name() const override { return (*name_)(state_); }
+
+  virtual bool FullMergeV2(const MergeOperationInput& merge_in,
+                           MergeOperationOutput* merge_out) const override {
+    size_t n = merge_in.operand_list.size();
+    std::vector<const char*> operand_pointers(n);
+    std::vector<size_t> operand_sizes(n);
+    for (size_t i = 0; i < n; i++) {
+      Slice operand(merge_in.operand_list[i]);
+      operand_pointers[i] = operand.data();
+      operand_sizes[i] = operand.size();
+    }
+
+    const char* existing_value_data = nullptr;
+    size_t existing_value_len = 0;
+    if (merge_in.existing_value != nullptr) {
+      existing_value_data = merge_in.existing_value->data();
+      existing_value_len = merge_in.existing_value->size();
+    }
+
+    unsigned char success;
+    size_t new_value_len;
+    char* tmp_new_value = (*full_merge_)(
+        state_, merge_in.key.data(), merge_in.key.size(), existing_value_data,
+        existing_value_len, &operand_pointers[0], &operand_sizes[0],
+        static_cast<int>(n), &success, &new_value_len);
+    merge_out->new_value.assign(tmp_new_value, new_value_len);
+
+    if (delete_value_ != nullptr) {
+      (*delete_value_)(state_, tmp_new_value, new_value_len);
+    } else {
+      free(tmp_new_value);
+    }
+
+    return success;
+  }
+
+  virtual bool PartialMergeMulti(const Slice& key,
+                                 const std::deque<Slice>& operand_list,
+                                 std::string* new_value,
+                                 Logger* logger) const override {
+    size_t operand_count = operand_list.size();
+    std::vector<const char*> operand_pointers(operand_count);
+    std::vector<size_t> operand_sizes(operand_count);
+    for (size_t i = 0; i < operand_count; ++i) {
+      Slice operand(operand_list[i]);
+      operand_pointers[i] = operand.data();
+      operand_sizes[i] = operand.size();
+    }
+
+    unsigned char success;
+    size_t new_value_len;
+    char* tmp_new_value = (*partial_merge_)(
+        state_, key.data(), key.size(), &operand_pointers[0], &operand_sizes[0],
+        static_cast<int>(operand_count), &success, &new_value_len);
+    new_value->assign(tmp_new_value, new_value_len);
+
+    if (delete_value_ != nullptr) {
+      (*delete_value_)(state_, tmp_new_value, new_value_len);
+    } else {
+      free(tmp_new_value);
+    }
+
+    return success;
+  }
+};
+
+struct crocksdb_env_t {
+  Env* rep;
+  bool is_default;
+};
+
+struct crocksdb_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);
+
+  virtual ~crocksdb_slicetransform_t() {
+    (*destructor_)(state_);
+  }
+
+  virtual const char* Name() const override { return (*name_)(state_); }
+
+  virtual Slice Transform(const Slice& src) const override {
+    size_t len;
+    char* dst = (*transform_)(state_, src.data(), src.size(), &len);
+    return Slice(dst, len);
+  }
+
+  virtual bool InDomain(const Slice& src) const override {
+    return (*in_domain_)(state_, src.data(), src.size());
+  }
+
+  virtual bool InRange(const Slice& src) const override {
+    return (*in_range_)(state_, src.data(), src.size());
+  }
+};
+
+struct crocksdb_universal_compaction_options_t {
+  rocksdb::CompactionOptionsUniversal *rep;
+};
+
+static bool SaveError(char** errptr, const Status& s) {
+  assert(errptr != nullptr);
+  if (s.ok()) {
+    return false;
+  } else if (*errptr == nullptr) {
+    *errptr = strdup(s.ToString().c_str());
+  } else {
+    // TODO(sanjay): Merge with existing error?
+    // This is a bug if *errptr is not created by malloc()
+    free(*errptr);
+    *errptr = strdup(s.ToString().c_str());
+  }
+  return true;
+}
+
+static char* CopyString(const std::string& str) {
+  char* result = reinterpret_cast<char*>(malloc(sizeof(char) * str.size()));
+  memcpy(result, str.data(), sizeof(char) * str.size());
+  return result;
+}
+
+crocksdb_t* crocksdb_open(
+    const crocksdb_options_t* options,
+    const char* name,
+    char** errptr) {
+  DB* db;
+  if (SaveError(errptr, DB::Open(options->rep, std::string(name), &db))) {
+    return nullptr;
+  }
+  crocksdb_t* result = new crocksdb_t;
+  result->rep = db;
+  return result;
+}
+
+crocksdb_t* crocksdb_open_for_read_only(
+    const crocksdb_options_t* options,
+    const char* name,
+    unsigned char error_if_log_file_exist,
+    char** errptr) {
+  DB* db;
+  if (SaveError(errptr, DB::OpenForReadOnly(options->rep, std::string(name), &db, error_if_log_file_exist))) {
+    return nullptr;
+  }
+  crocksdb_t* result = new crocksdb_t;
+  result->rep = db;
+  return result;
+}
+
+crocksdb_backup_engine_t* crocksdb_backup_engine_open(
+    const crocksdb_options_t* options, const char* path, char** errptr) {
+  BackupEngine* be;
+  if (SaveError(errptr, BackupEngine::Open(options->rep.env,
+                                           BackupableDBOptions(path), &be))) {
+    return nullptr;
+  }
+  crocksdb_backup_engine_t* result = new crocksdb_backup_engine_t;
+  result->rep = be;
+  return result;
+}
+
+void crocksdb_backup_engine_create_new_backup(crocksdb_backup_engine_t* be,
+                                             crocksdb_t* db, char** errptr) {
+  SaveError(errptr, be->rep->CreateNewBackup(db->rep));
+}
+
+void crocksdb_backup_engine_purge_old_backups(crocksdb_backup_engine_t* be,
+                                             uint32_t num_backups_to_keep,
+                                             char** errptr) {
+  SaveError(errptr, be->rep->PurgeOldBackups(num_backups_to_keep));
+}
+
+crocksdb_restore_options_t* crocksdb_restore_options_create() {
+  return new crocksdb_restore_options_t;
+}
+
+void crocksdb_restore_options_destroy(crocksdb_restore_options_t* opt) {
+  delete opt;
+}
+
+void crocksdb_restore_options_set_keep_log_files(crocksdb_restore_options_t* opt,
+                                                int v) {
+  opt->rep.keep_log_files = v;
+}
+
+void crocksdb_backup_engine_restore_db_from_latest_backup(
+    crocksdb_backup_engine_t* be, const char* db_dir, const char* wal_dir,
+    const crocksdb_restore_options_t* restore_options, char** errptr) {
+  SaveError(errptr, be->rep->RestoreDBFromLatestBackup(std::string(db_dir),
+                                                       std::string(wal_dir),
+                                                       restore_options->rep));
+}
+
+const crocksdb_backup_engine_info_t* crocksdb_backup_engine_get_backup_info(
+    crocksdb_backup_engine_t* be) {
+  crocksdb_backup_engine_info_t* result = new crocksdb_backup_engine_info_t;
+  be->rep->GetBackupInfo(&result->rep);
+  return result;
+}
+
+int crocksdb_backup_engine_info_count(const crocksdb_backup_engine_info_t* info) {
+  return static_cast<int>(info->rep.size());
+}
+
+int64_t crocksdb_backup_engine_info_timestamp(
+    const crocksdb_backup_engine_info_t* info, int index) {
+  return info->rep[index].timestamp;
+}
+
+uint32_t crocksdb_backup_engine_info_backup_id(
+    const crocksdb_backup_engine_info_t* info, int index) {
+  return info->rep[index].backup_id;
+}
+
+uint64_t crocksdb_backup_engine_info_size(
+    const crocksdb_backup_engine_info_t* info, int index) {
+  return info->rep[index].size;
+}
+
+uint32_t crocksdb_backup_engine_info_number_files(
+    const crocksdb_backup_engine_info_t* info, int index) {
+  return info->rep[index].number_files;
+}
+
+void crocksdb_backup_engine_info_destroy(
+    const crocksdb_backup_engine_info_t* info) {
+  delete info;
+}
+
+void crocksdb_backup_engine_close(crocksdb_backup_engine_t* be) {
+  delete be->rep;
+  delete be;
+}
+
+void crocksdb_close(crocksdb_t* db) {
+  delete db->rep;
+  delete db;
+}
+
+crocksdb_t* crocksdb_open_column_families(
+    const crocksdb_options_t* db_options,
+    const char* name,
+    int num_column_families,
+    const char** column_family_names,
+    const crocksdb_options_t** column_family_options,
+    crocksdb_column_family_handle_t** column_family_handles,
+    char** errptr) {
+  std::vector<ColumnFamilyDescriptor> column_families;
+  for (int i = 0; i < num_column_families; i++) {
+    column_families.push_back(ColumnFamilyDescriptor(
+        std::string(column_family_names[i]),
+        ColumnFamilyOptions(column_family_options[i]->rep)));
+  }
+
+  DB* db;
+  std::vector<ColumnFamilyHandle*> handles;
+  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++) {
+    crocksdb_column_family_handle_t* c_handle = new crocksdb_column_family_handle_t;
+    c_handle->rep = handles[i];
+    column_family_handles[i] = c_handle;
+  }
+  crocksdb_t* result = new crocksdb_t;
+  result->rep = db;
+  return result;
+}
+
+crocksdb_t* crocksdb_open_for_read_only_column_families(
+    const crocksdb_options_t* db_options,
+    const char* name,
+    int num_column_families,
+    const char** column_family_names,
+    const crocksdb_options_t** column_family_options,
+    crocksdb_column_family_handle_t** column_family_handles,
+    unsigned char error_if_log_file_exist,
+    char** errptr) {
+  std::vector<ColumnFamilyDescriptor> column_families;
+  for (int i = 0; i < num_column_families; i++) {
+    column_families.push_back(ColumnFamilyDescriptor(
+        std::string(column_family_names[i]),
+        ColumnFamilyOptions(column_family_options[i]->rep)));
+  }
+
+  DB* db;
+  std::vector<ColumnFamilyHandle*> handles;
+  if (SaveError(errptr, DB::OpenForReadOnly(DBOptions(db_options->rep),
+          std::string(name), column_families, &handles, &db, error_if_log_file_exist))) {
+    return nullptr;
+  }
+
+  for (size_t i = 0; i < handles.size(); i++) {
+    crocksdb_column_family_handle_t* c_handle = new crocksdb_column_family_handle_t;
+    c_handle->rep = handles[i];
+    column_family_handles[i] = c_handle;
+  }
+  crocksdb_t* result = new crocksdb_t;
+  result->rep = db;
+  return result;
+}
+
+char** crocksdb_list_column_families(
+    const crocksdb_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));
+
+  *lencfs = 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());
+  }
+  return column_families;
+}
+
+void crocksdb_list_column_families_destroy(char** list, size_t len) {
+  for (size_t i = 0; i < len; ++i) {
+    free(list[i]);
+  }
+  free(list);
+}
+
+crocksdb_column_family_handle_t* crocksdb_create_column_family(
+    crocksdb_t* db,
+    const crocksdb_options_t* column_family_options,
+    const char* column_family_name,
+    char** errptr) {
+  crocksdb_column_family_handle_t* handle = new crocksdb_column_family_handle_t;
+  SaveError(errptr,
+      db->rep->CreateColumnFamily(ColumnFamilyOptions(column_family_options->rep),
+        std::string(column_family_name), &(handle->rep)));
+  return handle;
+}
+
+void crocksdb_drop_column_family(
+    crocksdb_t* db,
+    crocksdb_column_family_handle_t* handle,
+    char** errptr) {
+  SaveError(errptr, db->rep->DropColumnFamily(handle->rep));
+}
+
+void crocksdb_column_family_handle_destroy(crocksdb_column_family_handle_t* handle) {
+  delete handle->rep;
+  delete handle;
+}
+
+void crocksdb_put(
+    crocksdb_t* db,
+    const crocksdb_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)));
+}
+
+void crocksdb_put_cf(
+    crocksdb_t* db,
+    const crocksdb_writeoptions_t* options,
+    crocksdb_column_family_handle_t* column_family,
+    const char* key, size_t keylen,
+    const char* val, size_t vallen,
+    char** errptr) {
+  SaveError(errptr,
+            db->rep->Put(options->rep, column_family->rep,
+              Slice(key, keylen), Slice(val, vallen)));
+}
+
+void crocksdb_delete(
+    crocksdb_t* db,
+    const crocksdb_writeoptions_t* options,
+    const char* key, size_t keylen,
+    char** errptr) {
+  SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen)));
+}
+
+void crocksdb_delete_cf(
+    crocksdb_t* db,
+    const crocksdb_writeoptions_t* options,
+    crocksdb_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)));
+}
+
+void crocksdb_merge(
+    crocksdb_t* db,
+    const crocksdb_writeoptions_t* options,
+    const char* key, size_t keylen,
+    const char* val, size_t vallen,
+    char** errptr) {
+  SaveError(errptr,
+            db->rep->Merge(options->rep, Slice(key, keylen), Slice(val, vallen)));
+}
+
+void crocksdb_merge_cf(
+    crocksdb_t* db,
+    const crocksdb_writeoptions_t* options,
+    crocksdb_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)));
+}
+
+void crocksdb_write(
+    crocksdb_t* db,
+    const crocksdb_writeoptions_t* options,
+    crocksdb_writebatch_t* batch,
+    char** errptr) {
+  SaveError(errptr, db->rep->Write(options->rep, &batch->rep));
+}
+
+char* crocksdb_get(
+    crocksdb_t* db,
+    const crocksdb_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);
+  if (s.ok()) {
+    *vallen = tmp.size();
+    result = CopyString(tmp);
+  } else {
+    *vallen = 0;
+    if (!s.IsNotFound()) {
+      SaveError(errptr, s);
+    }
+  }
+  return result;
+}
+
+char* crocksdb_get_cf(
+    crocksdb_t* db,
+    const crocksdb_readoptions_t* options,
+    crocksdb_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);
+  if (s.ok()) {
+    *vallen = tmp.size();
+    result = CopyString(tmp);
+  } else {
+    *vallen = 0;
+    if (!s.IsNotFound()) {
+      SaveError(errptr, s);
+    }
+  }
+  return result;
+}
+
+void crocksdb_multi_get(
+    crocksdb_t* db,
+    const crocksdb_readoptions_t* options,
+    size_t num_keys, const char* const* keys_list,
+    const size_t* keys_list_sizes,
+    char** values_list, size_t* values_list_sizes,
+    char** errs) {
+  std::vector<Slice> keys(num_keys);
+  for (size_t i = 0; i < num_keys; i++) {
+    keys[i] = Slice(keys_list[i], keys_list_sizes[i]);
+  }
+  std::vector<std::string> values(num_keys);
+  std::vector<Status> statuses = db->rep->MultiGet(options->rep, keys, &values);
+  for (size_t i = 0; i < num_keys; i++) {
+    if (statuses[i].ok()) {
+      values_list[i] = CopyString(values[i]);
+      values_list_sizes[i] = values[i].size();
+      errs[i] = nullptr;
+    } else {
+      values_list[i] = nullptr;
+      values_list_sizes[i] = 0;
+      if (!statuses[i].IsNotFound()) {
+        errs[i] = strdup(statuses[i].ToString().c_str());
+      } else {
+        errs[i] = nullptr;
+      }
+    }
+  }
+}
+
+void crocksdb_multi_get_cf(
+    crocksdb_t* db,
+    const crocksdb_readoptions_t* options,
+    const crocksdb_column_family_handle_t* const* column_families,
+    size_t num_keys, const char* const* keys_list,
+    const size_t* keys_list_sizes,
+    char** values_list, size_t* values_list_sizes,
+    char** errs) {
+  std::vector<Slice> keys(num_keys);
+  std::vector<ColumnFamilyHandle*> cfs(num_keys);
+  for (size_t i = 0; i < num_keys; i++) {
+    keys[i] = Slice(keys_list[i], keys_list_sizes[i]);
+    cfs[i] = column_families[i]->rep;
+  }
+  std::vector<std::string> values(num_keys);
+  std::vector<Status> statuses = db->rep->MultiGet(options->rep, cfs, keys, &values);
+  for (size_t i = 0; i < num_keys; i++) {
+    if (statuses[i].ok()) {
+      values_list[i] = CopyString(values[i]);
+      values_list_sizes[i] = values[i].size();
+      errs[i] = nullptr;
+    } else {
+      values_list[i] = nullptr;
+      values_list_sizes[i] = 0;
+      if (!statuses[i].IsNotFound()) {
+        errs[i] = strdup(statuses[i].ToString().c_str());
+      } else {
+        errs[i] = nullptr;
+      }
+    }
+  }
+}
+
+crocksdb_iterator_t* crocksdb_create_iterator(
+    crocksdb_t* db,
+    const crocksdb_readoptions_t* options) {
+  crocksdb_iterator_t* result = new crocksdb_iterator_t;
+  result->rep = db->rep->NewIterator(options->rep);
+  return result;
+}
+
+crocksdb_iterator_t* crocksdb_create_iterator_cf(
+    crocksdb_t* db,
+    const crocksdb_readoptions_t* options,
+    crocksdb_column_family_handle_t* column_family) {
+  crocksdb_iterator_t* result = new crocksdb_iterator_t;
+  result->rep = db->rep->NewIterator(options->rep, column_family->rep);
+  return result;
+}
+
+void crocksdb_create_iterators(
+    crocksdb_t *db,
+    crocksdb_readoptions_t* opts,
+    crocksdb_column_family_handle_t** column_families,
+    crocksdb_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);
+  }
+
+  std::vector<Iterator*> res;
+  Status status = db->rep->NewIterators(opts->rep, column_families_vec, &res);
+  assert(res.size() == size);
+  if (SaveError(errptr, status)) {
+    return;
+  }
+
+  for (size_t i = 0; i < size; i++) {
+    iterators[i] = new crocksdb_iterator_t;
+    iterators[i]->rep = res[i];
+  }
+}
+
+const crocksdb_snapshot_t* crocksdb_create_snapshot(
+    crocksdb_t* db) {
+  crocksdb_snapshot_t* result = new crocksdb_snapshot_t;
+  result->rep = db->rep->GetSnapshot();
+  return result;
+}
+
+void crocksdb_release_snapshot(
+    crocksdb_t* db,
+    const crocksdb_snapshot_t* snapshot) {
+  db->rep->ReleaseSnapshot(snapshot->rep);
+  delete snapshot;
+}
+
+char* crocksdb_property_value(
+    crocksdb_t* db,
+    const char* propname) {
+  std::string tmp;
+  if (db->rep->GetProperty(Slice(propname), &tmp)) {
+    // We use strdup() since we expect human readable output.
+    return strdup(tmp.c_str());
+  } else {
+    return nullptr;
+  }
+}
+
+char* crocksdb_property_value_cf(
+    crocksdb_t* db,
+    crocksdb_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.
+    return strdup(tmp.c_str());
+  } else {
+    return nullptr;
+  }
+}
+
+void crocksdb_approximate_sizes(
+    crocksdb_t* db,
+    int num_ranges,
+    const char* const* range_start_key, const size_t* range_start_key_len,
+    const char* const* range_limit_key, const size_t* range_limit_key_len,
+    uint64_t* sizes) {
+  Range* ranges = new Range[num_ranges];
+  for (int i = 0; i < num_ranges; i++) {
+    ranges[i].start = Slice(range_start_key[i], range_start_key_len[i]);
+    ranges[i].limit = Slice(range_limit_key[i], range_limit_key_len[i]);
+  }
+  db->rep->GetApproximateSizes(ranges, num_ranges, sizes);
+  delete[] ranges;
+}
+
+void crocksdb_approximate_sizes_cf(
+    crocksdb_t* db,
+    crocksdb_column_family_handle_t* column_family,
+    int num_ranges,
+    const char* const* range_start_key, const size_t* range_start_key_len,
+    const char* const* range_limit_key, const size_t* range_limit_key_len,
+    uint64_t* sizes) {
+  Range* ranges = new Range[num_ranges];
+  for (int i = 0; i < num_ranges; i++) {
+    ranges[i].start = Slice(range_start_key[i], range_start_key_len[i]);
+    ranges[i].limit = Slice(range_limit_key[i], range_limit_key_len[i]);
+  }
+  db->rep->GetApproximateSizes(column_family->rep, ranges, num_ranges, sizes);
+  delete[] ranges;
+}
+
+void crocksdb_delete_file(
+    crocksdb_t* db,
+    const char* name) {
+  db->rep->DeleteFile(name);
+}
+
+const crocksdb_livefiles_t* crocksdb_livefiles(
+    crocksdb_t* db) {
+  crocksdb_livefiles_t* result = new crocksdb_livefiles_t;
+  db->rep->GetLiveFilesMetaData(&result->rep);
+  return result;
+}
+
+void crocksdb_compact_range(
+    crocksdb_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(),
+      // Pass nullptr Slice if corresponding "const char*" is nullptr
+      (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
+      (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
+}
+
+void crocksdb_compact_range_cf(
+    crocksdb_t* db,
+    crocksdb_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,
+      // Pass nullptr Slice if corresponding "const char*" is nullptr
+      (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
+      (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
+}
+
+void crocksdb_compact_range_opt(crocksdb_t* db, crocksdb_compactoptions_t* opt,
+                               const char* start_key, size_t start_key_len,
+                               const char* limit_key, size_t limit_key_len) {
+  Slice a, b;
+  db->rep->CompactRange(
+      opt->rep,
+      // Pass nullptr Slice if corresponding "const char*" is nullptr
+      (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
+      (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
+}
+
+void crocksdb_compact_range_cf_opt(crocksdb_t* db,
+                                  crocksdb_column_family_handle_t* column_family,
+                                  crocksdb_compactoptions_t* opt,
+                                  const char* start_key, size_t start_key_len,
+                                  const char* limit_key, size_t limit_key_len) {
+  Slice a, b;
+  db->rep->CompactRange(
+      opt->rep, column_family->rep,
+      // Pass nullptr Slice if corresponding "const char*" is nullptr
+      (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
+      (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
+}
+
+void crocksdb_flush(
+    crocksdb_t* db,
+    const crocksdb_flushoptions_t* options,
+    char** errptr) {
+  SaveError(errptr, db->rep->Flush(options->rep));
+}
+
+void crocksdb_disable_file_deletions(
+    crocksdb_t* db,
+    char** errptr) {
+  SaveError(errptr, db->rep->DisableFileDeletions());
+}
+
+void crocksdb_enable_file_deletions(
+    crocksdb_t* db,
+    unsigned char force,
+    char** errptr) {
+  SaveError(errptr, db->rep->EnableFileDeletions(force));
+}
+
+void crocksdb_destroy_db(
+    const crocksdb_options_t* options,
+    const char* name,
+    char** errptr) {
+  SaveError(errptr, DestroyDB(name, options->rep));
+}
+
+void crocksdb_repair_db(
+    const crocksdb_options_t* options,
+    const char* name,
+    char** errptr) {
+  SaveError(errptr, RepairDB(name, options->rep));
+}
+
+void crocksdb_iter_destroy(crocksdb_iterator_t* iter) {
+  delete iter->rep;
+  delete iter;
+}
+
+unsigned char crocksdb_iter_valid(const crocksdb_iterator_t* iter) {
+  return iter->rep->Valid();
+}
+
+void crocksdb_iter_seek_to_first(crocksdb_iterator_t* iter) {
+  iter->rep->SeekToFirst();
+}
+
+void crocksdb_iter_seek_to_last(crocksdb_iterator_t* iter) {
+  iter->rep->SeekToLast();
+}
+
+void crocksdb_iter_seek(crocksdb_iterator_t* iter, const char* k, size_t klen) {
+  iter->rep->Seek(Slice(k, klen));
+}
+
+void crocksdb_iter_seek_for_prev(crocksdb_iterator_t* iter, const char* k,
+                                size_t klen) {
+  iter->rep->SeekForPrev(Slice(k, klen));
+}
+
+void crocksdb_iter_next(crocksdb_iterator_t* iter) {
+  iter->rep->Next();
+}
+
+void crocksdb_iter_prev(crocksdb_iterator_t* iter) {
+  iter->rep->Prev();
+}
+
+const char* crocksdb_iter_key(const crocksdb_iterator_t* iter, size_t* klen) {
+  Slice s = iter->rep->key();
+  *klen = s.size();
+  return s.data();
+}
+
+const char* crocksdb_iter_value(const crocksdb_iterator_t* iter, size_t* vlen) {
+  Slice s = iter->rep->value();
+  *vlen = s.size();
+  return s.data();
+}
+
+void crocksdb_iter_get_error(const crocksdb_iterator_t* iter, char** errptr) {
+  SaveError(errptr, iter->rep->status());
+}
+
+crocksdb_writebatch_t* crocksdb_writebatch_create() {
+  return new crocksdb_writebatch_t;
+}
+
+crocksdb_writebatch_t* crocksdb_writebatch_create_from(const char* rep,
+                                                     size_t size) {
+  crocksdb_writebatch_t* b = new crocksdb_writebatch_t;
+  b->rep = WriteBatch(std::string(rep, size));
+  return b;
+}
+
+void crocksdb_writebatch_destroy(crocksdb_writebatch_t* b) {
+  delete b;
+}
+
+void crocksdb_writebatch_clear(crocksdb_writebatch_t* b) {
+  b->rep.Clear();
+}
+
+int crocksdb_writebatch_count(crocksdb_writebatch_t* b) {
+  return b->rep.Count();
+}
+
+void crocksdb_writebatch_put(
+    crocksdb_writebatch_t* b,
+    const char* key, size_t klen,
+    const char* val, size_t vlen) {
+  b->rep.Put(Slice(key, klen), Slice(val, vlen));
+}
+
+void crocksdb_writebatch_put_cf(
+    crocksdb_writebatch_t* b,
+    crocksdb_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 crocksdb_writebatch_putv(
+    crocksdb_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]);
+  }
+  std::vector<Slice> value_slices(num_values);
+  for (int i = 0; i < num_values; i++) {
+    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));
+}
+
+void crocksdb_writebatch_putv_cf(
+    crocksdb_writebatch_t* b,
+    crocksdb_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]);
+  }
+  std::vector<Slice> value_slices(num_values);
+  for (int i = 0; i < num_values; i++) {
+    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));
+}
+
+void crocksdb_writebatch_merge(
+    crocksdb_writebatch_t* b,
+    const char* key, size_t klen,
+    const char* val, size_t vlen) {
+  b->rep.Merge(Slice(key, klen), Slice(val, vlen));
+}
+
+void crocksdb_writebatch_merge_cf(
+    crocksdb_writebatch_t* b,
+    crocksdb_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 crocksdb_writebatch_mergev(
+    crocksdb_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]);
+  }
+  std::vector<Slice> value_slices(num_values);
+  for (int i = 0; i < num_values; i++) {
+    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));
+}
+
+void crocksdb_writebatch_mergev_cf(
+    crocksdb_writebatch_t* b,
+    crocksdb_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]);
+  }
+  std::vector<Slice> value_slices(num_values);
+  for (int i = 0; i < num_values; i++) {
+    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));
+}
+
+void crocksdb_writebatch_delete(
+    crocksdb_writebatch_t* b,
+    const char* key, size_t klen) {
+  b->rep.Delete(Slice(key, klen));
+}
+
+void crocksdb_writebatch_delete_cf(
+    crocksdb_writebatch_t* b,
+    crocksdb_column_family_handle_t* column_family,
+    const char* key, size_t klen) {
+  b->rep.Delete(column_family->rep, Slice(key, klen));
+}
+
+void crocksdb_writebatch_deletev(
+    crocksdb_writebatch_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]);
+  }
+  b->rep.Delete(SliceParts(key_slices.data(), num_keys));
+}
+
+void crocksdb_writebatch_deletev_cf(
+    crocksdb_writebatch_t* b,
+    crocksdb_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]);
+  }
+  b->rep.Delete(column_family->rep, SliceParts(key_slices.data(), num_keys));
+}
+
+void crocksdb_writebatch_delete_range(crocksdb_writebatch_t* b,
+                                     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));
+}
+
+void crocksdb_writebatch_delete_range_cf(
+    crocksdb_writebatch_t* b, crocksdb_column_family_handle_t* column_family,
+    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));
+}
+
+void crocksdb_writebatch_delete_rangev(crocksdb_writebatch_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++) {
+    start_key_slices[i] = Slice(start_keys_list[i], start_keys_list_sizes[i]);
+    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));
+}
+
+void crocksdb_writebatch_delete_rangev_cf(
+    crocksdb_writebatch_t* b, crocksdb_column_family_handle_t* column_family,
+    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++) {
+    start_key_slices[i] = Slice(start_keys_list[i], start_keys_list_sizes[i]);
+    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));
+}
+
+void crocksdb_writebatch_put_log_data(
+    crocksdb_writebatch_t* b,
+    const char* blob, size_t len) {
+  b->rep.PutLogData(Slice(blob, len));
+}
+
+void crocksdb_writebatch_iterate(
+    crocksdb_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)) {
+  class H : public WriteBatch::Handler {
+   public:
+    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);
+    virtual void Put(const Slice& key, const Slice& value) override {
+      (*put_)(state_, key.data(), key.size(), value.data(), value.size());
+    }
+    virtual void Delete(const Slice& key) override {
+      (*deleted_)(state_, key.data(), key.size());
+    }
+  };
+  H handler;
+  handler.state_ = state;
+  handler.put_ = put;
+  handler.deleted_ = deleted;
+  b->rep.Iterate(&handler);
+}
+
+const char* crocksdb_writebatch_data(crocksdb_writebatch_t* b, size_t* size) {
+  *size = b->rep.GetDataSize();
+  return b->rep.Data().c_str();
+}
+
+crocksdb_block_based_table_options_t*
+crocksdb_block_based_options_create() {
+  return new crocksdb_block_based_table_options_t;
+}
+
+void crocksdb_block_based_options_destroy(
+    crocksdb_block_based_table_options_t* options) {
+  delete options;
+}
+
+void crocksdb_block_based_options_set_block_size(
+    crocksdb_block_based_table_options_t* options, size_t block_size) {
+  options->rep.block_size = block_size;
+}
+
+void crocksdb_block_based_options_set_block_size_deviation(
+    crocksdb_block_based_table_options_t* options, int block_size_deviation) {
+  options->rep.block_size_deviation = block_size_deviation;
+}
+
+void crocksdb_block_based_options_set_block_restart_interval(
+    crocksdb_block_based_table_options_t* options, int block_restart_interval) {
+  options->rep.block_restart_interval = block_restart_interval;
+}
+
+void crocksdb_block_based_options_set_filter_policy(
+    crocksdb_block_based_table_options_t* options,
+    crocksdb_filterpolicy_t* filter_policy) {
+  options->rep.filter_policy.reset(filter_policy);
+}
+
+void crocksdb_block_based_options_set_no_block_cache(
+    crocksdb_block_based_table_options_t* options,
+    unsigned char no_block_cache) {
+  options->rep.no_block_cache = no_block_cache;
+}
+
+void crocksdb_block_based_options_set_block_cache(
+    crocksdb_block_based_table_options_t* options,
+    crocksdb_cache_t* block_cache) {
+  if (block_cache) {
+    options->rep.block_cache = block_cache->rep;
+  }
+}
+
+void crocksdb_block_based_options_set_block_cache_compressed(
+    crocksdb_block_based_table_options_t* options,
+    crocksdb_cache_t* block_cache_compressed) {
+  if (block_cache_compressed) {
+    options->rep.block_cache_compressed = block_cache_compressed->rep;
+  }
+}
+
+void crocksdb_block_based_options_set_whole_key_filtering(
+    crocksdb_block_based_table_options_t* options, unsigned char v) {
+  options->rep.whole_key_filtering = v;
+}
+
+void crocksdb_block_based_options_set_format_version(
+    crocksdb_block_based_table_options_t* options, int v) {
+  options->rep.format_version = v;
+}
+
+void crocksdb_block_based_options_set_index_type(
+    crocksdb_block_based_table_options_t* options, int v) {
+  options->rep.index_type = static_cast<BlockBasedTableOptions::IndexType>(v);
+}
+
+void crocksdb_block_based_options_set_hash_index_allow_collision(
+    crocksdb_block_based_table_options_t* options, unsigned char v) {
+  options->rep.hash_index_allow_collision = v;
+}
+
+void crocksdb_block_based_options_set_cache_index_and_filter_blocks(
+    crocksdb_block_based_table_options_t* options, unsigned char v) {
+  options->rep.cache_index_and_filter_blocks = v;
+}
+
+void crocksdb_block_based_options_set_pin_l0_filter_and_index_blocks_in_cache(
+    crocksdb_block_based_table_options_t* options, unsigned char v) {
+  options->rep.pin_l0_filter_and_index_blocks_in_cache = v;
+}
+
+void crocksdb_block_based_options_set_skip_table_builder_flush(
+    crocksdb_block_based_table_options_t* options, unsigned char v) {
+  options->rep.skip_table_builder_flush = v;
+}
+
+void crocksdb_options_set_block_based_table_factory(
+    crocksdb_options_t *opt,
+    crocksdb_block_based_table_options_t* table_options) {
+  if (table_options) {
+    opt->rep.table_factory.reset(
+        rocksdb::NewBlockBasedTableFactory(table_options->rep));
+  }
+}
+
+
+crocksdb_cuckoo_table_options_t*
+crocksdb_cuckoo_options_create() {
+  return new crocksdb_cuckoo_table_options_t;
+}
+
+void crocksdb_cuckoo_options_destroy(
+    crocksdb_cuckoo_table_options_t* options) {
+  delete options;
+}
+
+void crocksdb_cuckoo_options_set_hash_ratio(
+    crocksdb_cuckoo_table_options_t* options, double v) {
+  options->rep.hash_table_ratio = v;
+}
+
+void crocksdb_cuckoo_options_set_max_search_depth(
+    crocksdb_cuckoo_table_options_t* options, uint32_t v) {
+  options->rep.max_search_depth = v;
+}
+
+void crocksdb_cuckoo_options_set_cuckoo_block_size(
+    crocksdb_cuckoo_table_options_t* options, uint32_t v) {
+  options->rep.cuckoo_block_size = v;
+}
+
+void crocksdb_cuckoo_options_set_identity_as_first_hash(
+    crocksdb_cuckoo_table_options_t* options, unsigned char v) {
+  options->rep.identity_as_first_hash = v;
+}
+
+void crocksdb_cuckoo_options_set_use_module_hash(
+    crocksdb_cuckoo_table_options_t* options, unsigned char v) {
+  options->rep.use_module_hash = v;
+}
+
+void crocksdb_options_set_cuckoo_table_factory(
+    crocksdb_options_t *opt,
+    crocksdb_cuckoo_table_options_t* table_options) {
+  if (table_options) {
+    opt->rep.table_factory.reset(
+        rocksdb::NewCuckooTableFactory(table_options->rep));
+  }
+}
+
+
+crocksdb_options_t* crocksdb_options_create() {
+  return new crocksdb_options_t;
+}
+
+void crocksdb_options_destroy(crocksdb_options_t* options) {
+  delete options;
+}
+
+void crocksdb_options_increase_parallelism(
+    crocksdb_options_t* opt, int total_threads) {
+  opt->rep.IncreaseParallelism(total_threads);
+}
+
+void crocksdb_options_optimize_for_point_lookup(
+    crocksdb_options_t* opt, uint64_t block_cache_size_mb) {
+  opt->rep.OptimizeForPointLookup(block_cache_size_mb);
+}
+
+void crocksdb_options_optimize_level_style_compaction(
+    crocksdb_options_t* opt, uint64_t memtable_memory_budget) {
+  opt->rep.OptimizeLevelStyleCompaction(memtable_memory_budget);
+}
+
+void crocksdb_options_optimize_universal_style_compaction(
+    crocksdb_options_t* opt, uint64_t memtable_memory_budget) {
+  opt->rep.OptimizeUniversalStyleCompaction(memtable_memory_budget);
+}
+
+void crocksdb_options_set_compaction_filter(
+    crocksdb_options_t* opt,
+    crocksdb_compactionfilter_t* filter) {
+  opt->rep.compaction_filter = filter;
+}
+
+void crocksdb_options_set_compaction_filter_factory(
+    crocksdb_options_t* opt, crocksdb_compactionfilterfactory_t* factory) {
+  opt->rep.compaction_filter_factory =
+      std::shared_ptr<CompactionFilterFactory>(factory);
+}
+
+void crocksdb_options_compaction_readahead_size(
+    crocksdb_options_t* opt, size_t s) {
+  opt->rep.compaction_readahead_size = s;
+}
+
+void crocksdb_options_set_comparator(
+    crocksdb_options_t* opt,
+    crocksdb_comparator_t* cmp) {
+  opt->rep.comparator = cmp;
+}
+
+void crocksdb_options_set_merge_operator(
+    crocksdb_options_t* opt,
+    crocksdb_mergeoperator_t* merge_operator) {
+  opt->rep.merge_operator = std::shared_ptr<MergeOperator>(merge_operator);
+}
+
+
+void crocksdb_options_set_create_if_missing(
+    crocksdb_options_t* opt, unsigned char v) {
+  opt->rep.create_if_missing = v;
+}
+
+void crocksdb_options_set_create_missing_column_families(
+    crocksdb_options_t* opt, unsigned char v) {
+  opt->rep.create_missing_column_families = v;
+}
+
+void crocksdb_options_set_error_if_exists(
+    crocksdb_options_t* opt, unsigned char v) {
+  opt->rep.error_if_exists = v;
+}
+
+void crocksdb_options_set_paranoid_checks(
+    crocksdb_options_t* opt, unsigned char v) {
+  opt->rep.paranoid_checks = v;
+}
+
+void crocksdb_options_set_env(crocksdb_options_t* opt, crocksdb_env_t* env) {
+  opt->rep.env = (env ? env->rep : nullptr);
+}
+
+void crocksdb_options_set_info_log(crocksdb_options_t* opt, crocksdb_logger_t* l) {
+  if (l) {
+    opt->rep.info_log = l->rep;
+  }
+}
+
+void crocksdb_options_set_info_log_level(
+    crocksdb_options_t* opt, int v) {
+  opt->rep.info_log_level = static_cast<InfoLogLevel>(v);
+}
+
+void crocksdb_options_set_db_write_buffer_size(crocksdb_options_t* opt,
+                                              size_t s) {
+  opt->rep.db_write_buffer_size = s;
+}
+
+void crocksdb_options_set_write_buffer_size(crocksdb_options_t* opt, size_t s) {
+  opt->rep.write_buffer_size = s;
+}
+
+void crocksdb_options_set_max_open_files(crocksdb_options_t* opt, int n) {
+  opt->rep.max_open_files = n;
+}
+
+void crocksdb_options_set_max_total_wal_size(crocksdb_options_t* opt, uint64_t n) {
+  opt->rep.max_total_wal_size = n;
+}
+
+void crocksdb_options_set_target_file_size_base(
+    crocksdb_options_t* opt, uint64_t n) {
+  opt->rep.target_file_size_base = n;
+}
+
+void crocksdb_options_set_target_file_size_multiplier(
+    crocksdb_options_t* opt, int n) {
+  opt->rep.target_file_size_multiplier = n;
+}
+
+void crocksdb_options_set_max_bytes_for_level_base(
+    crocksdb_options_t* opt, uint64_t n) {
+  opt->rep.max_bytes_for_level_base = n;
+}
+
+void crocksdb_options_set_level_compaction_dynamic_level_bytes(
+    crocksdb_options_t* opt, unsigned char v) {
+  opt->rep.level_compaction_dynamic_level_bytes = v;
+}
+
+void crocksdb_options_set_max_bytes_for_level_multiplier(crocksdb_options_t* opt,
+                                                        double n) {
+  opt->rep.max_bytes_for_level_multiplier = n;
+}
+
+void crocksdb_options_set_max_compaction_bytes(crocksdb_options_t* opt,
+                                              uint64_t n) {
+  opt->rep.max_compaction_bytes = n;
+}
+
+void crocksdb_options_set_max_bytes_for_level_multiplier_additional(
+    crocksdb_options_t* opt, int* level_values, size_t num_levels) {
+  opt->rep.max_bytes_for_level_multiplier_additional.resize(num_levels);
+  for (size_t i = 0; i < num_levels; ++i) {
+    opt->rep.max_bytes_for_level_multiplier_additional[i] = level_values[i];
+  }
+}
+
+void crocksdb_options_enable_statistics(crocksdb_options_t* opt) {
+  opt->rep.statistics = rocksdb::CreateDBStatistics();
+}
+
+void crocksdb_options_set_num_levels(crocksdb_options_t* opt, int n) {
+  opt->rep.num_levels = n;
+}
+
+void crocksdb_options_set_level0_file_num_compaction_trigger(
+    crocksdb_options_t* opt, int n) {
+  opt->rep.level0_file_num_compaction_trigger = n;
+}
+
+void crocksdb_options_set_level0_slowdown_writes_trigger(
+    crocksdb_options_t* opt, int n) {
+  opt->rep.level0_slowdown_writes_trigger = n;
+}
+
+void crocksdb_options_set_level0_stop_writes_trigger(
+    crocksdb_options_t* opt, int n) {
+  opt->rep.level0_stop_writes_trigger = n;
+}
+
+void crocksdb_options_set_max_mem_compaction_level(crocksdb_options_t* opt,
+                                                  int n) {}
+
+void crocksdb_options_set_wal_recovery_mode(crocksdb_options_t* opt,int mode) {
+  opt->rep.wal_recovery_mode = static_cast<WALRecoveryMode>(mode);
+}
+
+void crocksdb_options_set_compression(crocksdb_options_t* opt, int t) {
+  opt->rep.compression = static_cast<CompressionType>(t);
+}
+
+void crocksdb_options_set_compression_per_level(crocksdb_options_t* opt,
+                                               int* level_values,
+                                               size_t num_levels) {
+  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]);
+  }
+}
+
+void crocksdb_options_set_compression_options(crocksdb_options_t* opt, int w_bits,
+                                             int level, int strategy,
+                                             int max_dict_bytes) {
+  opt->rep.compression_opts.window_bits = w_bits;
+  opt->rep.compression_opts.level = level;
+  opt->rep.compression_opts.strategy = strategy;
+  opt->rep.compression_opts.max_dict_bytes = max_dict_bytes;
+}
+
+void crocksdb_options_set_prefix_extractor(
+    crocksdb_options_t* opt, crocksdb_slicetransform_t* prefix_extractor) {
+  opt->rep.prefix_extractor.reset(prefix_extractor);
+}
+
+void crocksdb_options_set_disable_data_sync(
+    crocksdb_options_t* opt, int disable_data_sync) {
+  opt->rep.disableDataSync = disable_data_sync;
+}
+
+void crocksdb_options_set_use_fsync(
+    crocksdb_options_t* opt, int use_fsync) {
+  opt->rep.use_fsync = use_fsync;
+}
+
+void crocksdb_options_set_db_log_dir(
+    crocksdb_options_t* opt, const char* db_log_dir) {
+  opt->rep.db_log_dir = db_log_dir;
+}
+
+void crocksdb_options_set_wal_dir(
+    crocksdb_options_t* opt, const char* v) {
+  opt->rep.wal_dir = v;
+}
+
+void crocksdb_options_set_WAL_ttl_seconds(crocksdb_options_t* opt, uint64_t ttl) {
+  opt->rep.WAL_ttl_seconds = ttl;
+}
+
+void crocksdb_options_set_WAL_size_limit_MB(
+    crocksdb_options_t* opt, uint64_t limit) {
+  opt->rep.WAL_size_limit_MB = limit;
+}
+
+void crocksdb_options_set_manifest_preallocation_size(
+    crocksdb_options_t* opt, size_t v) {
+  opt->rep.manifest_preallocation_size = v;
+}
+
+// noop
+void crocksdb_options_set_purge_redundant_kvs_while_flush(crocksdb_options_t* opt,
+                                                         unsigned char v) {}
+
+void crocksdb_options_set_allow_os_buffer(crocksdb_options_t* opt,
+                                         unsigned char v) {
+  opt->rep.allow_os_buffer = v;
+}
+
+void crocksdb_options_set_allow_mmap_reads(
+    crocksdb_options_t* opt, unsigned char v) {
+  opt->rep.allow_mmap_reads = v;
+}
+
+void crocksdb_options_set_allow_mmap_writes(
+    crocksdb_options_t* opt, unsigned char v) {
+  opt->rep.allow_mmap_writes = v;
+}
+
+void crocksdb_options_set_is_fd_close_on_exec(
+    crocksdb_options_t* opt, unsigned char v) {
+  opt->rep.is_fd_close_on_exec = v;
+}
+
+void crocksdb_options_set_skip_log_error_on_recovery(
+    crocksdb_options_t* opt, unsigned char v) {
+  opt->rep.skip_log_error_on_recovery = v;
+}
+
+void crocksdb_options_set_stats_dump_period_sec(
+    crocksdb_options_t* opt, unsigned int v) {
+  opt->rep.stats_dump_period_sec = v;
+}
+
+void crocksdb_options_set_advise_random_on_open(
+    crocksdb_options_t* opt, unsigned char v) {
+  opt->rep.advise_random_on_open = v;
+}
+
+void crocksdb_options_set_access_hint_on_compaction_start(
+    crocksdb_options_t* opt, int v) {
+  switch(v) {
+    case 0:
+      opt->rep.access_hint_on_compaction_start = rocksdb::Options::NONE;
+      break;
+    case 1:
+      opt->rep.access_hint_on_compaction_start = rocksdb::Options::NORMAL;
+      break;
+    case 2:
+      opt->rep.access_hint_on_compaction_start = rocksdb::Options::SEQUENTIAL;
+      break;
+    case 3:
+      opt->rep.access_hint_on_compaction_start = rocksdb::Options::WILLNEED;
+      break;
+  }
+}
+
+void crocksdb_options_set_use_adaptive_mutex(
+    crocksdb_options_t* opt, unsigned char v) {
+  opt->rep.use_adaptive_mutex = v;
+}
+
+void crocksdb_options_set_bytes_per_sync(
+    crocksdb_options_t* opt, uint64_t v) {
+  opt->rep.bytes_per_sync = v;
+}
+
+void crocksdb_options_set_allow_concurrent_memtable_write(crocksdb_options_t* opt,
+                                                         unsigned char v) {
+  opt->rep.allow_concurrent_memtable_write = v;
+}
+
+void crocksdb_options_set_enable_write_thread_adaptive_yield(
+    crocksdb_options_t* opt, unsigned char v) {
+  opt->rep.enable_write_thread_adaptive_yield = v;
+}
+
+void crocksdb_options_set_verify_checksums_in_compaction(
+    crocksdb_options_t* opt, unsigned char v) {
+  opt->rep.verify_checksums_in_compaction = v;
+}
+
+void crocksdb_options_set_max_sequential_skip_in_iterations(
+    crocksdb_options_t* opt, uint64_t v) {
+  opt->rep.max_sequential_skip_in_iterations = v;
+}
+
+void crocksdb_options_set_max_write_buffer_number(crocksdb_options_t* opt, int n) {
+  opt->rep.max_write_buffer_number = n;
+}
+
+void crocksdb_options_set_min_write_buffer_number_to_merge(crocksdb_options_t* opt, int n) {
+  opt->rep.min_write_buffer_number_to_merge = n;
+}
+
+void crocksdb_options_set_max_write_buffer_number_to_maintain(
+    crocksdb_options_t* opt, int n) {
+  opt->rep.max_write_buffer_number_to_maintain = n;
+}
+
+void crocksdb_options_set_max_background_compactions(crocksdb_options_t* opt, int n) {
+  opt->rep.max_background_compactions = n;
+}
+
+void crocksdb_options_set_base_background_compactions(crocksdb_options_t* opt,
+                                                     int n) {
+  opt->rep.base_background_compactions = n;
+}
+
+void crocksdb_options_set_max_background_flushes(crocksdb_options_t* opt, int n) {
+  opt->rep.max_background_flushes = n;
+}
+
+void crocksdb_options_set_max_log_file_size(crocksdb_options_t* opt, size_t v) {
+  opt->rep.max_log_file_size = v;
+}
+
+void crocksdb_options_set_log_file_time_to_roll(crocksdb_options_t* opt, size_t v) {
+  opt->rep.log_file_time_to_roll = v;
+}
+
+void crocksdb_options_set_keep_log_file_num(crocksdb_options_t* opt, size_t v) {
+  opt->rep.keep_log_file_num = v;
+}
+
+void crocksdb_options_set_recycle_log_file_num(crocksdb_options_t* opt,
+                                              size_t v) {
+  opt->rep.recycle_log_file_num = v;
+}
+
+void crocksdb_options_set_soft_rate_limit(crocksdb_options_t* opt, double v) {
+  opt->rep.soft_rate_limit = v;
+}
+
+void crocksdb_options_set_hard_rate_limit(crocksdb_options_t* opt, double v) {
+  opt->rep.hard_rate_limit = v;
+}
+
+void crocksdb_options_set_rate_limit_delay_max_milliseconds(
+    crocksdb_options_t* opt, unsigned int v) {
+  opt->rep.rate_limit_delay_max_milliseconds = v;
+}
+
+void crocksdb_options_set_max_manifest_file_size(
+    crocksdb_options_t* opt, size_t v) {
+  opt->rep.max_manifest_file_size = v;
+}
+
+void crocksdb_options_set_table_cache_numshardbits(
+    crocksdb_options_t* opt, int v) {
+  opt->rep.table_cache_numshardbits = v;
+}
+
+void crocksdb_options_set_table_cache_remove_scan_count_limit(
+    crocksdb_options_t* opt, int v) {
+  // this option is deprecated
+}
+
+void crocksdb_options_set_arena_block_size(
+    crocksdb_options_t* opt, size_t v) {
+  opt->rep.arena_block_size = v;
+}
+
+void crocksdb_options_set_disable_auto_compactions(crocksdb_options_t* opt, int disable) {
+  opt->rep.disable_auto_compactions = disable;
+}
+
+void crocksdb_options_set_delete_obsolete_files_period_micros(
+    crocksdb_options_t* opt, uint64_t v) {
+  opt->rep.delete_obsolete_files_period_micros = v;
+}
+
+void crocksdb_options_prepare_for_bulk_load(crocksdb_options_t* opt) {
+  opt->rep.PrepareForBulkLoad();
+}
+
+void crocksdb_options_set_memtable_vector_rep(crocksdb_options_t *opt) {
+  opt->rep.memtable_factory.reset(new rocksdb::VectorRepFactory);
+}
+
+void crocksdb_options_set_memtable_prefix_bloom_size_ratio(
+    crocksdb_options_t* opt, double v) {
+  opt->rep.memtable_prefix_bloom_size_ratio = v;
+}
+
+void crocksdb_options_set_memtable_huge_page_size(crocksdb_options_t* opt,
+                                                 size_t v) {
+  opt->rep.memtable_huge_page_size = v;
+}
+
+void crocksdb_options_set_hash_skip_list_rep(
+    crocksdb_options_t *opt, size_t bucket_count,
+    int32_t skiplist_height, int32_t skiplist_branching_factor) {
+  rocksdb::MemTableRepFactory* factory = rocksdb::NewHashSkipListRepFactory(
+      bucket_count, skiplist_height, skiplist_branching_factor);
+  opt->rep.memtable_factory.reset(factory);
+}
+
+void crocksdb_options_set_hash_link_list_rep(
+    crocksdb_options_t *opt, size_t bucket_count) {
+  opt->rep.memtable_factory.reset(rocksdb::NewHashLinkListRepFactory(bucket_count));
+}
+
+void crocksdb_options_set_plain_table_factory(
+    crocksdb_options_t *opt, uint32_t user_key_len, int bloom_bits_per_key,
+    double hash_table_ratio, size_t index_sparseness) {
+  rocksdb::PlainTableOptions options;
+  options.user_key_len = user_key_len;
+  options.bloom_bits_per_key = bloom_bits_per_key;
+  options.hash_table_ratio = hash_table_ratio;
+  options.index_sparseness = index_sparseness;
+
+  rocksdb::TableFactory* factory = rocksdb::NewPlainTableFactory(options);
+  opt->rep.table_factory.reset(factory);
+}
+
+void crocksdb_options_set_max_successive_merges(
+    crocksdb_options_t* opt, size_t v) {
+  opt->rep.max_successive_merges = v;
+}
+
+void crocksdb_options_set_min_partial_merge_operands(
+    crocksdb_options_t* opt, uint32_t v) {
+  opt->rep.min_partial_merge_operands = v;
+}
+
+void crocksdb_options_set_bloom_locality(
+    crocksdb_options_t* opt, uint32_t v) {
+  opt->rep.bloom_locality = v;
+}
+
+void crocksdb_options_set_inplace_update_support(
+    crocksdb_options_t* opt, unsigned char v) {
+  opt->rep.inplace_update_support = v;
+}
+
+void crocksdb_options_set_inplace_update_num_locks(
+    crocksdb_options_t* opt, size_t v) {
+  opt->rep.inplace_update_num_locks = v;
+}
+
+void crocksdb_options_set_report_bg_io_stats(
+    crocksdb_options_t* opt, int v) {
+  opt->rep.report_bg_io_stats = v;
+}
+
+void crocksdb_options_set_compaction_style(crocksdb_options_t *opt, int style) {
+  opt->rep.compaction_style = static_cast<rocksdb::CompactionStyle>(style);
+}
+
+void crocksdb_options_set_universal_compaction_options(crocksdb_options_t *opt, crocksdb_universal_compaction_options_t *uco) {
+  opt->rep.compaction_options_universal = *(uco->rep);
+}
+
+void crocksdb_options_set_fifo_compaction_options(
+    crocksdb_options_t* opt,
+    crocksdb_fifo_compaction_options_t* fifo) {
+  opt->rep.compaction_options_fifo = fifo->rep;
+}
+
+char *crocksdb_options_statistics_get_string(crocksdb_options_t *opt) {
+  rocksdb::Statistics *statistics = opt->rep.statistics.get();
+  if (statistics) {
+    return strdup(statistics->ToString().c_str());
+  }
+  return nullptr;
+}
+
+void crocksdb_options_set_ratelimiter(crocksdb_options_t *opt, crocksdb_ratelimiter_t *limiter) {
+  opt->rep.rate_limiter.reset(limiter->rep);
+  limiter->rep = nullptr;
+}
+
+crocksdb_ratelimiter_t* crocksdb_ratelimiter_create(
+    int64_t rate_bytes_per_sec,
+    int64_t refill_period_us,
+    int32_t fairness) {
+  crocksdb_ratelimiter_t* rate_limiter = new crocksdb_ratelimiter_t;
+  rate_limiter->rep = NewGenericRateLimiter(rate_bytes_per_sec,
+                                            refill_period_us, fairness);
+  return rate_limiter;
+}
+
+void crocksdb_ratelimiter_destroy(crocksdb_ratelimiter_t *limiter) {
+  if (limiter->rep) {
+	delete limiter->rep;
+  }
+  delete limiter;
+}
+
+/*
+TODO:
+DB::OpenForReadOnly
+DB::KeyMayExist
+DB::GetOptions
+DB::GetSortedWalFiles
+DB::GetLatestSequenceNumber
+DB::GetUpdatesSince
+DB::GetDbIdentity
+DB::RunManualCompaction
+custom cache
+table_properties_collectors
+*/
+
+crocksdb_compactionfilter_t* crocksdb_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),
+    const char* (*name)(void*)) {
+  crocksdb_compactionfilter_t* result = new crocksdb_compactionfilter_t;
+  result->state_ = state;
+  result->destructor_ = destructor;
+  result->filter_ = filter;
+  result->ignore_snapshots_ = false;
+  result->name_ = name;
+  return result;
+}
+
+void crocksdb_compactionfilter_set_ignore_snapshots(
+  crocksdb_compactionfilter_t* filter,
+  unsigned char whether_ignore) {
+  filter->ignore_snapshots_ = whether_ignore;
+}
+
+void crocksdb_compactionfilter_destroy(crocksdb_compactionfilter_t* filter) {
+  delete filter;
+}
+
+unsigned char crocksdb_compactionfiltercontext_is_full_compaction(
+    crocksdb_compactionfiltercontext_t* context) {
+  return context->rep.is_full_compaction;
+}
+
+unsigned char crocksdb_compactionfiltercontext_is_manual_compaction(
+    crocksdb_compactionfiltercontext_t* context) {
+  return context->rep.is_manual_compaction;
+}
+
+crocksdb_compactionfilterfactory_t* crocksdb_compactionfilterfactory_create(
+    void* state, void (*destructor)(void*),
+    crocksdb_compactionfilter_t* (*create_compaction_filter)(
+        void*, crocksdb_compactionfiltercontext_t* context),
+    const char* (*name)(void*)) {
+  crocksdb_compactionfilterfactory_t* result =
+      new crocksdb_compactionfilterfactory_t;
+  result->state_ = state;
+  result->destructor_ = destructor;
+  result->create_compaction_filter_ = create_compaction_filter;
+  result->name_ = name;
+  return result;
+}
+
+void crocksdb_compactionfilterfactory_destroy(
+    crocksdb_compactionfilterfactory_t* factory) {
+  delete factory;
+}
+
+crocksdb_comparator_t* crocksdb_comparator_create(
+    void* state,
+    void (*destructor)(void*),
+    int (*compare)(
+        void*,
+        const char* a, size_t alen,
+        const char* b, size_t blen),
+    const char* (*name)(void*)) {
+  crocksdb_comparator_t* result = new crocksdb_comparator_t;
+  result->state_ = state;
+  result->destructor_ = destructor;
+  result->compare_ = compare;
+  result->name_ = name;
+  return result;
+}
+
+void crocksdb_comparator_destroy(crocksdb_comparator_t* cmp) {
+  delete cmp;
+}
+
+crocksdb_filterpolicy_t* crocksdb_filterpolicy_create(
+    void* state,
+    void (*destructor)(void*),
+    char* (*create_filter)(
+        void*,
+        const char* const* key_array, const size_t* key_length_array,
+        int num_keys,
+        size_t* filter_length),
+    unsigned char (*key_may_match)(
+        void*,
+        const char* key, size_t length,
+        const char* filter, size_t filter_length),
+    void (*delete_filter)(
+        void*,
+        const char* filter, size_t filter_length),
+    const char* (*name)(void*)) {
+  crocksdb_filterpolicy_t* result = new crocksdb_filterpolicy_t;
+  result->state_ = state;
+  result->destructor_ = destructor;
+  result->create_ = create_filter;
+  result->key_match_ = key_may_match;
+  result->delete_filter_ = delete_filter;
+  result->name_ = name;
+  return result;
+}
+
+void crocksdb_filterpolicy_destroy(crocksdb_filterpolicy_t* filter) {
+  delete filter;
+}
+
+crocksdb_filterpolicy_t* crocksdb_filterpolicy_create_bloom_format(int bits_per_key, bool original_format) {
+  // Make a crocksdb_filterpolicy_t, but override all of its methods so
+  // they delegate to a NewBloomFilterPolicy() instead of user
+  // supplied C functions.
+  struct Wrapper : public crocksdb_filterpolicy_t {
+    const FilterPolicy* rep_;
+    ~Wrapper() { delete rep_; }
+    const char* Name() const override { return rep_->Name(); }
+    void CreateFilter(const Slice* keys, int n,
+                      std::string* dst) const override {
+      return rep_->CreateFilter(keys, n, dst);
+    }
+    bool KeyMayMatch(const Slice& key, const Slice& filter) const override {
+      return rep_->KeyMayMatch(key, filter);
+    }
+    static void DoNothing(void*) { }
+  };
+  Wrapper* wrapper = new Wrapper;
+  wrapper->rep_ = NewBloomFilterPolicy(bits_per_key, original_format);
+  wrapper->state_ = nullptr;
+  wrapper->delete_filter_ = nullptr;
+  wrapper->destructor_ = &Wrapper::DoNothing;
+  return wrapper;
+}
+
+crocksdb_filterpolicy_t* crocksdb_filterpolicy_create_bloom_full(int bits_per_key) {
+  return crocksdb_filterpolicy_create_bloom_format(bits_per_key, false);
+}
+
+crocksdb_filterpolicy_t* crocksdb_filterpolicy_create_bloom(int bits_per_key) {
+  return crocksdb_filterpolicy_create_bloom_format(bits_per_key, true);
+}
+
+crocksdb_mergeoperator_t* crocksdb_mergeoperator_create(
+    void* state, void (*destructor)(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* (*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),
+    const char* (*name)(void*)) {
+  crocksdb_mergeoperator_t* result = new crocksdb_mergeoperator_t;
+  result->state_ = state;
+  result->destructor_ = destructor;
+  result->full_merge_ = full_merge;
+  result->partial_merge_ = partial_merge;
+  result->delete_value_ = delete_value;
+  result->name_ = name;
+  return result;
+}
+
+void crocksdb_mergeoperator_destroy(crocksdb_mergeoperator_t* merge_operator) {
+  delete merge_operator;
+}
+
+crocksdb_readoptions_t* crocksdb_readoptions_create() {
+  return new crocksdb_readoptions_t;
+}
+
+void crocksdb_readoptions_destroy(crocksdb_readoptions_t* opt) {
+  delete opt;
+}
+
+void crocksdb_readoptions_set_verify_checksums(
+    crocksdb_readoptions_t* opt,
+    unsigned char v) {
+  opt->rep.verify_checksums = v;
+}
+
+void crocksdb_readoptions_set_fill_cache(
+    crocksdb_readoptions_t* opt, unsigned char v) {
+  opt->rep.fill_cache = v;
+}
+
+void crocksdb_readoptions_set_snapshot(
+    crocksdb_readoptions_t* opt,
+    const crocksdb_snapshot_t* snap) {
+  opt->rep.snapshot = (snap ? snap->rep : nullptr);
+}
+
+void crocksdb_readoptions_set_iterate_upper_bound(
+    crocksdb_readoptions_t* opt,
+    const char* key, size_t keylen) {
+  if (key == nullptr) {
+    opt->upper_bound = Slice();
+    opt->rep.iterate_upper_bound = nullptr;
+
+  } else {
+    opt->upper_bound = Slice(key, keylen);
+    opt->rep.iterate_upper_bound = &opt->upper_bound;
+  }
+}
+
+void crocksdb_readoptions_set_read_tier(
+    crocksdb_readoptions_t* opt, int v) {
+  opt->rep.read_tier = static_cast<rocksdb::ReadTier>(v);
+}
+
+void crocksdb_readoptions_set_tailing(
+    crocksdb_readoptions_t* opt, unsigned char v) {
+  opt->rep.tailing = v;
+}
+
+void crocksdb_readoptions_set_readahead_size(
+    crocksdb_readoptions_t* opt, size_t v) {
+  opt->rep.readahead_size = v;
+}
+
+void crocksdb_readoptions_set_total_order_seek(crocksdb_readoptions_t* opt,
+    unsigned char v) {
+  opt->rep.total_order_seek = v;
+}
+
+crocksdb_writeoptions_t* crocksdb_writeoptions_create() {
+  return new crocksdb_writeoptions_t;
+}
+
+void crocksdb_writeoptions_destroy(crocksdb_writeoptions_t* opt) {
+  delete opt;
+}
+
+void crocksdb_writeoptions_set_sync(
+    crocksdb_writeoptions_t* opt, unsigned char v) {
+  opt->rep.sync = v;
+}
+
+void crocksdb_writeoptions_disable_WAL(crocksdb_writeoptions_t* opt, int disable) {
+  opt->rep.disableWAL = disable;
+}
+
+crocksdb_compactoptions_t* crocksdb_compactoptions_create() {
+  return new crocksdb_compactoptions_t;
+}
+
+void crocksdb_compactoptions_destroy(crocksdb_compactoptions_t* opt) {
+  delete opt;
+}
+
+void crocksdb_compactoptions_set_exclusive_manual_compaction(
+    crocksdb_compactoptions_t* opt, unsigned char v) {
+  opt->rep.exclusive_manual_compaction = v;
+}
+
+void crocksdb_compactoptions_set_change_level(crocksdb_compactoptions_t* opt,
+                                             unsigned char v) {
+  opt->rep.change_level = v;
+}
+
+void crocksdb_compactoptions_set_target_level(crocksdb_compactoptions_t* opt,
+                                             int n) {
+  opt->rep.target_level = n;
+}
+
+crocksdb_flushoptions_t* crocksdb_flushoptions_create() {
+  return new crocksdb_flushoptions_t;
+}
+
+void crocksdb_flushoptions_destroy(crocksdb_flushoptions_t* opt) {
+  delete opt;
+}
+
+void crocksdb_flushoptions_set_wait(
+    crocksdb_flushoptions_t* opt, unsigned char v) {
+  opt->rep.wait = v;
+}
+
+crocksdb_cache_t* crocksdb_cache_create_lru(size_t capacity) {
+  crocksdb_cache_t* c = new crocksdb_cache_t;
+  c->rep = NewLRUCache(capacity);
+  return c;
+}
+
+void crocksdb_cache_destroy(crocksdb_cache_t* cache) {
+  delete cache;
+}
+
+void crocksdb_cache_set_capacity(crocksdb_cache_t* cache, size_t capacity) {
+  cache->rep->SetCapacity(capacity);
+}
+
+crocksdb_env_t* crocksdb_create_default_env() {
+  crocksdb_env_t* result = new crocksdb_env_t;
+  result->rep = Env::Default();
+  result->is_default = true;
+  return result;
+}
+
+crocksdb_env_t* crocksdb_create_mem_env() {
+  crocksdb_env_t* result = new crocksdb_env_t;
+  result->rep = rocksdb::NewMemEnv(Env::Default());
+  result->is_default = false;
+  return result;
+}
+
+void crocksdb_env_set_background_threads(crocksdb_env_t* env, int n) {
+  env->rep->SetBackgroundThreads(n);
+}
+
+void crocksdb_env_set_high_priority_background_threads(crocksdb_env_t* env, int n) {
+  env->rep->SetBackgroundThreads(n, Env::HIGH);
+}
+
+void crocksdb_env_join_all_threads(crocksdb_env_t* env) {
+  env->rep->WaitForJoin();
+}
+
+void crocksdb_env_destroy(crocksdb_env_t* env) {
+  if (!env->is_default) delete env->rep;
+  delete env;
+}
+
+crocksdb_envoptions_t* crocksdb_envoptions_create() {
+  crocksdb_envoptions_t* opt = new crocksdb_envoptions_t;
+  return opt;
+}
+
+void crocksdb_envoptions_destroy(crocksdb_envoptions_t* opt) { delete opt; }
+
+crocksdb_sstfilewriter_t* crocksdb_sstfilewriter_create(
+    const crocksdb_envoptions_t* env, const crocksdb_options_t* io_options) {
+  crocksdb_sstfilewriter_t* writer = new crocksdb_sstfilewriter_t;
+  writer->rep =
+      new SstFileWriter(env->rep, io_options->rep, io_options->rep.comparator);
+  return writer;
+}
+
+crocksdb_sstfilewriter_t* crocksdb_sstfilewriter_create_with_comparator(
+    const crocksdb_envoptions_t* env, const crocksdb_options_t* io_options,
+    const crocksdb_comparator_t* comparator) {
+  crocksdb_sstfilewriter_t* writer = new crocksdb_sstfilewriter_t;
+  writer->rep =
+      new SstFileWriter(env->rep, io_options->rep, io_options->rep.comparator);
+  return writer;
+}
+
+void crocksdb_sstfilewriter_open(crocksdb_sstfilewriter_t* writer,
+                                const char* name, char** errptr) {
+  SaveError(errptr, writer->rep->Open(std::string(name)));
+}
+
+void crocksdb_sstfilewriter_add(crocksdb_sstfilewriter_t* writer, const char* key,
+                               size_t keylen, const char* val, size_t vallen,
+                               char** errptr) {
+  SaveError(errptr, writer->rep->Add(Slice(key, keylen), Slice(val, vallen)));
+}
+
+void crocksdb_sstfilewriter_finish(crocksdb_sstfilewriter_t* writer,
+                                  char** errptr) {
+  SaveError(errptr, writer->rep->Finish(NULL));
+}
+
+void crocksdb_sstfilewriter_destroy(crocksdb_sstfilewriter_t* writer) {
+  delete writer->rep;
+  delete writer;
+}
+
+crocksdb_ingestexternalfileoptions_t*
+crocksdb_ingestexternalfileoptions_create() {
+  crocksdb_ingestexternalfileoptions_t* opt =
+      new crocksdb_ingestexternalfileoptions_t;
+  return opt;
+}
+
+void crocksdb_ingestexternalfileoptions_set_move_files(
+    crocksdb_ingestexternalfileoptions_t* opt, unsigned char move_files) {
+  opt->rep.move_files = move_files;
+}
+
+void crocksdb_ingestexternalfileoptions_set_snapshot_consistency(
+    crocksdb_ingestexternalfileoptions_t* opt,
+    unsigned char snapshot_consistency) {
+  opt->rep.snapshot_consistency = snapshot_consistency;
+}
+
+void crocksdb_ingestexternalfileoptions_set_allow_global_seqno(
+    crocksdb_ingestexternalfileoptions_t* opt,
+    unsigned char allow_global_seqno) {
+  opt->rep.allow_global_seqno = allow_global_seqno;
+}
+
+void crocksdb_ingestexternalfileoptions_set_allow_blocking_flush(
+    crocksdb_ingestexternalfileoptions_t* opt,
+    unsigned char allow_blocking_flush) {
+  opt->rep.allow_blocking_flush = allow_blocking_flush;
+}
+
+void crocksdb_ingestexternalfileoptions_destroy(
+    crocksdb_ingestexternalfileoptions_t* opt) {
+  delete opt;
+}
+
+void crocksdb_ingest_external_file(
+    crocksdb_t* db, const char* const* file_list, const size_t list_len,
+    const crocksdb_ingestexternalfileoptions_t* opt, char** errptr) {
+  std::vector<std::string> files(list_len);
+  for (size_t i = 0; i < list_len; ++i) {
+    files[i] = std::string(file_list[i]);
+  }
+  SaveError(errptr, db->rep->IngestExternalFile(files, opt->rep));
+}
+
+void crocksdb_ingest_external_file_cf(
+    crocksdb_t* db, crocksdb_column_family_handle_t* handle,
+    const char* const* file_list, const size_t list_len,
+    const crocksdb_ingestexternalfileoptions_t* opt, char** errptr) {
+  std::vector<std::string> files(list_len);
+  for (size_t i = 0; i < list_len; ++i) {
+    files[i] = std::string(file_list[i]);
+  }
+  SaveError(errptr, db->rep->IngestExternalFile(handle->rep, files, opt->rep));
+}
+
+crocksdb_slicetransform_t* crocksdb_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),
+    const char* (*name)(void*)) {
+  crocksdb_slicetransform_t* result = new crocksdb_slicetransform_t;
+  result->state_ = state;
+  result->destructor_ = destructor;
+  result->transform_ = transform;
+  result->in_domain_ = in_domain;
+  result->in_range_ = in_range;
+  result->name_ = name;
+  return result;
+}
+
+void crocksdb_slicetransform_destroy(crocksdb_slicetransform_t* st) {
+  delete st;
+}
+
+crocksdb_slicetransform_t* crocksdb_slicetransform_create_fixed_prefix(size_t prefixLen) {
+  struct Wrapper : public crocksdb_slicetransform_t {
+    const SliceTransform* rep_;
+    ~Wrapper() { delete rep_; }
+    const char* Name() const override { return rep_->Name(); }
+    Slice Transform(const Slice& src) const override {
+      return rep_->Transform(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*) { }
+  };
+  Wrapper* wrapper = new Wrapper;
+  wrapper->rep_ = rocksdb::NewFixedPrefixTransform(prefixLen);
+  wrapper->state_ = nullptr;
+  wrapper->destructor_ = &Wrapper::DoNothing;
+  return wrapper;
+}
+
+crocksdb_slicetransform_t* crocksdb_slicetransform_create_noop() {
+  struct Wrapper : public crocksdb_slicetransform_t {
+    const SliceTransform* rep_;
+    ~Wrapper() { delete rep_; }
+    const char* Name() const override { return rep_->Name(); }
+    Slice Transform(const Slice& src) const override {
+      return rep_->Transform(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*) { }
+  };
+  Wrapper* wrapper = new Wrapper;
+  wrapper->rep_ = rocksdb::NewNoopTransform();
+  wrapper->state_ = nullptr;
+  wrapper->destructor_ = &Wrapper::DoNothing;
+  return wrapper;
+}
+
+crocksdb_universal_compaction_options_t* crocksdb_universal_compaction_options_create() {
+  crocksdb_universal_compaction_options_t* result = new crocksdb_universal_compaction_options_t;
+  result->rep = new rocksdb::CompactionOptionsUniversal;
+  return result;
+}
+
+void crocksdb_universal_compaction_options_set_size_ratio(
+  crocksdb_universal_compaction_options_t* uco, int ratio) {
+  uco->rep->size_ratio = ratio;
+}
+
+void crocksdb_universal_compaction_options_set_min_merge_width(
+  crocksdb_universal_compaction_options_t* uco, int w) {
+  uco->rep->min_merge_width = w;
+}
+
+void crocksdb_universal_compaction_options_set_max_merge_width(
+  crocksdb_universal_compaction_options_t* uco, int w) {
+  uco->rep->max_merge_width = w;
+}
+
+void crocksdb_universal_compaction_options_set_max_size_amplification_percent(
+  crocksdb_universal_compaction_options_t* uco, int p) {
+  uco->rep->max_size_amplification_percent = p;
+}
+
+void crocksdb_universal_compaction_options_set_compression_size_percent(
+  crocksdb_universal_compaction_options_t* uco, int p) {
+  uco->rep->compression_size_percent = p;
+}
+
+void crocksdb_universal_compaction_options_set_stop_style(
+  crocksdb_universal_compaction_options_t* uco, int style) {
+  uco->rep->stop_style = static_cast<rocksdb::CompactionStopStyle>(style);
+}
+
+void crocksdb_universal_compaction_options_destroy(
+  crocksdb_universal_compaction_options_t* uco) {
+  delete uco->rep;
+  delete uco;
+}
+
+crocksdb_fifo_compaction_options_t* crocksdb_fifo_compaction_options_create() {
+  crocksdb_fifo_compaction_options_t* result = new crocksdb_fifo_compaction_options_t;
+  result->rep =  CompactionOptionsFIFO();
+  return result;
+}
+
+void crocksdb_fifo_compaction_options_set_max_table_files_size(
+    crocksdb_fifo_compaction_options_t* fifo_opts, uint64_t size) {
+  fifo_opts->rep.max_table_files_size = size;
+}
+
+void crocksdb_fifo_compaction_options_destroy(
+    crocksdb_fifo_compaction_options_t* fifo_opts) {
+  delete fifo_opts;
+}
+
+void crocksdb_options_set_min_level_to_compress(crocksdb_options_t* opt, int level) {
+  if (level >= 0) {
+    assert(level <= opt->rep.num_levels);
+    opt->rep.compression_per_level.resize(opt->rep.num_levels);
+    for (int i = 0; i < level; i++) {
+      opt->rep.compression_per_level[i] = rocksdb::kNoCompression;
+    }
+    for (int i = level; i < opt->rep.num_levels; i++) {
+      opt->rep.compression_per_level[i] = opt->rep.compression;
+    }
+  }
+}
+
+int crocksdb_livefiles_count(
+  const crocksdb_livefiles_t* lf) {
+  return static_cast<int>(lf->rep.size());
+}
+
+const char* crocksdb_livefiles_name(
+  const crocksdb_livefiles_t* lf,
+  int index) {
+  return lf->rep[index].name.c_str();
+}
+
+int crocksdb_livefiles_level(
+  const crocksdb_livefiles_t* lf,
+  int index) {
+  return lf->rep[index].level;
+}
+
+size_t crocksdb_livefiles_size(
+  const crocksdb_livefiles_t* lf,
+  int index) {
+  return lf->rep[index].size;
+}
+
+const char* crocksdb_livefiles_smallestkey(
+  const crocksdb_livefiles_t* lf,
+  int index,
+  size_t* size) {
+  *size = lf->rep[index].smallestkey.size();
+  return lf->rep[index].smallestkey.data();
+}
+
+const char* crocksdb_livefiles_largestkey(
+  const crocksdb_livefiles_t* lf,
+  int index,
+  size_t* size) {
+  *size = lf->rep[index].largestkey.size();
+  return lf->rep[index].largestkey.data();
+}
+
+extern void crocksdb_livefiles_destroy(
+  const crocksdb_livefiles_t* lf) {
+  delete lf;
+}
+
+void crocksdb_get_options_from_string(const crocksdb_options_t* base_options,
+                                     const char* opts_str,
+                                     crocksdb_options_t* new_options,
+                                     char** errptr) {
+  SaveError(errptr,
+            GetOptionsFromString(base_options->rep, std::string(opts_str),
+                                 &new_options->rep));
+}
+
+void crocksdb_delete_file_in_range(crocksdb_t* db, const char* start_key,
+                                  size_t start_key_len, const char* limit_key,
+                                  size_t limit_key_len, char** errptr) {
+  Slice a, b;
+  SaveError(
+      errptr,
+      DeleteFilesInRange(
+          db->rep, db->rep->DefaultColumnFamily(),
+          (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
+          (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr)));
+}
+
+void crocksdb_delete_file_in_range_cf(
+    crocksdb_t* db, crocksdb_column_family_handle_t* column_family,
+    const char* start_key, size_t start_key_len, const char* limit_key,
+    size_t limit_key_len, char** errptr) {
+  Slice a, b;
+  SaveError(
+      errptr,
+      DeleteFilesInRange(
+          db->rep, column_family->rep,
+          (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
+          (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr)));
+}
+
+void crocksdb_free(void* ptr) { free(ptr); }
+
+}  // end extern "C"

librocksdb_sys/crocksdb/rocksdb/c.h

+/*  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
+  This source code is licensed under the BSD-style license found in the
+  LICENSE file in the root directory of this source tree. An additional grant
+  of patent rights can be found in the PATENTS file in the same directory.
+ Copyright (c) 2011 The LevelDB Authors. All rights reserved.
+  Use of this source code is governed by a BSD-style license that can be
+  found in the LICENSE file. See the AUTHORS file for names of contributors.
+
+  C bindings for rocksdb.  May be useful as a stable ABI that can be
+  used by programs that keep rocksdb in a shared library, or for
+  a JNI api.
+
+  Does not support:
+  . getters for the option types
+  . custom comparators that implement key shortening
+  . capturing post-write-snapshot
+  . custom iter, db, env, cache implementations using just the C bindings
+
+  Some conventions:
+
+  (1) We expose just opaque struct pointers and functions to clients.
+  This allows us to change internal representations without having to
+  recompile clients.
+
+  (2) For simplicity, there is no equivalent to the Slice type.  Instead,
+  the caller has to pass the pointer and length as separate
+  arguments.
+
+  (3) Errors are represented by a null-terminated c string.  NULL
+  means no error.  All operations that can raise an error are passed
+  a "char** errptr" as the last argument.  One of the following must
+  be true on entry:
+     *errptr == NULL
+     *errptr points to a malloc()ed null-terminated error message
+  On success, a leveldb routine leaves *errptr unchanged.
+  On failure, leveldb frees the old value of *errptr and
+  set *errptr to a malloc()ed error message.
+
+  (4) Bools have the type unsigned char (0 == false; rest == true)
+
+  (5) All of the pointer arguments must be non-NULL.
+*/
+
+#ifndef C_ROCKSDB_INCLUDE_CWRAPPER_H_
+#define C_ROCKSDB_INCLUDE_CWRAPPER_H_
+
+#pragma once
+
+#ifdef _WIN32
+#ifdef C_ROCKSDB_DLL
+#ifdef C_ROCKSDB_LIBRARY_EXPORTS
+#define C_ROCKSDB_LIBRARY_API __declspec(dllexport)
+#else
+#define C_ROCKSDB_LIBRARY_API __declspec(dllimport)
+#endif
+#else
+#define C_ROCKSDB_LIBRARY_API
+#endif
+#else
+#define C_ROCKSDB_LIBRARY_API
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+
+/* Exported types */
+
+typedef struct crocksdb_t                 crocksdb_t;
+typedef struct crocksdb_backup_engine_t   crocksdb_backup_engine_t;
+typedef struct crocksdb_backup_engine_info_t   crocksdb_backup_engine_info_t;
+typedef struct crocksdb_restore_options_t crocksdb_restore_options_t;
+typedef struct crocksdb_cache_t           crocksdb_cache_t;
+typedef struct crocksdb_compactionfilter_t crocksdb_compactionfilter_t;
+typedef struct crocksdb_compactionfiltercontext_t
+    crocksdb_compactionfiltercontext_t;
+typedef struct crocksdb_compactionfilterfactory_t
+    crocksdb_compactionfilterfactory_t;
+typedef struct crocksdb_comparator_t      crocksdb_comparator_t;
+typedef struct crocksdb_env_t             crocksdb_env_t;
+typedef struct crocksdb_fifo_compaction_options_t crocksdb_fifo_compaction_options_t;
+typedef struct crocksdb_filelock_t        crocksdb_filelock_t;
+typedef struct crocksdb_filterpolicy_t    crocksdb_filterpolicy_t;
+typedef struct crocksdb_flushoptions_t    crocksdb_flushoptions_t;
+typedef struct crocksdb_iterator_t        crocksdb_iterator_t;
+typedef struct crocksdb_logger_t          crocksdb_logger_t;
+typedef struct crocksdb_mergeoperator_t   crocksdb_mergeoperator_t;
+typedef struct crocksdb_options_t         crocksdb_options_t;
+typedef struct crocksdb_compactoptions_t crocksdb_compactoptions_t;
+typedef struct crocksdb_block_based_table_options_t
+    crocksdb_block_based_table_options_t;
+typedef struct crocksdb_cuckoo_table_options_t
+    crocksdb_cuckoo_table_options_t;
+typedef struct crocksdb_randomfile_t      crocksdb_randomfile_t;
+typedef struct crocksdb_readoptions_t     crocksdb_readoptions_t;
+typedef struct crocksdb_seqfile_t         crocksdb_seqfile_t;
+typedef struct crocksdb_slicetransform_t  crocksdb_slicetransform_t;
+typedef struct crocksdb_snapshot_t        crocksdb_snapshot_t;
+typedef struct crocksdb_writablefile_t    crocksdb_writablefile_t;
+typedef struct crocksdb_writebatch_t      crocksdb_writebatch_t;
+typedef struct crocksdb_writeoptions_t    crocksdb_writeoptions_t;
+typedef struct crocksdb_universal_compaction_options_t crocksdb_universal_compaction_options_t;
+typedef struct crocksdb_livefiles_t     crocksdb_livefiles_t;
+typedef struct crocksdb_column_family_handle_t crocksdb_column_family_handle_t;
+typedef struct crocksdb_envoptions_t      crocksdb_envoptions_t;
+typedef struct crocksdb_ingestexternalfileoptions_t crocksdb_ingestexternalfileoptions_t;
+typedef struct crocksdb_sstfilewriter_t   crocksdb_sstfilewriter_t;
+typedef struct crocksdb_ratelimiter_t     crocksdb_ratelimiter_t;
+
+/* DB operations */
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_t* crocksdb_open(
+    const crocksdb_options_t* options, const char* name, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_t* crocksdb_open_for_read_only(
+    const crocksdb_options_t* options, const char* name,
+    unsigned char error_if_log_file_exist, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_backup_engine_t* crocksdb_backup_engine_open(
+    const crocksdb_options_t* options, const char* path, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_backup_engine_create_new_backup(
+    crocksdb_backup_engine_t* be, crocksdb_t* db, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_backup_engine_purge_old_backups(
+    crocksdb_backup_engine_t* be, uint32_t num_backups_to_keep, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_restore_options_t*
+crocksdb_restore_options_create();
+extern C_ROCKSDB_LIBRARY_API void crocksdb_restore_options_destroy(
+    crocksdb_restore_options_t* opt);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_restore_options_set_keep_log_files(
+    crocksdb_restore_options_t* opt, int v);
+
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_backup_engine_restore_db_from_latest_backup(
+    crocksdb_backup_engine_t* be, const char* db_dir, const char* wal_dir,
+    const crocksdb_restore_options_t* restore_options, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API const crocksdb_backup_engine_info_t*
+crocksdb_backup_engine_get_backup_info(crocksdb_backup_engine_t* be);
+
+extern C_ROCKSDB_LIBRARY_API int crocksdb_backup_engine_info_count(
+    const crocksdb_backup_engine_info_t* info);
+
+extern C_ROCKSDB_LIBRARY_API int64_t
+crocksdb_backup_engine_info_timestamp(const crocksdb_backup_engine_info_t* info,
+                                     int index);
+
+extern C_ROCKSDB_LIBRARY_API uint32_t
+crocksdb_backup_engine_info_backup_id(const crocksdb_backup_engine_info_t* info,
+                                     int index);
+
+extern C_ROCKSDB_LIBRARY_API uint64_t
+crocksdb_backup_engine_info_size(const crocksdb_backup_engine_info_t* info,
+                                int index);
+
+extern C_ROCKSDB_LIBRARY_API uint32_t crocksdb_backup_engine_info_number_files(
+    const crocksdb_backup_engine_info_t* info, int index);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_backup_engine_info_destroy(
+    const crocksdb_backup_engine_info_t* info);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_backup_engine_close(
+    crocksdb_backup_engine_t* be);
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_t* crocksdb_open_column_families(
+    const crocksdb_options_t* options, const char* name, int num_column_families,
+    const char** column_family_names,
+    const crocksdb_options_t** column_family_options,
+    crocksdb_column_family_handle_t** column_family_handles, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_t*
+crocksdb_open_for_read_only_column_families(
+    const crocksdb_options_t* options, const char* name, int num_column_families,
+    const char** column_family_names,
+    const crocksdb_options_t** column_family_options,
+    crocksdb_column_family_handle_t** column_family_handles,
+    unsigned char error_if_log_file_exist, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API char** crocksdb_list_column_families(
+    const crocksdb_options_t* options, const char* name, size_t* lencf,
+    char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_list_column_families_destroy(
+    char** list, size_t len);
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_column_family_handle_t*
+crocksdb_create_column_family(crocksdb_t* db,
+                             const crocksdb_options_t* column_family_options,
+                             const char* column_family_name, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_drop_column_family(
+    crocksdb_t* db, crocksdb_column_family_handle_t* handle, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_column_family_handle_destroy(
+    crocksdb_column_family_handle_t*);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_close(crocksdb_t* db);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_put(
+    crocksdb_t* db, const crocksdb_writeoptions_t* options, const char* key,
+    size_t keylen, const char* val, size_t vallen, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_put_cf(
+    crocksdb_t* db, const crocksdb_writeoptions_t* options,
+    crocksdb_column_family_handle_t* column_family, const char* key,
+    size_t keylen, const char* val, size_t vallen, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_delete(
+    crocksdb_t* db, const crocksdb_writeoptions_t* options, const char* key,
+    size_t keylen, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_delete_cf(
+    crocksdb_t* db, const crocksdb_writeoptions_t* options,
+    crocksdb_column_family_handle_t* column_family, const char* key,
+    size_t keylen, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_merge(
+    crocksdb_t* db, const crocksdb_writeoptions_t* options, const char* key,
+    size_t keylen, const char* val, size_t vallen, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_merge_cf(
+    crocksdb_t* db, const crocksdb_writeoptions_t* options,
+    crocksdb_column_family_handle_t* column_family, const char* key,
+    size_t keylen, const char* val, size_t vallen, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_write(
+    crocksdb_t* db, const crocksdb_writeoptions_t* options,
+    crocksdb_writebatch_t* batch, char** errptr);
+
+/* Returns NULL if not found.  A malloc()ed array otherwise.
+   Stores the length of the array in *vallen. */
+extern C_ROCKSDB_LIBRARY_API char* crocksdb_get(
+    crocksdb_t* db, const crocksdb_readoptions_t* options, const char* key,
+    size_t keylen, size_t* vallen, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API char* crocksdb_get_cf(
+    crocksdb_t* db, const crocksdb_readoptions_t* options,
+    crocksdb_column_family_handle_t* column_family, const char* key,
+    size_t keylen, size_t* vallen, char** errptr);
+
+// if values_list[i] == NULL and errs[i] == NULL,
+// then we got status.IsNotFound(), which we will not return.
+// all errors except status status.ok() and status.IsNotFound() are returned.
+//
+// errs, values_list and values_list_sizes must be num_keys in length,
+// allocated by the caller.
+// errs is a list of strings as opposed to the conventional one error,
+// where errs[i] is the status for retrieval of keys_list[i].
+// each non-NULL errs entry is a malloc()ed, null terminated string.
+// each non-NULL values_list entry is a malloc()ed array, with
+// the length for each stored in values_list_sizes[i].
+extern C_ROCKSDB_LIBRARY_API void crocksdb_multi_get(
+    crocksdb_t* db, const crocksdb_readoptions_t* options, size_t num_keys,
+    const char* const* keys_list, const size_t* keys_list_sizes,
+    char** values_list, size_t* values_list_sizes, char** errs);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_multi_get_cf(
+    crocksdb_t* db, const crocksdb_readoptions_t* options,
+    const crocksdb_column_family_handle_t* const* column_families,
+    size_t num_keys, const char* const* keys_list,
+    const size_t* keys_list_sizes, char** values_list,
+    size_t* values_list_sizes, char** errs);
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_iterator_t* crocksdb_create_iterator(
+    crocksdb_t* db, const crocksdb_readoptions_t* options);
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_iterator_t* crocksdb_create_iterator_cf(
+    crocksdb_t* db, const crocksdb_readoptions_t* options,
+    crocksdb_column_family_handle_t* column_family);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_create_iterators(
+    crocksdb_t *db, crocksdb_readoptions_t* opts,
+    crocksdb_column_family_handle_t** column_families,
+    crocksdb_iterator_t** iterators, size_t size, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API const crocksdb_snapshot_t* crocksdb_create_snapshot(
+    crocksdb_t* db);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_release_snapshot(
+    crocksdb_t* db, const crocksdb_snapshot_t* snapshot);
+
+/* Returns NULL if property name is unknown.
+   Else returns a pointer to a malloc()-ed null-terminated value. */
+extern C_ROCKSDB_LIBRARY_API char* crocksdb_property_value(crocksdb_t* db,
+                                                        const char* propname);
+
+extern C_ROCKSDB_LIBRARY_API char* crocksdb_property_value_cf(
+    crocksdb_t* db, crocksdb_column_family_handle_t* column_family,
+    const char* propname);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_approximate_sizes(
+    crocksdb_t* db, int num_ranges, const char* const* range_start_key,
+    const size_t* range_start_key_len, const char* const* range_limit_key,
+    const size_t* range_limit_key_len, uint64_t* sizes);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_approximate_sizes_cf(
+    crocksdb_t* db, crocksdb_column_family_handle_t* column_family,
+    int num_ranges, const char* const* range_start_key,
+    const size_t* range_start_key_len, const char* const* range_limit_key,
+    const size_t* range_limit_key_len, uint64_t* sizes);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_compact_range(crocksdb_t* db,
+                                                      const char* start_key,
+                                                      size_t start_key_len,
+                                                      const char* limit_key,
+                                                      size_t limit_key_len);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_compact_range_cf(
+    crocksdb_t* db, crocksdb_column_family_handle_t* column_family,
+    const char* start_key, size_t start_key_len, const char* limit_key,
+    size_t limit_key_len);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_compact_range_opt(
+    crocksdb_t* db, crocksdb_compactoptions_t* opt, const char* start_key,
+    size_t start_key_len, const char* limit_key, size_t limit_key_len);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_compact_range_cf_opt(
+    crocksdb_t* db, crocksdb_column_family_handle_t* column_family,
+    crocksdb_compactoptions_t* opt, const char* start_key, size_t start_key_len,
+    const char* limit_key, size_t limit_key_len);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_delete_file(crocksdb_t* db,
+                                                    const char* name);
+
+extern C_ROCKSDB_LIBRARY_API const crocksdb_livefiles_t* crocksdb_livefiles(
+    crocksdb_t* db);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_flush(
+    crocksdb_t* db, const crocksdb_flushoptions_t* options, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_disable_file_deletions(crocksdb_t* db,
+                                                               char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_enable_file_deletions(
+    crocksdb_t* db, unsigned char force, char** errptr);
+
+/* Management operations */
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_destroy_db(
+    const crocksdb_options_t* options, const char* name, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_repair_db(
+    const crocksdb_options_t* options, const char* name, char** errptr);
+
+/* Iterator */
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_iter_destroy(crocksdb_iterator_t*);
+extern C_ROCKSDB_LIBRARY_API unsigned char crocksdb_iter_valid(
+    const crocksdb_iterator_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_iter_seek_to_first(crocksdb_iterator_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_iter_seek_to_last(crocksdb_iterator_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_iter_seek(crocksdb_iterator_t*,
+                                                  const char* k, size_t klen);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_iter_seek_for_prev(crocksdb_iterator_t*,
+                                                           const char* k,
+                                                           size_t klen);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_iter_next(crocksdb_iterator_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_iter_prev(crocksdb_iterator_t*);
+extern C_ROCKSDB_LIBRARY_API const char* crocksdb_iter_key(
+    const crocksdb_iterator_t*, size_t* klen);
+extern C_ROCKSDB_LIBRARY_API const char* crocksdb_iter_value(
+    const crocksdb_iterator_t*, size_t* vlen);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_iter_get_error(
+    const crocksdb_iterator_t*, char** errptr);
+
+/* Write batch */
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_writebatch_t* crocksdb_writebatch_create();
+extern C_ROCKSDB_LIBRARY_API crocksdb_writebatch_t* crocksdb_writebatch_create_from(
+    const char* rep, size_t size);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_destroy(
+    crocksdb_writebatch_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_clear(crocksdb_writebatch_t*);
+extern C_ROCKSDB_LIBRARY_API int crocksdb_writebatch_count(crocksdb_writebatch_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_put(crocksdb_writebatch_t*,
+                                                       const char* key,
+                                                       size_t klen,
+                                                       const char* val,
+                                                       size_t vlen);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_put_cf(
+    crocksdb_writebatch_t*, crocksdb_column_family_handle_t* column_family,
+    const char* key, size_t klen, const char* val, size_t vlen);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_putv(
+    crocksdb_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);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_putv_cf(
+    crocksdb_writebatch_t* b, crocksdb_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);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_merge(crocksdb_writebatch_t*,
+                                                         const char* key,
+                                                         size_t klen,
+                                                         const char* val,
+                                                         size_t vlen);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_merge_cf(
+    crocksdb_writebatch_t*, crocksdb_column_family_handle_t* column_family,
+    const char* key, size_t klen, const char* val, size_t vlen);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_mergev(
+    crocksdb_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);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_mergev_cf(
+    crocksdb_writebatch_t* b, crocksdb_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);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_delete(crocksdb_writebatch_t*,
+                                                          const char* key,
+                                                          size_t klen);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_delete_cf(
+    crocksdb_writebatch_t*, crocksdb_column_family_handle_t* column_family,
+    const char* key, size_t klen);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_deletev(
+    crocksdb_writebatch_t* b, int num_keys, const char* const* keys_list,
+    const size_t* keys_list_sizes);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_deletev_cf(
+    crocksdb_writebatch_t* b, crocksdb_column_family_handle_t* column_family,
+    int num_keys, const char* const* keys_list, const size_t* keys_list_sizes);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_delete_range(
+    crocksdb_writebatch_t* b, const char* start_key, size_t start_key_len,
+    const char* end_key, size_t end_key_len);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_delete_range_cf(
+    crocksdb_writebatch_t* b, crocksdb_column_family_handle_t* column_family,
+    const char* start_key, size_t start_key_len, const char* end_key,
+    size_t end_key_len);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_delete_rangev(
+    crocksdb_writebatch_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);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_delete_rangev_cf(
+    crocksdb_writebatch_t* b, crocksdb_column_family_handle_t* column_family,
+    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);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_put_log_data(
+    crocksdb_writebatch_t*, const char* blob, size_t len);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_iterate(
+    crocksdb_writebatch_t*, 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));
+extern C_ROCKSDB_LIBRARY_API const char* crocksdb_writebatch_data(
+    crocksdb_writebatch_t*, size_t* size);
+
+/* Block based table options */
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_block_based_table_options_t*
+crocksdb_block_based_options_create();
+extern C_ROCKSDB_LIBRARY_API void crocksdb_block_based_options_destroy(
+    crocksdb_block_based_table_options_t* options);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_block_based_options_set_block_size(
+    crocksdb_block_based_table_options_t* options, size_t block_size);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_block_based_options_set_block_size_deviation(
+    crocksdb_block_based_table_options_t* options, int block_size_deviation);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_block_based_options_set_block_restart_interval(
+    crocksdb_block_based_table_options_t* options, int block_restart_interval);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_block_based_options_set_filter_policy(
+    crocksdb_block_based_table_options_t* options,
+    crocksdb_filterpolicy_t* filter_policy);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_block_based_options_set_no_block_cache(
+    crocksdb_block_based_table_options_t* options, unsigned char no_block_cache);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_block_based_options_set_block_cache(
+    crocksdb_block_based_table_options_t* options, crocksdb_cache_t* block_cache);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_block_based_options_set_block_cache_compressed(
+    crocksdb_block_based_table_options_t* options,
+    crocksdb_cache_t* block_cache_compressed);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_block_based_options_set_whole_key_filtering(
+    crocksdb_block_based_table_options_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_block_based_options_set_format_version(
+    crocksdb_block_based_table_options_t*, int);
+enum {
+  crocksdb_block_based_table_index_type_binary_search = 0,
+  crocksdb_block_based_table_index_type_hash_search = 1,
+};
+extern C_ROCKSDB_LIBRARY_API void crocksdb_block_based_options_set_index_type(
+    crocksdb_block_based_table_options_t*, int);  // uses one of the above enums
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_block_based_options_set_hash_index_allow_collision(
+    crocksdb_block_based_table_options_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_block_based_options_set_cache_index_and_filter_blocks(
+    crocksdb_block_based_table_options_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_block_based_options_set_pin_l0_filter_and_index_blocks_in_cache(
+    crocksdb_block_based_table_options_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_block_based_options_set_skip_table_builder_flush(
+    crocksdb_block_based_table_options_t* options, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_block_based_table_factory(
+    crocksdb_options_t* opt, crocksdb_block_based_table_options_t* table_options);
+
+/* Cuckoo table options */
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_cuckoo_table_options_t*
+crocksdb_cuckoo_options_create();
+extern C_ROCKSDB_LIBRARY_API void crocksdb_cuckoo_options_destroy(
+    crocksdb_cuckoo_table_options_t* options);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_cuckoo_options_set_hash_ratio(
+    crocksdb_cuckoo_table_options_t* options, double v);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_cuckoo_options_set_max_search_depth(
+    crocksdb_cuckoo_table_options_t* options, uint32_t v);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_cuckoo_options_set_cuckoo_block_size(
+    crocksdb_cuckoo_table_options_t* options, uint32_t v);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_cuckoo_options_set_identity_as_first_hash(
+    crocksdb_cuckoo_table_options_t* options, unsigned char v);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_cuckoo_options_set_use_module_hash(
+    crocksdb_cuckoo_table_options_t* options, unsigned char v);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_cuckoo_table_factory(
+    crocksdb_options_t* opt, crocksdb_cuckoo_table_options_t* table_options);
+
+/* Options */
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_options_t* crocksdb_options_create();
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_destroy(crocksdb_options_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_increase_parallelism(
+    crocksdb_options_t* opt, int total_threads);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_optimize_for_point_lookup(
+    crocksdb_options_t* opt, uint64_t block_cache_size_mb);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_optimize_level_style_compaction(
+    crocksdb_options_t* opt, uint64_t memtable_memory_budget);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_options_optimize_universal_style_compaction(
+    crocksdb_options_t* opt, uint64_t memtable_memory_budget);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_compaction_filter(
+    crocksdb_options_t*, crocksdb_compactionfilter_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_compaction_filter_factory(
+    crocksdb_options_t*, crocksdb_compactionfilterfactory_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_compaction_readahead_size(
+    crocksdb_options_t*, size_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_comparator(
+    crocksdb_options_t*, crocksdb_comparator_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_merge_operator(
+    crocksdb_options_t*, crocksdb_mergeoperator_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_compression_per_level(
+    crocksdb_options_t* opt, int* level_values, size_t num_levels);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_create_if_missing(
+    crocksdb_options_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_options_set_create_missing_column_families(crocksdb_options_t*,
+                                                   unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_error_if_exists(
+    crocksdb_options_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_paranoid_checks(
+    crocksdb_options_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_env(crocksdb_options_t*,
+                                                        crocksdb_env_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_info_log(crocksdb_options_t*,
+                                                             crocksdb_logger_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_info_log_level(
+    crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_write_buffer_size(
+    crocksdb_options_t*, size_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_db_write_buffer_size(
+    crocksdb_options_t*, size_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_max_open_files(
+    crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_max_total_wal_size(
+    crocksdb_options_t* opt, uint64_t n);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_compression_options(
+    crocksdb_options_t*, int, int, int, int);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_prefix_extractor(
+    crocksdb_options_t*, crocksdb_slicetransform_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_num_levels(
+    crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_options_set_level0_file_num_compaction_trigger(crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_options_set_level0_slowdown_writes_trigger(crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_level0_stop_writes_trigger(
+    crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_max_mem_compaction_level(
+    crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_target_file_size_base(
+    crocksdb_options_t*, uint64_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_target_file_size_multiplier(
+    crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_max_bytes_for_level_base(
+    crocksdb_options_t*, uint64_t);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_options_set_level_compaction_dynamic_level_bytes(crocksdb_options_t*,
+                                                         unsigned char);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_options_set_max_bytes_for_level_multiplier(crocksdb_options_t*, double);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_options_set_max_bytes_for_level_multiplier_additional(
+    crocksdb_options_t*, int* level_values, size_t num_levels);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_enable_statistics(
+    crocksdb_options_t*);
+
+/* returns a pointer to a malloc()-ed, null terminated string */
+extern C_ROCKSDB_LIBRARY_API char* crocksdb_options_statistics_get_string(
+    crocksdb_options_t* opt);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_max_write_buffer_number(
+    crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_options_set_min_write_buffer_number_to_merge(crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_options_set_max_write_buffer_number_to_maintain(crocksdb_options_t*,
+                                                        int);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_max_background_compactions(
+    crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_base_background_compactions(
+    crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_max_background_flushes(
+    crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_max_log_file_size(
+    crocksdb_options_t*, size_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_log_file_time_to_roll(
+    crocksdb_options_t*, size_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_keep_log_file_num(
+    crocksdb_options_t*, size_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_recycle_log_file_num(
+    crocksdb_options_t*, size_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_soft_rate_limit(
+    crocksdb_options_t*, double);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_hard_rate_limit(
+    crocksdb_options_t*, double);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_options_set_rate_limit_delay_max_milliseconds(crocksdb_options_t*,
+                                                      unsigned int);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_max_manifest_file_size(
+    crocksdb_options_t*, size_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_table_cache_numshardbits(
+    crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_options_set_table_cache_remove_scan_count_limit(crocksdb_options_t*,
+                                                        int);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_arena_block_size(
+    crocksdb_options_t*, size_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_use_fsync(
+    crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_db_log_dir(
+    crocksdb_options_t*, const char*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_wal_dir(crocksdb_options_t*,
+                                                            const char*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_WAL_ttl_seconds(
+    crocksdb_options_t*, uint64_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_WAL_size_limit_MB(
+    crocksdb_options_t*, uint64_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_manifest_preallocation_size(
+    crocksdb_options_t*, size_t);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_options_set_purge_redundant_kvs_while_flush(crocksdb_options_t*,
+                                                    unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_allow_os_buffer(
+    crocksdb_options_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_allow_mmap_reads(
+    crocksdb_options_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_allow_mmap_writes(
+    crocksdb_options_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_is_fd_close_on_exec(
+    crocksdb_options_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_skip_log_error_on_recovery(
+    crocksdb_options_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_stats_dump_period_sec(
+    crocksdb_options_t*, unsigned int);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_advise_random_on_open(
+    crocksdb_options_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_options_set_access_hint_on_compaction_start(crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_use_adaptive_mutex(
+    crocksdb_options_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_bytes_per_sync(
+    crocksdb_options_t*, uint64_t);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_options_set_allow_concurrent_memtable_write(crocksdb_options_t*,
+                                                    unsigned char);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_options_set_enable_write_thread_adaptive_yield(crocksdb_options_t*,
+                                                       unsigned char);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_options_set_verify_checksums_in_compaction(crocksdb_options_t*,
+                                                   unsigned char);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_options_set_max_sequential_skip_in_iterations(crocksdb_options_t*,
+                                                      uint64_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_disable_data_sync(
+    crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_disable_auto_compactions(
+    crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_options_set_delete_obsolete_files_period_micros(crocksdb_options_t*,
+                                                        uint64_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_prepare_for_bulk_load(
+    crocksdb_options_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_memtable_vector_rep(
+    crocksdb_options_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_memtable_prefix_bloom_size_ratio(
+    crocksdb_options_t*, double);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_max_compaction_bytes(
+    crocksdb_options_t*, uint64_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_hash_skip_list_rep(
+    crocksdb_options_t*, size_t, int32_t, int32_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_hash_link_list_rep(
+    crocksdb_options_t*, size_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_plain_table_factory(
+    crocksdb_options_t*, uint32_t, int, double, size_t);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_min_level_to_compress(
+    crocksdb_options_t* opt, int level);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_memtable_huge_page_size(
+    crocksdb_options_t*, size_t);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_max_successive_merges(
+    crocksdb_options_t*, size_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_min_partial_merge_operands(
+    crocksdb_options_t*, uint32_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_bloom_locality(
+    crocksdb_options_t*, uint32_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_inplace_update_support(
+    crocksdb_options_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_inplace_update_num_locks(
+    crocksdb_options_t*, size_t);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_report_bg_io_stats(
+    crocksdb_options_t*, int);
+
+enum {
+  crocksdb_tolerate_corrupted_tail_records_recovery = 0,
+  crocksdb_absolute_consistency_recovery = 1,
+  crocksdb_point_in_time_recovery = 2,
+  crocksdb_skip_any_corrupted_records_recovery = 3
+};
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_wal_recovery_mode(
+    crocksdb_options_t*, int);
+
+enum {
+  crocksdb_no_compression = 0,
+  crocksdb_snappy_compression = 1,
+  crocksdb_zlib_compression = 2,
+  crocksdb_bz2_compression = 3,
+  crocksdb_lz4_compression = 4,
+  crocksdb_lz4hc_compression = 5
+};
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_compression(
+    crocksdb_options_t*, int);
+
+enum {
+  crocksdb_level_compaction = 0,
+  crocksdb_universal_compaction = 1,
+  crocksdb_fifo_compaction = 2
+};
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_compaction_style(
+    crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_options_set_universal_compaction_options(
+    crocksdb_options_t*, crocksdb_universal_compaction_options_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_fifo_compaction_options(
+    crocksdb_options_t* opt, crocksdb_fifo_compaction_options_t* fifo);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_ratelimiter(
+    crocksdb_options_t* opt, crocksdb_ratelimiter_t* limiter);
+
+/* RateLimiter */
+extern C_ROCKSDB_LIBRARY_API crocksdb_ratelimiter_t* crocksdb_ratelimiter_create(
+    int64_t rate_bytes_per_sec, int64_t refill_period_us, int32_t fairness);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_ratelimiter_destroy(crocksdb_ratelimiter_t*);
+
+/* Compaction Filter */
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_compactionfilter_t*
+crocksdb_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),
+    const char* (*name)(void*));
+extern C_ROCKSDB_LIBRARY_API void crocksdb_compactionfilter_set_ignore_snapshots(
+    crocksdb_compactionfilter_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_compactionfilter_destroy(
+    crocksdb_compactionfilter_t*);
+
+/* Compaction Filter Context */
+
+extern C_ROCKSDB_LIBRARY_API unsigned char
+crocksdb_compactionfiltercontext_is_full_compaction(
+    crocksdb_compactionfiltercontext_t* context);
+
+extern C_ROCKSDB_LIBRARY_API unsigned char
+crocksdb_compactionfiltercontext_is_manual_compaction(
+    crocksdb_compactionfiltercontext_t* context);
+
+/* Compaction Filter Factory */
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_compactionfilterfactory_t*
+crocksdb_compactionfilterfactory_create(
+    void* state, void (*destructor)(void*),
+    crocksdb_compactionfilter_t* (*create_compaction_filter)(
+        void*, crocksdb_compactionfiltercontext_t* context),
+    const char* (*name)(void*));
+extern C_ROCKSDB_LIBRARY_API void crocksdb_compactionfilterfactory_destroy(
+    crocksdb_compactionfilterfactory_t*);
+
+/* Comparator */
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_comparator_t* crocksdb_comparator_create(
+    void* state, void (*destructor)(void*),
+    int (*compare)(void*, const char* a, size_t alen, const char* b,
+                   size_t blen),
+    const char* (*name)(void*));
+extern C_ROCKSDB_LIBRARY_API void crocksdb_comparator_destroy(
+    crocksdb_comparator_t*);
+
+/* Filter policy */
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_filterpolicy_t* crocksdb_filterpolicy_create(
+    void* state, void (*destructor)(void*),
+    char* (*create_filter)(void*, const char* const* key_array,
+                           const size_t* key_length_array, int num_keys,
+                           size_t* filter_length),
+    unsigned char (*key_may_match)(void*, const char* key, size_t length,
+                                   const char* filter, size_t filter_length),
+    void (*delete_filter)(void*, const char* filter, size_t filter_length),
+    const char* (*name)(void*));
+extern C_ROCKSDB_LIBRARY_API void crocksdb_filterpolicy_destroy(
+    crocksdb_filterpolicy_t*);
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_filterpolicy_t*
+crocksdb_filterpolicy_create_bloom(int bits_per_key);
+extern C_ROCKSDB_LIBRARY_API crocksdb_filterpolicy_t*
+crocksdb_filterpolicy_create_bloom_full(int bits_per_key);
+
+/* Merge Operator */
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_mergeoperator_t*
+crocksdb_mergeoperator_create(
+    void* state, void (*destructor)(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* (*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),
+    const char* (*name)(void*));
+extern C_ROCKSDB_LIBRARY_API void crocksdb_mergeoperator_destroy(
+    crocksdb_mergeoperator_t*);
+
+/* Read options */
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_readoptions_t* crocksdb_readoptions_create();
+extern C_ROCKSDB_LIBRARY_API void crocksdb_readoptions_destroy(
+    crocksdb_readoptions_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_readoptions_set_verify_checksums(
+    crocksdb_readoptions_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_readoptions_set_fill_cache(
+    crocksdb_readoptions_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_readoptions_set_snapshot(
+    crocksdb_readoptions_t*, const crocksdb_snapshot_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_readoptions_set_iterate_upper_bound(
+    crocksdb_readoptions_t*, const char* key, size_t keylen);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_readoptions_set_read_tier(
+    crocksdb_readoptions_t*, int);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_readoptions_set_tailing(
+    crocksdb_readoptions_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_readoptions_set_readahead_size(
+    crocksdb_readoptions_t*, size_t);
+extern ROCKSDB_LIBRARY_API void crocksdb_readoptions_set_total_order_seek(
+    crocksdb_readoptions_t*, unsigned char);
+
+/* Write options */
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_writeoptions_t*
+crocksdb_writeoptions_create();
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writeoptions_destroy(
+    crocksdb_writeoptions_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writeoptions_set_sync(
+    crocksdb_writeoptions_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writeoptions_disable_WAL(
+    crocksdb_writeoptions_t* opt, int disable);
+
+/* Compact range options */
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_compactoptions_t*
+crocksdb_compactoptions_create();
+extern C_ROCKSDB_LIBRARY_API void crocksdb_compactoptions_destroy(
+    crocksdb_compactoptions_t*);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_compactoptions_set_exclusive_manual_compaction(
+    crocksdb_compactoptions_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_compactoptions_set_change_level(
+    crocksdb_compactoptions_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_compactoptions_set_target_level(
+    crocksdb_compactoptions_t*, int);
+
+/* Flush options */
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_flushoptions_t*
+crocksdb_flushoptions_create();
+extern C_ROCKSDB_LIBRARY_API void crocksdb_flushoptions_destroy(
+    crocksdb_flushoptions_t*);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_flushoptions_set_wait(
+    crocksdb_flushoptions_t*, unsigned char);
+
+/* Cache */
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_cache_t* crocksdb_cache_create_lru(
+    size_t capacity);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_cache_destroy(crocksdb_cache_t* cache);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_cache_set_capacity(
+    crocksdb_cache_t* cache, size_t capacity);
+
+/* Env */
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_env_t* crocksdb_create_default_env();
+extern C_ROCKSDB_LIBRARY_API crocksdb_env_t* crocksdb_create_mem_env();
+extern C_ROCKSDB_LIBRARY_API void crocksdb_env_set_background_threads(
+    crocksdb_env_t* env, int n);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_env_set_high_priority_background_threads(crocksdb_env_t* env, int n);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_env_join_all_threads(
+    crocksdb_env_t* env);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_env_destroy(crocksdb_env_t*);
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_envoptions_t* crocksdb_envoptions_create();
+extern C_ROCKSDB_LIBRARY_API void crocksdb_envoptions_destroy(
+    crocksdb_envoptions_t* opt);
+
+/* SstFile */
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_sstfilewriter_t*
+crocksdb_sstfilewriter_create(const crocksdb_envoptions_t* env,
+                             const crocksdb_options_t* io_options);
+extern C_ROCKSDB_LIBRARY_API crocksdb_sstfilewriter_t*
+crocksdb_sstfilewriter_create_with_comparator(
+    const crocksdb_envoptions_t* env, const crocksdb_options_t* io_options,
+    const crocksdb_comparator_t* comparator);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_sstfilewriter_open(
+    crocksdb_sstfilewriter_t* writer, const char* name, char** errptr);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_sstfilewriter_add(
+    crocksdb_sstfilewriter_t* writer, const char* key, size_t keylen,
+    const char* val, size_t vallen, char** errptr);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_sstfilewriter_finish(
+    crocksdb_sstfilewriter_t* writer, char** errptr);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_sstfilewriter_destroy(
+    crocksdb_sstfilewriter_t* writer);
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_ingestexternalfileoptions_t*
+crocksdb_ingestexternalfileoptions_create();
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_ingestexternalfileoptions_set_move_files(
+    crocksdb_ingestexternalfileoptions_t* opt, unsigned char move_files);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_ingestexternalfileoptions_set_snapshot_consistency(
+    crocksdb_ingestexternalfileoptions_t* opt,
+    unsigned char snapshot_consistency);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_ingestexternalfileoptions_set_allow_global_seqno(
+    crocksdb_ingestexternalfileoptions_t* opt, unsigned char allow_global_seqno);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_ingestexternalfileoptions_set_allow_blocking_flush(
+    crocksdb_ingestexternalfileoptions_t* opt,
+    unsigned char allow_blocking_flush);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_ingestexternalfileoptions_destroy(
+    crocksdb_ingestexternalfileoptions_t* opt);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_ingest_external_file(
+    crocksdb_t* db, const char* const* file_list, const size_t list_len,
+    const crocksdb_ingestexternalfileoptions_t* opt, char** errptr);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_ingest_external_file_cf(
+    crocksdb_t* db, crocksdb_column_family_handle_t* handle,
+    const char* const* file_list, const size_t list_len,
+    const crocksdb_ingestexternalfileoptions_t* opt, char** errptr);
+
+/* SliceTransform */
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_slicetransform_t*
+crocksdb_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),
+    const char* (*name)(void*));
+extern C_ROCKSDB_LIBRARY_API crocksdb_slicetransform_t*
+    crocksdb_slicetransform_create_fixed_prefix(size_t);
+extern C_ROCKSDB_LIBRARY_API crocksdb_slicetransform_t*
+crocksdb_slicetransform_create_noop();
+extern C_ROCKSDB_LIBRARY_API void crocksdb_slicetransform_destroy(
+    crocksdb_slicetransform_t*);
+
+/* Universal Compaction options */
+
+enum {
+  crocksdb_similar_size_compaction_stop_style = 0,
+  crocksdb_total_size_compaction_stop_style = 1
+};
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_universal_compaction_options_t*
+crocksdb_universal_compaction_options_create();
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_universal_compaction_options_set_size_ratio(
+    crocksdb_universal_compaction_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_universal_compaction_options_set_min_merge_width(
+    crocksdb_universal_compaction_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_universal_compaction_options_set_max_merge_width(
+    crocksdb_universal_compaction_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_universal_compaction_options_set_max_size_amplification_percent(
+    crocksdb_universal_compaction_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_universal_compaction_options_set_compression_size_percent(
+    crocksdb_universal_compaction_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_universal_compaction_options_set_stop_style(
+    crocksdb_universal_compaction_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_universal_compaction_options_destroy(
+    crocksdb_universal_compaction_options_t*);
+
+extern C_ROCKSDB_LIBRARY_API crocksdb_fifo_compaction_options_t*
+crocksdb_fifo_compaction_options_create();
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_fifo_compaction_options_set_max_table_files_size(
+    crocksdb_fifo_compaction_options_t* fifo_opts, uint64_t size);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_fifo_compaction_options_destroy(
+    crocksdb_fifo_compaction_options_t* fifo_opts);
+
+extern C_ROCKSDB_LIBRARY_API int crocksdb_livefiles_count(
+    const crocksdb_livefiles_t*);
+extern C_ROCKSDB_LIBRARY_API const char* crocksdb_livefiles_name(
+    const crocksdb_livefiles_t*, int index);
+extern C_ROCKSDB_LIBRARY_API int crocksdb_livefiles_level(
+    const crocksdb_livefiles_t*, int index);
+extern C_ROCKSDB_LIBRARY_API size_t
+crocksdb_livefiles_size(const crocksdb_livefiles_t*, int index);
+extern C_ROCKSDB_LIBRARY_API const char* crocksdb_livefiles_smallestkey(
+    const crocksdb_livefiles_t*, int index, size_t* size);
+extern C_ROCKSDB_LIBRARY_API const char* crocksdb_livefiles_largestkey(
+    const crocksdb_livefiles_t*, int index, size_t* size);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_livefiles_destroy(
+    const crocksdb_livefiles_t*);
+
+/* Utility Helpers */
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_get_options_from_string(
+    const crocksdb_options_t* base_options, const char* opts_str,
+    crocksdb_options_t* new_options, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_delete_file_in_range(
+    crocksdb_t* db, const char* start_key, size_t start_key_len,
+    const char* limit_key, size_t limit_key_len, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_delete_file_in_range_cf(
+    crocksdb_t* db, crocksdb_column_family_handle_t* column_family,
+    const char* start_key, size_t start_key_len, const char* limit_key,
+    size_t limit_key_len, char** errptr);
+
+// referring to convention (3), this should be used by client
+// to free memory that was malloc()ed
+extern C_ROCKSDB_LIBRARY_API void crocksdb_free(void* ptr);
+
+#ifdef __cplusplus
+}  /* end extern "C" */
+#endif
+
+#endif  /* C_ROCKSDB_INCLUDE_CWRAPPER_H_ */

librocksdb_sys/src/lib.rs

@@ -39,11 +39,11 @@ pub enum DBBackupEngine {}
 pub enum DBRestoreOptions {}
 
 pub fn new_bloom_filter(bits: c_int) -> *mut DBFilterPolicy {
-    unsafe { rocksdb_filterpolicy_create_bloom(bits) }
+    unsafe { crocksdb_filterpolicy_create_bloom(bits) }
 }
 
 pub fn new_cache(capacity: size_t) -> *mut DBCache {
-    unsafe { rocksdb_cache_create_lru(capacity) }
+    unsafe { crocksdb_cache_create_lru(capacity) }
 }
 
 #[derive(Copy, Clone)]
@@ -66,8 +66,8 @@ pub enum DBCompactionStyle {
 
 #[repr(C)]
 pub enum DBUniversalCompactionStyle {
-    rocksdb_similar_size_compaction_stop_style = 0,
-    rocksdb_total_size_compaction_stop_style = 1,
+    crocksdb_similar_size_compaction_stop_style = 0,
+    crocksdb_total_size_compaction_stop_style = 1,
 }
 
 #[derive(Copy, Clone, PartialEq)]
@@ -103,112 +103,111 @@ macro_rules! ffi_try {
 
 // TODO audit the use of boolean arguments, b/c I think they need to be u8
 // instead...
-#[link(name = "rocksdb")]
 extern "C" {
-    pub fn rocksdb_options_create() -> *mut DBOptions;
-    pub fn rocksdb_options_destroy(opts: *mut DBOptions);
-    pub fn rocksdb_cache_create_lru(capacity: size_t) -> *mut DBCache;
-    pub fn rocksdb_cache_destroy(cache: *mut DBCache);
-    pub fn rocksdb_block_based_options_create() -> *mut DBBlockBasedTableOptions;
-    pub fn rocksdb_block_based_options_destroy(opts: *mut DBBlockBasedTableOptions);
-    pub fn rocksdb_block_based_options_set_block_size(
+    pub fn crocksdb_options_create() -> *mut DBOptions;
+    pub fn crocksdb_options_destroy(opts: *mut DBOptions);
+    pub fn crocksdb_cache_create_lru(capacity: size_t) -> *mut DBCache;
+    pub fn crocksdb_cache_destroy(cache: *mut DBCache);
+    pub fn crocksdb_block_based_options_create() -> *mut DBBlockBasedTableOptions;
+    pub fn crocksdb_block_based_options_destroy(opts: *mut DBBlockBasedTableOptions);
+    pub fn crocksdb_block_based_options_set_block_size(
         block_options: *mut DBBlockBasedTableOptions,
         block_size: size_t);
-    pub fn rocksdb_block_based_options_set_block_size_deviation(
+    pub fn crocksdb_block_based_options_set_block_size_deviation(
         block_options: *mut DBBlockBasedTableOptions,
         block_size_deviation: c_int);
-    pub fn rocksdb_block_based_options_set_block_restart_interval(
+    pub fn crocksdb_block_based_options_set_block_restart_interval(
         block_options: *mut DBBlockBasedTableOptions,
         block_restart_interval: c_int);
-    pub fn rocksdb_block_based_options_set_cache_index_and_filter_blocks(
+    pub fn crocksdb_block_based_options_set_cache_index_and_filter_blocks(
         block_options: *mut DBBlockBasedTableOptions, v: c_uchar);
-    pub fn rocksdb_block_based_options_set_filter_policy(
+    pub fn crocksdb_block_based_options_set_filter_policy(
         block_options: *mut DBBlockBasedTableOptions,
         filter_policy: *mut DBFilterPolicy);
-    pub fn rocksdb_block_based_options_set_no_block_cache(
+    pub fn crocksdb_block_based_options_set_no_block_cache(
         block_options: *mut DBBlockBasedTableOptions, no_block_cache: bool);
-    pub fn rocksdb_block_based_options_set_block_cache(
+    pub fn crocksdb_block_based_options_set_block_cache(
         block_options: *mut DBBlockBasedTableOptions, block_cache: *mut DBCache);
-    pub fn rocksdb_block_based_options_set_block_cache_compressed(
+    pub fn crocksdb_block_based_options_set_block_cache_compressed(
         block_options: *mut DBBlockBasedTableOptions,
         block_cache_compressed: *mut DBCache);
-    pub fn rocksdb_block_based_options_set_whole_key_filtering(
+    pub fn crocksdb_block_based_options_set_whole_key_filtering(
         ck_options: *mut DBBlockBasedTableOptions, doit: bool);
-    pub fn rocksdb_options_set_block_based_table_factory(
+    pub fn crocksdb_options_set_block_based_table_factory(
         options: *mut DBOptions,
         block_options: *mut DBBlockBasedTableOptions);
-    pub fn rocksdb_options_increase_parallelism(options: *mut DBOptions, threads: c_int);
-    pub fn rocksdb_options_optimize_level_style_compaction(options: *mut DBOptions,
+    pub fn crocksdb_options_increase_parallelism(options: *mut DBOptions, threads: c_int);
+    pub fn crocksdb_options_optimize_level_style_compaction(options: *mut DBOptions,
                                                            memtable_memory_budget: c_int);
-    pub fn rocksdb_options_set_compaction_filter(options: *mut DBOptions,
+    pub fn crocksdb_options_set_compaction_filter(options: *mut DBOptions,
                                                  filter: *mut DBCompactionFilter);
-    pub fn rocksdb_options_set_create_if_missing(options: *mut DBOptions, v: bool);
-    pub fn rocksdb_options_set_max_open_files(options: *mut DBOptions, files: c_int);
-    pub fn rocksdb_options_set_max_total_wal_size(options: *mut DBOptions, size: u64);
-    pub fn rocksdb_options_set_use_fsync(options: *mut DBOptions, v: c_int);
-    pub fn rocksdb_options_set_bytes_per_sync(options: *mut DBOptions, bytes: u64);
-    pub fn rocksdb_options_set_disable_data_sync(options: *mut DBOptions, v: c_int);
-    pub fn rocksdb_options_set_allow_os_buffer(options: *mut DBOptions, is_allow: bool);
-    pub fn rocksdb_options_optimize_for_point_lookup(options: *mut DBOptions,
+    pub fn crocksdb_options_set_create_if_missing(options: *mut DBOptions, v: bool);
+    pub fn crocksdb_options_set_max_open_files(options: *mut DBOptions, files: c_int);
+    pub fn crocksdb_options_set_max_total_wal_size(options: *mut DBOptions, size: u64);
+    pub fn crocksdb_options_set_use_fsync(options: *mut DBOptions, v: c_int);
+    pub fn crocksdb_options_set_bytes_per_sync(options: *mut DBOptions, bytes: u64);
+    pub fn crocksdb_options_set_disable_data_sync(options: *mut DBOptions, v: c_int);
+    pub fn crocksdb_options_set_allow_os_buffer(options: *mut DBOptions, is_allow: bool);
+    pub fn crocksdb_options_optimize_for_point_lookup(options: *mut DBOptions,
                                                      block_cache_size_mb: u64);
-    pub fn rocksdb_options_set_table_cache_numshardbits(options: *mut DBOptions, bits: c_int);
-    pub fn rocksdb_options_set_max_write_buffer_number(options: *mut DBOptions, bufno: c_int);
-    pub fn rocksdb_options_set_min_write_buffer_number_to_merge(options: *mut DBOptions,
+    pub fn crocksdb_options_set_table_cache_numshardbits(options: *mut DBOptions, bits: c_int);
+    pub fn crocksdb_options_set_max_write_buffer_number(options: *mut DBOptions, bufno: c_int);
+    pub fn crocksdb_options_set_min_write_buffer_number_to_merge(options: *mut DBOptions,
                                                                 bufno: c_int);
-    pub fn rocksdb_options_set_level0_file_num_compaction_trigger(options: *mut DBOptions,
+    pub fn crocksdb_options_set_level0_file_num_compaction_trigger(options: *mut DBOptions,
                                                                   no: c_int);
-    pub fn rocksdb_options_set_level0_slowdown_writes_trigger(options: *mut DBOptions, no: c_int);
-    pub fn rocksdb_options_set_level0_stop_writes_trigger(options: *mut DBOptions, no: c_int);
-    pub fn rocksdb_options_set_write_buffer_size(options: *mut DBOptions, bytes: u64);
-    pub fn rocksdb_options_set_target_file_size_base(options: *mut DBOptions, bytes: u64);
-    pub fn rocksdb_options_set_target_file_size_multiplier(options: *mut DBOptions, mul: c_int);
-    pub fn rocksdb_options_set_max_bytes_for_level_base(options: *mut DBOptions, bytes: u64);
-    pub fn rocksdb_options_set_max_bytes_for_level_multiplier(options: *mut DBOptions,
+    pub fn crocksdb_options_set_level0_slowdown_writes_trigger(options: *mut DBOptions, no: c_int);
+    pub fn crocksdb_options_set_level0_stop_writes_trigger(options: *mut DBOptions, no: c_int);
+    pub fn crocksdb_options_set_write_buffer_size(options: *mut DBOptions, bytes: u64);
+    pub fn crocksdb_options_set_target_file_size_base(options: *mut DBOptions, bytes: u64);
+    pub fn crocksdb_options_set_target_file_size_multiplier(options: *mut DBOptions, mul: c_int);
+    pub fn crocksdb_options_set_max_bytes_for_level_base(options: *mut DBOptions, bytes: u64);
+    pub fn crocksdb_options_set_max_bytes_for_level_multiplier(options: *mut DBOptions,
                                                               mul: c_int);
-    pub fn rocksdb_options_set_max_log_file_size(options: *mut DBOptions, bytes: size_t);
-    pub fn rocksdb_options_set_keep_log_file_num(options: *mut DBOptions, num: size_t);
-    pub fn rocksdb_options_set_max_manifest_file_size(options: *mut DBOptions, bytes: u64);
-    pub fn rocksdb_options_set_hash_skip_list_rep(options: *mut DBOptions,
+    pub fn crocksdb_options_set_max_log_file_size(options: *mut DBOptions, bytes: size_t);
+    pub fn crocksdb_options_set_keep_log_file_num(options: *mut DBOptions, num: size_t);
+    pub fn crocksdb_options_set_max_manifest_file_size(options: *mut DBOptions, bytes: u64);
+    pub fn crocksdb_options_set_hash_skip_list_rep(options: *mut DBOptions,
                                                   bytes: u64,
                                                   a1: i32,
                                                   a2: i32);
-    pub fn rocksdb_options_set_compaction_style(options: *mut DBOptions, cs: DBCompactionStyle);
-    pub fn rocksdb_options_set_compression(options: *mut DBOptions,
+    pub fn crocksdb_options_set_compaction_style(options: *mut DBOptions, cs: DBCompactionStyle);
+    pub fn crocksdb_options_set_compression(options: *mut DBOptions,
                                            compression_style_no: DBCompressionType);
-    pub fn rocksdb_options_set_compression_per_level(options: *mut DBOptions,
+    pub fn crocksdb_options_set_compression_per_level(options: *mut DBOptions,
                                                      level_values: *const DBCompressionType,
                                                      num_levels: size_t);
-    pub fn rocksdb_options_set_max_background_compactions(options: *mut DBOptions,
+    pub fn crocksdb_options_set_max_background_compactions(options: *mut DBOptions,
                                                           max_bg_compactions: c_int);
-    pub fn rocksdb_options_set_max_background_flushes(options: *mut DBOptions,
+    pub fn crocksdb_options_set_max_background_flushes(options: *mut DBOptions,
                                                       max_bg_flushes: c_int);
-    pub fn rocksdb_options_set_filter_deletes(options: *mut DBOptions, v: bool);
-    pub fn rocksdb_options_set_disable_auto_compactions(options: *mut DBOptions, v: c_int);
-    pub fn rocksdb_options_set_report_bg_io_stats(options: *mut DBOptions, v: c_int);
-    pub fn rocksdb_options_set_wal_recovery_mode(options: *mut DBOptions, mode: DBRecoveryMode);
-    pub fn rocksdb_options_enable_statistics(options: *mut DBOptions);
-    pub fn rocksdb_options_statistics_get_string(options: *mut DBOptions) -> *const c_char;
-    pub fn rocksdb_options_set_stats_dump_period_sec(options: *mut DBOptions, v: usize);
-    pub fn rocksdb_options_set_num_levels(options: *mut DBOptions, v: c_int);
-    pub fn rocksdb_options_set_db_log_dir(options: *mut DBOptions, path: *const c_char);
-    pub fn rocksdb_filterpolicy_create_bloom_full(bits_per_key: c_int) -> *mut DBFilterPolicy;
-    pub fn rocksdb_filterpolicy_create_bloom(bits_per_key: c_int) -> *mut DBFilterPolicy;
-    pub fn rocksdb_open(options: *mut DBOptions,
+    pub fn crocksdb_options_set_filter_deletes(options: *mut DBOptions, v: bool);
+    pub fn crocksdb_options_set_disable_auto_compactions(options: *mut DBOptions, v: c_int);
+    pub fn crocksdb_options_set_report_bg_io_stats(options: *mut DBOptions, v: c_int);
+    pub fn crocksdb_options_set_wal_recovery_mode(options: *mut DBOptions, mode: DBRecoveryMode);
+    pub fn crocksdb_options_enable_statistics(options: *mut DBOptions);
+    pub fn crocksdb_options_statistics_get_string(options: *mut DBOptions) -> *const c_char;
+    pub fn crocksdb_options_set_stats_dump_period_sec(options: *mut DBOptions, v: usize);
+    pub fn crocksdb_options_set_num_levels(options: *mut DBOptions, v: c_int);
+    pub fn crocksdb_options_set_db_log_dir(options: *mut DBOptions, path: *const c_char);
+    pub fn crocksdb_filterpolicy_create_bloom_full(bits_per_key: c_int) -> *mut DBFilterPolicy;
+    pub fn crocksdb_filterpolicy_create_bloom(bits_per_key: c_int) -> *mut DBFilterPolicy;
+    pub fn crocksdb_open(options: *mut DBOptions,
                         path: *const c_char,
                         err: *mut *mut c_char)
                         -> *mut DBInstance;
-    pub fn rocksdb_writeoptions_create() -> *mut DBWriteOptions;
-    pub fn rocksdb_writeoptions_destroy(writeopts: *mut DBWriteOptions);
-    pub fn rocksdb_writeoptions_set_sync(writeopts: *mut DBWriteOptions, v: bool);
-    pub fn rocksdb_writeoptions_disable_WAL(writeopts: *mut DBWriteOptions, v: c_int);
-    pub fn rocksdb_put(db: *mut DBInstance,
+    pub fn crocksdb_writeoptions_create() -> *mut DBWriteOptions;
+    pub fn crocksdb_writeoptions_destroy(writeopts: *mut DBWriteOptions);
+    pub fn crocksdb_writeoptions_set_sync(writeopts: *mut DBWriteOptions, v: bool);
+    pub fn crocksdb_writeoptions_disable_WAL(writeopts: *mut DBWriteOptions, v: c_int);
+    pub fn crocksdb_put(db: *mut DBInstance,
                        writeopts: *mut DBWriteOptions,
                        k: *const u8,
                        kLen: size_t,
                        v: *const u8,
                        vLen: size_t,
                        err: *mut *mut c_char);
-    pub fn rocksdb_put_cf(db: *mut DBInstance,
+    pub fn crocksdb_put_cf(db: *mut DBInstance,
                           writeopts: *mut DBWriteOptions,
                           cf: *mut DBCFHandle,
                           k: *const u8,
@@ -216,26 +215,26 @@ extern "C" {
                           v: *const u8,
                           vLen: size_t,
                           err: *mut *mut c_char);
-    pub fn rocksdb_readoptions_create() -> *mut DBReadOptions;
-    pub fn rocksdb_readoptions_destroy(readopts: *mut DBReadOptions);
-    pub fn rocksdb_readoptions_set_verify_checksums(readopts: *mut DBReadOptions, v: bool);
-    pub fn rocksdb_readoptions_set_fill_cache(readopts: *mut DBReadOptions, v: bool);
-    pub fn rocksdb_readoptions_set_snapshot(readopts: *mut DBReadOptions,
+    pub fn crocksdb_readoptions_create() -> *mut DBReadOptions;
+    pub fn crocksdb_readoptions_destroy(readopts: *mut DBReadOptions);
+    pub fn crocksdb_readoptions_set_verify_checksums(readopts: *mut DBReadOptions, v: bool);
+    pub fn crocksdb_readoptions_set_fill_cache(readopts: *mut DBReadOptions, v: bool);
+    pub fn crocksdb_readoptions_set_snapshot(readopts: *mut DBReadOptions,
                                             snapshot: *const DBSnapshot);
-    pub fn rocksdb_readoptions_set_iterate_upper_bound(readopts: *mut DBReadOptions,
+    pub fn crocksdb_readoptions_set_iterate_upper_bound(readopts: *mut DBReadOptions,
                                                        k: *const u8,
                                                        kLen: size_t);
-    pub fn rocksdb_readoptions_set_read_tier(readopts: *mut DBReadOptions, tier: c_int);
-    pub fn rocksdb_readoptions_set_tailing(readopts: *mut DBReadOptions, v: bool);
+    pub fn crocksdb_readoptions_set_read_tier(readopts: *mut DBReadOptions, tier: c_int);
+    pub fn crocksdb_readoptions_set_tailing(readopts: *mut DBReadOptions, v: bool);
 
-    pub fn rocksdb_get(db: *const DBInstance,
+    pub fn crocksdb_get(db: *const DBInstance,
                        readopts: *const DBReadOptions,
                        k: *const u8,
                        kLen: size_t,
                        valLen: *const size_t,
                        err: *mut *mut c_char)
                        -> *mut u8;
-    pub fn rocksdb_get_cf(db: *const DBInstance,
+    pub fn crocksdb_get_cf(db: *const DBInstance,
                           readopts: *const DBReadOptions,
                           cf_handle: *mut DBCFHandle,
                           k: *const u8,
@@ -243,43 +242,43 @@ extern "C" {
                           valLen: *const size_t,
                           err: *mut *mut c_char)
                           -> *mut u8;
-    pub fn rocksdb_create_iterator(db: *mut DBInstance,
+    pub fn crocksdb_create_iterator(db: *mut DBInstance,
                                    readopts: *const DBReadOptions)
                                    -> *mut DBIterator;
-    pub fn rocksdb_create_iterator_cf(db: *mut DBInstance,
+    pub fn crocksdb_create_iterator_cf(db: *mut DBInstance,
                                       readopts: *const DBReadOptions,
                                       cf_handle: *mut DBCFHandle)
                                       -> *mut DBIterator;
-    pub fn rocksdb_create_snapshot(db: *mut DBInstance) -> *const DBSnapshot;
-    pub fn rocksdb_release_snapshot(db: *mut DBInstance, snapshot: *const DBSnapshot);
+    pub fn crocksdb_create_snapshot(db: *mut DBInstance) -> *const DBSnapshot;
+    pub fn crocksdb_release_snapshot(db: *mut DBInstance, snapshot: *const DBSnapshot);
 
-    pub fn rocksdb_delete(db: *mut DBInstance,
+    pub fn crocksdb_delete(db: *mut DBInstance,
                           writeopts: *const DBWriteOptions,
                           k: *const u8,
                           kLen: size_t,
                           err: *mut *mut c_char);
-    pub fn rocksdb_delete_cf(db: *mut DBInstance,
+    pub fn crocksdb_delete_cf(db: *mut DBInstance,
                              writeopts: *const DBWriteOptions,
                              cf: *mut DBCFHandle,
                              k: *const u8,
                              kLen: size_t,
                              err: *mut *mut c_char);
-    pub fn rocksdb_close(db: *mut DBInstance);
-    pub fn rocksdb_destroy_db(options: *const DBOptions,
+    pub fn crocksdb_close(db: *mut DBInstance);
+    pub fn crocksdb_destroy_db(options: *const DBOptions,
                               path: *const c_char,
                               err: *mut *mut c_char);
-    pub fn rocksdb_repair_db(options: *const DBOptions,
+    pub fn crocksdb_repair_db(options: *const DBOptions,
                              path: *const c_char,
                              err: *mut *mut c_char);
     // Merge
-    pub fn rocksdb_merge(db: *mut DBInstance,
+    pub fn crocksdb_merge(db: *mut DBInstance,
                          writeopts: *const DBWriteOptions,
                          k: *const u8,
                          kLen: size_t,
                          v: *const u8,
                          vLen: size_t,
                          err: *mut *mut c_char);
-    pub fn rocksdb_merge_cf(db: *mut DBInstance,
+    pub fn crocksdb_merge_cf(db: *mut DBInstance,
                             writeopts: *const DBWriteOptions,
                             cf: *mut DBCFHandle,
                             k: *const u8,
@@ -287,7 +286,7 @@ extern "C" {
                             v: *const u8,
                             vLen: size_t,
                             err: *mut *mut c_char);
-    pub fn rocksdb_mergeoperator_create(
+    pub fn crocksdb_mergeoperator_create(
         state: *mut c_void,
         destroy: extern fn(*mut c_void) -> (),
         full_merge: extern fn (arg: *mut c_void,
@@ -312,57 +311,57 @@ extern "C" {
                                            ) -> ()>,
         name_fn: extern fn(*mut c_void) -> *const c_char,
     ) -> *mut DBMergeOperator;
-    pub fn rocksdb_mergeoperator_destroy(mo: *mut DBMergeOperator);
-    pub fn rocksdb_options_set_merge_operator(options: *mut DBOptions, mo: *mut DBMergeOperator);
+    pub fn crocksdb_mergeoperator_destroy(mo: *mut DBMergeOperator);
+    pub fn crocksdb_options_set_merge_operator(options: *mut DBOptions, mo: *mut DBMergeOperator);
     // Iterator
-    pub fn rocksdb_iter_destroy(iter: *mut DBIterator);
-    pub fn rocksdb_iter_valid(iter: *const DBIterator) -> bool;
-    pub fn rocksdb_iter_seek_to_first(iter: *mut DBIterator);
-    pub fn rocksdb_iter_seek_to_last(iter: *mut DBIterator);
-    pub fn rocksdb_iter_seek(iter: *mut DBIterator, key: *const u8, klen: size_t);
-    pub fn rocksdb_iter_next(iter: *mut DBIterator);
-    pub fn rocksdb_iter_prev(iter: *mut DBIterator);
-    pub fn rocksdb_iter_key(iter: *const DBIterator, klen: *mut size_t) -> *mut u8;
-    pub fn rocksdb_iter_value(iter: *const DBIterator, vlen: *mut size_t) -> *mut u8;
-    pub fn rocksdb_iter_get_error(iter: *const DBIterator, err: *mut *mut c_char);
+    pub fn crocksdb_iter_destroy(iter: *mut DBIterator);
+    pub fn crocksdb_iter_valid(iter: *const DBIterator) -> bool;
+    pub fn crocksdb_iter_seek_to_first(iter: *mut DBIterator);
+    pub fn crocksdb_iter_seek_to_last(iter: *mut DBIterator);
+    pub fn crocksdb_iter_seek(iter: *mut DBIterator, key: *const u8, klen: size_t);
+    pub fn crocksdb_iter_next(iter: *mut DBIterator);
+    pub fn crocksdb_iter_prev(iter: *mut DBIterator);
+    pub fn crocksdb_iter_key(iter: *const DBIterator, klen: *mut size_t) -> *mut u8;
+    pub fn crocksdb_iter_value(iter: *const DBIterator, vlen: *mut size_t) -> *mut u8;
+    pub fn crocksdb_iter_get_error(iter: *const DBIterator, err: *mut *mut c_char);
     // Write batch
-    pub fn rocksdb_write(db: *mut DBInstance,
+    pub fn crocksdb_write(db: *mut DBInstance,
                          writeopts: *const DBWriteOptions,
                          batch: *mut DBWriteBatch,
                          err: *mut *mut c_char);
-    pub fn rocksdb_writebatch_create() -> *mut DBWriteBatch;
-    pub fn rocksdb_writebatch_create_from(rep: *const u8, size: size_t) -> *mut DBWriteBatch;
-    pub fn rocksdb_writebatch_destroy(batch: *mut DBWriteBatch);
-    pub fn rocksdb_writebatch_clear(batch: *mut DBWriteBatch);
-    pub fn rocksdb_writebatch_count(batch: *mut DBWriteBatch) -> c_int;
-    pub fn rocksdb_writebatch_put(batch: *mut DBWriteBatch,
+    pub fn crocksdb_writebatch_create() -> *mut DBWriteBatch;
+    pub fn crocksdb_writebatch_create_from(rep: *const u8, size: size_t) -> *mut DBWriteBatch;
+    pub fn crocksdb_writebatch_destroy(batch: *mut DBWriteBatch);
+    pub fn crocksdb_writebatch_clear(batch: *mut DBWriteBatch);
+    pub fn crocksdb_writebatch_count(batch: *mut DBWriteBatch) -> c_int;
+    pub fn crocksdb_writebatch_put(batch: *mut DBWriteBatch,
                                   key: *const u8,
                                   klen: size_t,
                                   val: *const u8,
                                   vlen: size_t);
-    pub fn rocksdb_writebatch_put_cf(batch: *mut DBWriteBatch,
+    pub fn crocksdb_writebatch_put_cf(batch: *mut DBWriteBatch,
                                      cf: *mut DBCFHandle,
                                      key: *const u8,
                                      klen: size_t,
                                      val: *const u8,
                                      vlen: size_t);
-    pub fn rocksdb_writebatch_merge(batch: *mut DBWriteBatch,
+    pub fn crocksdb_writebatch_merge(batch: *mut DBWriteBatch,
                                     key: *const u8,
                                     klen: size_t,
                                     val: *const u8,
                                     vlen: size_t);
-    pub fn rocksdb_writebatch_merge_cf(batch: *mut DBWriteBatch,
+    pub fn crocksdb_writebatch_merge_cf(batch: *mut DBWriteBatch,
                                        cf: *mut DBCFHandle,
                                        key: *const u8,
                                        klen: size_t,
                                        val: *const u8,
                                        vlen: size_t);
-    pub fn rocksdb_writebatch_delete(batch: *mut DBWriteBatch, key: *const u8, klen: size_t);
-    pub fn rocksdb_writebatch_delete_cf(batch: *mut DBWriteBatch,
+    pub fn crocksdb_writebatch_delete(batch: *mut DBWriteBatch, key: *const u8, klen: size_t);
+    pub fn crocksdb_writebatch_delete_cf(batch: *mut DBWriteBatch,
                                         cf: *mut DBCFHandle,
                                         key: *const u8,
                                         klen: size_t);
-    pub fn rocksdb_writebatch_iterate(batch: *mut DBWriteBatch,
+    pub fn crocksdb_writebatch_iterate(batch: *mut DBWriteBatch,
                                       state: *mut c_void,
                                       put_fn: extern "C" fn(state: *mut c_void,
                                                             k: *const u8,
@@ -372,11 +371,11 @@ extern "C" {
                                       deleted_fn: extern "C" fn(state: *mut c_void,
                                                                 k: *const u8,
                                                                 klen: size_t));
-    pub fn rocksdb_writebatch_data(batch: *mut DBWriteBatch, size: *mut size_t) -> *const u8;
+    pub fn crocksdb_writebatch_data(batch: *mut DBWriteBatch, size: *mut size_t) -> *const u8;
 
     // Comparator
-    pub fn rocksdb_options_set_comparator(options: *mut DBOptions, cb: *mut DBComparator);
-    pub fn rocksdb_comparator_create(state: *mut c_void,
+    pub fn crocksdb_options_set_comparator(options: *mut DBOptions, cb: *mut DBComparator);
+    pub fn crocksdb_comparator_create(state: *mut c_void,
                                      destroy: extern "C" fn(*mut c_void) -> (),
                                      compare: extern "C" fn(arg: *mut c_void,
                                                             a: *const c_char,
@@ -386,10 +385,10 @@ extern "C" {
                                                             -> c_int,
                                      name_fn: extern "C" fn(*mut c_void) -> *const c_char)
                                      -> *mut DBComparator;
-    pub fn rocksdb_comparator_destroy(cmp: *mut DBComparator);
+    pub fn crocksdb_comparator_destroy(cmp: *mut DBComparator);
 
     // Column Family
-    pub fn rocksdb_open_column_families(options: *const DBOptions,
+    pub fn crocksdb_open_column_families(options: *const DBOptions,
                                         path: *const c_char,
                                         num_column_families: c_int,
                                         column_family_names: *const *const c_char,
@@ -397,39 +396,39 @@ extern "C" {
                                         column_family_handles: *const *mut DBCFHandle,
                                         err: *mut *mut c_char)
                                         -> *mut DBInstance;
-    pub fn rocksdb_create_column_family(db: *mut DBInstance,
+    pub fn crocksdb_create_column_family(db: *mut DBInstance,
                                         column_family_options: *const DBOptions,
                                         column_family_name: *const c_char,
                                         err: *mut *mut c_char)
                                         -> *mut DBCFHandle;
-    pub fn rocksdb_drop_column_family(db: *mut DBInstance,
+    pub fn crocksdb_drop_column_family(db: *mut DBInstance,
                                       column_family_handle: *mut DBCFHandle,
                                       err: *mut *mut c_char);
-    pub fn rocksdb_column_family_handle_destroy(column_family_handle: *mut DBCFHandle);
-    pub fn rocksdb_list_column_families(db: *const DBOptions,
+    pub fn crocksdb_column_family_handle_destroy(column_family_handle: *mut DBCFHandle);
+    pub fn crocksdb_list_column_families(db: *const DBOptions,
                                         path: *const c_char,
                                         lencf: *mut size_t,
                                         err: *mut *mut c_char)
                                         -> *mut *mut c_char;
-    pub fn rocksdb_list_column_families_destroy(list: *mut *mut c_char, len: size_t);
+    pub fn crocksdb_list_column_families_destroy(list: *mut *mut c_char, len: size_t);
 
     // Flush options
-    pub fn rocksdb_flushoptions_create() -> *mut DBFlushOptions;
-    pub fn rocksdb_flushoptions_destroy(opt: *mut DBFlushOptions);
-    pub fn rocksdb_flushoptions_set_wait(opt: *mut DBFlushOptions, whether_wait: bool);
+    pub fn crocksdb_flushoptions_create() -> *mut DBFlushOptions;
+    pub fn crocksdb_flushoptions_destroy(opt: *mut DBFlushOptions);
+    pub fn crocksdb_flushoptions_set_wait(opt: *mut DBFlushOptions, whether_wait: bool);
 
-    pub fn rocksdb_flush(db: *mut DBInstance,
+    pub fn crocksdb_flush(db: *mut DBInstance,
                          options: *const DBFlushOptions,
                          err: *mut *mut c_char);
 
-    pub fn rocksdb_approximate_sizes(db: *mut DBInstance,
+    pub fn crocksdb_approximate_sizes(db: *mut DBInstance,
                                      num_ranges: c_int,
                                      range_start_key: *const *const u8,
                                      range_start_key_len: *const size_t,
                                      range_limit_key: *const *const u8,
                                      range_limit_key_len: *const size_t,
                                      sizes: *mut uint64_t);
-    pub fn rocksdb_approximate_sizes_cf(db: *mut DBInstance,
+    pub fn crocksdb_approximate_sizes_cf(db: *mut DBInstance,
                                         cf: *mut DBCFHandle,
                                         num_ranges: c_int,
                                         range_start_key: *const *const u8,
@@ -437,37 +436,37 @@ extern "C" {
                                         range_limit_key: *const *const u8,
                                         range_limit_key_len: *const size_t,
                                         sizes: *mut uint64_t);
-    pub fn rocksdb_compact_range(db: *mut DBInstance,
+    pub fn crocksdb_compact_range(db: *mut DBInstance,
                                  start_key: *const u8,
                                  start_key_len: size_t,
                                  limit_key: *const u8,
                                  limit_key_len: size_t);
-    pub fn rocksdb_compact_range_cf(db: *mut DBInstance,
+    pub fn crocksdb_compact_range_cf(db: *mut DBInstance,
                                     cf: *mut DBCFHandle,
                                     start_key: *const u8,
                                     start_key_len: size_t,
                                     limit_key: *const u8,
                                     limit_key_len: size_t);
-    pub fn rocksdb_delete_file_in_range(db: *mut DBInstance,
+    pub fn crocksdb_delete_file_in_range(db: *mut DBInstance,
                                         range_start_key: *const u8,
                                         range_start_key_len: size_t,
                                         range_limit_key: *const u8,
                                         range_limit_key_len: size_t,
                                         err: *mut *mut c_char);
-    pub fn rocksdb_delete_file_in_range_cf(db: *mut DBInstance,
+    pub fn crocksdb_delete_file_in_range_cf(db: *mut DBInstance,
                                            cf: *mut DBCFHandle,
                                            range_start_key: *const u8,
                                            range_start_key_len: size_t,
                                            range_limit_key: *const u8,
                                            range_limit_key_len: size_t,
                                            err: *mut *mut c_char);
-    pub fn rocksdb_property_value(db: *mut DBInstance, propname: *const c_char) -> *mut c_char;
-    pub fn rocksdb_property_value_cf(db: *mut DBInstance,
+    pub fn crocksdb_property_value(db: *mut DBInstance, propname: *const c_char) -> *mut c_char;
+    pub fn crocksdb_property_value_cf(db: *mut DBInstance,
                                      cf: *mut DBCFHandle,
                                      propname: *const c_char)
                                      -> *mut c_char;
     // Compaction filter
-    pub fn rocksdb_compactionfilter_create(state: *mut c_void,
+    pub fn crocksdb_compactionfilter_create(state: *mut c_void,
                                            destructor: extern "C" fn(*mut c_void),
                                            filter: extern "C" fn(*mut c_void,
                                                                  c_int,
@@ -481,26 +480,26 @@ extern "C" {
                                                                  -> bool,
                                            name: extern "C" fn(*mut c_void) -> *const c_char)
                                            -> *mut DBCompactionFilter;
-    pub fn rocksdb_compactionfilter_set_ignore_snapshots(filter: *mut DBCompactionFilter,
+    pub fn crocksdb_compactionfilter_set_ignore_snapshots(filter: *mut DBCompactionFilter,
                                                          ignore_snapshot: bool);
-    pub fn rocksdb_compactionfilter_destroy(filter: *mut DBCompactionFilter);
+    pub fn crocksdb_compactionfilter_destroy(filter: *mut DBCompactionFilter);
 
     // Restore Option
-    pub fn rocksdb_restore_options_create() -> *mut DBRestoreOptions;
-    pub fn rocksdb_restore_options_destroy(ropts: *mut DBRestoreOptions);
-    pub fn rocksdb_restore_options_set_keep_log_files(ropts: *mut DBRestoreOptions, v: c_int);
+    pub fn crocksdb_restore_options_create() -> *mut DBRestoreOptions;
+    pub fn crocksdb_restore_options_destroy(ropts: *mut DBRestoreOptions);
+    pub fn crocksdb_restore_options_set_keep_log_files(ropts: *mut DBRestoreOptions, v: c_int);
 
     // Backup engine
     // TODO: add more ffis about backup engine.
-    pub fn rocksdb_backup_engine_open(options: *const DBOptions,
+    pub fn crocksdb_backup_engine_open(options: *const DBOptions,
                                       path: *const c_char,
                                       err: *mut *mut c_char)
                                       -> *mut DBBackupEngine;
-    pub fn rocksdb_backup_engine_create_new_backup(be: *mut DBBackupEngine,
+    pub fn crocksdb_backup_engine_create_new_backup(be: *mut DBBackupEngine,
                                                    db: *mut DBInstance,
                                                    err: *mut *mut c_char);
-    pub fn rocksdb_backup_engine_close(be: *mut DBBackupEngine);
-    pub fn rocksdb_backup_engine_restore_db_from_latest_backup(be: *mut DBBackupEngine,
+    pub fn crocksdb_backup_engine_close(be: *mut DBBackupEngine);
+    pub fn crocksdb_backup_engine_restore_db_from_latest_backup(be: *mut DBBackupEngine,
                                                                db_path: *const c_char,
                                                                wal_path: *const c_char,
                                                                ropts: *const DBRestoreOptions,
@@ -518,47 +517,47 @@ mod test {
     #[test]
     fn internal() {
         unsafe {
-            let opts = rocksdb_options_create();
+            let opts = crocksdb_options_create();
             assert!(!opts.is_null());
 
-            rocksdb_options_increase_parallelism(opts, 0);
-            rocksdb_options_optimize_level_style_compaction(opts, 0);
-            rocksdb_options_set_create_if_missing(opts, true);
+            crocksdb_options_increase_parallelism(opts, 0);
+            crocksdb_options_optimize_level_style_compaction(opts, 0);
+            crocksdb_options_set_create_if_missing(opts, true);
 
             let rustpath = TempDir::new("_rust_rocksdb_internaltest").expect("");
             let cpath = CString::new(rustpath.path().to_str().unwrap()).unwrap();
             let cpath_ptr = cpath.as_ptr();
 
             let mut err = ptr::null_mut();
-            let db = rocksdb_open(opts, cpath_ptr, &mut err);
+            let db = crocksdb_open(opts, cpath_ptr, &mut err);
             assert!(err.is_null(), error_message(err));
 
-            let writeopts = rocksdb_writeoptions_create();
+            let writeopts = crocksdb_writeoptions_create();
             assert!(!writeopts.is_null());
 
             let key = b"name\x00";
             let val = b"spacejam\x00";
-            rocksdb_put(db, writeopts, key.as_ptr(), 4, val.as_ptr(), 8, &mut err);
-            rocksdb_writeoptions_destroy(writeopts);
+            crocksdb_put(db, writeopts, key.as_ptr(), 4, val.as_ptr(), 8, &mut err);
+            crocksdb_writeoptions_destroy(writeopts);
             assert!(err.is_null(), error_message(err));
 
-            let readopts = rocksdb_readoptions_create();
+            let readopts = crocksdb_readoptions_create();
             assert!(!readopts.is_null());
 
             let mut val_len = 0;
-            rocksdb_get(db, readopts, key.as_ptr(), 4, &mut val_len, &mut err);
-            rocksdb_readoptions_destroy(readopts);
+            crocksdb_get(db, readopts, key.as_ptr(), 4, &mut val_len, &mut err);
+            crocksdb_readoptions_destroy(readopts);
             assert!(err.is_null(), error_message(err));
 
             // flush first to get approximate size later.
-            let flush_opt = rocksdb_flushoptions_create();
-            rocksdb_flushoptions_set_wait(flush_opt, true);
-            rocksdb_flush(db, flush_opt, &mut err);
-            rocksdb_flushoptions_destroy(flush_opt);
+            let flush_opt = crocksdb_flushoptions_create();
+            crocksdb_flushoptions_set_wait(flush_opt, true);
+            crocksdb_flush(db, flush_opt, &mut err);
+            crocksdb_flushoptions_destroy(flush_opt);
             assert!(err.is_null(), error_message(err));
 
             let mut sizes = vec![0; 1];
-            rocksdb_approximate_sizes(db,
+            crocksdb_approximate_sizes(db,
                                       1,
                                       vec![b"\x00\x00".as_ptr()].as_ptr(),
                                       vec![1].as_ptr(),
@@ -568,7 +567,7 @@ mod test {
             assert_eq!(sizes.len(), 1);
             assert!(sizes[0] > 0);
 
-            rocksdb_delete_file_in_range(db,
+            crocksdb_delete_file_in_range(db,
                                          b"\x00\x00".as_ptr(),
                                          2,
                                          b"\xff\x00".as_ptr(),
@@ -577,7 +576,7 @@ mod test {
             assert!(err.is_null(), error_message(err));
 
             let propname = CString::new("rocksdb.total-sst-files-size").unwrap();
-            let value = rocksdb_property_value(db, propname.as_ptr());
+            let value = crocksdb_property_value(db, propname.as_ptr());
             assert!(!value.is_null());
 
             let sst_size = CStr::from_ptr(value).to_str().unwrap().parse::<u64>().unwrap();
@@ -585,12 +584,12 @@ mod test {
             libc::free(value as *mut c_void);
 
             let propname = CString::new("fake_key").unwrap();
-            let value = rocksdb_property_value(db, propname.as_ptr());
+            let value = crocksdb_property_value(db, propname.as_ptr());
             assert!(value.is_null());
             libc::free(value as *mut c_void);
 
-            rocksdb_close(db);
-            rocksdb_destroy_db(opts, cpath_ptr, &mut err);
+            crocksdb_close(db);
+            crocksdb_destroy_db(opts, cpath_ptr, &mut err);
             assert!(err.is_null());
         }
     }

src/compaction_filter.rs

 use libc::{c_void, c_char, c_int, size_t};
 
-use rocksdb_ffi::{self, DBCompactionFilter};
+use crocksdb_ffi::{self, DBCompactionFilter};
 use std::ffi::CString;
 use std::slice;
 
@@ -61,7 +61,7 @@ pub struct CompactionFilterHandle {
 impl Drop for CompactionFilterHandle {
     fn drop(&mut self) {
         unsafe {
-            rocksdb_ffi::rocksdb_compactionfilter_destroy(self.inner);
+            crocksdb_ffi::crocksdb_compactionfilter_destroy(self.inner);
         }
     }
 }
@@ -74,10 +74,10 @@ pub unsafe fn new_compaction_filter(c_name: CString,
         name: c_name,
         filter: f,
     }));
-    let filter = rocksdb_ffi::rocksdb_compactionfilter_create(proxy as *mut c_void,
+    let filter = crocksdb_ffi::crocksdb_compactionfilter_create(proxy as *mut c_void,
                                                               destructor,
                                                               filter,
                                                               name);
-    rocksdb_ffi::rocksdb_compactionfilter_set_ignore_snapshots(filter, ignore_snapshots);
+    crocksdb_ffi::crocksdb_compactionfilter_set_ignore_snapshots(filter, ignore_snapshots);
     Ok(CompactionFilterHandle { inner: filter })
 }

src/lib.rs

@@ -28,7 +28,7 @@ mod compaction_filter;
 
 pub use compaction_filter::CompactionFilter;
 pub use librocksdb_sys::{DBCompactionStyle, DBCompressionType, DBRecoveryMode, new_bloom_filter,
-                         self as rocksdb_ffi};
+                         self as crocksdb_ffi};
 pub use merge_operator::MergeOperands;
 pub use rocksdb::{DB, DBIterator, DBVector, Kv, SeekKey, Writable, WriteBatch, CFHandle, Range,
                   BackupEngine};

src/rocksdb.rs

@@ -16,7 +16,7 @@
 
 use libc::{self, c_int, c_void, size_t};
 
-use rocksdb_ffi::{self, DBWriteBatch, DBCFHandle, DBInstance, DBBackupEngine};
+use crocksdb_ffi::{self, DBWriteBatch, DBCFHandle, DBInstance, DBBackupEngine};
 use rocksdb_options::{Options, ReadOptions, UnsafeSnap, WriteOptions, FlushOptions, RestoreOptions};
 use std::collections::BTreeMap;
 use std::collections::btree_map::Entry;
@@ -37,7 +37,7 @@ pub struct CFHandle {
 impl Drop for CFHandle {
     fn drop(&mut self) {
         unsafe {
-            rocksdb_ffi::rocksdb_column_family_handle_destroy(self.inner);
+            crocksdb_ffi::crocksdb_column_family_handle_destroy(self.inner);
         }
     }
 }
@@ -66,7 +66,7 @@ pub struct Snapshot<'a> {
 pub struct DBIterator<'a> {
     db: &'a DB,
     readopts: ReadOptions,
-    inner: *mut rocksdb_ffi::DBIterator,
+    inner: *mut crocksdb_ffi::DBIterator,
 }
 
 pub enum SeekKey<'a> {
@@ -84,7 +84,7 @@ impl<'a> From<&'a [u8]> for SeekKey<'a> {
 impl<'a> DBIterator<'a> {
     pub fn new(db: &'a DB, readopts: ReadOptions) -> DBIterator<'a> {
         unsafe {
-            let iterator = rocksdb_ffi::rocksdb_create_iterator(db.inner, readopts.get_inner());
+            let iterator = crocksdb_ffi::crocksdb_create_iterator(db.inner, readopts.get_inner());
 
             DBIterator {
                 db: db,
@@ -97,10 +97,10 @@ impl<'a> DBIterator<'a> {
     pub fn seek(&mut self, key: SeekKey) -> bool {
         unsafe {
             match key {
-                SeekKey::Start => rocksdb_ffi::rocksdb_iter_seek_to_first(self.inner),
-                SeekKey::End => rocksdb_ffi::rocksdb_iter_seek_to_last(self.inner),
+                SeekKey::Start => crocksdb_ffi::crocksdb_iter_seek_to_first(self.inner),
+                SeekKey::End => crocksdb_ffi::crocksdb_iter_seek_to_last(self.inner),
                 SeekKey::Key(key) => {
-                    rocksdb_ffi::rocksdb_iter_seek(self.inner, key.as_ptr(), key.len() as size_t)
+                    crocksdb_ffi::crocksdb_iter_seek(self.inner, key.as_ptr(), key.len() as size_t)
                 }
             }
         }
@@ -109,14 +109,14 @@ impl<'a> DBIterator<'a> {
 
     pub fn prev(&mut self) -> bool {
         unsafe {
-            rocksdb_ffi::rocksdb_iter_prev(self.inner);
+            crocksdb_ffi::crocksdb_iter_prev(self.inner);
         }
         self.valid()
     }
 
     pub fn next(&mut self) -> bool {
         unsafe {
-            rocksdb_ffi::rocksdb_iter_next(self.inner);
+            crocksdb_ffi::crocksdb_iter_next(self.inner);
         }
         self.valid()
     }
@@ -126,7 +126,7 @@ impl<'a> DBIterator<'a> {
         let mut key_len: size_t = 0;
         let key_len_ptr: *mut size_t = &mut key_len;
         unsafe {
-            let key_ptr = rocksdb_ffi::rocksdb_iter_key(self.inner, key_len_ptr);
+            let key_ptr = crocksdb_ffi::crocksdb_iter_key(self.inner, key_len_ptr);
             slice::from_raw_parts(key_ptr, key_len as usize)
         }
     }
@@ -136,7 +136,7 @@ impl<'a> DBIterator<'a> {
         let mut val_len: size_t = 0;
         let val_len_ptr: *mut size_t = &mut val_len;
         unsafe {
-            let val_ptr = rocksdb_ffi::rocksdb_iter_value(self.inner, val_len_ptr);
+            let val_ptr = crocksdb_ffi::crocksdb_iter_value(self.inner, val_len_ptr);
             slice::from_raw_parts(val_ptr, val_len as usize)
         }
     }
@@ -150,12 +150,12 @@ impl<'a> DBIterator<'a> {
     }
 
     pub fn valid(&self) -> bool {
-        unsafe { rocksdb_ffi::rocksdb_iter_valid(self.inner) }
+        unsafe { crocksdb_ffi::crocksdb_iter_valid(self.inner) }
     }
 
     pub fn new_cf(db: &'a DB, cf_handle: &CFHandle, readopts: ReadOptions) -> DBIterator<'a> {
         unsafe {
-            let iterator = rocksdb_ffi::rocksdb_create_iterator_cf(db.inner,
+            let iterator = crocksdb_ffi::crocksdb_create_iterator_cf(db.inner,
                                                                    readopts.get_inner(),
                                                                    cf_handle.inner);
             DBIterator {
@@ -184,7 +184,7 @@ impl<'b, 'a> Iterator for &'b mut DBIterator<'a> {
 impl<'a> Drop for DBIterator<'a> {
     fn drop(&mut self) {
         unsafe {
-            rocksdb_ffi::rocksdb_iter_destroy(self.inner);
+            crocksdb_ffi::crocksdb_iter_destroy(self.inner);
         }
     }
 }
@@ -320,11 +320,11 @@ impl DB {
                 .collect();
 
             let cfopts: Vec<_> = cf_opts_v.iter()
-                .map(|x| x.inner as *const rocksdb_ffi::DBOptions)
+                .map(|x| x.inner as *const crocksdb_ffi::DBOptions)
                 .collect();
 
             let db = unsafe {
-                ffi_try!(rocksdb_open_column_families(opts.inner,
+                ffi_try!(crocksdb_open_column_families(opts.inner,
                                                       cpath.as_ptr(),
                                                       cfs_v.len() as c_int,
                                                       cfnames.as_ptr(),
@@ -361,7 +361,7 @@ impl DB {
     pub fn destroy(opts: &Options, path: &str) -> Result<(), String> {
         let cpath = CString::new(path.as_bytes()).unwrap();
         unsafe {
-            ffi_try!(rocksdb_destroy_db(opts.inner, cpath.as_ptr()));
+            ffi_try!(crocksdb_destroy_db(opts.inner, cpath.as_ptr()));
         }
         Ok(())
     }
@@ -369,7 +369,7 @@ impl DB {
     pub fn repair(opts: Options, path: &str) -> Result<(), String> {
         let cpath = CString::new(path.as_bytes()).unwrap();
         unsafe {
-            ffi_try!(rocksdb_repair_db(opts.inner, cpath.as_ptr()));
+            ffi_try!(crocksdb_repair_db(opts.inner, cpath.as_ptr()));
         }
         Ok(())
     }
@@ -388,7 +388,7 @@ impl DB {
         unsafe {
             let mut lencf: size_t = 0;
             let list =
-                ffi_try!(rocksdb_list_column_families(opts.inner, cpath.as_ptr(), &mut lencf));
+                ffi_try!(crocksdb_list_column_families(opts.inner, cpath.as_ptr(), &mut lencf));
             let list_cfs = slice::from_raw_parts(list, lencf);
             for &cf_name in list_cfs {
                 let cf = match CStr::from_ptr(cf_name).to_owned().into_string() {
@@ -397,7 +397,7 @@ impl DB {
                 };
                 cfs.push(cf);
             }
-            rocksdb_ffi::rocksdb_list_column_families_destroy(list, lencf);
+            crocksdb_ffi::crocksdb_list_column_families_destroy(list, lencf);
         }
 
         Ok(cfs)
@@ -409,7 +409,7 @@ impl DB {
 
     pub fn write_opt(&self, batch: WriteBatch, writeopts: &WriteOptions) -> Result<(), String> {
         unsafe {
-            ffi_try!(rocksdb_write(self.inner, writeopts.inner, batch.inner));
+            ffi_try!(crocksdb_write(self.inner, writeopts.inner, batch.inner));
         }
         Ok(())
     }
@@ -428,7 +428,7 @@ impl DB {
         unsafe {
             let val_len: size_t = 0;
             let val_len_ptr = &val_len as *const size_t;
-            let val = ffi_try!(rocksdb_get(self.inner,
+            let val = ffi_try!(crocksdb_get(self.inner,
                                            readopts.get_inner(),
                                            key.as_ptr(),
                                            key.len() as size_t,
@@ -453,7 +453,7 @@ impl DB {
         unsafe {
             let val_len: size_t = 0;
             let val_len_ptr = &val_len as *const size_t;
-            let val = ffi_try!(rocksdb_get_cf(self.inner,
+            let val = ffi_try!(crocksdb_get_cf(self.inner,
                                               readopts.get_inner(),
                                               cf.inner,
                                               key.as_ptr(),
@@ -481,7 +481,7 @@ impl DB {
         let cname_ptr = cname.as_ptr();
         unsafe {
             let cf_handler =
-                ffi_try!(rocksdb_create_column_family(self.inner, opts.inner, cname_ptr));
+                ffi_try!(crocksdb_create_column_family(self.inner, opts.inner, cname_ptr));
             let handle = CFHandle { inner: cf_handler };
             Ok(match self.cfs.entry(name.to_owned()) {
                 Entry::Occupied(mut e) => {
@@ -500,7 +500,7 @@ impl DB {
         }
 
         unsafe {
-            ffi_try!(rocksdb_drop_column_family(self.inner, cf.unwrap().inner));
+            ffi_try!(crocksdb_drop_column_family(self.inner, cf.unwrap().inner));
         }
 
         Ok(())
@@ -538,7 +538,7 @@ impl DB {
     }
 
     pub unsafe fn release_snap(&self, snap: &UnsafeSnap) {
-        rocksdb_ffi::rocksdb_release_snapshot(self.inner, snap.get_inner())
+        crocksdb_ffi::crocksdb_release_snapshot(self.inner, snap.get_inner())
     }
 
     pub fn put_opt(&self,
@@ -547,7 +547,7 @@ impl DB {
                    writeopts: &WriteOptions)
                    -> Result<(), String> {
         unsafe {
-            ffi_try!(rocksdb_put(self.inner,
+            ffi_try!(crocksdb_put(self.inner,
                                  writeopts.inner,
                                  key.as_ptr(),
                                  key.len() as size_t,
@@ -564,7 +564,7 @@ impl DB {
                       writeopts: &WriteOptions)
                       -> Result<(), String> {
         unsafe {
-            ffi_try!(rocksdb_put_cf(self.inner,
+            ffi_try!(crocksdb_put_cf(self.inner,
                                     writeopts.inner,
                                     cf.inner,
                                     key.as_ptr(),
@@ -580,7 +580,7 @@ impl DB {
                      writeopts: &WriteOptions)
                      -> Result<(), String> {
         unsafe {
-            ffi_try!(rocksdb_merge(self.inner,
+            ffi_try!(crocksdb_merge(self.inner,
                                    writeopts.inner,
                                    key.as_ptr(),
                                    key.len() as size_t,
@@ -596,7 +596,7 @@ impl DB {
                     writeopts: &WriteOptions)
                     -> Result<(), String> {
         unsafe {
-            ffi_try!(rocksdb_merge_cf(self.inner,
+            ffi_try!(crocksdb_merge_cf(self.inner,
                                       writeopts.inner,
                                       cf.inner,
                                       key.as_ptr(),
@@ -608,7 +608,7 @@ impl DB {
     }
     fn delete_opt(&self, key: &[u8], writeopts: &WriteOptions) -> Result<(), String> {
         unsafe {
-            ffi_try!(rocksdb_delete(self.inner,
+            ffi_try!(crocksdb_delete(self.inner,
                                     writeopts.inner,
                                     key.as_ptr(),
                                     key.len() as size_t));
@@ -622,7 +622,7 @@ impl DB {
                      writeopts: &WriteOptions)
                      -> Result<(), String> {
         unsafe {
-            ffi_try!(rocksdb_delete_cf(self.inner,
+            ffi_try!(crocksdb_delete_cf(self.inner,
                                        writeopts.inner,
                                        cf.inner,
                                        key.as_ptr(),
@@ -640,7 +640,7 @@ impl DB {
         unsafe {
             let mut opts = FlushOptions::new();
             opts.set_wait(sync);
-            ffi_try!(rocksdb_flush(self.inner, opts.inner));
+            ffi_try!(crocksdb_flush(self.inner, opts.inner));
             Ok(())
         }
     }
@@ -683,7 +683,7 @@ impl DB {
              sizes.as_mut_ptr());
         match cf {
             None => unsafe {
-                rocksdb_ffi::rocksdb_approximate_sizes(self.inner,
+                crocksdb_ffi::crocksdb_approximate_sizes(self.inner,
                                                        n,
                                                        start_key_ptr,
                                                        start_key_len_ptr,
@@ -692,7 +692,7 @@ impl DB {
                                                        size_ptr)
             },
             Some(cf) => unsafe {
-                rocksdb_ffi::rocksdb_approximate_sizes_cf(self.inner,
+                crocksdb_ffi::crocksdb_approximate_sizes_cf(self.inner,
                                                           cf.inner,
                                                           n,
                                                           start_key_ptr,
@@ -709,7 +709,7 @@ impl DB {
         unsafe {
             let (start, s_len) = start_key.map_or((ptr::null(), 0), |k| (k.as_ptr(), k.len()));
             let (end, e_len) = end_key.map_or((ptr::null(), 0), |k| (k.as_ptr(), k.len()));
-            rocksdb_ffi::rocksdb_compact_range(self.inner, start, s_len, end, e_len);
+            crocksdb_ffi::crocksdb_compact_range(self.inner, start, s_len, end, e_len);
         }
     }
 
@@ -720,13 +720,13 @@ impl DB {
         unsafe {
             let (start, s_len) = start_key.map_or((ptr::null(), 0), |k| (k.as_ptr(), k.len()));
             let (end, e_len) = end_key.map_or((ptr::null(), 0), |k| (k.as_ptr(), k.len()));
-            rocksdb_ffi::rocksdb_compact_range_cf(self.inner, cf.inner, start, s_len, end, e_len);
+            crocksdb_ffi::crocksdb_compact_range_cf(self.inner, cf.inner, start, s_len, end, e_len);
         }
     }
 
     pub fn delete_file_in_range(&self, start_key: &[u8], end_key: &[u8]) -> Result<(), String> {
         unsafe {
-            ffi_try!(rocksdb_delete_file_in_range(self.inner,
+            ffi_try!(crocksdb_delete_file_in_range(self.inner,
                                                   start_key.as_ptr(),
                                                   start_key.len() as size_t,
                                                   end_key.as_ptr(),
@@ -741,7 +741,7 @@ impl DB {
                                    end_key: &[u8])
                                    -> Result<(), String> {
         unsafe {
-            ffi_try!(rocksdb_delete_file_in_range_cf(self.inner,
+            ffi_try!(crocksdb_delete_file_in_range_cf(self.inner,
                                                      cf.inner,
                                                      start_key.as_ptr(),
                                                      start_key.len() as size_t,
@@ -774,9 +774,9 @@ impl DB {
             let prop_name = CString::new(name).unwrap();
 
             let value = match cf {
-                None => rocksdb_ffi::rocksdb_property_value(self.inner, prop_name.as_ptr()),
+                None => crocksdb_ffi::crocksdb_property_value(self.inner, prop_name.as_ptr()),
                 Some(cf) => {
-                    rocksdb_ffi::rocksdb_property_value_cf(self.inner, cf.inner, prop_name.as_ptr())
+                    crocksdb_ffi::crocksdb_property_value_cf(self.inner, cf.inner, prop_name.as_ptr())
                 }
             };
 
@@ -810,7 +810,7 @@ impl DB {
     pub fn backup_at(&self, path: &str) -> Result<BackupEngine, String> {
         let backup_engine = BackupEngine::open(Options::new(), path).unwrap();
         unsafe {
-            ffi_try!(rocksdb_backup_engine_create_new_backup(backup_engine.inner, self.inner))
+            ffi_try!(crocksdb_backup_engine_create_new_backup(backup_engine.inner, self.inner))
         }
         Ok(backup_engine)
     }
@@ -837,7 +837,7 @@ impl DB {
         };
 
         unsafe {
-            ffi_try!(rocksdb_backup_engine_restore_db_from_latest_backup(backup_engine.inner,
+            ffi_try!(crocksdb_backup_engine_restore_db_from_latest_backup(backup_engine.inner,
                                                                          c_db_path.as_ptr(),
                                                                          c_wal_path.as_ptr(),
                                                                          ropts.inner))
@@ -875,7 +875,7 @@ impl Writable for DB {
 
 impl Default for WriteBatch {
     fn default() -> WriteBatch {
-        WriteBatch { inner: unsafe { rocksdb_ffi::rocksdb_writebatch_create() } }
+        WriteBatch { inner: unsafe { crocksdb_ffi::crocksdb_writebatch_create() } }
     }
 }
 
@@ -885,7 +885,7 @@ impl WriteBatch {
     }
 
     pub fn count(&self) -> usize {
-        unsafe { rocksdb_ffi::rocksdb_writebatch_count(self.inner) as usize }
+        unsafe { crocksdb_ffi::crocksdb_writebatch_count(self.inner) as usize }
     }
 
     pub fn is_empty(&self) -> bool {
@@ -909,7 +909,7 @@ impl WriteBatch {
 
 impl Drop for WriteBatch {
     fn drop(&mut self) {
-        unsafe { rocksdb_ffi::rocksdb_writebatch_destroy(self.inner) }
+        unsafe { crocksdb_ffi::crocksdb_writebatch_destroy(self.inner) }
     }
 }
 
@@ -917,7 +917,7 @@ impl Drop for DB {
     fn drop(&mut self) {
         unsafe {
             self.cfs.clear();
-            rocksdb_ffi::rocksdb_close(self.inner);
+            crocksdb_ffi::crocksdb_close(self.inner);
         }
     }
 }
@@ -925,7 +925,7 @@ impl Drop for DB {
 impl Writable for WriteBatch {
     fn put(&self, key: &[u8], value: &[u8]) -> Result<(), String> {
         unsafe {
-            rocksdb_ffi::rocksdb_writebatch_put(self.inner,
+            crocksdb_ffi::crocksdb_writebatch_put(self.inner,
                                                 key.as_ptr(),
                                                 key.len() as size_t,
                                                 value.as_ptr(),
@@ -936,7 +936,7 @@ impl Writable for WriteBatch {
 
     fn put_cf(&self, cf: &CFHandle, key: &[u8], value: &[u8]) -> Result<(), String> {
         unsafe {
-            rocksdb_ffi::rocksdb_writebatch_put_cf(self.inner,
+            crocksdb_ffi::crocksdb_writebatch_put_cf(self.inner,
                                                    cf.inner,
                                                    key.as_ptr(),
                                                    key.len() as size_t,
@@ -948,7 +948,7 @@ impl Writable for WriteBatch {
 
     fn merge(&self, key: &[u8], value: &[u8]) -> Result<(), String> {
         unsafe {
-            rocksdb_ffi::rocksdb_writebatch_merge(self.inner,
+            crocksdb_ffi::crocksdb_writebatch_merge(self.inner,
                                                   key.as_ptr(),
                                                   key.len() as size_t,
                                                   value.as_ptr(),
@@ -959,7 +959,7 @@ impl Writable for WriteBatch {
 
     fn merge_cf(&self, cf: &CFHandle, key: &[u8], value: &[u8]) -> Result<(), String> {
         unsafe {
-            rocksdb_ffi::rocksdb_writebatch_merge_cf(self.inner,
+            crocksdb_ffi::crocksdb_writebatch_merge_cf(self.inner,
                                                      cf.inner,
                                                      key.as_ptr(),
                                                      key.len() as size_t,
@@ -971,14 +971,14 @@ impl Writable for WriteBatch {
 
     fn delete(&self, key: &[u8]) -> Result<(), String> {
         unsafe {
-            rocksdb_ffi::rocksdb_writebatch_delete(self.inner, key.as_ptr(), key.len() as size_t);
+            crocksdb_ffi::crocksdb_writebatch_delete(self.inner, key.as_ptr(), key.len() as size_t);
             Ok(())
         }
     }
 
     fn delete_cf(&self, cf: &CFHandle, key: &[u8]) -> Result<(), String> {
         unsafe {
-            rocksdb_ffi::rocksdb_writebatch_delete_cf(self.inner,
+            crocksdb_ffi::crocksdb_writebatch_delete_cf(self.inner,
                                                       cf.inner,
                                                       key.as_ptr(),
                                                       key.len() as size_t);
@@ -1039,7 +1039,7 @@ impl BackupEngine {
         }
 
         let backup_engine =
-            unsafe { ffi_try!(rocksdb_backup_engine_open(opts.inner, cpath.as_ptr())) };
+            unsafe { ffi_try!(crocksdb_backup_engine_open(opts.inner, cpath.as_ptr())) };
 
         Ok(BackupEngine { inner: backup_engine })
     }
@@ -1048,7 +1048,7 @@ impl BackupEngine {
 impl Drop for BackupEngine {
     fn drop(&mut self) {
         unsafe {
-            rocksdb_ffi::rocksdb_backup_engine_close(self.inner);
+            crocksdb_ffi::crocksdb_backup_engine_close(self.inner);
         }
     }
 }

src/rocksdb_options.rs

@@ -19,7 +19,7 @@ use libc::{self, c_int, size_t, c_void};
 use merge_operator::{self, MergeOperatorCallback, full_merge_callback, partial_merge_callback};
 use merge_operator::MergeFn;
 
-use rocksdb_ffi::{self, DBOptions, DBWriteOptions, DBBlockBasedTableOptions, DBReadOptions,
+use crocksdb_ffi::{self, DBOptions, DBWriteOptions, DBBlockBasedTableOptions, DBReadOptions,
                   DBRestoreOptions, DBCompressionType, DBRecoveryMode, DBSnapshot, DBInstance,
                   DBFlushOptions};
 use std::ffi::{CStr, CString};
@@ -32,7 +32,7 @@ pub struct BlockBasedOptions {
 impl Drop for BlockBasedOptions {
     fn drop(&mut self) {
         unsafe {
-            rocksdb_ffi::rocksdb_block_based_options_destroy(self.inner);
+            crocksdb_ffi::crocksdb_block_based_options_destroy(self.inner);
         }
     }
 }
@@ -40,7 +40,7 @@ impl Drop for BlockBasedOptions {
 impl Default for BlockBasedOptions {
     fn default() -> BlockBasedOptions {
         unsafe {
-            let block_opts = rocksdb_ffi::rocksdb_block_based_options_create();
+            let block_opts = crocksdb_ffi::crocksdb_block_based_options_create();
             assert!(!block_opts.is_null(),
                     "Could not create rocksdb block based options");
             BlockBasedOptions { inner: block_opts }
@@ -55,34 +55,34 @@ impl BlockBasedOptions {
 
     pub fn set_block_size(&mut self, size: usize) {
         unsafe {
-            rocksdb_ffi::rocksdb_block_based_options_set_block_size(self.inner, size);
+            crocksdb_ffi::crocksdb_block_based_options_set_block_size(self.inner, size);
         }
     }
 
     pub fn set_lru_cache(&mut self, size: size_t) {
-        let cache = rocksdb_ffi::new_cache(size);
+        let cache = crocksdb_ffi::new_cache(size);
         unsafe {
             // because cache is wrapped in shared_ptr, so we don't need to call
             // rocksdb_cache_destroy explicitly.
-            rocksdb_ffi::rocksdb_block_based_options_set_block_cache(self.inner, cache);
+            crocksdb_ffi::crocksdb_block_based_options_set_block_cache(self.inner, cache);
         }
     }
 
     pub fn set_bloom_filter(&mut self, bits_per_key: c_int, block_based: bool) {
         unsafe {
             let bloom = if block_based {
-                rocksdb_ffi::rocksdb_filterpolicy_create_bloom(bits_per_key)
+                crocksdb_ffi::crocksdb_filterpolicy_create_bloom(bits_per_key)
             } else {
-                rocksdb_ffi::rocksdb_filterpolicy_create_bloom_full(bits_per_key)
+                crocksdb_ffi::crocksdb_filterpolicy_create_bloom_full(bits_per_key)
             };
 
-            rocksdb_ffi::rocksdb_block_based_options_set_filter_policy(self.inner, bloom);
+            crocksdb_ffi::crocksdb_block_based_options_set_filter_policy(self.inner, bloom);
         }
     }
 
     pub fn set_cache_index_and_filter_blocks(&mut self, v: bool) {
         unsafe {
-            rocksdb_ffi::rocksdb_block_based_options_set_cache_index_and_filter_blocks(self.inner,
+            crocksdb_ffi::crocksdb_block_based_options_set_cache_index_and_filter_blocks(self.inner,
                                                                                        v as u8);
         }
     }
@@ -99,7 +99,7 @@ pub struct UnsafeSnap {
 
 impl UnsafeSnap {
     pub unsafe fn new(db: *mut DBInstance) -> UnsafeSnap {
-        UnsafeSnap { inner: rocksdb_ffi::rocksdb_create_snapshot(db) }
+        UnsafeSnap { inner: crocksdb_ffi::crocksdb_create_snapshot(db) }
     }
 
     pub unsafe fn get_inner(&self) -> *const DBSnapshot {
@@ -114,14 +114,14 @@ pub struct ReadOptions {
 
 impl Drop for ReadOptions {
     fn drop(&mut self) {
-        unsafe { rocksdb_ffi::rocksdb_readoptions_destroy(self.inner) }
+        unsafe { crocksdb_ffi::crocksdb_readoptions_destroy(self.inner) }
     }
 }
 
 impl Default for ReadOptions {
     fn default() -> ReadOptions {
         unsafe {
-            let opts = rocksdb_ffi::rocksdb_readoptions_create();
+            let opts = crocksdb_ffi::crocksdb_readoptions_create();
             assert!(!opts.is_null(), "Unable to create rocksdb read options");
             ReadOptions {
                 inner: opts,
@@ -142,18 +142,18 @@ impl ReadOptions {
     #[allow(dead_code)]
     pub fn fill_cache(&mut self, v: bool) {
         unsafe {
-            rocksdb_ffi::rocksdb_readoptions_set_fill_cache(self.inner, v);
+            crocksdb_ffi::crocksdb_readoptions_set_fill_cache(self.inner, v);
         }
     }
 
     pub unsafe fn set_snapshot(&mut self, snapshot: &UnsafeSnap) {
-        rocksdb_ffi::rocksdb_readoptions_set_snapshot(self.inner, snapshot.inner);
+        crocksdb_ffi::crocksdb_readoptions_set_snapshot(self.inner, snapshot.inner);
     }
 
     pub fn set_iterate_upper_bound(&mut self, key: &[u8]) {
         self.upper_bound = Vec::from(key);
         unsafe {
-            rocksdb_ffi::rocksdb_readoptions_set_iterate_upper_bound(self.inner,
+            crocksdb_ffi::crocksdb_readoptions_set_iterate_upper_bound(self.inner,
                                                                      self.upper_bound.as_ptr(),
                                                                      self.upper_bound.len());
         }
@@ -171,14 +171,14 @@ pub struct WriteOptions {
 impl Drop for WriteOptions {
     fn drop(&mut self) {
         unsafe {
-            rocksdb_ffi::rocksdb_writeoptions_destroy(self.inner);
+            crocksdb_ffi::crocksdb_writeoptions_destroy(self.inner);
         }
     }
 }
 
 impl Default for WriteOptions {
     fn default() -> WriteOptions {
-        let write_opts = unsafe { rocksdb_ffi::rocksdb_writeoptions_create() };
+        let write_opts = unsafe { crocksdb_ffi::crocksdb_writeoptions_create() };
         assert!(!write_opts.is_null(),
                 "Could not create rocksdb write options");
         WriteOptions { inner: write_opts }
@@ -192,16 +192,16 @@ impl WriteOptions {
 
     pub fn set_sync(&mut self, sync: bool) {
         unsafe {
-            rocksdb_ffi::rocksdb_writeoptions_set_sync(self.inner, sync);
+            crocksdb_ffi::crocksdb_writeoptions_set_sync(self.inner, sync);
         }
     }
 
     pub fn disable_wal(&mut self, disable: bool) {
         unsafe {
             if disable {
-                rocksdb_ffi::rocksdb_writeoptions_disable_WAL(self.inner, 1);
+                crocksdb_ffi::crocksdb_writeoptions_disable_WAL(self.inner, 1);
             } else {
-                rocksdb_ffi::rocksdb_writeoptions_disable_WAL(self.inner, 0);
+                crocksdb_ffi::crocksdb_writeoptions_disable_WAL(self.inner, 0);
             }
         }
     }
@@ -215,7 +215,7 @@ pub struct Options {
 impl Drop for Options {
     fn drop(&mut self) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_destroy(self.inner);
+            crocksdb_ffi::crocksdb_options_destroy(self.inner);
         }
     }
 }
@@ -223,7 +223,7 @@ impl Drop for Options {
 impl Default for Options {
     fn default() -> Options {
         unsafe {
-            let opts = rocksdb_ffi::rocksdb_options_create();
+            let opts = crocksdb_ffi::crocksdb_options_create();
             assert!(!opts.is_null(), "Could not create rocksdb options");
             Options {
                 inner: opts,
@@ -240,13 +240,13 @@ impl Options {
 
     pub fn increase_parallelism(&mut self, parallelism: i32) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_increase_parallelism(self.inner, parallelism);
+            crocksdb_ffi::crocksdb_options_increase_parallelism(self.inner, parallelism);
         }
     }
 
     pub fn optimize_level_style_compaction(&mut self, memtable_memory_budget: i32) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_optimize_level_style_compaction(self.inner,
+            crocksdb_ffi::crocksdb_options_optimize_level_style_compaction(self.inner,
                                                                          memtable_memory_budget);
         }
     }
@@ -276,7 +276,7 @@ impl Options {
                 Err(e) => return Err(format!("failed to convert to cstring: {:?}", e)),
             };
             self.filter = Some(try!(new_compaction_filter(c_name, ignore_snapshots, filter)));
-            rocksdb_ffi::rocksdb_options_set_compaction_filter(self.inner,
+            crocksdb_ffi::crocksdb_options_set_compaction_filter(self.inner,
                                                                self.filter
                                                                    .as_ref()
                                                                    .unwrap()
@@ -287,19 +287,19 @@ impl Options {
 
     pub fn create_if_missing(&mut self, create_if_missing: bool) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_create_if_missing(self.inner, create_if_missing);
+            crocksdb_ffi::crocksdb_options_set_create_if_missing(self.inner, create_if_missing);
         }
     }
 
     pub fn compression(&mut self, t: DBCompressionType) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_compression(self.inner, t);
+            crocksdb_ffi::crocksdb_options_set_compression(self.inner, t);
         }
     }
 
     pub fn compression_per_level(&mut self, level_types: &[DBCompressionType]) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_compression_per_level(self.inner,
+            crocksdb_ffi::crocksdb_options_set_compression_per_level(self.inner,
                                                                    level_types.as_ptr(),
                                                                    level_types.len() as size_t)
         }
@@ -312,13 +312,13 @@ impl Options {
         });
 
         unsafe {
-            let mo = rocksdb_ffi::rocksdb_mergeoperator_create(mem::transmute(cb),
+            let mo = crocksdb_ffi::crocksdb_mergeoperator_create(mem::transmute(cb),
                                                                merge_operator::destructor_callback,
                                                                full_merge_callback,
                                                                partial_merge_callback,
                                                                None,
                                                                merge_operator::name_callback);
-            rocksdb_ffi::rocksdb_options_set_merge_operator(self.inner, mo);
+            crocksdb_ffi::crocksdb_options_set_merge_operator(self.inner, mo);
         }
     }
 
@@ -329,202 +329,202 @@ impl Options {
         });
 
         unsafe {
-            let cmp = rocksdb_ffi::rocksdb_comparator_create(mem::transmute(cb),
+            let cmp = crocksdb_ffi::crocksdb_comparator_create(mem::transmute(cb),
                                                              comparator::destructor_callback,
                                                              compare_callback,
                                                              comparator::name_callback);
-            rocksdb_ffi::rocksdb_options_set_comparator(self.inner, cmp);
+            crocksdb_ffi::crocksdb_options_set_comparator(self.inner, cmp);
         }
     }
 
 
     pub fn set_block_cache_size_mb(&mut self, cache_size: u64) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_optimize_for_point_lookup(self.inner, cache_size);
+            crocksdb_ffi::crocksdb_options_optimize_for_point_lookup(self.inner, cache_size);
         }
     }
 
     pub fn set_max_open_files(&mut self, nfiles: c_int) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_max_open_files(self.inner, nfiles);
+            crocksdb_ffi::crocksdb_options_set_max_open_files(self.inner, nfiles);
         }
     }
 
     pub fn set_max_total_wal_size(&mut self, size: u64) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_max_total_wal_size(self.inner, size);
+            crocksdb_ffi::crocksdb_options_set_max_total_wal_size(self.inner, size);
         }
     }
 
     pub fn set_use_fsync(&mut self, useit: bool) {
         unsafe {
             if useit {
-                rocksdb_ffi::rocksdb_options_set_use_fsync(self.inner, 1)
+                crocksdb_ffi::crocksdb_options_set_use_fsync(self.inner, 1)
             } else {
-                rocksdb_ffi::rocksdb_options_set_use_fsync(self.inner, 0)
+                crocksdb_ffi::crocksdb_options_set_use_fsync(self.inner, 0)
             }
         }
     }
 
     pub fn set_bytes_per_sync(&mut self, nbytes: u64) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_bytes_per_sync(self.inner, nbytes);
+            crocksdb_ffi::crocksdb_options_set_bytes_per_sync(self.inner, nbytes);
         }
     }
 
     pub fn set_disable_data_sync(&mut self, disable: bool) {
         unsafe {
             if disable {
-                rocksdb_ffi::rocksdb_options_set_disable_data_sync(self.inner, 1);
+                crocksdb_ffi::crocksdb_options_set_disable_data_sync(self.inner, 1);
             } else {
-                rocksdb_ffi::rocksdb_options_set_disable_data_sync(self.inner, 0);
+                crocksdb_ffi::crocksdb_options_set_disable_data_sync(self.inner, 0);
             }
         }
     }
 
     pub fn allow_os_buffer(&mut self, is_allow: bool) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_allow_os_buffer(self.inner, is_allow);
+            crocksdb_ffi::crocksdb_options_set_allow_os_buffer(self.inner, is_allow);
         }
     }
 
     pub fn set_table_cache_num_shard_bits(&mut self, nbits: c_int) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_table_cache_numshardbits(self.inner, nbits);
+            crocksdb_ffi::crocksdb_options_set_table_cache_numshardbits(self.inner, nbits);
         }
     }
 
     pub fn set_min_write_buffer_number(&mut self, nbuf: c_int) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_min_write_buffer_number_to_merge(self.inner, nbuf);
+            crocksdb_ffi::crocksdb_options_set_min_write_buffer_number_to_merge(self.inner, nbuf);
         }
     }
 
     pub fn set_max_write_buffer_number(&mut self, nbuf: c_int) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_max_write_buffer_number(self.inner, nbuf);
+            crocksdb_ffi::crocksdb_options_set_max_write_buffer_number(self.inner, nbuf);
         }
     }
 
     pub fn set_write_buffer_size(&mut self, size: u64) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_write_buffer_size(self.inner, size);
+            crocksdb_ffi::crocksdb_options_set_write_buffer_size(self.inner, size);
         }
     }
 
     pub fn set_max_bytes_for_level_base(&mut self, size: u64) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_max_bytes_for_level_base(self.inner, size);
+            crocksdb_ffi::crocksdb_options_set_max_bytes_for_level_base(self.inner, size);
         }
     }
 
     pub fn set_max_bytes_for_level_multiplier(&mut self, mul: i32) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_max_bytes_for_level_multiplier(self.inner, mul);
+            crocksdb_ffi::crocksdb_options_set_max_bytes_for_level_multiplier(self.inner, mul);
         }
     }
 
     pub fn set_max_manifest_file_size(&mut self, size: u64) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_max_manifest_file_size(self.inner, size);
+            crocksdb_ffi::crocksdb_options_set_max_manifest_file_size(self.inner, size);
         }
     }
 
     pub fn set_target_file_size_base(&mut self, size: u64) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_target_file_size_base(self.inner, size);
+            crocksdb_ffi::crocksdb_options_set_target_file_size_base(self.inner, size);
         }
     }
 
     pub fn set_min_write_buffer_number_to_merge(&mut self, to_merge: c_int) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_min_write_buffer_number_to_merge(self.inner, to_merge);
+            crocksdb_ffi::crocksdb_options_set_min_write_buffer_number_to_merge(self.inner, to_merge);
         }
     }
 
     pub fn set_level_zero_file_num_compaction_trigger(&mut self, n: c_int) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_level0_file_num_compaction_trigger(self.inner, n);
+            crocksdb_ffi::crocksdb_options_set_level0_file_num_compaction_trigger(self.inner, n);
         }
     }
 
     pub fn set_level_zero_slowdown_writes_trigger(&mut self, n: c_int) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_level0_slowdown_writes_trigger(self.inner, n);
+            crocksdb_ffi::crocksdb_options_set_level0_slowdown_writes_trigger(self.inner, n);
         }
     }
 
     pub fn set_level_zero_stop_writes_trigger(&mut self, n: c_int) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_level0_stop_writes_trigger(self.inner, n);
+            crocksdb_ffi::crocksdb_options_set_level0_stop_writes_trigger(self.inner, n);
         }
     }
 
-    pub fn set_compaction_style(&mut self, style: rocksdb_ffi::DBCompactionStyle) {
+    pub fn set_compaction_style(&mut self, style: crocksdb_ffi::DBCompactionStyle) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_compaction_style(self.inner, style);
+            crocksdb_ffi::crocksdb_options_set_compaction_style(self.inner, style);
         }
     }
 
     pub fn set_max_background_compactions(&mut self, n: c_int) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_max_background_compactions(self.inner, n);
+            crocksdb_ffi::crocksdb_options_set_max_background_compactions(self.inner, n);
         }
     }
 
     pub fn set_max_background_flushes(&mut self, n: c_int) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_max_background_flushes(self.inner, n);
+            crocksdb_ffi::crocksdb_options_set_max_background_flushes(self.inner, n);
         }
     }
 
     pub fn set_filter_deletes(&mut self, filter: bool) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_filter_deletes(self.inner, filter);
+            crocksdb_ffi::crocksdb_options_set_filter_deletes(self.inner, filter);
         }
     }
 
     pub fn set_disable_auto_compactions(&mut self, disable: bool) {
         unsafe {
             if disable {
-                rocksdb_ffi::rocksdb_options_set_disable_auto_compactions(self.inner, 1)
+                crocksdb_ffi::crocksdb_options_set_disable_auto_compactions(self.inner, 1)
             } else {
-                rocksdb_ffi::rocksdb_options_set_disable_auto_compactions(self.inner, 0)
+                crocksdb_ffi::crocksdb_options_set_disable_auto_compactions(self.inner, 0)
             }
         }
     }
 
     pub fn set_block_based_table_factory(&mut self, factory: &BlockBasedOptions) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_block_based_table_factory(self.inner, factory.inner);
+            crocksdb_ffi::crocksdb_options_set_block_based_table_factory(self.inner, factory.inner);
         }
     }
 
     pub fn set_report_bg_io_stats(&mut self, enable: bool) {
         unsafe {
             if enable {
-                rocksdb_ffi::rocksdb_options_set_report_bg_io_stats(self.inner, 1);
+                crocksdb_ffi::crocksdb_options_set_report_bg_io_stats(self.inner, 1);
             } else {
-                rocksdb_ffi::rocksdb_options_set_report_bg_io_stats(self.inner, 0);
+                crocksdb_ffi::crocksdb_options_set_report_bg_io_stats(self.inner, 0);
             }
         }
     }
 
     pub fn set_wal_recovery_mode(&mut self, mode: DBRecoveryMode) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_wal_recovery_mode(self.inner, mode);
+            crocksdb_ffi::crocksdb_options_set_wal_recovery_mode(self.inner, mode);
         }
     }
 
     pub fn enable_statistics(&mut self) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_enable_statistics(self.inner);
+            crocksdb_ffi::crocksdb_options_enable_statistics(self.inner);
         }
     }
 
     pub fn get_statistics(&self) -> Option<String> {
         unsafe {
-            let value = rocksdb_ffi::rocksdb_options_statistics_get_string(self.inner);
+            let value = crocksdb_ffi::crocksdb_options_statistics_get_string(self.inner);
 
 
             if value.is_null() {
@@ -540,32 +540,32 @@ impl Options {
 
     pub fn set_stats_dump_period_sec(&mut self, period: usize) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_stats_dump_period_sec(self.inner, period);
+            crocksdb_ffi::crocksdb_options_set_stats_dump_period_sec(self.inner, period);
         }
     }
 
     pub fn set_num_levels(&mut self, n: c_int) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_num_levels(self.inner, n);
+            crocksdb_ffi::crocksdb_options_set_num_levels(self.inner, n);
         }
     }
 
     pub fn set_db_log_dir(&mut self, path: &str) {
         let path = CString::new(path.as_bytes()).unwrap();
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_db_log_dir(self.inner, path.as_ptr());
+            crocksdb_ffi::crocksdb_options_set_db_log_dir(self.inner, path.as_ptr());
         }
     }
 
     pub fn set_max_log_file_size(&mut self, size: u64) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_max_log_file_size(self.inner, size as size_t);
+            crocksdb_ffi::crocksdb_options_set_max_log_file_size(self.inner, size as size_t);
         }
     }
 
     pub fn set_keep_log_file_num(&mut self, num: u64) {
         unsafe {
-            rocksdb_ffi::rocksdb_options_set_keep_log_file_num(self.inner, num as size_t);
+            crocksdb_ffi::crocksdb_options_set_keep_log_file_num(self.inner, num as size_t);
         }
     }
 }
@@ -576,12 +576,12 @@ pub struct FlushOptions {
 
 impl FlushOptions {
     pub fn new() -> FlushOptions {
-        unsafe { FlushOptions { inner: rocksdb_ffi::rocksdb_flushoptions_create() } }
+        unsafe { FlushOptions { inner: crocksdb_ffi::crocksdb_flushoptions_create() } }
     }
 
     pub fn set_wait(&mut self, wait: bool) {
         unsafe {
-            rocksdb_ffi::rocksdb_flushoptions_set_wait(self.inner, wait);
+            crocksdb_ffi::crocksdb_flushoptions_set_wait(self.inner, wait);
         }
     }
 }
@@ -589,7 +589,7 @@ impl FlushOptions {
 impl Drop for FlushOptions {
     fn drop(&mut self) {
         unsafe {
-            rocksdb_ffi::rocksdb_flushoptions_destroy(self.inner);
+            crocksdb_ffi::crocksdb_flushoptions_destroy(self.inner);
         }
     }
 }
@@ -600,12 +600,12 @@ pub struct RestoreOptions {
 
 impl RestoreOptions {
     pub fn new() -> RestoreOptions {
-        unsafe { RestoreOptions { inner: rocksdb_ffi::rocksdb_restore_options_create() } }
+        unsafe { RestoreOptions { inner: crocksdb_ffi::crocksdb_restore_options_create() } }
     }
 
     pub fn set_keep_log_files(&mut self, flag: bool) {
         unsafe {
-            rocksdb_ffi::rocksdb_restore_options_set_keep_log_files(self.inner,
+            crocksdb_ffi::crocksdb_restore_options_set_keep_log_files(self.inner,
                                                                     if flag { 1 } else { 0 })
         }
     }
@@ -614,7 +614,7 @@ impl RestoreOptions {
 impl Drop for RestoreOptions {
     fn drop(&mut self) {
         unsafe {
-            rocksdb_ffi::rocksdb_restore_options_destroy(self.inner);
+            crocksdb_ffi::crocksdb_restore_options_destroy(self.inner);
         }
     }
 }