using ROCKSDB_NAMESPACE::ColumnFamilyHandle;
using ROCKSDB_NAMESPACE::ColumnFamilyOptions;
using ROCKSDB_NAMESPACE::CompactionFilter;
-using ROCKSDB_NAMESPACE::CompactionFilterContext;
using ROCKSDB_NAMESPACE::CompactionFilterFactory;
using ROCKSDB_NAMESPACE::CompactionOptionsFIFO;
using ROCKSDB_NAMESPACE::CompactRangeOptions;
using ROCKSDB_NAMESPACE::Logger;
using ROCKSDB_NAMESPACE::MemoryUtil;
using ROCKSDB_NAMESPACE::MergeOperator;
-using ROCKSDB_NAMESPACE::MergeOperators;
using ROCKSDB_NAMESPACE::NewBloomFilterPolicy;
using ROCKSDB_NAMESPACE::NewGenericRateLimiter;
using ROCKSDB_NAMESPACE::NewLRUCache;
using ROCKSDB_NAMESPACE::WriteBatchWithIndex;
using ROCKSDB_NAMESPACE::WriteOptions;
-using std::shared_ptr;
using std::vector;
using std::unordered_set;
-using std::map;
extern "C" {
struct rocksdb_transaction_t {
Transaction* rep;
};
+struct rocksdb_backupable_db_options_t {
+ BackupableDBOptions rep;
+};
struct rocksdb_checkpoint_t {
Checkpoint* rep;
};
return result;
}
-rocksdb_t* rocksdb_open_for_read_only(
- const rocksdb_options_t* options,
- const char* name,
- unsigned char error_if_log_file_exist,
- char** errptr) {
+rocksdb_t* rocksdb_open_for_read_only(const rocksdb_options_t* options,
+ const char* name,
+ unsigned char error_if_wal_file_exists,
+ char** errptr) {
DB* db;
- if (SaveError(errptr, DB::OpenForReadOnly(options->rep, std::string(name), &db, error_if_log_file_exist))) {
+ if (SaveError(errptr, DB::OpenForReadOnly(options->rep, std::string(name),
+ &db, error_if_wal_file_exists))) {
return nullptr;
}
rocksdb_t* result = new rocksdb_t;
return result;
}
+rocksdb_backup_engine_t* rocksdb_backup_engine_open_opts(
+ const rocksdb_backupable_db_options_t* options, rocksdb_env_t* env,
+ char** errptr) {
+ BackupEngine* be;
+ if (SaveError(errptr, BackupEngine::Open(options->rep, env->rep, &be))) {
+ return nullptr;
+ }
+ rocksdb_backup_engine_t* result = new rocksdb_backup_engine_t;
+ result->rep = be;
+ return result;
+}
+
void rocksdb_backup_engine_create_new_backup(rocksdb_backup_engine_t* be,
rocksdb_t* db,
char** errptr) {
restore_options->rep));
}
+void rocksdb_backup_engine_restore_db_from_backup(
+ rocksdb_backup_engine_t* be, const char* db_dir, const char* wal_dir,
+ const rocksdb_restore_options_t* restore_options, const uint32_t backup_id,
+ char** errptr) {
+ SaveError(errptr, be->rep->RestoreDBFromBackup(backup_id, std::string(db_dir),
+ std::string(wal_dir),
+ restore_options->rep));
+}
+
const rocksdb_backup_engine_info_t* rocksdb_backup_engine_get_backup_info(
rocksdb_backup_engine_t* be) {
rocksdb_backup_engine_info_t* result = new rocksdb_backup_engine_info_t;
delete be;
}
+rocksdb_backupable_db_options_t* rocksdb_backupable_db_options_create(
+ const char* backup_dir) {
+ return new rocksdb_backupable_db_options_t{
+ BackupableDBOptions(std::string(backup_dir))};
+}
+
+void rocksdb_backupable_db_options_set_backup_dir(
+ rocksdb_backupable_db_options_t* options, const char* backup_dir) {
+ options->rep.backup_dir = std::string(backup_dir);
+}
+
+void rocksdb_backupable_db_options_set_env(
+ rocksdb_backupable_db_options_t* options, rocksdb_env_t* env) {
+ options->rep.backup_env = (env ? env->rep : nullptr);
+}
+
+void rocksdb_backupable_db_options_set_share_table_files(
+ rocksdb_backupable_db_options_t* options, unsigned char val) {
+ options->rep.share_table_files = val;
+}
+
+unsigned char rocksdb_backupable_db_options_get_share_table_files(
+ rocksdb_backupable_db_options_t* options) {
+ return options->rep.share_table_files;
+}
+
+void rocksdb_backupable_db_options_set_sync(
+ rocksdb_backupable_db_options_t* options, unsigned char val) {
+ options->rep.sync = val;
+}
+
+unsigned char rocksdb_backupable_db_options_get_sync(
+ rocksdb_backupable_db_options_t* options) {
+ return options->rep.sync;
+}
+
+void rocksdb_backupable_db_options_set_destroy_old_data(
+ rocksdb_backupable_db_options_t* options, unsigned char val) {
+ options->rep.destroy_old_data = val;
+}
+
+unsigned char rocksdb_backupable_db_options_get_destroy_old_data(
+ rocksdb_backupable_db_options_t* options) {
+ return options->rep.destroy_old_data;
+}
+
+void rocksdb_backupable_db_options_set_backup_log_files(
+ rocksdb_backupable_db_options_t* options, unsigned char val) {
+ options->rep.backup_log_files = val;
+}
+
+unsigned char rocksdb_backupable_db_options_get_backup_log_files(
+ rocksdb_backupable_db_options_t* options) {
+ return options->rep.backup_log_files;
+}
+
+void rocksdb_backupable_db_options_set_backup_rate_limit(
+ rocksdb_backupable_db_options_t* options, uint64_t limit) {
+ options->rep.backup_rate_limit = limit;
+}
+
+uint64_t rocksdb_backupable_db_options_get_backup_rate_limit(
+ rocksdb_backupable_db_options_t* options) {
+ return options->rep.backup_rate_limit;
+}
+
+void rocksdb_backupable_db_options_set_restore_rate_limit(
+ rocksdb_backupable_db_options_t* options, uint64_t limit) {
+ options->rep.restore_rate_limit = limit;
+}
+
+uint64_t rocksdb_backupable_db_options_get_restore_rate_limit(
+ rocksdb_backupable_db_options_t* options) {
+ return options->rep.restore_rate_limit;
+}
+
+void rocksdb_backupable_db_options_set_max_background_operations(
+ rocksdb_backupable_db_options_t* options, int val) {
+ options->rep.max_background_operations = val;
+}
+
+int rocksdb_backupable_db_options_get_max_background_operations(
+ rocksdb_backupable_db_options_t* options) {
+ return options->rep.max_background_operations;
+}
+
+void rocksdb_backupable_db_options_set_callback_trigger_interval_size(
+ rocksdb_backupable_db_options_t* options, uint64_t size) {
+ options->rep.callback_trigger_interval_size = size;
+}
+
+uint64_t rocksdb_backupable_db_options_get_callback_trigger_interval_size(
+ rocksdb_backupable_db_options_t* options) {
+ return options->rep.callback_trigger_interval_size;
+}
+
+void rocksdb_backupable_db_options_set_max_valid_backups_to_open(
+ rocksdb_backupable_db_options_t* options, int val) {
+ options->rep.max_valid_backups_to_open = val;
+}
+
+int rocksdb_backupable_db_options_get_max_valid_backups_to_open(
+ rocksdb_backupable_db_options_t* options) {
+ return options->rep.max_valid_backups_to_open;
+}
+
+void rocksdb_backupable_db_options_set_share_files_with_checksum_naming(
+ rocksdb_backupable_db_options_t* options, int val) {
+ options->rep.share_files_with_checksum_naming =
+ static_cast<BackupableDBOptions::ShareFilesNaming>(val);
+}
+
+int rocksdb_backupable_db_options_get_share_files_with_checksum_naming(
+ rocksdb_backupable_db_options_t* options) {
+ return static_cast<int>(options->rep.share_files_with_checksum_naming);
+}
+
+void rocksdb_backupable_db_options_destroy(
+ rocksdb_backupable_db_options_t* options) {
+ delete options;
+}
+
rocksdb_checkpoint_t* rocksdb_checkpoint_object_create(rocksdb_t* db,
char** errptr) {
Checkpoint* checkpoint;
return result;
}
+rocksdb_t* rocksdb_open_column_families_with_ttl(
+ const rocksdb_options_t* db_options, const char* name,
+ int num_column_families, const char* const* column_family_names,
+ const rocksdb_options_t* const* column_family_options,
+ rocksdb_column_family_handle_t** column_family_handles, const int* ttls,
+ char** errptr) {
+ std::vector<int32_t> ttls_vec;
+ std::vector<ColumnFamilyDescriptor> column_families;
+ for (int i = 0; i < num_column_families; i++) {
+ ttls_vec.push_back(ttls[i]);
+
+ column_families.push_back(ColumnFamilyDescriptor(
+ std::string(column_family_names[i]),
+ ColumnFamilyOptions(column_family_options[i]->rep)));
+ }
+
+ ROCKSDB_NAMESPACE::DBWithTTL* db;
+ std::vector<ColumnFamilyHandle*> handles;
+ if (SaveError(errptr, ROCKSDB_NAMESPACE::DBWithTTL::Open(
+ DBOptions(db_options->rep), std::string(name),
+ column_families, &handles, &db, ttls_vec))) {
+ return nullptr;
+ }
+
+ for (size_t i = 0; i < handles.size(); i++) {
+ rocksdb_column_family_handle_t* c_handle =
+ new rocksdb_column_family_handle_t;
+ c_handle->rep = handles[i];
+ column_family_handles[i] = c_handle;
+ }
+ rocksdb_t* result = new rocksdb_t;
+ result->rep = db;
+ return result;
+}
+
rocksdb_t* rocksdb_open_for_read_only_column_families(
const rocksdb_options_t* db_options, const char* name,
int num_column_families, const char* const* column_family_names,
const rocksdb_options_t* const* column_family_options,
rocksdb_column_family_handle_t** column_family_handles,
- unsigned char error_if_log_file_exist, char** errptr) {
+ unsigned char error_if_wal_file_exists, char** errptr) {
std::vector<ColumnFamilyDescriptor> column_families;
for (int i = 0; i < num_column_families; i++) {
column_families.push_back(ColumnFamilyDescriptor(
DB* db;
std::vector<ColumnFamilyHandle*> handles;
- if (SaveError(errptr, DB::OpenForReadOnly(DBOptions(db_options->rep),
- std::string(name), column_families, &handles, &db, error_if_log_file_exist))) {
+ if (SaveError(errptr,
+ DB::OpenForReadOnly(DBOptions(db_options->rep),
+ std::string(name), column_families,
+ &handles, &db, error_if_wal_file_exists))) {
return nullptr;
}
return handle;
}
+rocksdb_column_family_handle_t* rocksdb_create_column_family_with_ttl(
+ rocksdb_t* db, const rocksdb_options_t* column_family_options,
+ const char* column_family_name, int ttl, char** errptr) {
+ ROCKSDB_NAMESPACE::DBWithTTL* db_with_ttl =
+ static_cast<ROCKSDB_NAMESPACE::DBWithTTL*>(db->rep);
+ rocksdb_column_family_handle_t* handle = new rocksdb_column_family_handle_t;
+ SaveError(errptr, db_with_ttl->CreateColumnFamilyWithTtl(
+ ColumnFamilyOptions(column_family_options->rep),
+ std::string(column_family_name), &(handle->rep), ttl));
+ return handle;
+}
+
void rocksdb_drop_column_family(
rocksdb_t* db,
rocksdb_column_family_handle_t* handle,
}
}
+unsigned char rocksdb_key_may_exist(rocksdb_t* db,
+ const rocksdb_readoptions_t* options,
+ const char* key, size_t key_len,
+ char** value, size_t* val_len,
+ const char* timestamp, size_t timestamp_len,
+ unsigned char* value_found) {
+ std::string tmp;
+ std::string time;
+ if (timestamp) {
+ time.assign(timestamp, timestamp_len);
+ }
+ bool found = false;
+ const bool result = db->rep->KeyMayExist(options->rep, Slice(key, key_len),
+ &tmp, timestamp ? &time : nullptr,
+ value_found ? &found : nullptr);
+ if (value_found) {
+ *value_found = found;
+ if (found) {
+ *val_len = tmp.size();
+ *value = CopyString(tmp);
+ }
+ }
+ return result;
+}
+
+unsigned char rocksdb_key_may_exist_cf(
+ rocksdb_t* db, const rocksdb_readoptions_t* options,
+ rocksdb_column_family_handle_t* column_family, const char* key,
+ size_t key_len, char** value, size_t* val_len, const char* timestamp,
+ size_t timestamp_len, unsigned char* value_found) {
+ std::string tmp;
+ std::string time;
+ if (timestamp) {
+ time.assign(timestamp, timestamp_len);
+ }
+ bool found = false;
+ const bool result = db->rep->KeyMayExist(
+ options->rep, column_family->rep, Slice(key, key_len), &tmp,
+ timestamp ? &time : nullptr, value_found ? &found : nullptr);
+ if (value_found) {
+ *value_found = found;
+ if (found) {
+ *val_len = tmp.size();
+ *value = CopyString(tmp);
+ }
+ }
+ return result;
+}
+
rocksdb_iterator_t* rocksdb_create_iterator(
rocksdb_t* db,
const rocksdb_readoptions_t* options) {
b->rep.Delete(Slice(key, klen));
}
+void rocksdb_writebatch_singledelete(rocksdb_writebatch_t* b, const char* key,
+ size_t klen) {
+ b->rep.SingleDelete(Slice(key, klen));
+}
+
void rocksdb_writebatch_delete_cf(
rocksdb_writebatch_t* b,
rocksdb_column_family_handle_t* column_family,
b->rep.Delete(column_family->rep, Slice(key, klen));
}
+void rocksdb_writebatch_singledelete_cf(
+ rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family,
+ const char* key, size_t klen) {
+ b->rep.SingleDelete(column_family->rep, Slice(key, klen));
+}
+
void rocksdb_writebatch_deletev(
rocksdb_writebatch_t* b,
int num_keys, const char* const* keys_list,
b->rep->Delete(Slice(key, klen));
}
+void rocksdb_writebatch_wi_singledelete(rocksdb_writebatch_wi_t* b,
+ const char* key, size_t klen) {
+ b->rep->SingleDelete(Slice(key, klen));
+}
+
void rocksdb_writebatch_wi_delete_cf(
rocksdb_writebatch_wi_t* b,
rocksdb_column_family_handle_t* column_family,
b->rep->Delete(column_family->rep, Slice(key, klen));
}
+void rocksdb_writebatch_wi_singledelete_cf(
+ rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family,
+ const char* key, size_t klen) {
+ b->rep->SingleDelete(column_family->rep, Slice(key, klen));
+}
+
void rocksdb_writebatch_wi_deletev(
rocksdb_writebatch_wi_t* b,
int num_keys, const char* const* keys_list,
delete options;
}
+rocksdb_options_t* rocksdb_options_create_copy(rocksdb_options_t* options) {
+ return new rocksdb_options_t(*options);
+}
+
void rocksdb_options_increase_parallelism(
rocksdb_options_t* opt, int total_threads) {
opt->rep.IncreaseParallelism(total_threads);
opt->rep.allow_ingest_behind = v;
}
+unsigned char rocksdb_options_get_allow_ingest_behind(rocksdb_options_t* opt) {
+ return opt->rep.allow_ingest_behind;
+}
+
void rocksdb_options_set_compaction_filter(
rocksdb_options_t* opt,
rocksdb_compactionfilter_t* filter) {
opt->rep.compaction_readahead_size = s;
}
+size_t rocksdb_options_get_compaction_readahead_size(rocksdb_options_t* opt) {
+ return opt->rep.compaction_readahead_size;
+}
+
void rocksdb_options_set_comparator(
rocksdb_options_t* opt,
rocksdb_comparator_t* cmp) {
opt->rep.merge_operator = std::shared_ptr<MergeOperator>(merge_operator);
}
-
void rocksdb_options_set_create_if_missing(
rocksdb_options_t* opt, unsigned char v) {
opt->rep.create_if_missing = v;
}
+unsigned char rocksdb_options_get_create_if_missing(rocksdb_options_t* opt) {
+ return opt->rep.create_if_missing;
+}
+
void rocksdb_options_set_create_missing_column_families(
rocksdb_options_t* opt, unsigned char v) {
opt->rep.create_missing_column_families = v;
}
+unsigned char rocksdb_options_get_create_missing_column_families(
+ rocksdb_options_t* opt) {
+ return opt->rep.create_missing_column_families;
+}
+
void rocksdb_options_set_error_if_exists(
rocksdb_options_t* opt, unsigned char v) {
opt->rep.error_if_exists = v;
}
+unsigned char rocksdb_options_get_error_if_exists(rocksdb_options_t* opt) {
+ return opt->rep.error_if_exists;
+}
+
void rocksdb_options_set_paranoid_checks(
rocksdb_options_t* opt, unsigned char v) {
opt->rep.paranoid_checks = v;
}
+unsigned char rocksdb_options_get_paranoid_checks(rocksdb_options_t* opt) {
+ return opt->rep.paranoid_checks;
+}
+
void rocksdb_options_set_db_paths(rocksdb_options_t* opt,
const rocksdb_dbpath_t** dbpath_values,
size_t num_paths) {
opt->rep.info_log_level = static_cast<InfoLogLevel>(v);
}
+int rocksdb_options_get_info_log_level(rocksdb_options_t* opt) {
+ return static_cast<int>(opt->rep.info_log_level);
+}
+
void rocksdb_options_set_db_write_buffer_size(rocksdb_options_t* opt,
size_t s) {
opt->rep.db_write_buffer_size = s;
}
+size_t rocksdb_options_get_db_write_buffer_size(rocksdb_options_t* opt) {
+ return opt->rep.db_write_buffer_size;
+}
+
void rocksdb_options_set_write_buffer_size(rocksdb_options_t* opt, size_t s) {
opt->rep.write_buffer_size = s;
}
+size_t rocksdb_options_get_write_buffer_size(rocksdb_options_t* opt) {
+ return opt->rep.write_buffer_size;
+}
+
void rocksdb_options_set_max_open_files(rocksdb_options_t* opt, int n) {
opt->rep.max_open_files = n;
}
+int rocksdb_options_get_max_open_files(rocksdb_options_t* opt) {
+ return opt->rep.max_open_files;
+}
+
void rocksdb_options_set_max_file_opening_threads(rocksdb_options_t* opt, int n) {
opt->rep.max_file_opening_threads = n;
}
+int rocksdb_options_get_max_file_opening_threads(rocksdb_options_t* opt) {
+ return opt->rep.max_file_opening_threads;
+}
+
void rocksdb_options_set_max_total_wal_size(rocksdb_options_t* opt, uint64_t n) {
opt->rep.max_total_wal_size = n;
}
+uint64_t rocksdb_options_get_max_total_wal_size(rocksdb_options_t* opt) {
+ return opt->rep.max_total_wal_size;
+}
+
void rocksdb_options_set_target_file_size_base(
rocksdb_options_t* opt, uint64_t n) {
opt->rep.target_file_size_base = n;
}
+uint64_t rocksdb_options_get_target_file_size_base(rocksdb_options_t* opt) {
+ return opt->rep.target_file_size_base;
+}
+
void rocksdb_options_set_target_file_size_multiplier(
rocksdb_options_t* opt, int n) {
opt->rep.target_file_size_multiplier = n;
}
+int rocksdb_options_get_target_file_size_multiplier(rocksdb_options_t* opt) {
+ return opt->rep.target_file_size_multiplier;
+}
+
void rocksdb_options_set_max_bytes_for_level_base(
rocksdb_options_t* opt, uint64_t n) {
opt->rep.max_bytes_for_level_base = n;
}
+uint64_t rocksdb_options_get_max_bytes_for_level_base(rocksdb_options_t* opt) {
+ return opt->rep.max_bytes_for_level_base;
+}
+
void rocksdb_options_set_level_compaction_dynamic_level_bytes(
rocksdb_options_t* opt, unsigned char v) {
opt->rep.level_compaction_dynamic_level_bytes = v;
}
+unsigned char rocksdb_options_get_level_compaction_dynamic_level_bytes(
+ rocksdb_options_t* opt) {
+ return opt->rep.level_compaction_dynamic_level_bytes;
+}
+
void rocksdb_options_set_max_bytes_for_level_multiplier(rocksdb_options_t* opt,
double n) {
opt->rep.max_bytes_for_level_multiplier = n;
}
+double rocksdb_options_get_max_bytes_for_level_multiplier(
+ rocksdb_options_t* opt) {
+ return opt->rep.max_bytes_for_level_multiplier;
+}
+
void rocksdb_options_set_max_compaction_bytes(rocksdb_options_t* opt,
uint64_t n) {
opt->rep.max_compaction_bytes = n;
}
+uint64_t rocksdb_options_get_max_compaction_bytes(rocksdb_options_t* opt) {
+ return opt->rep.max_compaction_bytes;
+}
+
void rocksdb_options_set_max_bytes_for_level_multiplier_additional(
rocksdb_options_t* opt, int* level_values, size_t num_levels) {
opt->rep.max_bytes_for_level_multiplier_additional.resize(num_levels);
opt->rep.skip_stats_update_on_db_open = val;
}
+unsigned char rocksdb_options_get_skip_stats_update_on_db_open(
+ rocksdb_options_t* opt) {
+ return opt->rep.skip_stats_update_on_db_open;
+}
+
void rocksdb_options_set_skip_checking_sst_file_sizes_on_db_open(
rocksdb_options_t* opt, unsigned char val) {
opt->rep.skip_checking_sst_file_sizes_on_db_open = val;
}
+unsigned char rocksdb_options_get_skip_checking_sst_file_sizes_on_db_open(
+ rocksdb_options_t* opt) {
+ return opt->rep.skip_checking_sst_file_sizes_on_db_open;
+}
+
void rocksdb_options_set_num_levels(rocksdb_options_t* opt, int n) {
opt->rep.num_levels = n;
}
+int rocksdb_options_get_num_levels(rocksdb_options_t* opt) {
+ return opt->rep.num_levels;
+}
+
void rocksdb_options_set_level0_file_num_compaction_trigger(
rocksdb_options_t* opt, int n) {
opt->rep.level0_file_num_compaction_trigger = n;
}
+int rocksdb_options_get_level0_file_num_compaction_trigger(
+ rocksdb_options_t* opt) {
+ return opt->rep.level0_file_num_compaction_trigger;
+}
+
void rocksdb_options_set_level0_slowdown_writes_trigger(
rocksdb_options_t* opt, int n) {
opt->rep.level0_slowdown_writes_trigger = n;
}
+int rocksdb_options_get_level0_slowdown_writes_trigger(rocksdb_options_t* opt) {
+ return opt->rep.level0_slowdown_writes_trigger;
+}
+
void rocksdb_options_set_level0_stop_writes_trigger(
rocksdb_options_t* opt, int n) {
opt->rep.level0_stop_writes_trigger = n;
}
+int rocksdb_options_get_level0_stop_writes_trigger(rocksdb_options_t* opt) {
+ return opt->rep.level0_stop_writes_trigger;
+}
+
void rocksdb_options_set_max_mem_compaction_level(rocksdb_options_t* /*opt*/,
int /*n*/) {}
opt->rep.wal_recovery_mode = static_cast<WALRecoveryMode>(mode);
}
+int rocksdb_options_get_wal_recovery_mode(rocksdb_options_t* opt) {
+ return static_cast<int>(opt->rep.wal_recovery_mode);
+}
+
void rocksdb_options_set_compression(rocksdb_options_t* opt, int t) {
opt->rep.compression = static_cast<CompressionType>(t);
}
+int rocksdb_options_get_compression(rocksdb_options_t* opt) {
+ return opt->rep.compression;
+}
+
+void rocksdb_options_set_bottommost_compression(rocksdb_options_t* opt, int t) {
+ opt->rep.bottommost_compression = static_cast<CompressionType>(t);
+}
+
+int rocksdb_options_get_bottommost_compression(rocksdb_options_t* opt) {
+ return opt->rep.bottommost_compression;
+}
+
void rocksdb_options_set_compression_per_level(rocksdb_options_t* opt,
int* level_values,
size_t num_levels) {
int w_bits, int level,
int strategy,
int max_dict_bytes,
- bool enabled) {
+ unsigned char enabled) {
opt->rep.bottommost_compression_opts.window_bits = w_bits;
opt->rep.bottommost_compression_opts.level = level;
opt->rep.bottommost_compression_opts.strategy = strategy;
opt->rep.bottommost_compression_opts.enabled = enabled;
}
+void rocksdb_options_set_bottommost_compression_options_zstd_max_train_bytes(
+ rocksdb_options_t* opt, int zstd_max_train_bytes, unsigned char enabled) {
+ opt->rep.bottommost_compression_opts.zstd_max_train_bytes =
+ zstd_max_train_bytes;
+ opt->rep.bottommost_compression_opts.enabled = enabled;
+}
+
void rocksdb_options_set_compression_options(rocksdb_options_t* opt, int w_bits,
int level, int strategy,
int max_dict_bytes) {
opt->rep.compression_opts.max_dict_bytes = max_dict_bytes;
}
+void rocksdb_options_set_compression_options_zstd_max_train_bytes(
+ rocksdb_options_t* opt, int zstd_max_train_bytes) {
+ opt->rep.compression_opts.zstd_max_train_bytes = zstd_max_train_bytes;
+}
+
void rocksdb_options_set_prefix_extractor(
rocksdb_options_t* opt, rocksdb_slicetransform_t* prefix_extractor) {
opt->rep.prefix_extractor.reset(prefix_extractor);
opt->rep.use_fsync = use_fsync;
}
+int rocksdb_options_get_use_fsync(rocksdb_options_t* opt) {
+ return opt->rep.use_fsync;
+}
+
void rocksdb_options_set_db_log_dir(
rocksdb_options_t* opt, const char* db_log_dir) {
opt->rep.db_log_dir = db_log_dir;
opt->rep.WAL_ttl_seconds = ttl;
}
+uint64_t rocksdb_options_get_WAL_ttl_seconds(rocksdb_options_t* opt) {
+ return opt->rep.WAL_ttl_seconds;
+}
+
void rocksdb_options_set_WAL_size_limit_MB(
rocksdb_options_t* opt, uint64_t limit) {
opt->rep.WAL_size_limit_MB = limit;
}
+uint64_t rocksdb_options_get_WAL_size_limit_MB(rocksdb_options_t* opt) {
+ return opt->rep.WAL_size_limit_MB;
+}
+
void rocksdb_options_set_manifest_preallocation_size(
rocksdb_options_t* opt, size_t v) {
opt->rep.manifest_preallocation_size = v;
}
+size_t rocksdb_options_get_manifest_preallocation_size(rocksdb_options_t* opt) {
+ return opt->rep.manifest_preallocation_size;
+}
+
// noop
void rocksdb_options_set_purge_redundant_kvs_while_flush(
rocksdb_options_t* /*opt*/, unsigned char /*v*/) {}
opt->rep.use_direct_reads = v;
}
+unsigned char rocksdb_options_get_use_direct_reads(rocksdb_options_t* opt) {
+ return opt->rep.use_direct_reads;
+}
+
void rocksdb_options_set_use_direct_io_for_flush_and_compaction(
rocksdb_options_t* opt, unsigned char v) {
opt->rep.use_direct_io_for_flush_and_compaction = v;
}
+unsigned char rocksdb_options_get_use_direct_io_for_flush_and_compaction(
+ rocksdb_options_t* opt) {
+ return opt->rep.use_direct_io_for_flush_and_compaction;
+}
+
void rocksdb_options_set_allow_mmap_reads(
rocksdb_options_t* opt, unsigned char v) {
opt->rep.allow_mmap_reads = v;
}
+unsigned char rocksdb_options_get_allow_mmap_reads(rocksdb_options_t* opt) {
+ return opt->rep.allow_mmap_reads;
+}
+
void rocksdb_options_set_allow_mmap_writes(
rocksdb_options_t* opt, unsigned char v) {
opt->rep.allow_mmap_writes = v;
}
+unsigned char rocksdb_options_get_allow_mmap_writes(rocksdb_options_t* opt) {
+ return opt->rep.allow_mmap_writes;
+}
+
void rocksdb_options_set_is_fd_close_on_exec(
rocksdb_options_t* opt, unsigned char v) {
opt->rep.is_fd_close_on_exec = v;
}
+unsigned char rocksdb_options_get_is_fd_close_on_exec(rocksdb_options_t* opt) {
+ return opt->rep.is_fd_close_on_exec;
+}
+
void rocksdb_options_set_skip_log_error_on_recovery(
rocksdb_options_t* opt, unsigned char v) {
opt->rep.skip_log_error_on_recovery = v;
}
+unsigned char rocksdb_options_get_skip_log_error_on_recovery(
+ rocksdb_options_t* opt) {
+ return opt->rep.skip_log_error_on_recovery;
+}
+
void rocksdb_options_set_stats_dump_period_sec(
rocksdb_options_t* opt, unsigned int v) {
opt->rep.stats_dump_period_sec = v;
}
+unsigned int rocksdb_options_get_stats_dump_period_sec(rocksdb_options_t* opt) {
+ return opt->rep.stats_dump_period_sec;
+}
+
+void rocksdb_options_set_stats_persist_period_sec(rocksdb_options_t* opt,
+ unsigned int v) {
+ opt->rep.stats_persist_period_sec = v;
+}
+
+unsigned int rocksdb_options_get_stats_persist_period_sec(
+ rocksdb_options_t* opt) {
+ return opt->rep.stats_persist_period_sec;
+}
+
void rocksdb_options_set_advise_random_on_open(
rocksdb_options_t* opt, unsigned char v) {
opt->rep.advise_random_on_open = v;
}
+unsigned char rocksdb_options_get_advise_random_on_open(
+ rocksdb_options_t* opt) {
+ return opt->rep.advise_random_on_open;
+}
+
void rocksdb_options_set_access_hint_on_compaction_start(
rocksdb_options_t* opt, int v) {
switch(v) {
}
}
+int rocksdb_options_get_access_hint_on_compaction_start(
+ rocksdb_options_t* opt) {
+ return opt->rep.access_hint_on_compaction_start;
+}
+
void rocksdb_options_set_use_adaptive_mutex(
rocksdb_options_t* opt, unsigned char v) {
opt->rep.use_adaptive_mutex = v;
}
+unsigned char rocksdb_options_get_use_adaptive_mutex(rocksdb_options_t* opt) {
+ return opt->rep.use_adaptive_mutex;
+}
+
void rocksdb_options_set_wal_bytes_per_sync(
rocksdb_options_t* opt, uint64_t v) {
opt->rep.wal_bytes_per_sync = v;
}
+uint64_t rocksdb_options_get_wal_bytes_per_sync(rocksdb_options_t* opt) {
+ return opt->rep.wal_bytes_per_sync;
+}
+
void rocksdb_options_set_bytes_per_sync(
rocksdb_options_t* opt, uint64_t v) {
opt->rep.bytes_per_sync = v;
}
+uint64_t rocksdb_options_get_bytes_per_sync(rocksdb_options_t* opt) {
+ return opt->rep.bytes_per_sync;
+}
+
void rocksdb_options_set_writable_file_max_buffer_size(rocksdb_options_t* opt,
uint64_t v) {
opt->rep.writable_file_max_buffer_size = static_cast<size_t>(v);
}
+uint64_t rocksdb_options_get_writable_file_max_buffer_size(
+ rocksdb_options_t* opt) {
+ return opt->rep.writable_file_max_buffer_size;
+}
+
void rocksdb_options_set_allow_concurrent_memtable_write(rocksdb_options_t* opt,
unsigned char v) {
opt->rep.allow_concurrent_memtable_write = v;
}
+unsigned char rocksdb_options_get_allow_concurrent_memtable_write(
+ rocksdb_options_t* opt) {
+ return opt->rep.allow_concurrent_memtable_write;
+}
+
void rocksdb_options_set_enable_write_thread_adaptive_yield(
rocksdb_options_t* opt, unsigned char v) {
opt->rep.enable_write_thread_adaptive_yield = v;
}
+unsigned char rocksdb_options_get_enable_write_thread_adaptive_yield(
+ rocksdb_options_t* opt) {
+ return opt->rep.enable_write_thread_adaptive_yield;
+}
+
void rocksdb_options_set_max_sequential_skip_in_iterations(
rocksdb_options_t* opt, uint64_t v) {
opt->rep.max_sequential_skip_in_iterations = v;
}
+uint64_t rocksdb_options_get_max_sequential_skip_in_iterations(
+ rocksdb_options_t* opt) {
+ return opt->rep.max_sequential_skip_in_iterations;
+}
+
void rocksdb_options_set_max_write_buffer_number(rocksdb_options_t* opt, int n) {
opt->rep.max_write_buffer_number = n;
}
+int rocksdb_options_get_max_write_buffer_number(rocksdb_options_t* opt) {
+ return opt->rep.max_write_buffer_number;
+}
+
void rocksdb_options_set_min_write_buffer_number_to_merge(rocksdb_options_t* opt, int n) {
opt->rep.min_write_buffer_number_to_merge = n;
}
+int rocksdb_options_get_min_write_buffer_number_to_merge(
+ rocksdb_options_t* opt) {
+ return opt->rep.min_write_buffer_number_to_merge;
+}
+
void rocksdb_options_set_max_write_buffer_number_to_maintain(
rocksdb_options_t* opt, int n) {
opt->rep.max_write_buffer_number_to_maintain = n;
}
+int rocksdb_options_get_max_write_buffer_number_to_maintain(
+ rocksdb_options_t* opt) {
+ return opt->rep.max_write_buffer_number_to_maintain;
+}
+
void rocksdb_options_set_max_write_buffer_size_to_maintain(
rocksdb_options_t* opt, int64_t n) {
opt->rep.max_write_buffer_size_to_maintain = n;
}
+int64_t rocksdb_options_get_max_write_buffer_size_to_maintain(
+ rocksdb_options_t* opt) {
+ return opt->rep.max_write_buffer_size_to_maintain;
+}
+
void rocksdb_options_set_enable_pipelined_write(rocksdb_options_t* opt,
unsigned char v) {
opt->rep.enable_pipelined_write = v;
}
+unsigned char rocksdb_options_get_enable_pipelined_write(
+ rocksdb_options_t* opt) {
+ return opt->rep.enable_pipelined_write;
+}
+
void rocksdb_options_set_unordered_write(rocksdb_options_t* opt,
unsigned char v) {
opt->rep.unordered_write = v;
}
+unsigned char rocksdb_options_get_unordered_write(rocksdb_options_t* opt) {
+ return opt->rep.unordered_write;
+}
+
void rocksdb_options_set_max_subcompactions(rocksdb_options_t* opt,
uint32_t n) {
opt->rep.max_subcompactions = n;
}
+uint32_t rocksdb_options_get_max_subcompactions(rocksdb_options_t* opt) {
+ return opt->rep.max_subcompactions;
+}
+
void rocksdb_options_set_max_background_jobs(rocksdb_options_t* opt, int n) {
opt->rep.max_background_jobs = n;
}
+int rocksdb_options_get_max_background_jobs(rocksdb_options_t* opt) {
+ return opt->rep.max_background_jobs;
+}
+
void rocksdb_options_set_max_background_compactions(rocksdb_options_t* opt, int n) {
opt->rep.max_background_compactions = n;
}
+int rocksdb_options_get_max_background_compactions(rocksdb_options_t* opt) {
+ return opt->rep.max_background_compactions;
+}
+
void rocksdb_options_set_base_background_compactions(rocksdb_options_t* opt,
int n) {
opt->rep.base_background_compactions = n;
}
+int rocksdb_options_get_base_background_compactions(rocksdb_options_t* opt) {
+ return opt->rep.base_background_compactions;
+}
+
void rocksdb_options_set_max_background_flushes(rocksdb_options_t* opt, int n) {
opt->rep.max_background_flushes = n;
}
+int rocksdb_options_get_max_background_flushes(rocksdb_options_t* opt) {
+ return opt->rep.max_background_flushes;
+}
+
void rocksdb_options_set_max_log_file_size(rocksdb_options_t* opt, size_t v) {
opt->rep.max_log_file_size = v;
}
+size_t rocksdb_options_get_max_log_file_size(rocksdb_options_t* opt) {
+ return opt->rep.max_log_file_size;
+}
+
void rocksdb_options_set_log_file_time_to_roll(rocksdb_options_t* opt, size_t v) {
opt->rep.log_file_time_to_roll = v;
}
+size_t rocksdb_options_get_log_file_time_to_roll(rocksdb_options_t* opt) {
+ return opt->rep.log_file_time_to_roll;
+}
+
void rocksdb_options_set_keep_log_file_num(rocksdb_options_t* opt, size_t v) {
opt->rep.keep_log_file_num = v;
}
+size_t rocksdb_options_get_keep_log_file_num(rocksdb_options_t* opt) {
+ return opt->rep.keep_log_file_num;
+}
+
void rocksdb_options_set_recycle_log_file_num(rocksdb_options_t* opt,
size_t v) {
opt->rep.recycle_log_file_num = v;
}
+size_t rocksdb_options_get_recycle_log_file_num(rocksdb_options_t* opt) {
+ return opt->rep.recycle_log_file_num;
+}
+
void rocksdb_options_set_soft_rate_limit(rocksdb_options_t* opt, double v) {
opt->rep.soft_rate_limit = v;
}
+double rocksdb_options_get_soft_rate_limit(rocksdb_options_t* opt) {
+ return opt->rep.soft_rate_limit;
+}
+
void rocksdb_options_set_hard_rate_limit(rocksdb_options_t* opt, double v) {
opt->rep.hard_rate_limit = v;
}
+double rocksdb_options_get_hard_rate_limit(rocksdb_options_t* opt) {
+ return opt->rep.hard_rate_limit;
+}
+
void rocksdb_options_set_soft_pending_compaction_bytes_limit(rocksdb_options_t* opt, size_t v) {
opt->rep.soft_pending_compaction_bytes_limit = v;
}
+size_t rocksdb_options_get_soft_pending_compaction_bytes_limit(
+ rocksdb_options_t* opt) {
+ return opt->rep.soft_pending_compaction_bytes_limit;
+}
+
void rocksdb_options_set_hard_pending_compaction_bytes_limit(rocksdb_options_t* opt, size_t v) {
opt->rep.hard_pending_compaction_bytes_limit = v;
}
+size_t rocksdb_options_get_hard_pending_compaction_bytes_limit(
+ rocksdb_options_t* opt) {
+ return opt->rep.hard_pending_compaction_bytes_limit;
+}
+
void rocksdb_options_set_rate_limit_delay_max_milliseconds(
rocksdb_options_t* opt, unsigned int v) {
opt->rep.rate_limit_delay_max_milliseconds = v;
}
+unsigned int rocksdb_options_get_rate_limit_delay_max_milliseconds(
+ rocksdb_options_t* opt) {
+ return opt->rep.rate_limit_delay_max_milliseconds;
+}
+
void rocksdb_options_set_max_manifest_file_size(
rocksdb_options_t* opt, size_t v) {
opt->rep.max_manifest_file_size = v;
}
+size_t rocksdb_options_get_max_manifest_file_size(rocksdb_options_t* opt) {
+ return opt->rep.max_manifest_file_size;
+}
+
void rocksdb_options_set_table_cache_numshardbits(
rocksdb_options_t* opt, int v) {
opt->rep.table_cache_numshardbits = v;
}
+int rocksdb_options_get_table_cache_numshardbits(rocksdb_options_t* opt) {
+ return opt->rep.table_cache_numshardbits;
+}
+
void rocksdb_options_set_table_cache_remove_scan_count_limit(
rocksdb_options_t* /*opt*/, int /*v*/) {
// this option is deprecated
opt->rep.arena_block_size = v;
}
+size_t rocksdb_options_get_arena_block_size(rocksdb_options_t* opt) {
+ return opt->rep.arena_block_size;
+}
+
void rocksdb_options_set_disable_auto_compactions(rocksdb_options_t* opt, int disable) {
opt->rep.disable_auto_compactions = disable;
}
+unsigned char rocksdb_options_get_disable_auto_compactions(
+ rocksdb_options_t* opt) {
+ return opt->rep.disable_auto_compactions;
+}
+
void rocksdb_options_set_optimize_filters_for_hits(rocksdb_options_t* opt, int v) {
opt->rep.optimize_filters_for_hits = v;
}
+unsigned char rocksdb_options_get_optimize_filters_for_hits(
+ rocksdb_options_t* opt) {
+ return opt->rep.optimize_filters_for_hits;
+}
+
void rocksdb_options_set_delete_obsolete_files_period_micros(
rocksdb_options_t* opt, uint64_t v) {
opt->rep.delete_obsolete_files_period_micros = v;
}
+uint64_t rocksdb_options_get_delete_obsolete_files_period_micros(
+ rocksdb_options_t* opt) {
+ return opt->rep.delete_obsolete_files_period_micros;
+}
+
void rocksdb_options_prepare_for_bulk_load(rocksdb_options_t* opt) {
opt->rep.PrepareForBulkLoad();
}
opt->rep.memtable_prefix_bloom_size_ratio = v;
}
+double rocksdb_options_get_memtable_prefix_bloom_size_ratio(
+ rocksdb_options_t* opt) {
+ return opt->rep.memtable_prefix_bloom_size_ratio;
+}
+
void rocksdb_options_set_memtable_huge_page_size(rocksdb_options_t* opt,
size_t v) {
opt->rep.memtable_huge_page_size = v;
}
+size_t rocksdb_options_get_memtable_huge_page_size(rocksdb_options_t* opt) {
+ return opt->rep.memtable_huge_page_size;
+}
+
void rocksdb_options_set_hash_skip_list_rep(
rocksdb_options_t *opt, size_t bucket_count,
int32_t skiplist_height, int32_t skiplist_branching_factor) {
opt->rep.max_successive_merges = v;
}
+size_t rocksdb_options_get_max_successive_merges(rocksdb_options_t* opt) {
+ return opt->rep.max_successive_merges;
+}
+
void rocksdb_options_set_bloom_locality(
rocksdb_options_t* opt, uint32_t v) {
opt->rep.bloom_locality = v;
}
+uint32_t rocksdb_options_get_bloom_locality(rocksdb_options_t* opt) {
+ return opt->rep.bloom_locality;
+}
+
void rocksdb_options_set_inplace_update_support(
rocksdb_options_t* opt, unsigned char v) {
opt->rep.inplace_update_support = v;
}
+unsigned char rocksdb_options_get_inplace_update_support(
+ rocksdb_options_t* opt) {
+ return opt->rep.inplace_update_support;
+}
+
void rocksdb_options_set_inplace_update_num_locks(
rocksdb_options_t* opt, size_t v) {
opt->rep.inplace_update_num_locks = v;
}
+size_t rocksdb_options_get_inplace_update_num_locks(rocksdb_options_t* opt) {
+ return opt->rep.inplace_update_num_locks;
+}
+
void rocksdb_options_set_report_bg_io_stats(
rocksdb_options_t* opt, int v) {
opt->rep.report_bg_io_stats = v;
}
+unsigned char rocksdb_options_get_report_bg_io_stats(rocksdb_options_t* opt) {
+ return opt->rep.report_bg_io_stats;
+}
+
void rocksdb_options_set_compaction_style(rocksdb_options_t *opt, int style) {
opt->rep.compaction_style =
static_cast<ROCKSDB_NAMESPACE::CompactionStyle>(style);
}
+int rocksdb_options_get_compaction_style(rocksdb_options_t* opt) {
+ return opt->rep.compaction_style;
+}
+
void rocksdb_options_set_universal_compaction_options(rocksdb_options_t *opt, rocksdb_universal_compaction_options_t *uco) {
opt->rep.compaction_options_universal = *(uco->rep);
}
opt->rep.atomic_flush = atomic_flush;
}
+unsigned char rocksdb_options_get_atomic_flush(rocksdb_options_t* opt) {
+ return opt->rep.atomic_flush;
+}
+
rocksdb_ratelimiter_t* rocksdb_ratelimiter_create(
int64_t rate_bytes_per_sec,
int64_t refill_period_us,
opt->rep.verify_checksums = v;
}
+unsigned char rocksdb_readoptions_get_verify_checksums(
+ rocksdb_readoptions_t* opt) {
+ return opt->rep.verify_checksums;
+}
+
void rocksdb_readoptions_set_fill_cache(
rocksdb_readoptions_t* opt, unsigned char v) {
opt->rep.fill_cache = v;
}
+unsigned char rocksdb_readoptions_get_fill_cache(rocksdb_readoptions_t* opt) {
+ return opt->rep.fill_cache;
+}
+
void rocksdb_readoptions_set_snapshot(
rocksdb_readoptions_t* opt,
const rocksdb_snapshot_t* snap) {
opt->rep.read_tier = static_cast<ROCKSDB_NAMESPACE::ReadTier>(v);
}
+int rocksdb_readoptions_get_read_tier(rocksdb_readoptions_t* opt) {
+ return static_cast<int>(opt->rep.read_tier);
+}
+
void rocksdb_readoptions_set_tailing(
rocksdb_readoptions_t* opt, unsigned char v) {
opt->rep.tailing = v;
}
+unsigned char rocksdb_readoptions_get_tailing(rocksdb_readoptions_t* opt) {
+ return opt->rep.tailing;
+}
+
void rocksdb_readoptions_set_managed(
rocksdb_readoptions_t* opt, unsigned char v) {
opt->rep.managed = v;
opt->rep.readahead_size = v;
}
+size_t rocksdb_readoptions_get_readahead_size(rocksdb_readoptions_t* opt) {
+ return opt->rep.readahead_size;
+}
+
void rocksdb_readoptions_set_prefix_same_as_start(
rocksdb_readoptions_t* opt, unsigned char v) {
opt->rep.prefix_same_as_start = v;
}
+unsigned char rocksdb_readoptions_get_prefix_same_as_start(
+ rocksdb_readoptions_t* opt) {
+ return opt->rep.prefix_same_as_start;
+}
+
void rocksdb_readoptions_set_pin_data(rocksdb_readoptions_t* opt,
unsigned char v) {
opt->rep.pin_data = v;
}
+unsigned char rocksdb_readoptions_get_pin_data(rocksdb_readoptions_t* opt) {
+ return opt->rep.pin_data;
+}
+
void rocksdb_readoptions_set_total_order_seek(rocksdb_readoptions_t* opt,
unsigned char v) {
opt->rep.total_order_seek = v;
}
+unsigned char rocksdb_readoptions_get_total_order_seek(
+ rocksdb_readoptions_t* opt) {
+ return opt->rep.total_order_seek;
+}
+
void rocksdb_readoptions_set_max_skippable_internal_keys(
rocksdb_readoptions_t* opt,
uint64_t v) {
opt->rep.max_skippable_internal_keys = v;
}
+uint64_t rocksdb_readoptions_get_max_skippable_internal_keys(
+ rocksdb_readoptions_t* opt) {
+ return opt->rep.max_skippable_internal_keys;
+}
+
void rocksdb_readoptions_set_background_purge_on_iterator_cleanup(
rocksdb_readoptions_t* opt, unsigned char v) {
opt->rep.background_purge_on_iterator_cleanup = v;
}
+unsigned char rocksdb_readoptions_get_background_purge_on_iterator_cleanup(
+ rocksdb_readoptions_t* opt) {
+ return opt->rep.background_purge_on_iterator_cleanup;
+}
+
void rocksdb_readoptions_set_ignore_range_deletions(
rocksdb_readoptions_t* opt, unsigned char v) {
opt->rep.ignore_range_deletions = v;
}
+unsigned char rocksdb_readoptions_get_ignore_range_deletions(
+ rocksdb_readoptions_t* opt) {
+ return opt->rep.ignore_range_deletions;
+}
+
rocksdb_writeoptions_t* rocksdb_writeoptions_create() {
return new rocksdb_writeoptions_t;
}
opt->rep.sync = v;
}
+unsigned char rocksdb_writeoptions_get_sync(rocksdb_writeoptions_t* opt) {
+ return opt->rep.sync;
+}
+
void rocksdb_writeoptions_disable_WAL(rocksdb_writeoptions_t* opt, int disable) {
opt->rep.disableWAL = disable;
}
+unsigned char rocksdb_writeoptions_get_disable_WAL(
+ rocksdb_writeoptions_t* opt) {
+ return opt->rep.disableWAL;
+}
+
void rocksdb_writeoptions_set_ignore_missing_column_families(
rocksdb_writeoptions_t* opt,
unsigned char v) {
opt->rep.ignore_missing_column_families = v;
}
+unsigned char rocksdb_writeoptions_get_ignore_missing_column_families(
+ rocksdb_writeoptions_t* opt) {
+ return opt->rep.ignore_missing_column_families;
+}
+
void rocksdb_writeoptions_set_no_slowdown(
rocksdb_writeoptions_t* opt,
unsigned char v) {
opt->rep.no_slowdown = v;
}
+unsigned char rocksdb_writeoptions_get_no_slowdown(
+ rocksdb_writeoptions_t* opt) {
+ return opt->rep.no_slowdown;
+}
+
void rocksdb_writeoptions_set_low_pri(
rocksdb_writeoptions_t* opt,
unsigned char v) {
opt->rep.low_pri = v;
}
+unsigned char rocksdb_writeoptions_get_low_pri(rocksdb_writeoptions_t* opt) {
+ return opt->rep.low_pri;
+}
+
void rocksdb_writeoptions_set_memtable_insert_hint_per_batch(
rocksdb_writeoptions_t* opt, unsigned char v) {
opt->rep.memtable_insert_hint_per_batch = v;
}
+unsigned char rocksdb_writeoptions_get_memtable_insert_hint_per_batch(
+ rocksdb_writeoptions_t* opt) {
+ return opt->rep.memtable_insert_hint_per_batch;
+}
+
rocksdb_compactoptions_t* rocksdb_compactoptions_create() {
return new rocksdb_compactoptions_t;
}
opt->rep.bottommost_level_compaction = static_cast<BottommostLevelCompaction>(v);
}
+unsigned char rocksdb_compactoptions_get_bottommost_level_compaction(
+ rocksdb_compactoptions_t* opt) {
+ return static_cast<unsigned char>(opt->rep.bottommost_level_compaction);
+}
+
void rocksdb_compactoptions_set_exclusive_manual_compaction(
rocksdb_compactoptions_t* opt, unsigned char v) {
opt->rep.exclusive_manual_compaction = v;
}
+unsigned char rocksdb_compactoptions_get_exclusive_manual_compaction(
+ rocksdb_compactoptions_t* opt) {
+ return opt->rep.exclusive_manual_compaction;
+}
+
void rocksdb_compactoptions_set_change_level(rocksdb_compactoptions_t* opt,
unsigned char v) {
opt->rep.change_level = v;
}
+unsigned char rocksdb_compactoptions_get_change_level(
+ rocksdb_compactoptions_t* opt) {
+ return opt->rep.change_level;
+}
+
void rocksdb_compactoptions_set_target_level(rocksdb_compactoptions_t* opt,
int n) {
opt->rep.target_level = n;
}
+int rocksdb_compactoptions_get_target_level(rocksdb_compactoptions_t* opt) {
+ return opt->rep.target_level;
+}
+
rocksdb_flushoptions_t* rocksdb_flushoptions_create() {
return new rocksdb_flushoptions_t;
}
opt->rep.wait = v;
}
+unsigned char rocksdb_flushoptions_get_wait(rocksdb_flushoptions_t* opt) {
+ return opt->rep.wait;
+}
+
rocksdb_cache_t* rocksdb_cache_create_lru(size_t capacity) {
rocksdb_cache_t* c = new rocksdb_cache_t;
c->rep = NewLRUCache(capacity);
cache->rep->SetCapacity(capacity);
}
+size_t rocksdb_cache_get_capacity(rocksdb_cache_t* cache) {
+ return cache->rep->GetCapacity();
+}
+
size_t rocksdb_cache_get_usage(rocksdb_cache_t* cache) {
return cache->rep->GetUsage();
}
env->rep->SetBackgroundThreads(n);
}
+int rocksdb_env_get_background_threads(rocksdb_env_t* env) {
+ return env->rep->GetBackgroundThreads();
+}
+
+void rocksdb_env_set_bottom_priority_background_threads(rocksdb_env_t* env,
+ int n) {
+ env->rep->SetBackgroundThreads(n, Env::BOTTOM);
+}
+
+int rocksdb_env_get_bottom_priority_background_threads(rocksdb_env_t* env) {
+ return env->rep->GetBackgroundThreads(Env::BOTTOM);
+}
+
void rocksdb_env_set_high_priority_background_threads(rocksdb_env_t* env, int n) {
env->rep->SetBackgroundThreads(n, Env::HIGH);
}
+int rocksdb_env_get_high_priority_background_threads(rocksdb_env_t* env) {
+ return env->rep->GetBackgroundThreads(Env::HIGH);
+}
+
+void rocksdb_env_set_low_priority_background_threads(rocksdb_env_t* env,
+ int n) {
+ env->rep->SetBackgroundThreads(n, Env::LOW);
+}
+
+int rocksdb_env_get_low_priority_background_threads(rocksdb_env_t* env) {
+ return env->rep->GetBackgroundThreads(Env::LOW);
+}
+
void rocksdb_env_join_all_threads(rocksdb_env_t* env) {
env->rep->WaitForJoin();
}
uco->rep->size_ratio = ratio;
}
+int rocksdb_universal_compaction_options_get_size_ratio(
+ rocksdb_universal_compaction_options_t* uco) {
+ return uco->rep->size_ratio;
+}
+
void rocksdb_universal_compaction_options_set_min_merge_width(
rocksdb_universal_compaction_options_t* uco, int w) {
uco->rep->min_merge_width = w;
}
+int rocksdb_universal_compaction_options_get_min_merge_width(
+ rocksdb_universal_compaction_options_t* uco) {
+ return uco->rep->min_merge_width;
+}
+
void rocksdb_universal_compaction_options_set_max_merge_width(
rocksdb_universal_compaction_options_t* uco, int w) {
uco->rep->max_merge_width = w;
}
+int rocksdb_universal_compaction_options_get_max_merge_width(
+ rocksdb_universal_compaction_options_t* uco) {
+ return uco->rep->max_merge_width;
+}
+
void rocksdb_universal_compaction_options_set_max_size_amplification_percent(
rocksdb_universal_compaction_options_t* uco, int p) {
uco->rep->max_size_amplification_percent = p;
}
+int rocksdb_universal_compaction_options_get_max_size_amplification_percent(
+ rocksdb_universal_compaction_options_t* uco) {
+ return uco->rep->max_size_amplification_percent;
+}
+
void rocksdb_universal_compaction_options_set_compression_size_percent(
rocksdb_universal_compaction_options_t* uco, int p) {
uco->rep->compression_size_percent = p;
}
+int rocksdb_universal_compaction_options_get_compression_size_percent(
+ rocksdb_universal_compaction_options_t* uco) {
+ return uco->rep->compression_size_percent;
+}
+
void rocksdb_universal_compaction_options_set_stop_style(
rocksdb_universal_compaction_options_t* uco, int style) {
uco->rep->stop_style =
static_cast<ROCKSDB_NAMESPACE::CompactionStopStyle>(style);
}
+int rocksdb_universal_compaction_options_get_stop_style(
+ rocksdb_universal_compaction_options_t* uco) {
+ return static_cast<int>(uco->rep->stop_style);
+}
+
void rocksdb_universal_compaction_options_destroy(
rocksdb_universal_compaction_options_t* uco) {
delete uco->rep;
fifo_opts->rep.max_table_files_size = size;
}
+uint64_t rocksdb_fifo_compaction_options_get_max_table_files_size(
+ rocksdb_fifo_compaction_options_t* fifo_opts) {
+ return fifo_opts->rep.max_table_files_size;
+}
+
void rocksdb_fifo_compaction_options_destroy(
rocksdb_fifo_compaction_options_t* fifo_opts) {
delete fifo_opts;
return memory_usage->cache_total;
}
+void rocksdb_options_set_dump_malloc_stats(rocksdb_options_t* opt,
+ unsigned char val) {
+ opt->rep.dump_malloc_stats = val;
+}
+
+void rocksdb_options_set_memtable_whole_key_filtering(rocksdb_options_t* opt,
+ unsigned char val) {
+ opt->rep.memtable_whole_key_filtering = val;
+}
+
// deletes container with memory usage estimates
void rocksdb_approximate_memory_usage_destroy(rocksdb_memory_usage_t* usage) {
delete usage;
}
+void rocksdb_cancel_all_background_work(rocksdb_t* db, unsigned char wait) {
+ CancelAllBackgroundWork(db->rep, wait);
+}
+
} // end extern "C"
#endif // !ROCKSDB_LITE
projects / ceph.git / blobdiff