From 6c4e110c8cd04588c40ea646b57b48e433a7c482 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dog=CC=86an=20C=CC=A7ec=CC=A7en?= Date: Tue, 10 Dec 2013 10:45:07 +0200 Subject: [PATCH] Rename leveldb to rocksdb in C api --- db/c.cc | 326 ++++++++++++++++++++++---------------------- db/c_test.c | 212 ++++++++++++++-------------- include/rocksdb/c.h | 238 ++++++++++++++++---------------- 3 files changed, 388 insertions(+), 388 deletions(-) diff --git a/db/c.cc b/db/c.cc index 0d99c44dd..021122301 100644 --- a/db/c.cc +++ b/db/c.cc @@ -48,21 +48,21 @@ using std::shared_ptr; extern "C" { -struct leveldb_t { DB* rep; }; -struct leveldb_iterator_t { Iterator* rep; }; -struct leveldb_writebatch_t { WriteBatch rep; }; -struct leveldb_snapshot_t { const Snapshot* rep; }; -struct leveldb_readoptions_t { ReadOptions rep; }; -struct leveldb_writeoptions_t { WriteOptions rep; }; -struct leveldb_options_t { Options rep; }; -struct leveldb_seqfile_t { SequentialFile* rep; }; -struct leveldb_randomfile_t { RandomAccessFile* rep; }; -struct leveldb_writablefile_t { WritableFile* rep; }; -struct leveldb_filelock_t { FileLock* rep; }; -struct leveldb_logger_t { shared_ptr rep; }; -struct leveldb_cache_t { shared_ptr rep; }; +struct rocksdb_t { DB* rep; }; +struct rocksdb_iterator_t { Iterator* rep; }; +struct rocksdb_writebatch_t { WriteBatch rep; }; +struct rocksdb_snapshot_t { const Snapshot* rep; }; +struct rocksdb_readoptions_t { ReadOptions rep; }; +struct rocksdb_writeoptions_t { WriteOptions rep; }; +struct rocksdb_options_t { Options rep; }; +struct rocksdb_seqfile_t { SequentialFile* rep; }; +struct rocksdb_randomfile_t { RandomAccessFile* rep; }; +struct rocksdb_writablefile_t { WritableFile* rep; }; +struct rocksdb_filelock_t { FileLock* rep; }; +struct rocksdb_logger_t { shared_ptr rep; }; +struct rocksdb_cache_t { shared_ptr rep; }; -struct leveldb_comparator_t : public Comparator { +struct rocksdb_comparator_t : public Comparator { void* state_; void (*destructor_)(void*); int (*compare_)( @@ -71,7 +71,7 @@ struct leveldb_comparator_t : public Comparator { const char* b, size_t blen); const char* (*name_)(void*); - virtual ~leveldb_comparator_t() { + virtual ~rocksdb_comparator_t() { (*destructor_)(state_); } @@ -88,7 +88,7 @@ struct leveldb_comparator_t : public Comparator { virtual void FindShortSuccessor(std::string* key) const { } }; -struct leveldb_filterpolicy_t : public FilterPolicy { +struct rocksdb_filterpolicy_t : public FilterPolicy { void* state_; void (*destructor_)(void*); const char* (*name_)(void*); @@ -102,7 +102,7 @@ struct leveldb_filterpolicy_t : public FilterPolicy { const char* key, size_t length, const char* filter, size_t filter_length); - virtual ~leveldb_filterpolicy_t() { + virtual ~rocksdb_filterpolicy_t() { (*destructor_)(state_); } @@ -129,7 +129,7 @@ struct leveldb_filterpolicy_t : public FilterPolicy { } }; -struct leveldb_env_t { +struct rocksdb_env_t { Env* rep; bool is_default; }; @@ -154,27 +154,27 @@ static char* CopyString(const std::string& str) { return result; } -leveldb_t* leveldb_open( - const leveldb_options_t* options, +rocksdb_t* rocksdb_open( + const rocksdb_options_t* options, const char* name, char** errptr) { DB* db; if (SaveError(errptr, DB::Open(options->rep, std::string(name), &db))) { return NULL; } - leveldb_t* result = new leveldb_t; + rocksdb_t* result = new rocksdb_t; result->rep = db; return result; } -void leveldb_close(leveldb_t* db) { +void rocksdb_close(rocksdb_t* db) { delete db->rep; delete db; } -void leveldb_put( - leveldb_t* db, - const leveldb_writeoptions_t* options, +void rocksdb_put( + rocksdb_t* db, + const rocksdb_writeoptions_t* options, const char* key, size_t keylen, const char* val, size_t vallen, char** errptr) { @@ -182,26 +182,26 @@ void leveldb_put( db->rep->Put(options->rep, Slice(key, keylen), Slice(val, vallen))); } -void leveldb_delete( - leveldb_t* db, - const leveldb_writeoptions_t* options, +void rocksdb_delete( + rocksdb_t* db, + const rocksdb_writeoptions_t* options, const char* key, size_t keylen, char** errptr) { SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen))); } -void leveldb_write( - leveldb_t* db, - const leveldb_writeoptions_t* options, - leveldb_writebatch_t* batch, +void rocksdb_write( + rocksdb_t* db, + const rocksdb_writeoptions_t* options, + rocksdb_writebatch_t* batch, char** errptr) { SaveError(errptr, db->rep->Write(options->rep, &batch->rep)); } -char* leveldb_get( - leveldb_t* db, - const leveldb_readoptions_t* options, +char* rocksdb_get( + rocksdb_t* db, + const rocksdb_readoptions_t* options, const char* key, size_t keylen, size_t* vallen, char** errptr) { @@ -220,30 +220,30 @@ char* leveldb_get( return result; } -leveldb_iterator_t* leveldb_create_iterator( - leveldb_t* db, - const leveldb_readoptions_t* options) { - leveldb_iterator_t* result = new leveldb_iterator_t; +rocksdb_iterator_t* rocksdb_create_iterator( + rocksdb_t* db, + const rocksdb_readoptions_t* options) { + rocksdb_iterator_t* result = new rocksdb_iterator_t; result->rep = db->rep->NewIterator(options->rep); return result; } -const leveldb_snapshot_t* leveldb_create_snapshot( - leveldb_t* db) { - leveldb_snapshot_t* result = new leveldb_snapshot_t; +const rocksdb_snapshot_t* rocksdb_create_snapshot( + rocksdb_t* db) { + rocksdb_snapshot_t* result = new rocksdb_snapshot_t; result->rep = db->rep->GetSnapshot(); return result; } -void leveldb_release_snapshot( - leveldb_t* db, - const leveldb_snapshot_t* snapshot) { +void rocksdb_release_snapshot( + rocksdb_t* db, + const rocksdb_snapshot_t* snapshot) { db->rep->ReleaseSnapshot(snapshot->rep); delete snapshot; } -char* leveldb_property_value( - leveldb_t* db, +char* rocksdb_property_value( + rocksdb_t* db, const char* propname) { std::string tmp; if (db->rep->GetProperty(Slice(propname), &tmp)) { @@ -254,8 +254,8 @@ char* leveldb_property_value( } } -void leveldb_approximate_sizes( - leveldb_t* db, +void rocksdb_approximate_sizes( + rocksdb_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, @@ -269,8 +269,8 @@ void leveldb_approximate_sizes( delete[] ranges; } -void leveldb_compact_range( - leveldb_t* db, +void rocksdb_compact_range( + rocksdb_t* db, const char* start_key, size_t start_key_len, const char* limit_key, size_t limit_key_len) { Slice a, b; @@ -280,92 +280,92 @@ void leveldb_compact_range( (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : NULL)); } -void leveldb_destroy_db( - const leveldb_options_t* options, +void rocksdb_destroy_db( + const rocksdb_options_t* options, const char* name, char** errptr) { SaveError(errptr, DestroyDB(name, options->rep)); } -void leveldb_repair_db( - const leveldb_options_t* options, +void rocksdb_repair_db( + const rocksdb_options_t* options, const char* name, char** errptr) { SaveError(errptr, RepairDB(name, options->rep)); } -void leveldb_iter_destroy(leveldb_iterator_t* iter) { +void rocksdb_iter_destroy(rocksdb_iterator_t* iter) { delete iter->rep; delete iter; } -unsigned char leveldb_iter_valid(const leveldb_iterator_t* iter) { +unsigned char rocksdb_iter_valid(const rocksdb_iterator_t* iter) { return iter->rep->Valid(); } -void leveldb_iter_seek_to_first(leveldb_iterator_t* iter) { +void rocksdb_iter_seek_to_first(rocksdb_iterator_t* iter) { iter->rep->SeekToFirst(); } -void leveldb_iter_seek_to_last(leveldb_iterator_t* iter) { +void rocksdb_iter_seek_to_last(rocksdb_iterator_t* iter) { iter->rep->SeekToLast(); } -void leveldb_iter_seek(leveldb_iterator_t* iter, const char* k, size_t klen) { +void rocksdb_iter_seek(rocksdb_iterator_t* iter, const char* k, size_t klen) { iter->rep->Seek(Slice(k, klen)); } -void leveldb_iter_next(leveldb_iterator_t* iter) { +void rocksdb_iter_next(rocksdb_iterator_t* iter) { iter->rep->Next(); } -void leveldb_iter_prev(leveldb_iterator_t* iter) { +void rocksdb_iter_prev(rocksdb_iterator_t* iter) { iter->rep->Prev(); } -const char* leveldb_iter_key(const leveldb_iterator_t* iter, size_t* klen) { +const char* rocksdb_iter_key(const rocksdb_iterator_t* iter, size_t* klen) { Slice s = iter->rep->key(); *klen = s.size(); return s.data(); } -const char* leveldb_iter_value(const leveldb_iterator_t* iter, size_t* vlen) { +const char* rocksdb_iter_value(const rocksdb_iterator_t* iter, size_t* vlen) { Slice s = iter->rep->value(); *vlen = s.size(); return s.data(); } -void leveldb_iter_get_error(const leveldb_iterator_t* iter, char** errptr) { +void rocksdb_iter_get_error(const rocksdb_iterator_t* iter, char** errptr) { SaveError(errptr, iter->rep->status()); } -leveldb_writebatch_t* leveldb_writebatch_create() { - return new leveldb_writebatch_t; +rocksdb_writebatch_t* rocksdb_writebatch_create() { + return new rocksdb_writebatch_t; } -void leveldb_writebatch_destroy(leveldb_writebatch_t* b) { +void rocksdb_writebatch_destroy(rocksdb_writebatch_t* b) { delete b; } -void leveldb_writebatch_clear(leveldb_writebatch_t* b) { +void rocksdb_writebatch_clear(rocksdb_writebatch_t* b) { b->rep.Clear(); } -void leveldb_writebatch_put( - leveldb_writebatch_t* b, +void rocksdb_writebatch_put( + rocksdb_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 leveldb_writebatch_delete( - leveldb_writebatch_t* b, +void rocksdb_writebatch_delete( + rocksdb_writebatch_t* b, const char* key, size_t klen) { b->rep.Delete(Slice(key, klen)); } -void leveldb_writebatch_iterate( - leveldb_writebatch_t* b, +void rocksdb_writebatch_iterate( + rocksdb_writebatch_t* b, void* state, void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen), void (*deleted)(void*, const char* k, size_t klen)) { @@ -388,132 +388,132 @@ void leveldb_writebatch_iterate( b->rep.Iterate(&handler); } -leveldb_options_t* leveldb_options_create() { - return new leveldb_options_t; +rocksdb_options_t* rocksdb_options_create() { + return new rocksdb_options_t; } -void leveldb_options_destroy(leveldb_options_t* options) { +void rocksdb_options_destroy(rocksdb_options_t* options) { delete options; } -void leveldb_options_set_comparator( - leveldb_options_t* opt, - leveldb_comparator_t* cmp) { +void rocksdb_options_set_comparator( + rocksdb_options_t* opt, + rocksdb_comparator_t* cmp) { opt->rep.comparator = cmp; } -void leveldb_options_set_filter_policy( - leveldb_options_t* opt, - leveldb_filterpolicy_t* policy) { +void rocksdb_options_set_filter_policy( + rocksdb_options_t* opt, + rocksdb_filterpolicy_t* policy) { opt->rep.filter_policy = policy; } -void leveldb_options_set_create_if_missing( - leveldb_options_t* opt, unsigned char v) { +void rocksdb_options_set_create_if_missing( + rocksdb_options_t* opt, unsigned char v) { opt->rep.create_if_missing = v; } -void leveldb_options_set_error_if_exists( - leveldb_options_t* opt, unsigned char v) { +void rocksdb_options_set_error_if_exists( + rocksdb_options_t* opt, unsigned char v) { opt->rep.error_if_exists = v; } -void leveldb_options_set_paranoid_checks( - leveldb_options_t* opt, unsigned char v) { +void rocksdb_options_set_paranoid_checks( + rocksdb_options_t* opt, unsigned char v) { opt->rep.paranoid_checks = v; } -void leveldb_options_set_env(leveldb_options_t* opt, leveldb_env_t* env) { +void rocksdb_options_set_env(rocksdb_options_t* opt, rocksdb_env_t* env) { opt->rep.env = (env ? env->rep : NULL); } -void leveldb_options_set_info_log(leveldb_options_t* opt, leveldb_logger_t* l) { +void rocksdb_options_set_info_log(rocksdb_options_t* opt, rocksdb_logger_t* l) { if (l) { opt->rep.info_log = l->rep; } } -void leveldb_options_set_write_buffer_size(leveldb_options_t* opt, size_t s) { +void rocksdb_options_set_write_buffer_size(rocksdb_options_t* opt, size_t s) { opt->rep.write_buffer_size = s; } -void leveldb_options_set_max_open_files(leveldb_options_t* opt, int n) { +void rocksdb_options_set_max_open_files(rocksdb_options_t* opt, int n) { opt->rep.max_open_files = n; } -void leveldb_options_set_cache(leveldb_options_t* opt, leveldb_cache_t* c) { +void rocksdb_options_set_cache(rocksdb_options_t* opt, rocksdb_cache_t* c) { if (c) { opt->rep.block_cache = c->rep; } } -void leveldb_options_set_block_size(leveldb_options_t* opt, size_t s) { +void rocksdb_options_set_block_size(rocksdb_options_t* opt, size_t s) { opt->rep.block_size = s; } -void leveldb_options_set_block_restart_interval(leveldb_options_t* opt, int n) { +void rocksdb_options_set_block_restart_interval(rocksdb_options_t* opt, int n) { opt->rep.block_restart_interval = n; } -void leveldb_options_set_target_file_size_base( - leveldb_options_t* opt, uint64_t n) { +void rocksdb_options_set_target_file_size_base( + rocksdb_options_t* opt, uint64_t n) { opt->rep.target_file_size_base = n; } -void leveldb_options_set_target_file_size_multiplier( - leveldb_options_t* opt, int n) { +void rocksdb_options_set_target_file_size_multiplier( + rocksdb_options_t* opt, int n) { opt->rep.target_file_size_multiplier = n; } -void leveldb_options_set_max_bytes_for_level_base( - leveldb_options_t* opt, uint64_t n) { +void rocksdb_options_set_max_bytes_for_level_base( + rocksdb_options_t* opt, uint64_t n) { opt->rep.max_bytes_for_level_base = n; } -void leveldb_options_set_max_bytes_for_level_multiplier( - leveldb_options_t* opt, int n) { +void rocksdb_options_set_max_bytes_for_level_multiplier( + rocksdb_options_t* opt, int n) { opt->rep.max_bytes_for_level_multiplier = n; } -void leveldb_options_set_expanded_compaction_factor( - leveldb_options_t* opt, int n) { +void rocksdb_options_set_expanded_compaction_factor( + rocksdb_options_t* opt, int n) { opt->rep.expanded_compaction_factor = n; } -void leveldb_options_set_max_grandparent_overlap_factor( - leveldb_options_t* opt, int n) { +void rocksdb_options_set_max_grandparent_overlap_factor( + rocksdb_options_t* opt, int n) { opt->rep.max_grandparent_overlap_factor = n; } -void leveldb_options_set_num_levels(leveldb_options_t* opt, int n) { +void rocksdb_options_set_num_levels(rocksdb_options_t* opt, int n) { opt->rep.num_levels = n; } -void leveldb_options_set_level0_file_num_compaction_trigger( - leveldb_options_t* opt, int n) { +void rocksdb_options_set_level0_file_num_compaction_trigger( + rocksdb_options_t* opt, int n) { opt->rep.level0_file_num_compaction_trigger = n; } -void leveldb_options_set_level0_slowdown_writes_trigger( - leveldb_options_t* opt, int n) { +void rocksdb_options_set_level0_slowdown_writes_trigger( + rocksdb_options_t* opt, int n) { opt->rep.level0_slowdown_writes_trigger = n; } -void leveldb_options_set_level0_stop_writes_trigger( - leveldb_options_t* opt, int n) { +void rocksdb_options_set_level0_stop_writes_trigger( + rocksdb_options_t* opt, int n) { opt->rep.level0_stop_writes_trigger = n; } -void leveldb_options_set_max_mem_compaction_level( - leveldb_options_t* opt, int n) { +void rocksdb_options_set_max_mem_compaction_level( + rocksdb_options_t* opt, int n) { opt->rep.max_mem_compaction_level = n; } -void leveldb_options_set_compression(leveldb_options_t* opt, int t) { +void rocksdb_options_set_compression(rocksdb_options_t* opt, int t) { opt->rep.compression = static_cast(t); } -void leveldb_options_set_compression_per_level(leveldb_options_t* opt, +void rocksdb_options_set_compression_per_level(rocksdb_options_t* opt, int* level_values, size_t num_levels) { opt->rep.compression_per_level.resize(num_levels); @@ -523,43 +523,43 @@ void leveldb_options_set_compression_per_level(leveldb_options_t* opt, } } -void leveldb_options_set_compression_options( - leveldb_options_t* opt, int w_bits, int level, int strategy) { +void rocksdb_options_set_compression_options( + rocksdb_options_t* opt, int w_bits, int level, int strategy) { opt->rep.compression_opts.window_bits = w_bits; opt->rep.compression_opts.level = level; opt->rep.compression_opts.strategy = strategy; } -void leveldb_options_set_disable_data_sync( - leveldb_options_t* opt, bool disable_data_sync) { +void rocksdb_options_set_disable_data_sync( + rocksdb_options_t* opt, bool disable_data_sync) { opt->rep.disableDataSync = disable_data_sync; } -void leveldb_options_set_use_fsync( - leveldb_options_t* opt, bool use_fsync) { +void rocksdb_options_set_use_fsync( + rocksdb_options_t* opt, bool use_fsync) { opt->rep.use_fsync = use_fsync; } -void leveldb_options_set_db_stats_log_interval( - leveldb_options_t* opt, int db_stats_log_interval) { +void rocksdb_options_set_db_stats_log_interval( + rocksdb_options_t* opt, int db_stats_log_interval) { opt->rep.db_stats_log_interval = db_stats_log_interval; } -void leveldb_options_set_db_log_dir( - leveldb_options_t* opt, const char* db_log_dir) { +void rocksdb_options_set_db_log_dir( + rocksdb_options_t* opt, const char* db_log_dir) { opt->rep.db_log_dir = db_log_dir; } -void leveldb_options_set_WAL_ttl_seconds(leveldb_options_t* opt, uint64_t ttl) { +void rocksdb_options_set_WAL_ttl_seconds(rocksdb_options_t* opt, uint64_t ttl) { opt->rep.WAL_ttl_seconds = ttl; } -void leveldb_options_set_WAL_size_limit_MB( - leveldb_options_t* opt, uint64_t limit) { +void rocksdb_options_set_WAL_size_limit_MB( + rocksdb_options_t* opt, uint64_t limit) { opt->rep.WAL_size_limit_MB = limit; } -leveldb_comparator_t* leveldb_comparator_create( +rocksdb_comparator_t* rocksdb_comparator_create( void* state, void (*destructor)(void*), int (*compare)( @@ -567,7 +567,7 @@ leveldb_comparator_t* leveldb_comparator_create( const char* a, size_t alen, const char* b, size_t blen), const char* (*name)(void*)) { - leveldb_comparator_t* result = new leveldb_comparator_t; + rocksdb_comparator_t* result = new rocksdb_comparator_t; result->state_ = state; result->destructor_ = destructor; result->compare_ = compare; @@ -575,11 +575,11 @@ leveldb_comparator_t* leveldb_comparator_create( return result; } -void leveldb_comparator_destroy(leveldb_comparator_t* cmp) { +void rocksdb_comparator_destroy(rocksdb_comparator_t* cmp) { delete cmp; } -leveldb_filterpolicy_t* leveldb_filterpolicy_create( +rocksdb_filterpolicy_t* rocksdb_filterpolicy_create( void* state, void (*destructor)(void*), char* (*create_filter)( @@ -592,7 +592,7 @@ leveldb_filterpolicy_t* leveldb_filterpolicy_create( const char* key, size_t length, const char* filter, size_t filter_length), const char* (*name)(void*)) { - leveldb_filterpolicy_t* result = new leveldb_filterpolicy_t; + rocksdb_filterpolicy_t* result = new rocksdb_filterpolicy_t; result->state_ = state; result->destructor_ = destructor; result->create_ = create_filter; @@ -601,15 +601,15 @@ leveldb_filterpolicy_t* leveldb_filterpolicy_create( return result; } -void leveldb_filterpolicy_destroy(leveldb_filterpolicy_t* filter) { +void rocksdb_filterpolicy_destroy(rocksdb_filterpolicy_t* filter) { delete filter; } -leveldb_filterpolicy_t* leveldb_filterpolicy_create_bloom(int bits_per_key) { - // Make a leveldb_filterpolicy_t, but override all of its methods so +rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom(int bits_per_key) { + // Make a rocksdb_filterpolicy_t, but override all of its methods so // they delegate to a NewBloomFilterPolicy() instead of user // supplied C functions. - struct Wrapper : public leveldb_filterpolicy_t { + struct Wrapper : public rocksdb_filterpolicy_t { const FilterPolicy* rep_; ~Wrapper() { delete rep_; } const char* Name() const { return rep_->Name(); } @@ -628,62 +628,62 @@ leveldb_filterpolicy_t* leveldb_filterpolicy_create_bloom(int bits_per_key) { return wrapper; } -leveldb_readoptions_t* leveldb_readoptions_create() { - return new leveldb_readoptions_t; +rocksdb_readoptions_t* rocksdb_readoptions_create() { + return new rocksdb_readoptions_t; } -void leveldb_readoptions_destroy(leveldb_readoptions_t* opt) { +void rocksdb_readoptions_destroy(rocksdb_readoptions_t* opt) { delete opt; } -void leveldb_readoptions_set_verify_checksums( - leveldb_readoptions_t* opt, +void rocksdb_readoptions_set_verify_checksums( + rocksdb_readoptions_t* opt, unsigned char v) { opt->rep.verify_checksums = v; } -void leveldb_readoptions_set_fill_cache( - leveldb_readoptions_t* opt, unsigned char v) { +void rocksdb_readoptions_set_fill_cache( + rocksdb_readoptions_t* opt, unsigned char v) { opt->rep.fill_cache = v; } -void leveldb_readoptions_set_snapshot( - leveldb_readoptions_t* opt, - const leveldb_snapshot_t* snap) { +void rocksdb_readoptions_set_snapshot( + rocksdb_readoptions_t* opt, + const rocksdb_snapshot_t* snap) { opt->rep.snapshot = (snap ? snap->rep : NULL); } -leveldb_writeoptions_t* leveldb_writeoptions_create() { - return new leveldb_writeoptions_t; +rocksdb_writeoptions_t* rocksdb_writeoptions_create() { + return new rocksdb_writeoptions_t; } -void leveldb_writeoptions_destroy(leveldb_writeoptions_t* opt) { +void rocksdb_writeoptions_destroy(rocksdb_writeoptions_t* opt) { delete opt; } -void leveldb_writeoptions_set_sync( - leveldb_writeoptions_t* opt, unsigned char v) { +void rocksdb_writeoptions_set_sync( + rocksdb_writeoptions_t* opt, unsigned char v) { opt->rep.sync = v; } -leveldb_cache_t* leveldb_cache_create_lru(size_t capacity) { - leveldb_cache_t* c = new leveldb_cache_t; +rocksdb_cache_t* rocksdb_cache_create_lru(size_t capacity) { + rocksdb_cache_t* c = new rocksdb_cache_t; c->rep = NewLRUCache(capacity); return c; } -void leveldb_cache_destroy(leveldb_cache_t* cache) { +void rocksdb_cache_destroy(rocksdb_cache_t* cache) { delete cache; } -leveldb_env_t* leveldb_create_default_env() { - leveldb_env_t* result = new leveldb_env_t; +rocksdb_env_t* rocksdb_create_default_env() { + rocksdb_env_t* result = new rocksdb_env_t; result->rep = Env::Default(); result->is_default = true; return result; } -void leveldb_env_destroy(leveldb_env_t* env) { +void rocksdb_env_destroy(rocksdb_env_t* env) { if (!env->is_default) delete env->rep; delete env; } diff --git a/db/c_test.c b/db/c_test.c index abbe1ddd5..8c5e8e534 100644 --- a/db/c_test.c +++ b/db/c_test.c @@ -62,30 +62,30 @@ static void Free(char** ptr) { } static void CheckGet( - leveldb_t* db, - const leveldb_readoptions_t* options, + rocksdb_t* db, + const rocksdb_readoptions_t* options, const char* key, const char* expected) { char* err = NULL; size_t val_len; char* val; - val = leveldb_get(db, options, key, strlen(key), &val_len, &err); + val = rocksdb_get(db, options, key, strlen(key), &val_len, &err); CheckNoError(err); CheckEqual(expected, val, val_len); Free(&val); } -static void CheckIter(leveldb_iterator_t* iter, +static void CheckIter(rocksdb_iterator_t* iter, const char* key, const char* val) { size_t len; const char* str; - str = leveldb_iter_key(iter, &len); + str = rocksdb_iter_key(iter, &len); CheckEqual(key, str, len); - str = leveldb_iter_value(iter, &len); + str = rocksdb_iter_value(iter, &len); CheckEqual(val, str, len); } -// Callback from leveldb_writebatch_iterate() +// Callback from rocksdb_writebatch_iterate() static void CheckPut(void* ptr, const char* k, size_t klen, const char* v, size_t vlen) { @@ -104,7 +104,7 @@ static void CheckPut(void* ptr, (*state)++; } -// Callback from leveldb_writebatch_iterate() +// Callback from rocksdb_writebatch_iterate() static void CheckDel(void* ptr, const char* k, size_t klen) { int* state = (int*) ptr; CheckCondition(*state == 2); @@ -155,117 +155,117 @@ unsigned char FilterKeyMatch( } int main(int argc, char** argv) { - leveldb_t* db; - leveldb_comparator_t* cmp; - leveldb_cache_t* cache; - leveldb_env_t* env; - leveldb_options_t* options; - leveldb_readoptions_t* roptions; - leveldb_writeoptions_t* woptions; + rocksdb_t* db; + rocksdb_comparator_t* cmp; + rocksdb_cache_t* cache; + rocksdb_env_t* env; + rocksdb_options_t* options; + rocksdb_readoptions_t* roptions; + rocksdb_writeoptions_t* woptions; char* err = NULL; int run = -1; snprintf(dbname, sizeof(dbname), - "%s/leveldb_c_test-%d", + "%s/rocksdb_c_test-%d", GetTempDir(), ((int) geteuid())); StartPhase("create_objects"); - cmp = leveldb_comparator_create(NULL, CmpDestroy, CmpCompare, CmpName); - env = leveldb_create_default_env(); - cache = leveldb_cache_create_lru(100000); + cmp = rocksdb_comparator_create(NULL, CmpDestroy, CmpCompare, CmpName); + env = rocksdb_create_default_env(); + cache = rocksdb_cache_create_lru(100000); - options = leveldb_options_create(); - leveldb_options_set_comparator(options, cmp); - leveldb_options_set_error_if_exists(options, 1); - leveldb_options_set_cache(options, cache); - leveldb_options_set_env(options, env); - leveldb_options_set_info_log(options, NULL); - leveldb_options_set_write_buffer_size(options, 100000); - leveldb_options_set_paranoid_checks(options, 1); - leveldb_options_set_max_open_files(options, 10); - leveldb_options_set_block_size(options, 1024); - leveldb_options_set_block_restart_interval(options, 8); - leveldb_options_set_compression(options, leveldb_no_compression); - leveldb_options_set_compression_options(options, -14, -1, 0); - int compression_levels[] = {leveldb_no_compression, leveldb_no_compression, - leveldb_no_compression, leveldb_no_compression}; - leveldb_options_set_compression_per_level(options, compression_levels, 4); + options = rocksdb_options_create(); + rocksdb_options_set_comparator(options, cmp); + rocksdb_options_set_error_if_exists(options, 1); + rocksdb_options_set_cache(options, cache); + rocksdb_options_set_env(options, env); + rocksdb_options_set_info_log(options, NULL); + rocksdb_options_set_write_buffer_size(options, 100000); + rocksdb_options_set_paranoid_checks(options, 1); + rocksdb_options_set_max_open_files(options, 10); + rocksdb_options_set_block_size(options, 1024); + rocksdb_options_set_block_restart_interval(options, 8); + rocksdb_options_set_compression(options, rocksdb_no_compression); + rocksdb_options_set_compression_options(options, -14, -1, 0); + int compression_levels[] = {rocksdb_no_compression, rocksdb_no_compression, + rocksdb_no_compression, rocksdb_no_compression}; + rocksdb_options_set_compression_per_level(options, compression_levels, 4); - roptions = leveldb_readoptions_create(); - leveldb_readoptions_set_verify_checksums(roptions, 1); - leveldb_readoptions_set_fill_cache(roptions, 0); + roptions = rocksdb_readoptions_create(); + rocksdb_readoptions_set_verify_checksums(roptions, 1); + rocksdb_readoptions_set_fill_cache(roptions, 0); - woptions = leveldb_writeoptions_create(); - leveldb_writeoptions_set_sync(woptions, 1); + woptions = rocksdb_writeoptions_create(); + rocksdb_writeoptions_set_sync(woptions, 1); StartPhase("destroy"); - leveldb_destroy_db(options, dbname, &err); + rocksdb_destroy_db(options, dbname, &err); Free(&err); StartPhase("open_error"); - db = leveldb_open(options, dbname, &err); + db = rocksdb_open(options, dbname, &err); CheckCondition(err != NULL); Free(&err); StartPhase("open"); - leveldb_options_set_create_if_missing(options, 1); - db = leveldb_open(options, dbname, &err); + rocksdb_options_set_create_if_missing(options, 1); + db = rocksdb_open(options, dbname, &err); CheckNoError(err); CheckGet(db, roptions, "foo", NULL); StartPhase("put"); - leveldb_put(db, woptions, "foo", 3, "hello", 5, &err); + rocksdb_put(db, woptions, "foo", 3, "hello", 5, &err); CheckNoError(err); CheckGet(db, roptions, "foo", "hello"); StartPhase("compactall"); - leveldb_compact_range(db, NULL, 0, NULL, 0); + rocksdb_compact_range(db, NULL, 0, NULL, 0); CheckGet(db, roptions, "foo", "hello"); StartPhase("compactrange"); - leveldb_compact_range(db, "a", 1, "z", 1); + rocksdb_compact_range(db, "a", 1, "z", 1); CheckGet(db, roptions, "foo", "hello"); StartPhase("writebatch"); { - leveldb_writebatch_t* wb = leveldb_writebatch_create(); - leveldb_writebatch_put(wb, "foo", 3, "a", 1); - leveldb_writebatch_clear(wb); - leveldb_writebatch_put(wb, "bar", 3, "b", 1); - leveldb_writebatch_put(wb, "box", 3, "c", 1); - leveldb_writebatch_delete(wb, "bar", 3); - leveldb_write(db, woptions, wb, &err); + rocksdb_writebatch_t* wb = rocksdb_writebatch_create(); + rocksdb_writebatch_put(wb, "foo", 3, "a", 1); + rocksdb_writebatch_clear(wb); + rocksdb_writebatch_put(wb, "bar", 3, "b", 1); + rocksdb_writebatch_put(wb, "box", 3, "c", 1); + rocksdb_writebatch_delete(wb, "bar", 3); + rocksdb_write(db, woptions, wb, &err); CheckNoError(err); CheckGet(db, roptions, "foo", "hello"); CheckGet(db, roptions, "bar", NULL); CheckGet(db, roptions, "box", "c"); int pos = 0; - leveldb_writebatch_iterate(wb, &pos, CheckPut, CheckDel); + rocksdb_writebatch_iterate(wb, &pos, CheckPut, CheckDel); CheckCondition(pos == 3); - leveldb_writebatch_destroy(wb); + rocksdb_writebatch_destroy(wb); } StartPhase("iter"); { - leveldb_iterator_t* iter = leveldb_create_iterator(db, roptions); - CheckCondition(!leveldb_iter_valid(iter)); - leveldb_iter_seek_to_first(iter); - CheckCondition(leveldb_iter_valid(iter)); + rocksdb_iterator_t* iter = rocksdb_create_iterator(db, roptions); + CheckCondition(!rocksdb_iter_valid(iter)); + rocksdb_iter_seek_to_first(iter); + CheckCondition(rocksdb_iter_valid(iter)); CheckIter(iter, "box", "c"); - leveldb_iter_next(iter); + rocksdb_iter_next(iter); CheckIter(iter, "foo", "hello"); - leveldb_iter_prev(iter); + rocksdb_iter_prev(iter); CheckIter(iter, "box", "c"); - leveldb_iter_prev(iter); - CheckCondition(!leveldb_iter_valid(iter)); - leveldb_iter_seek_to_last(iter); + rocksdb_iter_prev(iter); + CheckCondition(!rocksdb_iter_valid(iter)); + rocksdb_iter_seek_to_last(iter); CheckIter(iter, "foo", "hello"); - leveldb_iter_seek(iter, "b", 1); + rocksdb_iter_seek(iter, "b", 1); CheckIter(iter, "box", "c"); - leveldb_iter_get_error(iter, &err); + rocksdb_iter_get_error(iter, &err); CheckNoError(err); - leveldb_iter_destroy(iter); + rocksdb_iter_destroy(iter); } StartPhase("approximate_sizes"); @@ -279,39 +279,39 @@ int main(int argc, char** argv) { size_t start_len[2] = { 1, 21 }; const char* limit[2] = { "k00000000000000010000", "z" }; size_t limit_len[2] = { 21, 1 }; - leveldb_writeoptions_set_sync(woptions, 0); + rocksdb_writeoptions_set_sync(woptions, 0); for (i = 0; i < n; i++) { snprintf(keybuf, sizeof(keybuf), "k%020d", i); snprintf(valbuf, sizeof(valbuf), "v%020d", i); - leveldb_put(db, woptions, keybuf, strlen(keybuf), valbuf, strlen(valbuf), + rocksdb_put(db, woptions, keybuf, strlen(keybuf), valbuf, strlen(valbuf), &err); CheckNoError(err); } - leveldb_approximate_sizes(db, 2, start, start_len, limit, limit_len, sizes); + rocksdb_approximate_sizes(db, 2, start, start_len, limit, limit_len, sizes); CheckCondition(sizes[0] > 0); CheckCondition(sizes[1] > 0); } StartPhase("property"); { - char* prop = leveldb_property_value(db, "nosuchprop"); + char* prop = rocksdb_property_value(db, "nosuchprop"); CheckCondition(prop == NULL); - prop = leveldb_property_value(db, "rocksdb.stats"); + prop = rocksdb_property_value(db, "rocksdb.stats"); CheckCondition(prop != NULL); Free(&prop); } StartPhase("snapshot"); { - const leveldb_snapshot_t* snap; - snap = leveldb_create_snapshot(db); - leveldb_delete(db, woptions, "foo", 3, &err); + const rocksdb_snapshot_t* snap; + snap = rocksdb_create_snapshot(db); + rocksdb_delete(db, woptions, "foo", 3, &err); CheckNoError(err); - leveldb_readoptions_set_snapshot(roptions, snap); + rocksdb_readoptions_set_snapshot(roptions, snap); CheckGet(db, roptions, "foo", "hello"); - leveldb_readoptions_set_snapshot(roptions, NULL); + rocksdb_readoptions_set_snapshot(roptions, NULL); CheckGet(db, roptions, "foo", NULL); - leveldb_release_snapshot(db, snap); + rocksdb_release_snapshot(db, snap); } StartPhase("repair"); @@ -320,44 +320,44 @@ int main(int argc, char** argv) { // files (https://reviews.facebook.net/D6123) would leave // around deleted files and the repair process will find // those files and put them back into the database. - leveldb_compact_range(db, NULL, 0, NULL, 0); - leveldb_close(db); - leveldb_options_set_create_if_missing(options, 0); - leveldb_options_set_error_if_exists(options, 0); - leveldb_repair_db(options, dbname, &err); + rocksdb_compact_range(db, NULL, 0, NULL, 0); + rocksdb_close(db); + rocksdb_options_set_create_if_missing(options, 0); + rocksdb_options_set_error_if_exists(options, 0); + rocksdb_repair_db(options, dbname, &err); CheckNoError(err); - db = leveldb_open(options, dbname, &err); + db = rocksdb_open(options, dbname, &err); CheckNoError(err); CheckGet(db, roptions, "foo", NULL); CheckGet(db, roptions, "bar", NULL); CheckGet(db, roptions, "box", "c"); - leveldb_options_set_create_if_missing(options, 1); - leveldb_options_set_error_if_exists(options, 1); + rocksdb_options_set_create_if_missing(options, 1); + rocksdb_options_set_error_if_exists(options, 1); } StartPhase("filter"); for (run = 0; run < 2; run++) { // First run uses custom filter, second run uses bloom filter CheckNoError(err); - leveldb_filterpolicy_t* policy; + rocksdb_filterpolicy_t* policy; if (run == 0) { - policy = leveldb_filterpolicy_create( + policy = rocksdb_filterpolicy_create( NULL, FilterDestroy, FilterCreate, FilterKeyMatch, FilterName); } else { - policy = leveldb_filterpolicy_create_bloom(10); + policy = rocksdb_filterpolicy_create_bloom(10); } // Create new database - leveldb_close(db); - leveldb_destroy_db(options, dbname, &err); - leveldb_options_set_filter_policy(options, policy); - db = leveldb_open(options, dbname, &err); + rocksdb_close(db); + rocksdb_destroy_db(options, dbname, &err); + rocksdb_options_set_filter_policy(options, policy); + db = rocksdb_open(options, dbname, &err); CheckNoError(err); - leveldb_put(db, woptions, "foo", 3, "foovalue", 8, &err); + rocksdb_put(db, woptions, "foo", 3, "foovalue", 8, &err); CheckNoError(err); - leveldb_put(db, woptions, "bar", 3, "barvalue", 8, &err); + rocksdb_put(db, woptions, "bar", 3, "barvalue", 8, &err); CheckNoError(err); - leveldb_compact_range(db, NULL, 0, NULL, 0); + rocksdb_compact_range(db, NULL, 0, NULL, 0); fake_filter_result = 1; CheckGet(db, roptions, "foo", "foovalue"); @@ -372,18 +372,18 @@ int main(int argc, char** argv) { CheckGet(db, roptions, "foo", "foovalue"); CheckGet(db, roptions, "bar", "barvalue"); } - leveldb_options_set_filter_policy(options, NULL); - leveldb_filterpolicy_destroy(policy); + rocksdb_options_set_filter_policy(options, NULL); + rocksdb_filterpolicy_destroy(policy); } StartPhase("cleanup"); - leveldb_close(db); - leveldb_options_destroy(options); - leveldb_readoptions_destroy(roptions); - leveldb_writeoptions_destroy(woptions); - leveldb_cache_destroy(cache); - leveldb_comparator_destroy(cmp); - leveldb_env_destroy(env); + rocksdb_close(db); + rocksdb_options_destroy(options); + rocksdb_readoptions_destroy(roptions); + rocksdb_writeoptions_destroy(woptions); + rocksdb_cache_destroy(cache); + rocksdb_comparator_destroy(cmp); + rocksdb_env_destroy(env); fprintf(stderr, "PASS\n"); return 0; diff --git a/include/rocksdb/c.h b/include/rocksdb/c.h index 787bcf431..e093e9448 100644 --- a/include/rocksdb/c.h +++ b/include/rocksdb/c.h @@ -54,171 +54,171 @@ extern "C" { /* Exported types */ -typedef struct leveldb_t leveldb_t; -typedef struct leveldb_cache_t leveldb_cache_t; -typedef struct leveldb_comparator_t leveldb_comparator_t; -typedef struct leveldb_env_t leveldb_env_t; -typedef struct leveldb_filelock_t leveldb_filelock_t; -typedef struct leveldb_filterpolicy_t leveldb_filterpolicy_t; -typedef struct leveldb_iterator_t leveldb_iterator_t; -typedef struct leveldb_logger_t leveldb_logger_t; -typedef struct leveldb_options_t leveldb_options_t; -typedef struct leveldb_randomfile_t leveldb_randomfile_t; -typedef struct leveldb_readoptions_t leveldb_readoptions_t; -typedef struct leveldb_seqfile_t leveldb_seqfile_t; -typedef struct leveldb_snapshot_t leveldb_snapshot_t; -typedef struct leveldb_writablefile_t leveldb_writablefile_t; -typedef struct leveldb_writebatch_t leveldb_writebatch_t; -typedef struct leveldb_writeoptions_t leveldb_writeoptions_t; +typedef struct rocksdb_t rocksdb_t; +typedef struct rocksdb_cache_t rocksdb_cache_t; +typedef struct rocksdb_comparator_t rocksdb_comparator_t; +typedef struct rocksdb_env_t rocksdb_env_t; +typedef struct rocksdb_filelock_t rocksdb_filelock_t; +typedef struct rocksdb_filterpolicy_t rocksdb_filterpolicy_t; +typedef struct rocksdb_iterator_t rocksdb_iterator_t; +typedef struct rocksdb_logger_t rocksdb_logger_t; +typedef struct rocksdb_options_t rocksdb_options_t; +typedef struct rocksdb_randomfile_t rocksdb_randomfile_t; +typedef struct rocksdb_readoptions_t rocksdb_readoptions_t; +typedef struct rocksdb_seqfile_t rocksdb_seqfile_t; +typedef struct rocksdb_snapshot_t rocksdb_snapshot_t; +typedef struct rocksdb_writablefile_t rocksdb_writablefile_t; +typedef struct rocksdb_writebatch_t rocksdb_writebatch_t; +typedef struct rocksdb_writeoptions_t rocksdb_writeoptions_t; /* DB operations */ -extern leveldb_t* leveldb_open( - const leveldb_options_t* options, +extern rocksdb_t* rocksdb_open( + const rocksdb_options_t* options, const char* name, char** errptr); -extern void leveldb_close(leveldb_t* db); +extern void rocksdb_close(rocksdb_t* db); -extern void leveldb_put( - leveldb_t* db, - const leveldb_writeoptions_t* options, +extern void rocksdb_put( + rocksdb_t* db, + const rocksdb_writeoptions_t* options, const char* key, size_t keylen, const char* val, size_t vallen, char** errptr); -extern void leveldb_delete( - leveldb_t* db, - const leveldb_writeoptions_t* options, +extern void rocksdb_delete( + rocksdb_t* db, + const rocksdb_writeoptions_t* options, const char* key, size_t keylen, char** errptr); -extern void leveldb_write( - leveldb_t* db, - const leveldb_writeoptions_t* options, - leveldb_writebatch_t* batch, +extern void rocksdb_write( + rocksdb_t* db, + const rocksdb_writeoptions_t* options, + rocksdb_writebatch_t* batch, char** errptr); /* Returns NULL if not found. A malloc()ed array otherwise. Stores the length of the array in *vallen. */ -extern char* leveldb_get( - leveldb_t* db, - const leveldb_readoptions_t* options, +extern char* rocksdb_get( + rocksdb_t* db, + const rocksdb_readoptions_t* options, const char* key, size_t keylen, size_t* vallen, char** errptr); -extern leveldb_iterator_t* leveldb_create_iterator( - leveldb_t* db, - const leveldb_readoptions_t* options); +extern rocksdb_iterator_t* rocksdb_create_iterator( + rocksdb_t* db, + const rocksdb_readoptions_t* options); -extern const leveldb_snapshot_t* leveldb_create_snapshot( - leveldb_t* db); +extern const rocksdb_snapshot_t* rocksdb_create_snapshot( + rocksdb_t* db); -extern void leveldb_release_snapshot( - leveldb_t* db, - const leveldb_snapshot_t* snapshot); +extern void rocksdb_release_snapshot( + rocksdb_t* db, + const rocksdb_snapshot_t* snapshot); /* Returns NULL if property name is unknown. Else returns a pointer to a malloc()-ed null-terminated value. */ -extern char* leveldb_property_value( - leveldb_t* db, +extern char* rocksdb_property_value( + rocksdb_t* db, const char* propname); -extern void leveldb_approximate_sizes( - leveldb_t* db, +extern void rocksdb_approximate_sizes( + rocksdb_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 void leveldb_compact_range( - leveldb_t* db, +extern void rocksdb_compact_range( + rocksdb_t* db, const char* start_key, size_t start_key_len, const char* limit_key, size_t limit_key_len); /* Management operations */ -extern void leveldb_destroy_db( - const leveldb_options_t* options, +extern void rocksdb_destroy_db( + const rocksdb_options_t* options, const char* name, char** errptr); -extern void leveldb_repair_db( - const leveldb_options_t* options, +extern void rocksdb_repair_db( + const rocksdb_options_t* options, const char* name, char** errptr); /* Iterator */ -extern void leveldb_iter_destroy(leveldb_iterator_t*); -extern unsigned char leveldb_iter_valid(const leveldb_iterator_t*); -extern void leveldb_iter_seek_to_first(leveldb_iterator_t*); -extern void leveldb_iter_seek_to_last(leveldb_iterator_t*); -extern void leveldb_iter_seek(leveldb_iterator_t*, const char* k, size_t klen); -extern void leveldb_iter_next(leveldb_iterator_t*); -extern void leveldb_iter_prev(leveldb_iterator_t*); -extern const char* leveldb_iter_key(const leveldb_iterator_t*, size_t* klen); -extern const char* leveldb_iter_value(const leveldb_iterator_t*, size_t* vlen); -extern void leveldb_iter_get_error(const leveldb_iterator_t*, char** errptr); +extern void rocksdb_iter_destroy(rocksdb_iterator_t*); +extern unsigned char rocksdb_iter_valid(const rocksdb_iterator_t*); +extern void rocksdb_iter_seek_to_first(rocksdb_iterator_t*); +extern void rocksdb_iter_seek_to_last(rocksdb_iterator_t*); +extern void rocksdb_iter_seek(rocksdb_iterator_t*, const char* k, size_t klen); +extern void rocksdb_iter_next(rocksdb_iterator_t*); +extern void rocksdb_iter_prev(rocksdb_iterator_t*); +extern const char* rocksdb_iter_key(const rocksdb_iterator_t*, size_t* klen); +extern const char* rocksdb_iter_value(const rocksdb_iterator_t*, size_t* vlen); +extern void rocksdb_iter_get_error(const rocksdb_iterator_t*, char** errptr); /* Write batch */ -extern leveldb_writebatch_t* leveldb_writebatch_create(); -extern void leveldb_writebatch_destroy(leveldb_writebatch_t*); -extern void leveldb_writebatch_clear(leveldb_writebatch_t*); -extern void leveldb_writebatch_put( - leveldb_writebatch_t*, +extern rocksdb_writebatch_t* rocksdb_writebatch_create(); +extern void rocksdb_writebatch_destroy(rocksdb_writebatch_t*); +extern void rocksdb_writebatch_clear(rocksdb_writebatch_t*); +extern void rocksdb_writebatch_put( + rocksdb_writebatch_t*, const char* key, size_t klen, const char* val, size_t vlen); -extern void leveldb_writebatch_delete( - leveldb_writebatch_t*, +extern void rocksdb_writebatch_delete( + rocksdb_writebatch_t*, const char* key, size_t klen); -extern void leveldb_writebatch_iterate( - leveldb_writebatch_t*, +extern void rocksdb_writebatch_iterate( + rocksdb_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)); /* Options */ -extern leveldb_options_t* leveldb_options_create(); -extern void leveldb_options_destroy(leveldb_options_t*); -extern void leveldb_options_set_comparator( - leveldb_options_t*, - leveldb_comparator_t*); -extern void leveldb_options_set_compression_per_level( - leveldb_options_t* opt, +extern rocksdb_options_t* rocksdb_options_create(); +extern void rocksdb_options_destroy(rocksdb_options_t*); +extern void rocksdb_options_set_comparator( + rocksdb_options_t*, + rocksdb_comparator_t*); +extern void rocksdb_options_set_compression_per_level( + rocksdb_options_t* opt, int* level_values, size_t num_levels); -extern void leveldb_options_set_filter_policy( - leveldb_options_t*, - leveldb_filterpolicy_t*); -extern void leveldb_options_set_create_if_missing( - leveldb_options_t*, unsigned char); -extern void leveldb_options_set_error_if_exists( - leveldb_options_t*, unsigned char); -extern void leveldb_options_set_paranoid_checks( - leveldb_options_t*, unsigned char); -extern void leveldb_options_set_env(leveldb_options_t*, leveldb_env_t*); -extern void leveldb_options_set_info_log(leveldb_options_t*, leveldb_logger_t*); -extern void leveldb_options_set_write_buffer_size(leveldb_options_t*, size_t); -extern void leveldb_options_set_max_open_files(leveldb_options_t*, int); -extern void leveldb_options_set_cache(leveldb_options_t*, leveldb_cache_t*); -extern void leveldb_options_set_block_size(leveldb_options_t*, size_t); -extern void leveldb_options_set_block_restart_interval(leveldb_options_t*, int); -extern void leveldb_options_set_compression_options( - leveldb_options_t* opt, int w_bits, int level, int strategy); +extern void rocksdb_options_set_filter_policy( + rocksdb_options_t*, + rocksdb_filterpolicy_t*); +extern void rocksdb_options_set_create_if_missing( + rocksdb_options_t*, unsigned char); +extern void rocksdb_options_set_error_if_exists( + rocksdb_options_t*, unsigned char); +extern void rocksdb_options_set_paranoid_checks( + rocksdb_options_t*, unsigned char); +extern void rocksdb_options_set_env(rocksdb_options_t*, rocksdb_env_t*); +extern void rocksdb_options_set_info_log(rocksdb_options_t*, rocksdb_logger_t*); +extern void rocksdb_options_set_write_buffer_size(rocksdb_options_t*, size_t); +extern void rocksdb_options_set_max_open_files(rocksdb_options_t*, int); +extern void rocksdb_options_set_cache(rocksdb_options_t*, rocksdb_cache_t*); +extern void rocksdb_options_set_block_size(rocksdb_options_t*, size_t); +extern void rocksdb_options_set_block_restart_interval(rocksdb_options_t*, int); +extern void rocksdb_options_set_compression_options( + rocksdb_options_t* opt, int w_bits, int level, int strategy); enum { - leveldb_no_compression = 0, - leveldb_snappy_compression = 1 + rocksdb_no_compression = 0, + rocksdb_snappy_compression = 1 }; -extern void leveldb_options_set_compression(leveldb_options_t*, int); +extern void rocksdb_options_set_compression(rocksdb_options_t*, int); /* Comparator */ -extern leveldb_comparator_t* leveldb_comparator_create( +extern rocksdb_comparator_t* rocksdb_comparator_create( void* state, void (*destructor)(void*), int (*compare)( @@ -226,11 +226,11 @@ extern leveldb_comparator_t* leveldb_comparator_create( const char* a, size_t alen, const char* b, size_t blen), const char* (*name)(void*)); -extern void leveldb_comparator_destroy(leveldb_comparator_t*); +extern void rocksdb_comparator_destroy(rocksdb_comparator_t*); /* Filter policy */ -extern leveldb_filterpolicy_t* leveldb_filterpolicy_create( +extern rocksdb_filterpolicy_t* rocksdb_filterpolicy_create( void* state, void (*destructor)(void*), char* (*create_filter)( @@ -243,40 +243,40 @@ extern leveldb_filterpolicy_t* leveldb_filterpolicy_create( const char* key, size_t length, const char* filter, size_t filter_length), const char* (*name)(void*)); -extern void leveldb_filterpolicy_destroy(leveldb_filterpolicy_t*); +extern void rocksdb_filterpolicy_destroy(rocksdb_filterpolicy_t*); -extern leveldb_filterpolicy_t* leveldb_filterpolicy_create_bloom( +extern rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom( int bits_per_key); /* Read options */ -extern leveldb_readoptions_t* leveldb_readoptions_create(); -extern void leveldb_readoptions_destroy(leveldb_readoptions_t*); -extern void leveldb_readoptions_set_verify_checksums( - leveldb_readoptions_t*, +extern rocksdb_readoptions_t* rocksdb_readoptions_create(); +extern void rocksdb_readoptions_destroy(rocksdb_readoptions_t*); +extern void rocksdb_readoptions_set_verify_checksums( + rocksdb_readoptions_t*, unsigned char); -extern void leveldb_readoptions_set_fill_cache( - leveldb_readoptions_t*, unsigned char); -extern void leveldb_readoptions_set_snapshot( - leveldb_readoptions_t*, - const leveldb_snapshot_t*); +extern void rocksdb_readoptions_set_fill_cache( + rocksdb_readoptions_t*, unsigned char); +extern void rocksdb_readoptions_set_snapshot( + rocksdb_readoptions_t*, + const rocksdb_snapshot_t*); /* Write options */ -extern leveldb_writeoptions_t* leveldb_writeoptions_create(); -extern void leveldb_writeoptions_destroy(leveldb_writeoptions_t*); -extern void leveldb_writeoptions_set_sync( - leveldb_writeoptions_t*, unsigned char); +extern rocksdb_writeoptions_t* rocksdb_writeoptions_create(); +extern void rocksdb_writeoptions_destroy(rocksdb_writeoptions_t*); +extern void rocksdb_writeoptions_set_sync( + rocksdb_writeoptions_t*, unsigned char); /* Cache */ -extern leveldb_cache_t* leveldb_cache_create_lru(size_t capacity); -extern void leveldb_cache_destroy(leveldb_cache_t* cache); +extern rocksdb_cache_t* rocksdb_cache_create_lru(size_t capacity); +extern void rocksdb_cache_destroy(rocksdb_cache_t* cache); /* Env */ -extern leveldb_env_t* leveldb_create_default_env(); -extern void leveldb_env_destroy(leveldb_env_t*); +extern rocksdb_env_t* rocksdb_create_default_env(); +extern void rocksdb_env_destroy(rocksdb_env_t*); #ifdef __cplusplus } /* end extern "C" */