NextGraph
/
rocksdb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #31 from sepeth/c-api

Browse Source 
Rename leveldb to rocksdb in C api
main
Igor Canadi 11 years ago
parent 784e62f98d 6c4e110c8c
commit a204dabb9d
3 changed files with 392 additions and 392 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 328
      db/c.cc
  2. 218
      db/c_test.c
  3. 238
      include/rocksdb/c.h

328
db/c.cc
Unescape View File

@ -48,21 +48,21 @@ using std::shared_ptr;
extern "C" { extern "C" {
struct leveldb_t { DB* rep; }; struct rocksdb_t { DB* rep; };
struct leveldb_iterator_t { Iterator* rep; }; struct rocksdb_iterator_t { Iterator* rep; };
struct leveldb_writebatch_t { WriteBatch rep; }; struct rocksdb_writebatch_t { WriteBatch rep; };
struct leveldb_snapshot_t { const Snapshot* rep; }; struct rocksdb_snapshot_t { const Snapshot* rep; };
struct leveldb_readoptions_t { ReadOptions rep; }; struct rocksdb_readoptions_t { ReadOptions rep; };
struct leveldb_writeoptions_t { WriteOptions rep; }; struct rocksdb_writeoptions_t { WriteOptions rep; };
struct leveldb_options_t { Options rep; }; struct rocksdb_options_t { Options rep; };
struct leveldb_seqfile_t { SequentialFile* rep; }; struct rocksdb_seqfile_t { SequentialFile* rep; };
struct leveldb_randomfile_t { RandomAccessFile* rep; }; struct rocksdb_randomfile_t { RandomAccessFile* rep; };
struct leveldb_writablefile_t { WritableFile* rep; }; struct rocksdb_writablefile_t { WritableFile* rep; };
struct leveldb_filelock_t { FileLock* rep; }; struct rocksdb_filelock_t { FileLock* rep; };
struct leveldb_logger_t { shared_ptr<Logger> rep; }; struct rocksdb_logger_t { shared_ptr<Logger> rep; };
struct leveldb_cache_t { shared_ptr<Cache> rep; }; struct rocksdb_cache_t { shared_ptr<Cache> rep; };
struct leveldb_comparator_t : public Comparator { struct rocksdb_comparator_t : public Comparator {
void* state_; void* state_;
void (*destructor_)(void*); void (*destructor_)(void*);
int (*compare_)( int (*compare_)(
@ -71,7 +71,7 @@ struct leveldb_comparator_t : public Comparator {
const char* b, size_t blen); const char* b, size_t blen);
const char* (*name_)(void*); const char* (*name_)(void*);
virtual ~leveldb_comparator_t() { virtual ~rocksdb_comparator_t() {
(*destructor_)(state_); (*destructor_)(state_);
} }
@ -88,7 +88,7 @@ struct leveldb_comparator_t : public Comparator {
virtual void FindShortSuccessor(std::string* key) const { } virtual void FindShortSuccessor(std::string* key) const { }
}; };
struct leveldb_filterpolicy_t : public FilterPolicy { struct rocksdb_filterpolicy_t : public FilterPolicy {
void* state_; void* state_;
void (*destructor_)(void*); void (*destructor_)(void*);
const char* (*name_)(void*); const char* (*name_)(void*);
@ -102,7 +102,7 @@ struct leveldb_filterpolicy_t : public FilterPolicy {
const char* key, size_t length, const char* key, size_t length,
const char* filter, size_t filter_length); const char* filter, size_t filter_length);
virtual ~leveldb_filterpolicy_t() { virtual ~rocksdb_filterpolicy_t() {
(*destructor_)(state_); (*destructor_)(state_);
} }
@ -129,7 +129,7 @@ struct leveldb_filterpolicy_t : public FilterPolicy {
} }
}; };
struct leveldb_env_t { struct rocksdb_env_t {
Env* rep; Env* rep;
bool is_default; bool is_default;
}; };
@ -154,27 +154,27 @@ static char* CopyString(const std::string& str) {
return result; return result;
} }
leveldb_t* leveldb_open( rocksdb_t* rocksdb_open(
const leveldb_options_t* options, const rocksdb_options_t* options,
const char* name, const char* name,
char** errptr) { char** errptr) {
DB* db; DB* db;
if (SaveError(errptr, DB::Open(options->rep, std::string(name), &db))) { if (SaveError(errptr, DB::Open(options->rep, std::string(name), &db))) {
return NULL; return NULL;
} }
leveldb_t* result = new leveldb_t; rocksdb_t* result = new rocksdb_t;
result->rep = db; result->rep = db;
return result; return result;
} }
void leveldb_close(leveldb_t* db) { void rocksdb_close(rocksdb_t* db) {
delete db->rep; delete db->rep;
delete db; delete db;
} }
void leveldb_put( void rocksdb_put(
leveldb_t* db, rocksdb_t* db,
const leveldb_writeoptions_t* options, const rocksdb_writeoptions_t* options,
const char* key, size_t keylen, const char* key, size_t keylen,
const char* val, size_t vallen, const char* val, size_t vallen,
char** errptr) { char** errptr) {
@ -182,26 +182,26 @@ void leveldb_put(
db->rep->Put(options->rep, Slice(key, keylen), Slice(val, vallen))); db->rep->Put(options->rep, Slice(key, keylen), Slice(val, vallen)));
} }
void leveldb_delete( void rocksdb_delete(
leveldb_t* db, rocksdb_t* db,
const leveldb_writeoptions_t* options, const rocksdb_writeoptions_t* options,
const char* key, size_t keylen, const char* key, size_t keylen,
char** errptr) { char** errptr) {
SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen))); SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen)));
} }
void leveldb_write( void rocksdb_write(
leveldb_t* db, rocksdb_t* db,
const leveldb_writeoptions_t* options, const rocksdb_writeoptions_t* options,
leveldb_writebatch_t* batch, rocksdb_writebatch_t* batch,
char** errptr) { char** errptr) {
SaveError(errptr, db->rep->Write(options->rep, &batch->rep)); SaveError(errptr, db->rep->Write(options->rep, &batch->rep));
} }
char* leveldb_get( char* rocksdb_get(
leveldb_t* db, rocksdb_t* db,
const leveldb_readoptions_t* options, const rocksdb_readoptions_t* options,
const char* key, size_t keylen, const char* key, size_t keylen,
size_t* vallen, size_t* vallen,
char** errptr) { char** errptr) {
@ -220,30 +220,30 @@ char* leveldb_get(
return result; return result;
} }
leveldb_iterator_t* leveldb_create_iterator( rocksdb_iterator_t* rocksdb_create_iterator(
leveldb_t* db, rocksdb_t* db,
const leveldb_readoptions_t* options) { const rocksdb_readoptions_t* options) {
leveldb_iterator_t* result = new leveldb_iterator_t; rocksdb_iterator_t* result = new rocksdb_iterator_t;
result->rep = db->rep->NewIterator(options->rep); result->rep = db->rep->NewIterator(options->rep);
return result; return result;
} }
const leveldb_snapshot_t* leveldb_create_snapshot( const rocksdb_snapshot_t* rocksdb_create_snapshot(
leveldb_t* db) { rocksdb_t* db) {
leveldb_snapshot_t* result = new leveldb_snapshot_t; rocksdb_snapshot_t* result = new rocksdb_snapshot_t;
result->rep = db->rep->GetSnapshot(); result->rep = db->rep->GetSnapshot();
return result; return result;
} }
void leveldb_release_snapshot( void rocksdb_release_snapshot(
leveldb_t* db, rocksdb_t* db,
const leveldb_snapshot_t* snapshot) { const rocksdb_snapshot_t* snapshot) {
db->rep->ReleaseSnapshot(snapshot->rep); db->rep->ReleaseSnapshot(snapshot->rep);
delete snapshot; delete snapshot;
} }
char* leveldb_property_value( char* rocksdb_property_value(
leveldb_t* db, rocksdb_t* db,
const char* propname) { const char* propname) {
std::string tmp; std::string tmp;
if (db->rep->GetProperty(Slice(propname), &tmp)) { if (db->rep->GetProperty(Slice(propname), &tmp)) {
@ -254,8 +254,8 @@ char* leveldb_property_value(
} }
} }
void leveldb_approximate_sizes( void rocksdb_approximate_sizes(
leveldb_t* db, rocksdb_t* db,
int num_ranges, int num_ranges,
const char* const* range_start_key, const size_t* range_start_key_len, 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, const char* const* range_limit_key, const size_t* range_limit_key_len,
@ -269,8 +269,8 @@ void leveldb_approximate_sizes(
delete[] ranges; delete[] ranges;
} }
void leveldb_compact_range( void rocksdb_compact_range(
leveldb_t* db, rocksdb_t* db,
const char* start_key, size_t start_key_len, const char* start_key, size_t start_key_len,
const char* limit_key, size_t limit_key_len) { const char* limit_key, size_t limit_key_len) {
Slice a, b; Slice a, b;
@ -280,92 +280,92 @@ void leveldb_compact_range(
(limit_key ? (b = Slice(limit_key, limit_key_len), &b) : NULL)); (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : NULL));
} }
void leveldb_destroy_db( void rocksdb_destroy_db(
const leveldb_options_t* options, const rocksdb_options_t* options,
const char* name, const char* name,
char** errptr) { char** errptr) {
SaveError(errptr, DestroyDB(name, options->rep)); SaveError(errptr, DestroyDB(name, options->rep));
} }
void leveldb_repair_db( void rocksdb_repair_db(
const leveldb_options_t* options, const rocksdb_options_t* options,
const char* name, const char* name,
char** errptr) { char** errptr) {
SaveError(errptr, RepairDB(name, options->rep)); 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->rep;
delete iter; 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(); 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(); 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(); 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)); 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(); iter->rep->Next();
} }
void leveldb_iter_prev(leveldb_iterator_t* iter) { void rocksdb_iter_prev(rocksdb_iterator_t* iter) {
iter->rep->Prev(); 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(); Slice s = iter->rep->key();
*klen = s.size(); *klen = s.size();
return s.data(); 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(); Slice s = iter->rep->value();
*vlen = s.size(); *vlen = s.size();
return s.data(); 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()); SaveError(errptr, iter->rep->status());
} }
leveldb_writebatch_t* leveldb_writebatch_create() { rocksdb_writebatch_t* rocksdb_writebatch_create() {
return new leveldb_writebatch_t; return new rocksdb_writebatch_t;
} }
void leveldb_writebatch_destroy(leveldb_writebatch_t* b) { void rocksdb_writebatch_destroy(rocksdb_writebatch_t* b) {
delete b; delete b;
} }
void leveldb_writebatch_clear(leveldb_writebatch_t* b) { void rocksdb_writebatch_clear(rocksdb_writebatch_t* b) {
b->rep.Clear(); b->rep.Clear();
} }
void leveldb_writebatch_put( void rocksdb_writebatch_put(
leveldb_writebatch_t* b, rocksdb_writebatch_t* b,
const char* key, size_t klen, const char* key, size_t klen,
const char* val, size_t vlen) { const char* val, size_t vlen) {
b->rep.Put(Slice(key, klen), Slice(val, vlen)); b->rep.Put(Slice(key, klen), Slice(val, vlen));
} }
void leveldb_writebatch_delete( void rocksdb_writebatch_delete(
leveldb_writebatch_t* b, rocksdb_writebatch_t* b,
const char* key, size_t klen) { const char* key, size_t klen) {
b->rep.Delete(Slice(key, klen)); b->rep.Delete(Slice(key, klen));
} }
void leveldb_writebatch_iterate( void rocksdb_writebatch_iterate(
leveldb_writebatch_t* b, rocksdb_writebatch_t* b,
void* state, void* state,
void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen), void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen),
void (*deleted)(void*, const char* k, size_t klen)) { void (*deleted)(void*, const char* k, size_t klen)) {
@ -388,132 +388,132 @@ void leveldb_writebatch_iterate(
b->rep.Iterate(&handler); b->rep.Iterate(&handler);
} }
leveldb_options_t* leveldb_options_create() { rocksdb_options_t* rocksdb_options_create() {
return new leveldb_options_t; return new rocksdb_options_t;
} }
void leveldb_options_destroy(leveldb_options_t* options) { void rocksdb_options_destroy(rocksdb_options_t* options) {
delete options; delete options;
} }
void leveldb_options_set_comparator( void rocksdb_options_set_comparator(
leveldb_options_t* opt, rocksdb_options_t* opt,
leveldb_comparator_t* cmp) { rocksdb_comparator_t* cmp) {
opt->rep.comparator = cmp; opt->rep.comparator = cmp;
} }
void leveldb_options_set_filter_policy( void rocksdb_options_set_filter_policy(
leveldb_options_t* opt, rocksdb_options_t* opt,
leveldb_filterpolicy_t* policy) { rocksdb_filterpolicy_t* policy) {
opt->rep.filter_policy = policy; opt->rep.filter_policy = policy;
} }
void leveldb_options_set_create_if_missing( void rocksdb_options_set_create_if_missing(
leveldb_options_t* opt, unsigned char v) { rocksdb_options_t* opt, unsigned char v) {
opt->rep.create_if_missing = v; opt->rep.create_if_missing = v;
} }
void leveldb_options_set_error_if_exists( void rocksdb_options_set_error_if_exists(
leveldb_options_t* opt, unsigned char v) { rocksdb_options_t* opt, unsigned char v) {
opt->rep.error_if_exists = v; opt->rep.error_if_exists = v;
} }
void leveldb_options_set_paranoid_checks( void rocksdb_options_set_paranoid_checks(
leveldb_options_t* opt, unsigned char v) { rocksdb_options_t* opt, unsigned char v) {
opt->rep.paranoid_checks = 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); 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) { if (l) {
opt->rep.info_log = l->rep; 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; 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; 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) { if (c) {
opt->rep.block_cache = c->rep; 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; 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; opt->rep.block_restart_interval = n;
} }
void leveldb_options_set_target_file_size_base( void rocksdb_options_set_target_file_size_base(
leveldb_options_t* opt, uint64_t n) { rocksdb_options_t* opt, uint64_t n) {
opt->rep.target_file_size_base = n; opt->rep.target_file_size_base = n;
} }
void leveldb_options_set_target_file_size_multiplier( void rocksdb_options_set_target_file_size_multiplier(
leveldb_options_t* opt, int n) { rocksdb_options_t* opt, int n) {
opt->rep.target_file_size_multiplier = n; opt->rep.target_file_size_multiplier = n;
} }
void leveldb_options_set_max_bytes_for_level_base( void rocksdb_options_set_max_bytes_for_level_base(
leveldb_options_t* opt, uint64_t n) { rocksdb_options_t* opt, uint64_t n) {
opt->rep.max_bytes_for_level_base = n; opt->rep.max_bytes_for_level_base = n;
} }
void leveldb_options_set_max_bytes_for_level_multiplier( void rocksdb_options_set_max_bytes_for_level_multiplier(
leveldb_options_t* opt, int n) { rocksdb_options_t* opt, int n) {
opt->rep.max_bytes_for_level_multiplier = n; opt->rep.max_bytes_for_level_multiplier = n;
} }
void leveldb_options_set_expanded_compaction_factor( void rocksdb_options_set_expanded_compaction_factor(
leveldb_options_t* opt, int n) { rocksdb_options_t* opt, int n) {
opt->rep.expanded_compaction_factor = n; opt->rep.expanded_compaction_factor = n;
} }
void leveldb_options_set_max_grandparent_overlap_factor( void rocksdb_options_set_max_grandparent_overlap_factor(
leveldb_options_t* opt, int n) { rocksdb_options_t* opt, int n) {
opt->rep.max_grandparent_overlap_factor = 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; opt->rep.num_levels = n;
} }
void leveldb_options_set_level0_file_num_compaction_trigger( void rocksdb_options_set_level0_file_num_compaction_trigger(
leveldb_options_t* opt, int n) { rocksdb_options_t* opt, int n) {
opt->rep.level0_file_num_compaction_trigger = n; opt->rep.level0_file_num_compaction_trigger = n;
} }
void leveldb_options_set_level0_slowdown_writes_trigger( void rocksdb_options_set_level0_slowdown_writes_trigger(
leveldb_options_t* opt, int n) { rocksdb_options_t* opt, int n) {
opt->rep.level0_slowdown_writes_trigger = n; opt->rep.level0_slowdown_writes_trigger = n;
} }
void leveldb_options_set_level0_stop_writes_trigger( void rocksdb_options_set_level0_stop_writes_trigger(
leveldb_options_t* opt, int n) { rocksdb_options_t* opt, int n) {
opt->rep.level0_stop_writes_trigger = n; opt->rep.level0_stop_writes_trigger = n;
} }
void leveldb_options_set_max_mem_compaction_level( void rocksdb_options_set_max_mem_compaction_level(
leveldb_options_t* opt, int n) { rocksdb_options_t* opt, int n) {
opt->rep.max_mem_compaction_level = 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<CompressionType>(t); opt->rep.compression = static_cast<CompressionType>(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, int* level_values,
size_t num_levels) { size_t num_levels) {
opt->rep.compression_per_level.resize(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( void rocksdb_options_set_compression_options(
leveldb_options_t* opt, int w_bits, int level, int strategy) { rocksdb_options_t* opt, int w_bits, int level, int strategy) {
opt->rep.compression_opts.window_bits = w_bits; opt->rep.compression_opts.window_bits = w_bits;
opt->rep.compression_opts.level = level; opt->rep.compression_opts.level = level;
opt->rep.compression_opts.strategy = strategy; opt->rep.compression_opts.strategy = strategy;
} }
void leveldb_options_set_disable_data_sync( void rocksdb_options_set_disable_data_sync(
leveldb_options_t* opt, bool disable_data_sync) { rocksdb_options_t* opt, bool disable_data_sync) {
opt->rep.disableDataSync = disable_data_sync; opt->rep.disableDataSync = disable_data_sync;
} }
void leveldb_options_set_use_fsync( void rocksdb_options_set_use_fsync(
leveldb_options_t* opt, bool use_fsync) { rocksdb_options_t* opt, bool use_fsync) {
opt->rep.use_fsync = use_fsync; opt->rep.use_fsync = use_fsync;
} }
void leveldb_options_set_db_stats_log_interval( void rocksdb_options_set_db_stats_log_interval(
leveldb_options_t* opt, int db_stats_log_interval) { rocksdb_options_t* opt, int db_stats_log_interval) {
opt->rep.db_stats_log_interval = db_stats_log_interval; opt->rep.db_stats_log_interval = db_stats_log_interval;
} }
void leveldb_options_set_db_log_dir( void rocksdb_options_set_db_log_dir(
leveldb_options_t* opt, const char* db_log_dir) { rocksdb_options_t* opt, const char* db_log_dir) {
opt->rep.db_log_dir = 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; opt->rep.WAL_ttl_seconds = ttl;
} }
void leveldb_options_set_WAL_size_limit_MB( void rocksdb_options_set_WAL_size_limit_MB(
leveldb_options_t* opt, uint64_t limit) { rocksdb_options_t* opt, uint64_t limit) {
opt->rep.WAL_size_limit_MB = limit; opt->rep.WAL_size_limit_MB = limit;
} }
leveldb_comparator_t* leveldb_comparator_create( rocksdb_comparator_t* rocksdb_comparator_create(
void* state, void* state,
void (*destructor)(void*), void (*destructor)(void*),
int (*compare)( int (*compare)(
@ -567,7 +567,7 @@ leveldb_comparator_t* leveldb_comparator_create(
const char* a, size_t alen, const char* a, size_t alen,
const char* b, size_t blen), const char* b, size_t blen),
const char* (*name)(void*)) { const char* (*name)(void*)) {
leveldb_comparator_t* result = new leveldb_comparator_t; rocksdb_comparator_t* result = new rocksdb_comparator_t;
result->state_ = state; result->state_ = state;
result->destructor_ = destructor; result->destructor_ = destructor;
result->compare_ = compare; result->compare_ = compare;
@ -575,11 +575,11 @@ leveldb_comparator_t* leveldb_comparator_create(
return result; return result;
} }
void leveldb_comparator_destroy(leveldb_comparator_t* cmp) { void rocksdb_comparator_destroy(rocksdb_comparator_t* cmp) {
delete cmp; delete cmp;
} }
leveldb_filterpolicy_t* leveldb_filterpolicy_create( rocksdb_filterpolicy_t* rocksdb_filterpolicy_create(
void* state, void* state,
void (*destructor)(void*), void (*destructor)(void*),
char* (*create_filter)( char* (*create_filter)(
@ -592,7 +592,7 @@ leveldb_filterpolicy_t* leveldb_filterpolicy_create(
const char* key, size_t length, const char* key, size_t length,
const char* filter, size_t filter_length), const char* filter, size_t filter_length),
const char* (*name)(void*)) { const char* (*name)(void*)) {
leveldb_filterpolicy_t* result = new leveldb_filterpolicy_t; rocksdb_filterpolicy_t* result = new rocksdb_filterpolicy_t;
result->state_ = state; result->state_ = state;
result->destructor_ = destructor; result->destructor_ = destructor;
result->create_ = create_filter; result->create_ = create_filter;
@ -601,15 +601,15 @@ leveldb_filterpolicy_t* leveldb_filterpolicy_create(
return result; return result;
} }
void leveldb_filterpolicy_destroy(leveldb_filterpolicy_t* filter) { void rocksdb_filterpolicy_destroy(rocksdb_filterpolicy_t* filter) {
delete filter; delete filter;
} }
leveldb_filterpolicy_t* leveldb_filterpolicy_create_bloom(int bits_per_key) { rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom(int bits_per_key) {
// Make a leveldb_filterpolicy_t, but override all of its methods so // Make a rocksdb_filterpolicy_t, but override all of its methods so
// they delegate to a NewBloomFilterPolicy() instead of user // they delegate to a NewBloomFilterPolicy() instead of user
// supplied C functions. // supplied C functions.
struct Wrapper : public leveldb_filterpolicy_t { struct Wrapper : public rocksdb_filterpolicy_t {
const FilterPolicy* rep_; const FilterPolicy* rep_;
~Wrapper() { delete rep_; } ~Wrapper() { delete rep_; }
const char* Name() const { return rep_->Name(); } const char* Name() const { return rep_->Name(); }
@ -628,62 +628,62 @@ leveldb_filterpolicy_t* leveldb_filterpolicy_create_bloom(int bits_per_key) {
return wrapper; return wrapper;
} }
leveldb_readoptions_t* leveldb_readoptions_create() { rocksdb_readoptions_t* rocksdb_readoptions_create() {
return new leveldb_readoptions_t; return new rocksdb_readoptions_t;
} }
void leveldb_readoptions_destroy(leveldb_readoptions_t* opt) { void rocksdb_readoptions_destroy(rocksdb_readoptions_t* opt) {
delete opt; delete opt;
} }
void leveldb_readoptions_set_verify_checksums( void rocksdb_readoptions_set_verify_checksums(
leveldb_readoptions_t* opt, rocksdb_readoptions_t* opt,
unsigned char v) { unsigned char v) {
opt->rep.verify_checksums = v; opt->rep.verify_checksums = v;
} }
void leveldb_readoptions_set_fill_cache( void rocksdb_readoptions_set_fill_cache(
leveldb_readoptions_t* opt, unsigned char v) { rocksdb_readoptions_t* opt, unsigned char v) {
opt->rep.fill_cache = v; opt->rep.fill_cache = v;
} }
void leveldb_readoptions_set_snapshot( void rocksdb_readoptions_set_snapshot(
leveldb_readoptions_t* opt, rocksdb_readoptions_t* opt,
const leveldb_snapshot_t* snap) { const rocksdb_snapshot_t* snap) {
opt->rep.snapshot = (snap ? snap->rep : NULL); opt->rep.snapshot = (snap ? snap->rep : NULL);
} }
leveldb_writeoptions_t* leveldb_writeoptions_create() { rocksdb_writeoptions_t* rocksdb_writeoptions_create() {
return new leveldb_writeoptions_t; return new rocksdb_writeoptions_t;
} }
void leveldb_writeoptions_destroy(leveldb_writeoptions_t* opt) { void rocksdb_writeoptions_destroy(rocksdb_writeoptions_t* opt) {
delete opt; delete opt;
} }
void leveldb_writeoptions_set_sync( void rocksdb_writeoptions_set_sync(
leveldb_writeoptions_t* opt, unsigned char v) { rocksdb_writeoptions_t* opt, unsigned char v) {
opt->rep.sync = v; opt->rep.sync = v;
} }
leveldb_cache_t* leveldb_cache_create_lru(size_t capacity) { rocksdb_cache_t* rocksdb_cache_create_lru(size_t capacity) {
leveldb_cache_t* c = new leveldb_cache_t; rocksdb_cache_t* c = new rocksdb_cache_t;
c->rep = NewLRUCache(capacity); c->rep = NewLRUCache(capacity);
return c; return c;
} }
void leveldb_cache_destroy(leveldb_cache_t* cache) { void rocksdb_cache_destroy(rocksdb_cache_t* cache) {
delete cache; delete cache;
} }
leveldb_env_t* leveldb_create_default_env() { rocksdb_env_t* rocksdb_create_default_env() {
leveldb_env_t* result = new leveldb_env_t; rocksdb_env_t* result = new rocksdb_env_t;
result->rep = Env::Default(); result->rep = Env::Default();
result->is_default = true; result->is_default = true;
return result; 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; if (!env->is_default) delete env->rep;
delete env; delete env;
} }

218
db/c_test.c
Unescape View File

@ -62,30 +62,30 @@ static void Free(char** ptr) {
} }
static void CheckGet( static void CheckGet(
leveldb_t* db, rocksdb_t* db,
const leveldb_readoptions_t* options, const rocksdb_readoptions_t* options,
const char* key, const char* key,
const char* expected) { const char* expected) {
char* err = NULL; char* err = NULL;
size_t val_len; size_t val_len;
char* val; 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); CheckNoError(err);
CheckEqual(expected, val, val_len); CheckEqual(expected, val, val_len);
Free(&val); Free(&val);
} }
static void CheckIter(leveldb_iterator_t* iter, static void CheckIter(rocksdb_iterator_t* iter,
const char* key, const char* val) { const char* key, const char* val) {
size_t len; size_t len;
const char* str; const char* str;
str = leveldb_iter_key(iter, &len); str = rocksdb_iter_key(iter, &len);
CheckEqual(key, str, len); CheckEqual(key, str, len);
str = leveldb_iter_value(iter, &len); str = rocksdb_iter_value(iter, &len);
CheckEqual(val, str, len); CheckEqual(val, str, len);
} }
// Callback from leveldb_writebatch_iterate() // Callback from rocksdb_writebatch_iterate()
static void CheckPut(void* ptr, static void CheckPut(void* ptr,
const char* k, size_t klen, const char* k, size_t klen,
const char* v, size_t vlen) { const char* v, size_t vlen) {
@ -104,7 +104,7 @@ static void CheckPut(void* ptr,
(*state)++; (*state)++;
} }
// Callback from leveldb_writebatch_iterate() // Callback from rocksdb_writebatch_iterate()
static void CheckDel(void* ptr, const char* k, size_t klen) { static void CheckDel(void* ptr, const char* k, size_t klen) {
int* state = (int*) ptr; int* state = (int*) ptr;
CheckCondition(*state == 2); CheckCondition(*state == 2);
@ -155,117 +155,117 @@ unsigned char FilterKeyMatch(
} }
int main(int argc, char** argv) { int main(int argc, char** argv) {
leveldb_t* db; rocksdb_t* db;
leveldb_comparator_t* cmp; rocksdb_comparator_t* cmp;
leveldb_cache_t* cache; rocksdb_cache_t* cache;
leveldb_env_t* env; rocksdb_env_t* env;
leveldb_options_t* options; rocksdb_options_t* options;
leveldb_readoptions_t* roptions; rocksdb_readoptions_t* roptions;
leveldb_writeoptions_t* woptions; rocksdb_writeoptions_t* woptions;
char* err = NULL; char* err = NULL;
int run = -1; int run = -1;
snprintf(dbname, sizeof(dbname), snprintf(dbname, sizeof(dbname),
"%s/leveldb_c_test-%d", "%s/rocksdb_c_test-%d",
GetTempDir(), GetTempDir(),
((int) geteuid())); ((int) geteuid()));
StartPhase("create_objects"); StartPhase("create_objects");
cmp = leveldb_comparator_create(NULL, CmpDestroy, CmpCompare, CmpName); cmp = rocksdb_comparator_create(NULL, CmpDestroy, CmpCompare, CmpName);
env = leveldb_create_default_env(); env = rocksdb_create_default_env();
cache = leveldb_cache_create_lru(100000); cache = rocksdb_cache_create_lru(100000);
options = leveldb_options_create(); options = rocksdb_options_create();
leveldb_options_set_comparator(options, cmp); rocksdb_options_set_comparator(options, cmp);
leveldb_options_set_error_if_exists(options, 1); rocksdb_options_set_error_if_exists(options, 1);
leveldb_options_set_cache(options, cache); rocksdb_options_set_cache(options, cache);
leveldb_options_set_env(options, env); rocksdb_options_set_env(options, env);
leveldb_options_set_info_log(options, NULL); rocksdb_options_set_info_log(options, NULL);
leveldb_options_set_write_buffer_size(options, 100000); rocksdb_options_set_write_buffer_size(options, 100000);
leveldb_options_set_paranoid_checks(options, 1); rocksdb_options_set_paranoid_checks(options, 1);
leveldb_options_set_max_open_files(options, 10); rocksdb_options_set_max_open_files(options, 10);
leveldb_options_set_block_size(options, 1024); rocksdb_options_set_block_size(options, 1024);
leveldb_options_set_block_restart_interval(options, 8); rocksdb_options_set_block_restart_interval(options, 8);
leveldb_options_set_compression(options, leveldb_no_compression); rocksdb_options_set_compression(options, rocksdb_no_compression);
leveldb_options_set_compression_options(options, -14, -1, 0); rocksdb_options_set_compression_options(options, -14, -1, 0);
int compression_levels[] = {leveldb_no_compression, leveldb_no_compression, int compression_levels[] = {rocksdb_no_compression, rocksdb_no_compression,
leveldb_no_compression, leveldb_no_compression}; rocksdb_no_compression, rocksdb_no_compression};
leveldb_options_set_compression_per_level(options, compression_levels, 4); rocksdb_options_set_compression_per_level(options, compression_levels, 4);
roptions = leveldb_readoptions_create(); roptions = rocksdb_readoptions_create();
leveldb_readoptions_set_verify_checksums(roptions, 1); rocksdb_readoptions_set_verify_checksums(roptions, 1);
leveldb_readoptions_set_fill_cache(roptions, 0); rocksdb_readoptions_set_fill_cache(roptions, 0);
woptions = leveldb_writeoptions_create(); woptions = rocksdb_writeoptions_create();
leveldb_writeoptions_set_sync(woptions, 1); rocksdb_writeoptions_set_sync(woptions, 1);
StartPhase("destroy"); StartPhase("destroy");
leveldb_destroy_db(options, dbname, &err); rocksdb_destroy_db(options, dbname, &err);
Free(&err); Free(&err);
StartPhase("open_error"); StartPhase("open_error");
db = leveldb_open(options, dbname, &err); db = rocksdb_open(options, dbname, &err);
CheckCondition(err != NULL); CheckCondition(err != NULL);
Free(&err); Free(&err);
StartPhase("open"); StartPhase("open");
leveldb_options_set_create_if_missing(options, 1); rocksdb_options_set_create_if_missing(options, 1);
db = leveldb_open(options, dbname, &err); db = rocksdb_open(options, dbname, &err);
CheckNoError(err); CheckNoError(err);
CheckGet(db, roptions, "foo", NULL); CheckGet(db, roptions, "foo", NULL);
StartPhase("put"); StartPhase("put");
leveldb_put(db, woptions, "foo", 3, "hello", 5, &err); rocksdb_put(db, woptions, "foo", 3, "hello", 5, &err);
CheckNoError(err); CheckNoError(err);
CheckGet(db, roptions, "foo", "hello"); CheckGet(db, roptions, "foo", "hello");
StartPhase("compactall"); StartPhase("compactall");
leveldb_compact_range(db, NULL, 0, NULL, 0); rocksdb_compact_range(db, NULL, 0, NULL, 0);
CheckGet(db, roptions, "foo", "hello"); CheckGet(db, roptions, "foo", "hello");
StartPhase("compactrange"); StartPhase("compactrange");
leveldb_compact_range(db, "a", 1, "z", 1); rocksdb_compact_range(db, "a", 1, "z", 1);
CheckGet(db, roptions, "foo", "hello"); CheckGet(db, roptions, "foo", "hello");
StartPhase("writebatch"); StartPhase("writebatch");
{ {
leveldb_writebatch_t* wb = leveldb_writebatch_create(); rocksdb_writebatch_t* wb = rocksdb_writebatch_create();
leveldb_writebatch_put(wb, "foo", 3, "a", 1); rocksdb_writebatch_put(wb, "foo", 3, "a", 1);
leveldb_writebatch_clear(wb); rocksdb_writebatch_clear(wb);
leveldb_writebatch_put(wb, "bar", 3, "b", 1); rocksdb_writebatch_put(wb, "bar", 3, "b", 1);
leveldb_writebatch_put(wb, "box", 3, "c", 1); rocksdb_writebatch_put(wb, "box", 3, "c", 1);
leveldb_writebatch_delete(wb, "bar", 3); rocksdb_writebatch_delete(wb, "bar", 3);
leveldb_write(db, woptions, wb, &err); rocksdb_write(db, woptions, wb, &err);
CheckNoError(err); CheckNoError(err);
CheckGet(db, roptions, "foo", "hello"); CheckGet(db, roptions, "foo", "hello");
CheckGet(db, roptions, "bar", NULL); CheckGet(db, roptions, "bar", NULL);
CheckGet(db, roptions, "box", "c"); CheckGet(db, roptions, "box", "c");
int pos = 0; int pos = 0;
leveldb_writebatch_iterate(wb, &pos, CheckPut, CheckDel); rocksdb_writebatch_iterate(wb, &pos, CheckPut, CheckDel);
CheckCondition(pos == 3); CheckCondition(pos == 3);
leveldb_writebatch_destroy(wb); rocksdb_writebatch_destroy(wb);
} }
StartPhase("iter"); StartPhase("iter");
{ {
leveldb_iterator_t* iter = leveldb_create_iterator(db, roptions); rocksdb_iterator_t* iter = rocksdb_create_iterator(db, roptions);
CheckCondition(!leveldb_iter_valid(iter)); CheckCondition(!rocksdb_iter_valid(iter));
leveldb_iter_seek_to_first(iter); rocksdb_iter_seek_to_first(iter);
CheckCondition(leveldb_iter_valid(iter)); CheckCondition(rocksdb_iter_valid(iter));
CheckIter(iter, "box", "c"); CheckIter(iter, "box", "c");
leveldb_iter_next(iter); rocksdb_iter_next(iter);
CheckIter(iter, "foo", "hello"); CheckIter(iter, "foo", "hello");
leveldb_iter_prev(iter); rocksdb_iter_prev(iter);
CheckIter(iter, "box", "c"); CheckIter(iter, "box", "c");
leveldb_iter_prev(iter); rocksdb_iter_prev(iter);
CheckCondition(!leveldb_iter_valid(iter)); CheckCondition(!rocksdb_iter_valid(iter));
leveldb_iter_seek_to_last(iter); rocksdb_iter_seek_to_last(iter);
CheckIter(iter, "foo", "hello"); CheckIter(iter, "foo", "hello");
leveldb_iter_seek(iter, "b", 1); rocksdb_iter_seek(iter, "b", 1);
CheckIter(iter, "box", "c"); CheckIter(iter, "box", "c");
leveldb_iter_get_error(iter, &err); rocksdb_iter_get_error(iter, &err);
CheckNoError(err); CheckNoError(err);
leveldb_iter_destroy(iter); rocksdb_iter_destroy(iter);
} }
StartPhase("approximate_sizes"); StartPhase("approximate_sizes");
@ -279,39 +279,39 @@ int main(int argc, char** argv) {
size_t start_len[2] = { 1, 21 }; size_t start_len[2] = { 1, 21 };
const char* limit[2] = { "k00000000000000010000", "z" }; const char* limit[2] = { "k00000000000000010000", "z" };
size_t limit_len[2] = { 21, 1 }; 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++) { for (i = 0; i < n; i++) {
snprintf(keybuf, sizeof(keybuf), "k%020d", i); snprintf(keybuf, sizeof(keybuf), "k%020d", i);
snprintf(valbuf, sizeof(valbuf), "v%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); &err);
CheckNoError(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[0] > 0);
CheckCondition(sizes[1] > 0); CheckCondition(sizes[1] > 0);
} }
StartPhase("property"); StartPhase("property");
{ {
char* prop = leveldb_property_value(db, "nosuchprop"); char* prop = rocksdb_property_value(db, "nosuchprop");
CheckCondition(prop == NULL); CheckCondition(prop == NULL);
prop = leveldb_property_value(db, "rocksdb.stats"); prop = rocksdb_property_value(db, "rocksdb.stats");
CheckCondition(prop != NULL); CheckCondition(prop != NULL);
Free(&prop); Free(&prop);
} }
StartPhase("snapshot"); StartPhase("snapshot");
{ {
const leveldb_snapshot_t* snap; const rocksdb_snapshot_t* snap;
snap = leveldb_create_snapshot(db); snap = rocksdb_create_snapshot(db);
leveldb_delete(db, woptions, "foo", 3, &err); rocksdb_delete(db, woptions, "foo", 3, &err);
CheckNoError(err); CheckNoError(err);
leveldb_readoptions_set_snapshot(roptions, snap); rocksdb_readoptions_set_snapshot(roptions, snap);
CheckGet(db, roptions, "foo", "hello"); CheckGet(db, roptions, "foo", "hello");
leveldb_readoptions_set_snapshot(roptions, NULL); rocksdb_readoptions_set_snapshot(roptions, NULL);
CheckGet(db, roptions, "foo", NULL); CheckGet(db, roptions, "foo", NULL);
leveldb_release_snapshot(db, snap); rocksdb_release_snapshot(db, snap);
} }
StartPhase("repair"); StartPhase("repair");
@ -320,44 +320,44 @@ int main(int argc, char** argv) {
// files (https://reviews.facebook.net/D6123) would leave // files (https://reviews.facebook.net/D6123) would leave
// around deleted files and the repair process will find // around deleted files and the repair process will find
// those files and put them back into the database. // those files and put them back into the database.
leveldb_compact_range(db, NULL, 0, NULL, 0); rocksdb_compact_range(db, NULL, 0, NULL, 0);
leveldb_close(db); rocksdb_close(db);
leveldb_options_set_create_if_missing(options, 0); rocksdb_options_set_create_if_missing(options, 0);
leveldb_options_set_error_if_exists(options, 0); rocksdb_options_set_error_if_exists(options, 0);
leveldb_repair_db(options, dbname, &err); rocksdb_repair_db(options, dbname, &err);
CheckNoError(err); CheckNoError(err);
db = leveldb_open(options, dbname, &err); db = rocksdb_open(options, dbname, &err);
CheckNoError(err); CheckNoError(err);
CheckGet(db, roptions, "foo", NULL); CheckGet(db, roptions, "foo", NULL);
CheckGet(db, roptions, "bar", NULL); CheckGet(db, roptions, "bar", NULL);
CheckGet(db, roptions, "box", "c"); CheckGet(db, roptions, "box", "c");
leveldb_options_set_create_if_missing(options, 1); rocksdb_options_set_create_if_missing(options, 1);
leveldb_options_set_error_if_exists(options, 1); rocksdb_options_set_error_if_exists(options, 1);
} }
StartPhase("filter"); StartPhase("filter");
for (run = 0; run < 2; run++) { for (run = 0; run < 2; run++) {
// First run uses custom filter, second run uses bloom filter // First run uses custom filter, second run uses bloom filter
CheckNoError(err); CheckNoError(err);
leveldb_filterpolicy_t* policy; rocksdb_filterpolicy_t* policy;
if (run == 0) { if (run == 0) {
policy = leveldb_filterpolicy_create( policy = rocksdb_filterpolicy_create(
NULL, FilterDestroy, FilterCreate, FilterKeyMatch, FilterName); NULL, FilterDestroy, FilterCreate, FilterKeyMatch, FilterName);
} else { } else {
policy = leveldb_filterpolicy_create_bloom(10); policy = rocksdb_filterpolicy_create_bloom(10);
} }
// Create new database // Create new database
leveldb_close(db); rocksdb_close(db);
leveldb_destroy_db(options, dbname, &err); rocksdb_destroy_db(options, dbname, &err);
leveldb_options_set_filter_policy(options, policy); rocksdb_options_set_filter_policy(options, policy);
db = leveldb_open(options, dbname, &err); db = rocksdb_open(options, dbname, &err);
CheckNoError(err); CheckNoError(err);
leveldb_put(db, woptions, "foo", 3, "foovalue", 8, &err); rocksdb_put(db, woptions, "foo", 3, "foovalue", 8, &err);
CheckNoError(err); CheckNoError(err);
leveldb_put(db, woptions, "bar", 3, "barvalue", 8, &err); rocksdb_put(db, woptions, "bar", 3, "barvalue", 8, &err);
CheckNoError(err); CheckNoError(err);
leveldb_compact_range(db, NULL, 0, NULL, 0); rocksdb_compact_range(db, NULL, 0, NULL, 0);
fake_filter_result = 1; fake_filter_result = 1;
CheckGet(db, roptions, "foo", "foovalue"); CheckGet(db, roptions, "foo", "foovalue");
@ -372,18 +372,18 @@ int main(int argc, char** argv) {
CheckGet(db, roptions, "foo", "foovalue"); CheckGet(db, roptions, "foo", "foovalue");
CheckGet(db, roptions, "bar", "barvalue"); CheckGet(db, roptions, "bar", "barvalue");
} }
leveldb_options_set_filter_policy(options, NULL); rocksdb_options_set_filter_policy(options, NULL);
leveldb_filterpolicy_destroy(policy); rocksdb_filterpolicy_destroy(policy);
} }
StartPhase("cleanup"); StartPhase("cleanup");
leveldb_close(db); rocksdb_close(db);
leveldb_options_destroy(options); rocksdb_options_destroy(options);
leveldb_readoptions_destroy(roptions); rocksdb_readoptions_destroy(roptions);
leveldb_writeoptions_destroy(woptions); rocksdb_writeoptions_destroy(woptions);
leveldb_cache_destroy(cache); rocksdb_cache_destroy(cache);
leveldb_comparator_destroy(cmp); rocksdb_comparator_destroy(cmp);
leveldb_env_destroy(env); rocksdb_env_destroy(env);
fprintf(stderr, "PASS\n"); fprintf(stderr, "PASS\n");
return 0; return 0;

238
include/rocksdb/c.h
Unescape View File

@ -54,171 +54,171 @@ extern "C" {
/* Exported types */ /* Exported types */
typedef struct leveldb_t leveldb_t; typedef struct rocksdb_t rocksdb_t;
typedef struct leveldb_cache_t leveldb_cache_t; typedef struct rocksdb_cache_t rocksdb_cache_t;
typedef struct leveldb_comparator_t leveldb_comparator_t; typedef struct rocksdb_comparator_t rocksdb_comparator_t;
typedef struct leveldb_env_t leveldb_env_t; typedef struct rocksdb_env_t rocksdb_env_t;
typedef struct leveldb_filelock_t leveldb_filelock_t; typedef struct rocksdb_filelock_t rocksdb_filelock_t;
typedef struct leveldb_filterpolicy_t leveldb_filterpolicy_t; typedef struct rocksdb_filterpolicy_t rocksdb_filterpolicy_t;
typedef struct leveldb_iterator_t leveldb_iterator_t; typedef struct rocksdb_iterator_t rocksdb_iterator_t;
typedef struct leveldb_logger_t leveldb_logger_t; typedef struct rocksdb_logger_t rocksdb_logger_t;
typedef struct leveldb_options_t leveldb_options_t; typedef struct rocksdb_options_t rocksdb_options_t;
typedef struct leveldb_randomfile_t leveldb_randomfile_t; typedef struct rocksdb_randomfile_t rocksdb_randomfile_t;
typedef struct leveldb_readoptions_t leveldb_readoptions_t; typedef struct rocksdb_readoptions_t rocksdb_readoptions_t;
typedef struct leveldb_seqfile_t leveldb_seqfile_t; typedef struct rocksdb_seqfile_t rocksdb_seqfile_t;
typedef struct leveldb_snapshot_t leveldb_snapshot_t; typedef struct rocksdb_snapshot_t rocksdb_snapshot_t;
typedef struct leveldb_writablefile_t leveldb_writablefile_t; typedef struct rocksdb_writablefile_t rocksdb_writablefile_t;
typedef struct leveldb_writebatch_t leveldb_writebatch_t; typedef struct rocksdb_writebatch_t rocksdb_writebatch_t;
typedef struct leveldb_writeoptions_t leveldb_writeoptions_t; typedef struct rocksdb_writeoptions_t rocksdb_writeoptions_t;
/* DB operations */ /* DB operations */
extern leveldb_t* leveldb_open( extern rocksdb_t* rocksdb_open(
const leveldb_options_t* options, const rocksdb_options_t* options,
const char* name, const char* name,
char** errptr); char** errptr);
extern void leveldb_close(leveldb_t* db); extern void rocksdb_close(rocksdb_t* db);
extern void leveldb_put( extern void rocksdb_put(
leveldb_t* db, rocksdb_t* db,
const leveldb_writeoptions_t* options, const rocksdb_writeoptions_t* options,
const char* key, size_t keylen, const char* key, size_t keylen,
const char* val, size_t vallen, const char* val, size_t vallen,
char** errptr); char** errptr);
extern void leveldb_delete( extern void rocksdb_delete(
leveldb_t* db, rocksdb_t* db,
const leveldb_writeoptions_t* options, const rocksdb_writeoptions_t* options,
const char* key, size_t keylen, const char* key, size_t keylen,
char** errptr); char** errptr);
extern void leveldb_write( extern void rocksdb_write(
leveldb_t* db, rocksdb_t* db,
const leveldb_writeoptions_t* options, const rocksdb_writeoptions_t* options,
leveldb_writebatch_t* batch, rocksdb_writebatch_t* batch,
char** errptr); char** errptr);
/* Returns NULL if not found. A malloc()ed array otherwise. /* Returns NULL if not found. A malloc()ed array otherwise.
Stores the length of the array in *vallen. */ Stores the length of the array in *vallen. */
extern char* leveldb_get( extern char* rocksdb_get(
leveldb_t* db, rocksdb_t* db,
const leveldb_readoptions_t* options, const rocksdb_readoptions_t* options,
const char* key, size_t keylen, const char* key, size_t keylen,
size_t* vallen, size_t* vallen,
char** errptr); char** errptr);
extern leveldb_iterator_t* leveldb_create_iterator( extern rocksdb_iterator_t* rocksdb_create_iterator(
leveldb_t* db, rocksdb_t* db,
const leveldb_readoptions_t* options); const rocksdb_readoptions_t* options);
extern const leveldb_snapshot_t* leveldb_create_snapshot( extern const rocksdb_snapshot_t* rocksdb_create_snapshot(
leveldb_t* db); rocksdb_t* db);
extern void leveldb_release_snapshot( extern void rocksdb_release_snapshot(
leveldb_t* db, rocksdb_t* db,
const leveldb_snapshot_t* snapshot); const rocksdb_snapshot_t* snapshot);
/* Returns NULL if property name is unknown. /* Returns NULL if property name is unknown.
Else returns a pointer to a malloc()-ed null-terminated value. */ Else returns a pointer to a malloc()-ed null-terminated value. */
extern char* leveldb_property_value( extern char* rocksdb_property_value(
leveldb_t* db, rocksdb_t* db,
const char* propname); const char* propname);
extern void leveldb_approximate_sizes( extern void rocksdb_approximate_sizes(
leveldb_t* db, rocksdb_t* db,
int num_ranges, int num_ranges,
const char* const* range_start_key, const size_t* range_start_key_len, 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, const char* const* range_limit_key, const size_t* range_limit_key_len,
uint64_t* sizes); uint64_t* sizes);
extern void leveldb_compact_range( extern void rocksdb_compact_range(
leveldb_t* db, rocksdb_t* db,
const char* start_key, size_t start_key_len, const char* start_key, size_t start_key_len,
const char* limit_key, size_t limit_key_len); const char* limit_key, size_t limit_key_len);
/* Management operations */ /* Management operations */
extern void leveldb_destroy_db( extern void rocksdb_destroy_db(
const leveldb_options_t* options, const rocksdb_options_t* options,
const char* name, const char* name,
char** errptr); char** errptr);
extern void leveldb_repair_db( extern void rocksdb_repair_db(
const leveldb_options_t* options, const rocksdb_options_t* options,
const char* name, const char* name,
char** errptr); char** errptr);
/* Iterator */ /* Iterator */
extern void leveldb_iter_destroy(leveldb_iterator_t*); extern void rocksdb_iter_destroy(rocksdb_iterator_t*);
extern unsigned char leveldb_iter_valid(const leveldb_iterator_t*); extern unsigned char rocksdb_iter_valid(const rocksdb_iterator_t*);
extern void leveldb_iter_seek_to_first(leveldb_iterator_t*); extern void rocksdb_iter_seek_to_first(rocksdb_iterator_t*);
extern void leveldb_iter_seek_to_last(leveldb_iterator_t*); extern void rocksdb_iter_seek_to_last(rocksdb_iterator_t*);
extern void leveldb_iter_seek(leveldb_iterator_t*, const char* k, size_t klen); extern void rocksdb_iter_seek(rocksdb_iterator_t*, const char* k, size_t klen);
extern void leveldb_iter_next(leveldb_iterator_t*); extern void rocksdb_iter_next(rocksdb_iterator_t*);
extern void leveldb_iter_prev(leveldb_iterator_t*); extern void rocksdb_iter_prev(rocksdb_iterator_t*);
extern const char* leveldb_iter_key(const leveldb_iterator_t*, size_t* klen); extern const char* rocksdb_iter_key(const rocksdb_iterator_t*, size_t* klen);
extern const char* leveldb_iter_value(const leveldb_iterator_t*, size_t* vlen); extern const char* rocksdb_iter_value(const rocksdb_iterator_t*, size_t* vlen);
extern void leveldb_iter_get_error(const leveldb_iterator_t*, char** errptr); extern void rocksdb_iter_get_error(const rocksdb_iterator_t*, char** errptr);
/* Write batch */ /* Write batch */
extern leveldb_writebatch_t* leveldb_writebatch_create(); extern rocksdb_writebatch_t* rocksdb_writebatch_create();
extern void leveldb_writebatch_destroy(leveldb_writebatch_t*); extern void rocksdb_writebatch_destroy(rocksdb_writebatch_t*);
extern void leveldb_writebatch_clear(leveldb_writebatch_t*); extern void rocksdb_writebatch_clear(rocksdb_writebatch_t*);
extern void leveldb_writebatch_put( extern void rocksdb_writebatch_put(
leveldb_writebatch_t*, rocksdb_writebatch_t*,
const char* key, size_t klen, const char* key, size_t klen,
const char* val, size_t vlen); const char* val, size_t vlen);
extern void leveldb_writebatch_delete( extern void rocksdb_writebatch_delete(
leveldb_writebatch_t*, rocksdb_writebatch_t*,
const char* key, size_t klen); const char* key, size_t klen);
extern void leveldb_writebatch_iterate( extern void rocksdb_writebatch_iterate(
leveldb_writebatch_t*, rocksdb_writebatch_t*,
void* state, void* state,
void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen), void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen),
void (*deleted)(void*, const char* k, size_t klen)); void (*deleted)(void*, const char* k, size_t klen));
/* Options */ /* Options */
extern leveldb_options_t* leveldb_options_create(); extern rocksdb_options_t* rocksdb_options_create();
extern void leveldb_options_destroy(leveldb_options_t*); extern void rocksdb_options_destroy(rocksdb_options_t*);
extern void leveldb_options_set_comparator( extern void rocksdb_options_set_comparator(
leveldb_options_t*, rocksdb_options_t*,
leveldb_comparator_t*); rocksdb_comparator_t*);
extern void leveldb_options_set_compression_per_level( extern void rocksdb_options_set_compression_per_level(
leveldb_options_t* opt, rocksdb_options_t* opt,
int* level_values, int* level_values,
size_t num_levels); size_t num_levels);
extern void leveldb_options_set_filter_policy( extern void rocksdb_options_set_filter_policy(
leveldb_options_t*, rocksdb_options_t*,
leveldb_filterpolicy_t*); rocksdb_filterpolicy_t*);
extern void leveldb_options_set_create_if_missing( extern void rocksdb_options_set_create_if_missing(
leveldb_options_t*, unsigned char); rocksdb_options_t*, unsigned char);
extern void leveldb_options_set_error_if_exists( extern void rocksdb_options_set_error_if_exists(
leveldb_options_t*, unsigned char); rocksdb_options_t*, unsigned char);
extern void leveldb_options_set_paranoid_checks( extern void rocksdb_options_set_paranoid_checks(
leveldb_options_t*, unsigned char); rocksdb_options_t*, unsigned char);
extern void leveldb_options_set_env(leveldb_options_t*, leveldb_env_t*); extern void rocksdb_options_set_env(rocksdb_options_t*, rocksdb_env_t*);
extern void leveldb_options_set_info_log(leveldb_options_t*, leveldb_logger_t*); extern void rocksdb_options_set_info_log(rocksdb_options_t*, rocksdb_logger_t*);
extern void leveldb_options_set_write_buffer_size(leveldb_options_t*, size_t); extern void rocksdb_options_set_write_buffer_size(rocksdb_options_t*, size_t);
extern void leveldb_options_set_max_open_files(leveldb_options_t*, int); extern void rocksdb_options_set_max_open_files(rocksdb_options_t*, int);
extern void leveldb_options_set_cache(leveldb_options_t*, leveldb_cache_t*); extern void rocksdb_options_set_cache(rocksdb_options_t*, rocksdb_cache_t*);
extern void leveldb_options_set_block_size(leveldb_options_t*, size_t); extern void rocksdb_options_set_block_size(rocksdb_options_t*, size_t);
extern void leveldb_options_set_block_restart_interval(leveldb_options_t*, int); extern void rocksdb_options_set_block_restart_interval(rocksdb_options_t*, int);
extern void leveldb_options_set_compression_options( extern void rocksdb_options_set_compression_options(
leveldb_options_t* opt, int w_bits, int level, int strategy); rocksdb_options_t* opt, int w_bits, int level, int strategy);
enum { enum {
leveldb_no_compression = 0, rocksdb_no_compression = 0,
leveldb_snappy_compression = 1 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 */ /* Comparator */
extern leveldb_comparator_t* leveldb_comparator_create( extern rocksdb_comparator_t* rocksdb_comparator_create(
void* state, void* state,
void (*destructor)(void*), void (*destructor)(void*),
int (*compare)( int (*compare)(
@ -226,11 +226,11 @@ extern leveldb_comparator_t* leveldb_comparator_create(
const char* a, size_t alen, const char* a, size_t alen,
const char* b, size_t blen), const char* b, size_t blen),
const char* (*name)(void*)); const char* (*name)(void*));
extern void leveldb_comparator_destroy(leveldb_comparator_t*); extern void rocksdb_comparator_destroy(rocksdb_comparator_t*);
/* Filter policy */ /* Filter policy */
extern leveldb_filterpolicy_t* leveldb_filterpolicy_create( extern rocksdb_filterpolicy_t* rocksdb_filterpolicy_create(
void* state, void* state,
void (*destructor)(void*), void (*destructor)(void*),
char* (*create_filter)( char* (*create_filter)(
@ -243,40 +243,40 @@ extern leveldb_filterpolicy_t* leveldb_filterpolicy_create(
const char* key, size_t length, const char* key, size_t length,
const char* filter, size_t filter_length), const char* filter, size_t filter_length),
const char* (*name)(void*)); 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); int bits_per_key);
/* Read options */ /* Read options */
extern leveldb_readoptions_t* leveldb_readoptions_create(); extern rocksdb_readoptions_t* rocksdb_readoptions_create();
extern void leveldb_readoptions_destroy(leveldb_readoptions_t*); extern void rocksdb_readoptions_destroy(rocksdb_readoptions_t*);
extern void leveldb_readoptions_set_verify_checksums( extern void rocksdb_readoptions_set_verify_checksums(
leveldb_readoptions_t*, rocksdb_readoptions_t*,
unsigned char); unsigned char);
extern void leveldb_readoptions_set_fill_cache( extern void rocksdb_readoptions_set_fill_cache(
leveldb_readoptions_t*, unsigned char); rocksdb_readoptions_t*, unsigned char);
extern void leveldb_readoptions_set_snapshot( extern void rocksdb_readoptions_set_snapshot(
leveldb_readoptions_t*, rocksdb_readoptions_t*,
const leveldb_snapshot_t*); const rocksdb_snapshot_t*);
/* Write options */ /* Write options */
extern leveldb_writeoptions_t* leveldb_writeoptions_create(); extern rocksdb_writeoptions_t* rocksdb_writeoptions_create();
extern void leveldb_writeoptions_destroy(leveldb_writeoptions_t*); extern void rocksdb_writeoptions_destroy(rocksdb_writeoptions_t*);
extern void leveldb_writeoptions_set_sync( extern void rocksdb_writeoptions_set_sync(
leveldb_writeoptions_t*, unsigned char); rocksdb_writeoptions_t*, unsigned char);
/* Cache */ /* Cache */
extern leveldb_cache_t* leveldb_cache_create_lru(size_t capacity); extern rocksdb_cache_t* rocksdb_cache_create_lru(size_t capacity);
extern void leveldb_cache_destroy(leveldb_cache_t* cache); extern void rocksdb_cache_destroy(rocksdb_cache_t* cache);
/* Env */ /* Env */
extern leveldb_env_t* leveldb_create_default_env(); extern rocksdb_env_t* rocksdb_create_default_env();
extern void leveldb_env_destroy(leveldb_env_t*); extern void rocksdb_env_destroy(rocksdb_env_t*);
#ifdef __cplusplus #ifdef __cplusplus
} /* end extern "C" */ } /* end extern "C" */

Write Preview
Loading…
Cancel
Save