diff --git a/db/c.cc b/db/c.cc index 15815f372c84..0f2e7d381491 100644 --- a/db/c.cc +++ b/db/c.cc @@ -9,12 +9,17 @@ #include "rocksdb/c.h" +#include #include #include #include +#include #include #include +#include "options/cf_options.h" +#include "options/db_options.h" +#include "options/options_helper.h" #include "port/port.h" #include "rocksdb/advanced_cache.h" #include "rocksdb/compaction_filter.h" @@ -30,6 +35,7 @@ #include "rocksdb/merge_operator.h" #include "rocksdb/options.h" #include "rocksdb/perf_context.h" +#include "rocksdb/persistent_cache.h" #include "rocksdb/rate_limiter.h" #include "rocksdb/slice_transform.h" #include "rocksdb/sst_file_manager.h" @@ -64,6 +70,7 @@ using ROCKSDB_NAMESPACE::BlockBasedTableOptions; using ROCKSDB_NAMESPACE::BottommostLevelCompaction; using ROCKSDB_NAMESPACE::BytewiseComparator; using ROCKSDB_NAMESPACE::Cache; +using ROCKSDB_NAMESPACE::CFOptionsAsConfigurable; using ROCKSDB_NAMESPACE::Checkpoint; using ROCKSDB_NAMESPACE::ColumnFamilyDescriptor; using ROCKSDB_NAMESPACE::ColumnFamilyHandle; @@ -85,7 +92,9 @@ using ROCKSDB_NAMESPACE::CreateBackupOptions; using ROCKSDB_NAMESPACE::CuckooTableOptions; using ROCKSDB_NAMESPACE::DB; using ROCKSDB_NAMESPACE::DBOptions; +using ROCKSDB_NAMESPACE::DBOptionsAsConfigurable; using ROCKSDB_NAMESPACE::DbPath; +using ROCKSDB_NAMESPACE::DBWithTTL; using ROCKSDB_NAMESPACE::Env; using ROCKSDB_NAMESPACE::EnvOptions; using ROCKSDB_NAMESPACE::EventListener; @@ -108,16 +117,20 @@ using ROCKSDB_NAMESPACE::MemoryAllocator; using ROCKSDB_NAMESPACE::MemoryUtil; using ROCKSDB_NAMESPACE::MemTableInfo; using ROCKSDB_NAMESPACE::MergeOperator; +using ROCKSDB_NAMESPACE::MutableCFOptions; +using ROCKSDB_NAMESPACE::MutableDBOptions; using ROCKSDB_NAMESPACE::NewBloomFilterPolicy; using ROCKSDB_NAMESPACE::NewCompactOnDeletionCollectorFactory; using ROCKSDB_NAMESPACE::NewGenericRateLimiter; using ROCKSDB_NAMESPACE::NewLRUCache; +using ROCKSDB_NAMESPACE::NewPersistentCache; using ROCKSDB_NAMESPACE::NewRibbonFilterPolicy; using ROCKSDB_NAMESPACE::OptimisticTransactionDB; using ROCKSDB_NAMESPACE::OptimisticTransactionOptions; using ROCKSDB_NAMESPACE::Options; using ROCKSDB_NAMESPACE::PerfContext; using ROCKSDB_NAMESPACE::PerfLevel; +using ROCKSDB_NAMESPACE::PersistentCache; using ROCKSDB_NAMESPACE::PinnableSlice; using ROCKSDB_NAMESPACE::PrepopulateBlobCache; using ROCKSDB_NAMESPACE::RandomAccessFile; @@ -137,6 +150,7 @@ using ROCKSDB_NAMESPACE::SstFileReader; using ROCKSDB_NAMESPACE::SstFileWriter; using ROCKSDB_NAMESPACE::Status; using ROCKSDB_NAMESPACE::StderrLogger; +using ROCKSDB_NAMESPACE::StringToMap; using ROCKSDB_NAMESPACE::SubcompactionJobInfo; using ROCKSDB_NAMESPACE::TableProperties; using ROCKSDB_NAMESPACE::TablePropertiesCollectorFactory; @@ -163,6 +177,7 @@ extern "C" { struct rocksdb_t { DB* rep; + bool owns_db; }; struct rocksdb_status_ptr_t { Status* rep; @@ -213,6 +228,7 @@ struct rocksdb_readoptions_t { Slice lower_bound; Slice timestamp; Slice iter_start_ts; + rocksdb_table_filter_t* table_filter; }; struct rocksdb_writeoptions_t { WriteOptions rep; @@ -254,6 +270,12 @@ struct rocksdb_filelock_t { struct rocksdb_logger_t { std::shared_ptr rep; }; +struct rocksdb_mutable_cf_options_t { + MutableCFOptions rep; +}; +struct rocksdb_mutable_db_options_t { + MutableDBOptions rep; +}; struct rocksdb_lru_cache_options_t { LRUCacheOptions rep; }; @@ -314,12 +336,20 @@ struct rocksdb_sstfilereader_t { struct rocksdb_tableproperties_t { std::shared_ptr rep; }; +struct rocksdb_table_filter_t { + void* state; + void (*destructor)(void*); + rocksdb_table_filter_callback callback; +}; struct rocksdb_ratelimiter_t { std::shared_ptr rep; }; struct rocksdb_perfcontext_t { PerfContext* rep; }; +struct rocksdb_persistent_cache_t { + std::shared_ptr rep; +}; struct rocksdb_pinnableslice_t { PinnableSlice rep; }; @@ -341,6 +371,9 @@ struct rocksdb_backup_engine_options_t { struct rocksdb_checkpoint_t { Checkpoint* rep; }; +struct rocksdb_ttl_t { + DBWithTTL* rep; +}; struct rocksdb_optimistictransactiondb_t { OptimisticTransactionDB* rep; }; @@ -656,6 +689,58 @@ struct rocksdb_callback_logger_t : public Logger { void* priv_ = nullptr; }; +struct rocksdb_log_callback_logger_t : public Logger { + static const ssize_t STACK_BUFSZ = 512; + rocksdb_log_callback_logger_t(void* state, void (*destructor)(void*), + rocksdb_log_callback callback) + : Logger(), state_(state), destructor_(destructor), callback_(callback) {} + + ~rocksdb_log_callback_logger_t() override { + if (destructor_ != nullptr) { + destructor_(state_); + } + } + + using Logger::Logv; + void Logv(const InfoLogLevel level, const char* fmt, va_list ap0) override { + if (callback_ == nullptr) { + return; + } + char stack_buf[STACK_BUFSZ]; + char* alloc_buf = nullptr; + char* buf = stack_buf; + int len = 0; + va_list ap1; + va_copy(ap1, ap0); + len = vsnprintf(buf, STACK_BUFSZ, fmt, ap0); + if (len <= 0) { + va_end(ap1); + return; + } + if (len >= STACK_BUFSZ) { + buf = alloc_buf = reinterpret_cast(malloc(len + 1)); + if (buf == nullptr) { + va_end(ap1); + return; + } + len = vsnprintf(buf, len + 1, fmt, ap1); + if (len <= 0) { + free(alloc_buf); + va_end(ap1); + return; + } + } + callback_(state_, static_cast(level), buf); + free(alloc_buf); + va_end(ap1); + } + + private: + void* state_ = nullptr; + void (*destructor_)(void*) = nullptr; + rocksdb_log_callback callback_ = nullptr; +}; + static bool SaveError(char** errptr, const Status& s) { assert(errptr != nullptr); if (s.ok()) { @@ -692,6 +777,7 @@ rocksdb_t* rocksdb_open(const rocksdb_options_t* options, const char* name, } rocksdb_t* result = new rocksdb_t; result->rep = db; + result->owns_db = true; return result; } @@ -704,6 +790,7 @@ rocksdb_t* rocksdb_open_with_ttl(const rocksdb_options_t* options, } rocksdb_t* result = new rocksdb_t; result->rep = db; + result->owns_db = true; return result; } @@ -718,6 +805,7 @@ rocksdb_t* rocksdb_open_for_read_only(const rocksdb_options_t* options, } rocksdb_t* result = new rocksdb_t; result->rep = db; + result->owns_db = true; return result; } @@ -733,6 +821,7 @@ rocksdb_t* rocksdb_open_as_secondary(const rocksdb_options_t* options, } rocksdb_t* result = new rocksdb_t; result->rep = db; + result->owns_db = true; return result; } @@ -1081,7 +1170,12 @@ void rocksdb_checkpoint_object_destroy(rocksdb_checkpoint_t* checkpoint) { } void rocksdb_close(rocksdb_t* db) { - delete db->rep; + if (db == nullptr) { + return; + } + if (db->owns_db && db->rep != nullptr) { + delete db->rep; + } delete db; } @@ -1122,6 +1216,7 @@ rocksdb_t* rocksdb_open_and_trim_history( } rocksdb_t* result = new rocksdb_t; result->rep = db; + result->owns_db = true; return result; } @@ -1153,6 +1248,7 @@ rocksdb_t* rocksdb_open_column_families( } rocksdb_t* result = new rocksdb_t; result->rep = db; + result->owns_db = true; return result; } @@ -1189,6 +1285,58 @@ rocksdb_t* rocksdb_open_column_families_with_ttl( } rocksdb_t* result = new rocksdb_t; result->rep = db; + result->owns_db = true; + return result; +} + +rocksdb_ttl_t* rocksdb_ttl_open(rocksdb_options_t* options, const char* name, + int ttl, unsigned char read_only, + char** errptr) { + DBWithTTL* db = nullptr; + if (SaveError(errptr, DBWithTTL::Open(options->rep, std::string(name), &db, + ttl, read_only != 0))) { + return nullptr; + } + auto* result = new rocksdb_ttl_t; + result->rep = db; + return result; +} + +rocksdb_ttl_t* rocksdb_ttl_open_column_families( + rocksdb_options_t* options, const char* name, int num_column_families, + const char* const* column_family_names, + rocksdb_options_t* const* column_family_options, const int* ttls, + rocksdb_column_family_handle_t** handles, unsigned char read_only, + char** errptr) { + std::vector ttl_values; + std::vector column_families; + ttl_values.reserve(num_column_families); + column_families.reserve(num_column_families); + for (int i = 0; i < num_column_families; ++i) { + ttl_values.push_back(ttls[i]); + column_families.emplace_back( + std::string(column_family_names[i]), + ColumnFamilyOptions(column_family_options[i]->rep)); + } + + DBWithTTL* db = nullptr; + std::vector cf_handles; + if (SaveError(errptr, + DBWithTTL::Open(DBOptions(options->rep), std::string(name), + column_families, &cf_handles, &db, ttl_values, + read_only != 0))) { + return nullptr; + } + + for (size_t i = 0; i < cf_handles.size(); ++i) { + rocksdb_column_family_handle_t* handle = new rocksdb_column_family_handle_t; + handle->rep = cf_handles[i]; + handle->immortal = false; + handles[i] = handle; + } + + auto* result = new rocksdb_ttl_t; + result->rep = db; return result; } @@ -1223,6 +1371,7 @@ rocksdb_t* rocksdb_open_for_read_only_column_families( } rocksdb_t* result = new rocksdb_t; result->rep = db; + result->owns_db = true; return result; } @@ -1255,6 +1404,7 @@ rocksdb_t* rocksdb_open_as_secondary_column_families( } rocksdb_t* result = new rocksdb_t; result->rep = db; + result->owns_db = true; return result; } @@ -1336,6 +1486,35 @@ rocksdb_column_family_handle_t* rocksdb_create_column_family_with_ttl( return handle; } +rocksdb_column_family_handle_t* rocksdb_ttl_create_column_family( + rocksdb_ttl_t* db, rocksdb_options_t* column_family_options, + const char* column_family_name, int ttl, char** errptr) { + rocksdb_column_family_handle_t* handle = new rocksdb_column_family_handle_t; + SaveError(errptr, db->rep->CreateColumnFamilyWithTtl( + ColumnFamilyOptions(column_family_options->rep), + std::string(column_family_name), &(handle->rep), ttl)); + handle->immortal = false; + return handle; +} + +rocksdb_t* rocksdb_ttl_get_base_db(rocksdb_ttl_t* db) { + if (db == nullptr) { + return nullptr; + } + rocksdb_t* result = new rocksdb_t; + result->rep = db->rep->GetBaseDB(); + result->owns_db = false; + return result; +} + +void rocksdb_ttl_close(rocksdb_ttl_t* db) { + if (db == nullptr) { + return; + } + delete db->rep; + delete db; +} + void rocksdb_drop_column_family(rocksdb_t* db, rocksdb_column_family_handle_t* handle, char** errptr) { @@ -4013,6 +4192,14 @@ rocksdb_logger_t* rocksdb_logger_create_callback_logger( return logger; } +rocksdb_logger_t* rocksdb_logger_create(void* state, void (*destructor)(void*), + rocksdb_log_callback callback) { + rocksdb_logger_t* logger = new rocksdb_logger_t; + logger->rep = std::make_shared( + state, destructor, callback); + return logger; +} + void rocksdb_logger_destroy(rocksdb_logger_t* logger) { delete logger; } void rocksdb_options_set_env(rocksdb_options_t* opt, rocksdb_env_t* env) { @@ -5567,6 +5754,11 @@ rocksdb_comparator_t* rocksdb_comparator_with_ts_create( return result; } +int rocksdb_comparator_get_comparator_type( + const rocksdb_comparator_t* /*comparator*/) { + return 0; +} + void rocksdb_filterpolicy_destroy(rocksdb_filterpolicy_t* filter) { delete filter; } @@ -5683,7 +5875,9 @@ void rocksdb_mergeoperator_destroy(rocksdb_mergeoperator_t* merge_operator) { } rocksdb_readoptions_t* rocksdb_readoptions_create() { - return new rocksdb_readoptions_t; + rocksdb_readoptions_t* result = new rocksdb_readoptions_t; + result->table_filter = nullptr; + return result; } void rocksdb_readoptions_destroy(rocksdb_readoptions_t* opt) { delete opt; } @@ -5877,6 +6071,45 @@ void rocksdb_readoptions_set_iter_start_ts(rocksdb_readoptions_t* opt, } } +rocksdb_table_filter_t* rocksdb_table_filter_create( + void* state, void (*destructor)(void*), + rocksdb_table_filter_callback callback) { + rocksdb_table_filter_t* filter = new rocksdb_table_filter_t; + filter->state = state; + filter->destructor = destructor; + filter->callback = callback; + return filter; +} + +void rocksdb_table_filter_destroy(rocksdb_table_filter_t* filter) { + if (filter == nullptr) { + return; + } + if (filter->destructor != nullptr) { + filter->destructor(filter->state); + } + delete filter; +} + +void rocksdb_readoptions_set_table_filter(rocksdb_readoptions_t* opt, + rocksdb_table_filter_t* filter) { + if (filter == nullptr) { + opt->rep.table_filter = nullptr; + opt->table_filter = nullptr; + return; + } + opt->table_filter = filter; + opt->rep.table_filter = [filter](const TableProperties& props) { + if (filter->callback == nullptr) { + return true; + } + rocksdb_tableproperties_t props_wrapper; + props_wrapper.rep = std::shared_ptr( + &props, [](const TableProperties*) {}); + return filter->callback(filter->state, &props_wrapper) != 0; + }; +} + void rocksdb_readoptions_set_auto_readahead_size(rocksdb_readoptions_t* opt, unsigned char v) { opt->rep.auto_readahead_size = v; @@ -6158,6 +6391,28 @@ rocksdb_cache_t* rocksdb_cache_create_hyper_clock_opts( return c; } +rocksdb_persistent_cache_t* rocksdb_persistent_cache_create( + rocksdb_env_t* env, const char* path, uint64_t size_bytes, + rocksdb_logger_t* logger, unsigned char optimized_for_nvm, char** errptr) { + std::shared_ptr cache; + Env* base_env = env != nullptr ? env->rep : Env::Default(); + std::shared_ptr log_ptr = + logger != nullptr ? logger->rep : std::shared_ptr(); + Status s = ROCKSDB_NAMESPACE::NewPersistentCache( + base_env, path != nullptr ? path : std::string(), size_bytes, log_ptr, + optimized_for_nvm != 0, &cache); + if (SaveError(errptr, s)) { + return nullptr; + } + rocksdb_persistent_cache_t* result = new rocksdb_persistent_cache_t; + result->rep = std::move(cache); + return result; +} + +void rocksdb_persistent_cache_destroy(rocksdb_persistent_cache_t* cache) { + delete cache; +} + void rocksdb_cache_destroy(rocksdb_cache_t* cache) { delete cache; } void rocksdb_cache_disown_data(rocksdb_cache_t* cache) { @@ -6327,6 +6582,22 @@ rocksdb_env_t* rocksdb_create_mem_env() { return result; } +rocksdb_env_t* rocksdb_mem_env_create(rocksdb_env_t* base_env) { + rocksdb_env_t* result = new rocksdb_env_t; + Env* env = base_env != nullptr ? base_env->rep : Env::Default(); + result->rep = ROCKSDB_NAMESPACE::NewMemEnv(env); + result->is_default = false; + return result; +} + +rocksdb_env_t* rocksdb_timed_env_create(rocksdb_env_t* base_env) { + rocksdb_env_t* result = new rocksdb_env_t; + Env* env = base_env != nullptr ? base_env->rep : Env::Default(); + result->rep = ROCKSDB_NAMESPACE::NewTimedEnv(env); + result->is_default = false; + return result; +} + void rocksdb_env_set_background_threads(rocksdb_env_t* env, int n) { env->rep->SetBackgroundThreads(n); } @@ -7994,13 +8265,18 @@ rocksdb_t* rocksdb_transactiondb_get_base_db(rocksdb_transactiondb_t* txn_db) { if (base_db != nullptr) { rocksdb_t* result = new rocksdb_t; result->rep = base_db; + result->owns_db = false; return result; } return nullptr; } -void rocksdb_transactiondb_close_base_db(rocksdb_t* base_db) { delete base_db; } +void rocksdb_transactiondb_close_base_db(rocksdb_t* base_db) { + if (base_db != nullptr) { + rocksdb_close(base_db); + } +} rocksdb_transaction_t* rocksdb_transaction_begin( rocksdb_transactiondb_t* txn_db, @@ -8988,6 +9264,7 @@ rocksdb_t* rocksdb_optimistictransactiondb_get_base_db( if (base_db != nullptr) { rocksdb_t* result = new rocksdb_t; result->rep = base_db; + result->owns_db = false; return result; } @@ -8995,7 +9272,9 @@ rocksdb_t* rocksdb_optimistictransactiondb_get_base_db( } void rocksdb_optimistictransactiondb_close_base_db(rocksdb_t* base_db) { - delete base_db; + if (base_db != nullptr) { + rocksdb_close(base_db); + } } rocksdb_transaction_t* rocksdb_optimistictransaction_begin( @@ -9339,4 +9618,324 @@ uint64_t rocksdb_wait_for_compact_options_get_timeout( return opt->rep.timeout.count(); } +rocksdb_mutable_cf_options_t* rocksdb_mutable_cf_options_create(void) { + auto* opts = new rocksdb_mutable_cf_options_t; + opts->rep = MutableCFOptions(); + return opts; +} + +void rocksdb_mutable_cf_options_destroy(rocksdb_mutable_cf_options_t* opts) { + delete opts; +} + +rocksdb_mutable_cf_options_t* rocksdb_mutable_cf_options_clone( + const rocksdb_mutable_cf_options_t* opts) { + auto* result = new rocksdb_mutable_cf_options_t; + result->rep = opts->rep; + return result; +} + +void rocksdb_mutable_cf_options_set_write_buffer_size( + rocksdb_mutable_cf_options_t* opts, uint64_t size) { + opts->rep.write_buffer_size = size; +} + +uint64_t rocksdb_mutable_cf_options_get_write_buffer_size( + const rocksdb_mutable_cf_options_t* opts) { + return opts->rep.write_buffer_size; +} + +void rocksdb_mutable_cf_options_set_disable_auto_compactions( + rocksdb_mutable_cf_options_t* opts, unsigned char disable) { + opts->rep.disable_auto_compactions = disable != 0; +} + +unsigned char rocksdb_mutable_cf_options_get_disable_auto_compactions( + const rocksdb_mutable_cf_options_t* opts) { + return opts->rep.disable_auto_compactions ? 1 : 0; +} + +void rocksdb_mutable_cf_options_set_level0_file_num_compaction_trigger( + rocksdb_mutable_cf_options_t* opts, int trigger) { + opts->rep.level0_file_num_compaction_trigger = trigger; +} + +int rocksdb_mutable_cf_options_get_level0_file_num_compaction_trigger( + const rocksdb_mutable_cf_options_t* opts) { + return opts->rep.level0_file_num_compaction_trigger; +} + +void rocksdb_mutable_cf_options_set_max_compaction_bytes( + rocksdb_mutable_cf_options_t* opts, uint64_t bytes) { + opts->rep.max_compaction_bytes = bytes; +} + +uint64_t rocksdb_mutable_cf_options_get_max_compaction_bytes( + const rocksdb_mutable_cf_options_t* opts) { + return opts->rep.max_compaction_bytes; +} + +void rocksdb_mutable_cf_options_set_max_bytes_for_level_base( + rocksdb_mutable_cf_options_t* opts, uint64_t bytes) { + opts->rep.max_bytes_for_level_base = bytes; +} + +uint64_t rocksdb_mutable_cf_options_get_max_bytes_for_level_base( + const rocksdb_mutable_cf_options_t* opts) { + return opts->rep.max_bytes_for_level_base; +} + +void rocksdb_mutable_cf_options_set_compression( + rocksdb_mutable_cf_options_t* opts, int compression) { + opts->rep.compression = static_cast(compression); +} + +int rocksdb_mutable_cf_options_get_compression( + const rocksdb_mutable_cf_options_t* opts) { + return static_cast(opts->rep.compression); +} + +rocksdb_mutable_cf_options_t* rocksdb_mutable_cf_options_create_from_string( + const char* opts_str, unsigned char ignore_unknown, char** errptr) { + std::unordered_map opts_map; + if (opts_str != nullptr) { + Status parse = StringToMap(std::string(opts_str), &opts_map); + if (!parse.ok()) { + SaveError(errptr, parse); + return nullptr; + } + } + MutableCFOptions base_options; + auto config = CFOptionsAsConfigurable(base_options); + ConfigOptions config_options; + config_options.ignore_unknown_options = ignore_unknown != 0; + Status s = config->ConfigureFromMap(config_options, opts_map); + if (!s.ok()) { + SaveError(errptr, s); + return nullptr; + } + const MutableCFOptions* configured = + config->GetOptions(MutableCFOptions::kName()); + if (configured == nullptr) { + SaveError(errptr, + Status::InvalidArgument("MutableCFOptions configuration failed")); + return nullptr; + } + auto* result = new rocksdb_mutable_cf_options_t; + result->rep = *configured; + return result; +} + +rocksdb_mutable_db_options_t* rocksdb_mutable_db_options_create(void) { + auto* opts = new rocksdb_mutable_db_options_t; + opts->rep = MutableDBOptions(); + return opts; +} + +void rocksdb_mutable_db_options_destroy(rocksdb_mutable_db_options_t* opts) { + delete opts; +} + +rocksdb_mutable_db_options_t* rocksdb_mutable_db_options_clone( + const rocksdb_mutable_db_options_t* opts) { + auto* result = new rocksdb_mutable_db_options_t; + result->rep = opts->rep; + return result; +} + +rocksdb_mutable_db_options_t* rocksdb_mutable_db_options_create_from_string( + const char* opts_str, unsigned char ignore_unknown, char** errptr) { + std::unordered_map opts_map; + if (opts_str != nullptr) { + Status parse = StringToMap(std::string(opts_str), &opts_map); + if (!parse.ok()) { + SaveError(errptr, parse); + return nullptr; + } + } + MutableDBOptions base_options; + auto config = DBOptionsAsConfigurable(base_options); + ConfigOptions config_options; + config_options.ignore_unknown_options = ignore_unknown != 0; + Status s = config->ConfigureFromMap(config_options, opts_map); + if (!s.ok()) { + SaveError(errptr, s); + return nullptr; + } + const MutableDBOptions* configured = + config->GetOptions(MutableDBOptions::kName()); + if (configured == nullptr) { + SaveError(errptr, + Status::InvalidArgument("MutableDBOptions configuration failed")); + return nullptr; + } + auto* result = new rocksdb_mutable_db_options_t; + result->rep = *configured; + return result; +} + +void rocksdb_mutable_db_options_set_max_background_jobs( + rocksdb_mutable_db_options_t* opts, int jobs) { + opts->rep.max_background_jobs = jobs; +} + +int rocksdb_mutable_db_options_get_max_background_jobs( + const rocksdb_mutable_db_options_t* opts) { + return opts->rep.max_background_jobs; +} + +void rocksdb_mutable_db_options_set_max_background_compactions( + rocksdb_mutable_db_options_t* opts, int jobs) { + opts->rep.max_background_compactions = jobs; +} + +int rocksdb_mutable_db_options_get_max_background_compactions( + const rocksdb_mutable_db_options_t* opts) { + return opts->rep.max_background_compactions; +} + +void rocksdb_mutable_db_options_set_avoid_flush_during_shutdown( + rocksdb_mutable_db_options_t* opts, unsigned char avoid) { + opts->rep.avoid_flush_during_shutdown = avoid != 0; +} + +unsigned char rocksdb_mutable_db_options_get_avoid_flush_during_shutdown( + const rocksdb_mutable_db_options_t* opts) { + return opts->rep.avoid_flush_during_shutdown ? 1 : 0; +} + +void rocksdb_mutable_db_options_set_writable_file_max_buffer_size( + rocksdb_mutable_db_options_t* opts, uint64_t bytes) { + opts->rep.writable_file_max_buffer_size = static_cast(bytes); +} + +uint64_t rocksdb_mutable_db_options_get_writable_file_max_buffer_size( + const rocksdb_mutable_db_options_t* opts) { + return opts->rep.writable_file_max_buffer_size; +} + +void rocksdb_mutable_db_options_set_delayed_write_rate( + rocksdb_mutable_db_options_t* opts, uint64_t bytes_per_sec) { + opts->rep.delayed_write_rate = bytes_per_sec; +} + +uint64_t rocksdb_mutable_db_options_get_delayed_write_rate( + const rocksdb_mutable_db_options_t* opts) { + return opts->rep.delayed_write_rate; +} + +void rocksdb_mutable_db_options_set_max_total_wal_size( + rocksdb_mutable_db_options_t* opts, uint64_t bytes) { + opts->rep.max_total_wal_size = bytes; +} + +uint64_t rocksdb_mutable_db_options_get_max_total_wal_size( + const rocksdb_mutable_db_options_t* opts) { + return opts->rep.max_total_wal_size; +} + +void rocksdb_mutable_db_options_set_delete_obsolete_files_period_micros( + rocksdb_mutable_db_options_t* opts, uint64_t micros) { + opts->rep.delete_obsolete_files_period_micros = micros; +} + +uint64_t rocksdb_mutable_db_options_get_delete_obsolete_files_period_micros( + const rocksdb_mutable_db_options_t* opts) { + return opts->rep.delete_obsolete_files_period_micros; +} + +void rocksdb_mutable_db_options_set_stats_dump_period_sec( + rocksdb_mutable_db_options_t* opts, int seconds) { + opts->rep.stats_dump_period_sec = seconds; +} + +int rocksdb_mutable_db_options_get_stats_dump_period_sec( + const rocksdb_mutable_db_options_t* opts) { + return opts->rep.stats_dump_period_sec; +} + +void rocksdb_mutable_db_options_set_stats_persist_period_sec( + rocksdb_mutable_db_options_t* opts, int seconds) { + opts->rep.stats_persist_period_sec = seconds; +} + +int rocksdb_mutable_db_options_get_stats_persist_period_sec( + const rocksdb_mutable_db_options_t* opts) { + return opts->rep.stats_persist_period_sec; +} + +void rocksdb_mutable_db_options_set_stats_history_buffer_size( + rocksdb_mutable_db_options_t* opts, uint64_t bytes) { + opts->rep.stats_history_buffer_size = bytes; +} + +uint64_t rocksdb_mutable_db_options_get_stats_history_buffer_size( + const rocksdb_mutable_db_options_t* opts) { + return opts->rep.stats_history_buffer_size; +} + +void rocksdb_mutable_db_options_set_max_open_files( + rocksdb_mutable_db_options_t* opts, int files) { + opts->rep.max_open_files = files; +} + +int rocksdb_mutable_db_options_get_max_open_files( + const rocksdb_mutable_db_options_t* opts) { + return opts->rep.max_open_files; +} + +void rocksdb_mutable_db_options_set_bytes_per_sync( + rocksdb_mutable_db_options_t* opts, uint64_t bytes) { + opts->rep.bytes_per_sync = bytes; +} + +uint64_t rocksdb_mutable_db_options_get_bytes_per_sync( + const rocksdb_mutable_db_options_t* opts) { + return opts->rep.bytes_per_sync; +} + +void rocksdb_mutable_db_options_set_wal_bytes_per_sync( + rocksdb_mutable_db_options_t* opts, uint64_t bytes) { + opts->rep.wal_bytes_per_sync = bytes; +} + +uint64_t rocksdb_mutable_db_options_get_wal_bytes_per_sync( + const rocksdb_mutable_db_options_t* opts) { + return opts->rep.wal_bytes_per_sync; +} + +void rocksdb_mutable_db_options_set_strict_bytes_per_sync( + rocksdb_mutable_db_options_t* opts, unsigned char strict) { + opts->rep.strict_bytes_per_sync = strict != 0; +} + +unsigned char rocksdb_mutable_db_options_get_strict_bytes_per_sync( + const rocksdb_mutable_db_options_t* opts) { + return opts->rep.strict_bytes_per_sync ? 1 : 0; +} + +void rocksdb_mutable_db_options_set_compaction_readahead_size( + rocksdb_mutable_db_options_t* opts, uint64_t bytes) { + opts->rep.compaction_readahead_size = bytes; +} + +uint64_t rocksdb_mutable_db_options_get_compaction_readahead_size( + const rocksdb_mutable_db_options_t* opts) { + return opts->rep.compaction_readahead_size; +} + +void rocksdb_mutable_db_options_set_daily_offpeak_time_utc( + rocksdb_mutable_db_options_t* opts, const char* offpeak_time) { + if (offpeak_time == nullptr) { + opts->rep.daily_offpeak_time_utc.clear(); + } else { + opts->rep.daily_offpeak_time_utc = offpeak_time; + } +} + +const char* rocksdb_mutable_db_options_get_daily_offpeak_time_utc( + const rocksdb_mutable_db_options_t* opts) { + return opts->rep.daily_offpeak_time_utc.c_str(); +} + } // end extern "C" diff --git a/db/c_test.c b/db/c_test.c index b9850cc5694e..a854d11ce47e 100644 --- a/db/c_test.c +++ b/db/c_test.c @@ -75,6 +75,51 @@ static const char* GetTempDir(void) { abort(); \ } +typedef struct LoggerCallbackState { + int destructor_called; + int callback_called; + int last_level; +} LoggerCallbackState; + +static void TestLoggerDestructor(void* state) { + LoggerCallbackState* logger_state = (LoggerCallbackState*)state; + if (logger_state != NULL) { + logger_state->destructor_called += 1; + } +} + +static void TestLoggerCallback(void* state, int info_log_level, + const char* message) { + LoggerCallbackState* logger_state = (LoggerCallbackState*)state; + if (logger_state != NULL) { + logger_state->callback_called += 1; + logger_state->last_level = info_log_level; + } + (void)message; +} + +typedef struct TableFilterState { + int destructor_called; + int callback_called; +} TableFilterState; + +static void TestTableFilterDestructor(void* state) { + TableFilterState* filter_state = (TableFilterState*)state; + if (filter_state != NULL) { + filter_state->destructor_called += 1; + } +} + +static unsigned char TestTableFilterCallback( + void* state, const rocksdb_tableproperties_t* props) { + TableFilterState* filter_state = (TableFilterState*)state; + if (filter_state != NULL) { + filter_state->callback_called += 1; + } + (void)props; + return 1; +} + static void CheckEqual(const char* expected, const char* v, size_t n) { if (expected == NULL && v == NULL) { // ok @@ -4838,6 +4883,258 @@ int main(int argc, char** argv) { rocksdb_sst_file_manager_destroy(sst_file_manager); } + StartPhase("mutable_cf_options_api"); + { + rocksdb_mutable_cf_options_t* mutable_cf = + rocksdb_mutable_cf_options_create(); + rocksdb_mutable_cf_options_set_write_buffer_size(mutable_cf, 2048); + rocksdb_mutable_cf_options_set_disable_auto_compactions(mutable_cf, 1); + rocksdb_mutable_cf_options_set_level0_file_num_compaction_trigger( + mutable_cf, 4); + rocksdb_mutable_cf_options_set_max_compaction_bytes(mutable_cf, 4096); + rocksdb_mutable_cf_options_set_max_bytes_for_level_base(mutable_cf, 8192); + rocksdb_mutable_cf_options_set_compression(mutable_cf, + rocksdb_no_compression); + CheckCondition( + rocksdb_mutable_cf_options_get_write_buffer_size(mutable_cf) == 2048); + CheckCondition(rocksdb_mutable_cf_options_get_disable_auto_compactions( + mutable_cf) == 1); + CheckCondition( + rocksdb_mutable_cf_options_get_level0_file_num_compaction_trigger( + mutable_cf) == 4); + CheckCondition(rocksdb_mutable_cf_options_get_max_compaction_bytes( + mutable_cf) == 4096); + CheckCondition(rocksdb_mutable_cf_options_get_max_bytes_for_level_base( + mutable_cf) == 8192); + CheckCondition(rocksdb_mutable_cf_options_get_compression(mutable_cf) == + rocksdb_no_compression); + + rocksdb_mutable_cf_options_t* mutable_cf_clone = + rocksdb_mutable_cf_options_clone(mutable_cf); + CheckCondition(rocksdb_mutable_cf_options_get_write_buffer_size( + mutable_cf_clone) == 2048); + rocksdb_mutable_cf_options_destroy(mutable_cf_clone); + + char* mutable_cf_err = NULL; + rocksdb_mutable_cf_options_t* mutable_cf_from_string = + rocksdb_mutable_cf_options_create_from_string( + "write_buffer_size=4096;disable_auto_compactions=true", 0, + &mutable_cf_err); + CheckNoError(mutable_cf_err); + CheckCondition(rocksdb_mutable_cf_options_get_write_buffer_size( + mutable_cf_from_string) == 4096); + CheckCondition(rocksdb_mutable_cf_options_get_disable_auto_compactions( + mutable_cf_from_string) == 1); + rocksdb_mutable_cf_options_destroy(mutable_cf_from_string); + + mutable_cf_err = NULL; + rocksdb_mutable_cf_options_t* mutable_cf_ignore_unknown = + rocksdb_mutable_cf_options_create_from_string("unknown_option=5", 1, + &mutable_cf_err); + CheckNoError(mutable_cf_err); + rocksdb_mutable_cf_options_destroy(mutable_cf_ignore_unknown); + + mutable_cf_err = NULL; + rocksdb_mutable_cf_options_t* mutable_cf_error = + rocksdb_mutable_cf_options_create_from_string("unknown_option=5", 0, + &mutable_cf_err); + CheckCondition(mutable_cf_error == NULL); + CheckCondition(mutable_cf_err != NULL); + free(mutable_cf_err); + + rocksdb_mutable_cf_options_destroy(mutable_cf); + } + + StartPhase("mutable_db_options_api"); + { + rocksdb_mutable_db_options_t* mutable_db = + rocksdb_mutable_db_options_create(); + rocksdb_mutable_db_options_set_max_background_jobs(mutable_db, 3); + rocksdb_mutable_db_options_set_max_background_compactions(mutable_db, 2); + rocksdb_mutable_db_options_set_avoid_flush_during_shutdown(mutable_db, 1); + rocksdb_mutable_db_options_set_writable_file_max_buffer_size(mutable_db, + 1024); + rocksdb_mutable_db_options_set_delayed_write_rate(mutable_db, 2048); + rocksdb_mutable_db_options_set_max_total_wal_size(mutable_db, 4096); + rocksdb_mutable_db_options_set_delete_obsolete_files_period_micros( + mutable_db, 1234); + rocksdb_mutable_db_options_set_stats_dump_period_sec(mutable_db, 55); + rocksdb_mutable_db_options_set_stats_persist_period_sec(mutable_db, 77); + rocksdb_mutable_db_options_set_stats_history_buffer_size(mutable_db, 8888); + rocksdb_mutable_db_options_set_max_open_files(mutable_db, 50); + rocksdb_mutable_db_options_set_bytes_per_sync(mutable_db, 512); + rocksdb_mutable_db_options_set_wal_bytes_per_sync(mutable_db, 256); + rocksdb_mutable_db_options_set_strict_bytes_per_sync(mutable_db, 1); + rocksdb_mutable_db_options_set_compaction_readahead_size(mutable_db, 64); + rocksdb_mutable_db_options_set_daily_offpeak_time_utc(mutable_db, + "01:02-03:04"); + + CheckCondition( + rocksdb_mutable_db_options_get_max_background_jobs(mutable_db) == 3); + CheckCondition(rocksdb_mutable_db_options_get_max_background_compactions( + mutable_db) == 2); + CheckCondition(rocksdb_mutable_db_options_get_avoid_flush_during_shutdown( + mutable_db) == 1); + CheckCondition(rocksdb_mutable_db_options_get_writable_file_max_buffer_size( + mutable_db) == 1024); + CheckCondition( + rocksdb_mutable_db_options_get_delayed_write_rate(mutable_db) == 2048); + CheckCondition( + rocksdb_mutable_db_options_get_max_total_wal_size(mutable_db) == 4096); + CheckCondition( + rocksdb_mutable_db_options_get_delete_obsolete_files_period_micros( + mutable_db) == 1234); + CheckCondition( + rocksdb_mutable_db_options_get_stats_dump_period_sec(mutable_db) == 55); + CheckCondition(rocksdb_mutable_db_options_get_stats_persist_period_sec( + mutable_db) == 77); + CheckCondition(rocksdb_mutable_db_options_get_stats_history_buffer_size( + mutable_db) == 8888); + CheckCondition(rocksdb_mutable_db_options_get_max_open_files(mutable_db) == + 50); + CheckCondition(rocksdb_mutable_db_options_get_bytes_per_sync(mutable_db) == + 512); + CheckCondition( + rocksdb_mutable_db_options_get_wal_bytes_per_sync(mutable_db) == 256); + CheckCondition( + rocksdb_mutable_db_options_get_strict_bytes_per_sync(mutable_db) == 1); + CheckCondition(rocksdb_mutable_db_options_get_compaction_readahead_size( + mutable_db) == 64); + CheckCondition(strcmp(rocksdb_mutable_db_options_get_daily_offpeak_time_utc( + mutable_db), + "01:02-03:04") == 0); + + rocksdb_mutable_db_options_t* mutable_db_clone = + rocksdb_mutable_db_options_clone(mutable_db); + CheckCondition(rocksdb_mutable_db_options_get_max_background_jobs( + mutable_db_clone) == 3); + rocksdb_mutable_db_options_destroy(mutable_db_clone); + + char* mutable_db_err = NULL; + rocksdb_mutable_db_options_t* mutable_db_from_string = + rocksdb_mutable_db_options_create_from_string( + "max_background_jobs=7;avoid_flush_during_shutdown=true", 0, + &mutable_db_err); + CheckNoError(mutable_db_err); + CheckCondition(rocksdb_mutable_db_options_get_max_background_jobs( + mutable_db_from_string) == 7); + CheckCondition(rocksdb_mutable_db_options_get_avoid_flush_during_shutdown( + mutable_db_from_string) == 1); + rocksdb_mutable_db_options_destroy(mutable_db_from_string); + + mutable_db_err = NULL; + rocksdb_mutable_db_options_t* mutable_db_ignore_unknown = + rocksdb_mutable_db_options_create_from_string("unknown_option=1", 1, + &mutable_db_err); + CheckNoError(mutable_db_err); + rocksdb_mutable_db_options_destroy(mutable_db_ignore_unknown); + + mutable_db_err = NULL; + rocksdb_mutable_db_options_t* mutable_db_error = + rocksdb_mutable_db_options_create_from_string("unknown_option=1", 0, + &mutable_db_err); + CheckCondition(mutable_db_error == NULL); + CheckCondition(mutable_db_err != NULL); + free(mutable_db_err); + + rocksdb_mutable_db_options_set_daily_offpeak_time_utc(mutable_db, NULL); + CheckCondition(strcmp(rocksdb_mutable_db_options_get_daily_offpeak_time_utc( + mutable_db), + "") == 0); + + rocksdb_mutable_db_options_destroy(mutable_db); + } + + StartPhase("logger_factory"); + { + LoggerCallbackState logger_state; + logger_state.destructor_called = 0; + logger_state.callback_called = 0; + logger_state.last_level = -1; + rocksdb_logger_t* logger = rocksdb_logger_create( + &logger_state, TestLoggerDestructor, TestLoggerCallback); + CheckCondition(logger != NULL); + rocksdb_logger_destroy(logger); + CheckCondition(logger_state.destructor_called == 1); + CheckCondition(logger_state.callback_called == 0); + } + + StartPhase("table_filter_api"); + { + TableFilterState filter_state; + filter_state.destructor_called = 0; + filter_state.callback_called = 0; + rocksdb_table_filter_t* filter = rocksdb_table_filter_create( + &filter_state, TestTableFilterDestructor, TestTableFilterCallback); + CheckCondition(filter != NULL); + rocksdb_readoptions_t* local_roptions = rocksdb_readoptions_create(); + rocksdb_readoptions_set_table_filter(local_roptions, filter); + rocksdb_readoptions_set_table_filter(local_roptions, NULL); + rocksdb_readoptions_destroy(local_roptions); + rocksdb_table_filter_destroy(filter); + CheckCondition(filter_state.destructor_called == 1); + } + + StartPhase("mem_and_timed_env_creation"); + { + rocksdb_env_t* base_env_local = rocksdb_create_default_env(); + rocksdb_env_t* mem_env_local = rocksdb_mem_env_create(base_env_local); + rocksdb_env_t* timed_env_local = rocksdb_timed_env_create(base_env_local); + CheckCondition(mem_env_local != NULL); + CheckCondition(timed_env_local != NULL); + rocksdb_env_destroy(mem_env_local); + rocksdb_env_destroy(timed_env_local); + rocksdb_env_destroy(base_env_local); + } + + StartPhase("persistent_cache_factory"); + { + rocksdb_env_t* cache_env = rocksdb_create_default_env(); + char persistent_cache_path[200]; + snprintf(persistent_cache_path, sizeof(persistent_cache_path), + "%s/rocksdb_c_test-%d-pcache", GetTempDir(), (int)geteuid()); + char* cache_err = NULL; + rocksdb_create_dir_if_missing(cache_env, persistent_cache_path, &cache_err); + CheckNoError(cache_err); + const uint64_t kCacheSizeBytes = 128ull * 1024 * 1024; + rocksdb_persistent_cache_t* persistent_cache = + rocksdb_persistent_cache_create(cache_env, persistent_cache_path, + kCacheSizeBytes, NULL, 0, &cache_err); + CheckNoError(cache_err); + CheckCondition(persistent_cache != NULL); + rocksdb_persistent_cache_destroy(persistent_cache); + rocksdb_env_destroy(cache_env); + } + + StartPhase("ttl_db_wrappers"); + { + char ttl_path[200]; + snprintf(ttl_path, sizeof(ttl_path), "%s/rocksdb_c_test-%d-ttl", + GetTempDir(), (int)geteuid()); + rocksdb_options_t* ttl_options = rocksdb_options_create(); + rocksdb_options_set_create_if_missing(ttl_options, 1); + char* ttl_err = NULL; + rocksdb_ttl_t* ttl_db = + rocksdb_ttl_open(ttl_options, ttl_path, 5, 0, &ttl_err); + CheckNoError(ttl_err); + rocksdb_options_t* ttl_cf_options = rocksdb_options_create(); + rocksdb_column_family_handle_t* ttl_handle = + rocksdb_ttl_create_column_family(ttl_db, ttl_cf_options, "ttl_cf", 5, + &ttl_err); + CheckNoError(ttl_err); + rocksdb_t* ttl_base = rocksdb_ttl_get_base_db(ttl_db); + CheckCondition(ttl_base != NULL); + rocksdb_drop_column_family(ttl_base, ttl_handle, &ttl_err); + CheckNoError(ttl_err); + rocksdb_close(ttl_base); + rocksdb_column_family_handle_destroy(ttl_handle); + rocksdb_ttl_close(ttl_db); + rocksdb_destroy_db(ttl_options, ttl_path, &ttl_err); + CheckNoError(ttl_err); + rocksdb_options_destroy(ttl_cf_options); + rocksdb_options_destroy(ttl_options); + } + StartPhase("pause_and_continue_all_background_work"); rocksdb_pause_background_work(db); rocksdb_continue_background_work(db); diff --git a/include/rocksdb/c.h b/include/rocksdb/c.h index 49a12a92ca64..bb3aa3ea2197 100644 --- a/include/rocksdb/c.h +++ b/include/rocksdb/c.h @@ -104,6 +104,8 @@ typedef struct rocksdb_filterpolicy_t rocksdb_filterpolicy_t; typedef struct rocksdb_flushoptions_t rocksdb_flushoptions_t; typedef struct rocksdb_iterator_t rocksdb_iterator_t; typedef struct rocksdb_logger_t rocksdb_logger_t; +typedef struct rocksdb_mutable_cf_options_t rocksdb_mutable_cf_options_t; +typedef struct rocksdb_mutable_db_options_t rocksdb_mutable_db_options_t; typedef struct rocksdb_mergeoperator_t rocksdb_mergeoperator_t; typedef struct rocksdb_options_t rocksdb_options_t; typedef struct rocksdb_compactoptions_t rocksdb_compactoptions_t; @@ -135,6 +137,7 @@ typedef struct rocksdb_sstfilewriter_t rocksdb_sstfilewriter_t; typedef struct rocksdb_ratelimiter_t rocksdb_ratelimiter_t; typedef struct rocksdb_perfcontext_t rocksdb_perfcontext_t; typedef struct rocksdb_pinnableslice_t rocksdb_pinnableslice_t; +typedef struct rocksdb_table_filter_t rocksdb_table_filter_t; typedef struct rocksdb_transactiondb_options_t rocksdb_transactiondb_options_t; typedef struct rocksdb_transactiondb_t rocksdb_transactiondb_t; typedef struct rocksdb_transaction_options_t rocksdb_transaction_options_t; @@ -158,6 +161,8 @@ typedef struct rocksdb_subcompactionjobinfo_t rocksdb_subcompactionjobinfo_t; typedef struct rocksdb_externalfileingestioninfo_t rocksdb_externalfileingestioninfo_t; typedef struct rocksdb_eventlistener_t rocksdb_eventlistener_t; +typedef struct rocksdb_persistent_cache_t rocksdb_persistent_cache_t; +typedef struct rocksdb_ttl_t rocksdb_ttl_t; typedef struct rocksdb_writestallinfo_t rocksdb_writestallinfo_t; typedef struct rocksdb_writestallcondition_t rocksdb_writestallcondition_t; typedef struct rocksdb_memtableinfo_t rocksdb_memtableinfo_t; @@ -493,6 +498,23 @@ extern ROCKSDB_LIBRARY_API 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); +extern ROCKSDB_LIBRARY_API rocksdb_ttl_t* rocksdb_ttl_open( + rocksdb_options_t* options, const char* name, int ttl, + unsigned char read_only, char** errptr); +extern ROCKSDB_LIBRARY_API rocksdb_ttl_t* rocksdb_ttl_open_column_families( + rocksdb_options_t* options, const char* name, int num_column_families, + const char* const* column_family_names, + rocksdb_options_t* const* column_family_options, const int* ttls, + rocksdb_column_family_handle_t** handles, unsigned char read_only, + char** errptr); +extern ROCKSDB_LIBRARY_API rocksdb_column_family_handle_t* +rocksdb_ttl_create_column_family(rocksdb_ttl_t* db, + rocksdb_options_t* column_family_options, + const char* column_family_name, int ttl, + char** errptr); +extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_ttl_get_base_db( + rocksdb_ttl_t* db); +extern ROCKSDB_LIBRARY_API void rocksdb_ttl_close(rocksdb_ttl_t* db); extern ROCKSDB_LIBRARY_API void rocksdb_drop_column_family( rocksdb_t* db, rocksdb_column_family_handle_t* handle, char** errptr); @@ -1450,6 +1472,8 @@ typedef void (*on_background_error_cb)(void*, uint32_t, rocksdb_status_ptr_t*); typedef void (*on_stall_conditions_changed_cb)(void*, const rocksdb_writestallinfo_t*); typedef void (*rocksdb_logger_logv_cb)(void*, uint32_t log_level, const char*); +typedef void (*rocksdb_log_callback)(void* state, int info_log_level, + const char* message); typedef void (*on_memtable_sealed_cb)(void*, const rocksdb_memtableinfo_t*); extern ROCKSDB_LIBRARY_API rocksdb_eventlistener_t* rocksdb_eventlistener_create( @@ -1569,6 +1593,8 @@ rocksdb_logger_create_callback_logger(int log_level, void (*)(void* priv, unsigned lev, char* msg, size_t len), void* priv); +extern ROCKSDB_LIBRARY_API rocksdb_logger_t* rocksdb_logger_create( + void* state, void (*destructor)(void*), rocksdb_log_callback callback); extern ROCKSDB_LIBRARY_API void rocksdb_logger_destroy( rocksdb_logger_t* logger); extern ROCKSDB_LIBRARY_API void rocksdb_options_set_write_buffer_size( @@ -2316,6 +2342,8 @@ rocksdb_comparator_with_ts_create( unsigned char a_has_ts, const char* b, size_t blen, unsigned char b_has_ts), const char* (*name)(void*), size_t timestamp_size); +extern ROCKSDB_LIBRARY_API int rocksdb_comparator_get_comparator_type( + const rocksdb_comparator_t* comparator); /* Filter policy */ @@ -2354,6 +2382,9 @@ extern ROCKSDB_LIBRARY_API void rocksdb_mergeoperator_destroy( /* Read options */ +typedef unsigned char (*rocksdb_table_filter_callback)( + void* state, const rocksdb_tableproperties_t* props); + extern ROCKSDB_LIBRARY_API rocksdb_readoptions_t* rocksdb_readoptions_create( void); extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_destroy( @@ -2430,6 +2461,13 @@ extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_timestamp( rocksdb_readoptions_t*, const char* ts, size_t tslen); extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_iter_start_ts( rocksdb_readoptions_t*, const char* ts, size_t tslen); +extern ROCKSDB_LIBRARY_API rocksdb_table_filter_t* rocksdb_table_filter_create( + void* state, void (*destructor)(void*), + rocksdb_table_filter_callback callback); +extern ROCKSDB_LIBRARY_API void rocksdb_table_filter_destroy( + rocksdb_table_filter_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_table_filter( + rocksdb_readoptions_t*, rocksdb_table_filter_t*); extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_auto_readahead_size( rocksdb_readoptions_t*, unsigned char); @@ -2665,6 +2703,13 @@ extern ROCKSDB_LIBRARY_API rocksdb_cache_t* rocksdb_cache_create_hyper_clock_opts( const rocksdb_hyper_clock_cache_options_t*); +extern ROCKSDB_LIBRARY_API rocksdb_persistent_cache_t* +rocksdb_persistent_cache_create(rocksdb_env_t* env, const char* path, + uint64_t size_bytes, rocksdb_logger_t* logger, + unsigned char optimized_for_nvm, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_persistent_cache_destroy( + rocksdb_persistent_cache_t* cache); + /* DBPath */ extern ROCKSDB_LIBRARY_API rocksdb_dbpath_t* rocksdb_dbpath_create( @@ -2675,6 +2720,10 @@ extern ROCKSDB_LIBRARY_API void rocksdb_dbpath_destroy(rocksdb_dbpath_t*); extern ROCKSDB_LIBRARY_API rocksdb_env_t* rocksdb_create_default_env(void); extern ROCKSDB_LIBRARY_API rocksdb_env_t* rocksdb_create_mem_env(void); +extern ROCKSDB_LIBRARY_API rocksdb_env_t* rocksdb_mem_env_create( + rocksdb_env_t* base_env); +extern ROCKSDB_LIBRARY_API rocksdb_env_t* rocksdb_timed_env_create( + rocksdb_env_t* base_env); extern ROCKSDB_LIBRARY_API void rocksdb_env_set_background_threads( rocksdb_env_t* env, int n); extern ROCKSDB_LIBRARY_API int rocksdb_env_get_background_threads( @@ -3993,6 +4042,159 @@ extern ROCKSDB_LIBRARY_API uint64_t rocksdb_wait_for_compact_options_get_timeout( rocksdb_wait_for_compact_options_t* opt); +/* Mutable Column Family Options */ + +extern ROCKSDB_LIBRARY_API rocksdb_mutable_cf_options_t* +rocksdb_mutable_cf_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_mutable_cf_options_destroy( + rocksdb_mutable_cf_options_t*); +extern ROCKSDB_LIBRARY_API rocksdb_mutable_cf_options_t* +rocksdb_mutable_cf_options_clone(const rocksdb_mutable_cf_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_mutable_cf_options_set_write_buffer_size(rocksdb_mutable_cf_options_t*, + uint64_t size); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_mutable_cf_options_get_write_buffer_size( + const rocksdb_mutable_cf_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_mutable_cf_options_set_disable_auto_compactions( + rocksdb_mutable_cf_options_t*, unsigned char disable); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_mutable_cf_options_get_disable_auto_compactions( + const rocksdb_mutable_cf_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_mutable_cf_options_set_level0_file_num_compaction_trigger( + rocksdb_mutable_cf_options_t*, int trigger); +extern ROCKSDB_LIBRARY_API int +rocksdb_mutable_cf_options_get_level0_file_num_compaction_trigger( + const rocksdb_mutable_cf_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_mutable_cf_options_set_max_compaction_bytes( + rocksdb_mutable_cf_options_t*, uint64_t bytes); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_mutable_cf_options_get_max_compaction_bytes( + const rocksdb_mutable_cf_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_mutable_cf_options_set_max_bytes_for_level_base( + rocksdb_mutable_cf_options_t*, uint64_t bytes); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_mutable_cf_options_get_max_bytes_for_level_base( + const rocksdb_mutable_cf_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_mutable_cf_options_set_compression( + rocksdb_mutable_cf_options_t*, int compression); +extern ROCKSDB_LIBRARY_API int rocksdb_mutable_cf_options_get_compression( + const rocksdb_mutable_cf_options_t*); +extern ROCKSDB_LIBRARY_API rocksdb_mutable_cf_options_t* +rocksdb_mutable_cf_options_create_from_string(const char* opts, + unsigned char ignore_unknown, + char** errptr); + +/* Mutable DB Options */ + +extern ROCKSDB_LIBRARY_API rocksdb_mutable_db_options_t* +rocksdb_mutable_db_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_mutable_db_options_destroy( + rocksdb_mutable_db_options_t*); +extern ROCKSDB_LIBRARY_API rocksdb_mutable_db_options_t* +rocksdb_mutable_db_options_clone(const rocksdb_mutable_db_options_t*); +extern ROCKSDB_LIBRARY_API rocksdb_mutable_db_options_t* +rocksdb_mutable_db_options_create_from_string(const char* opts, + unsigned char ignore_unknown, + char** errptr); +extern ROCKSDB_LIBRARY_API void +rocksdb_mutable_db_options_set_max_background_jobs( + rocksdb_mutable_db_options_t*, int jobs); +extern ROCKSDB_LIBRARY_API int +rocksdb_mutable_db_options_get_max_background_jobs( + const rocksdb_mutable_db_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_mutable_db_options_set_max_background_compactions( + rocksdb_mutable_db_options_t*, int jobs); +extern ROCKSDB_LIBRARY_API int +rocksdb_mutable_db_options_get_max_background_compactions( + const rocksdb_mutable_db_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_mutable_db_options_set_avoid_flush_during_shutdown( + rocksdb_mutable_db_options_t*, unsigned char avoid); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_mutable_db_options_get_avoid_flush_during_shutdown( + const rocksdb_mutable_db_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_mutable_db_options_set_writable_file_max_buffer_size( + rocksdb_mutable_db_options_t*, uint64_t bytes); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_mutable_db_options_get_writable_file_max_buffer_size( + const rocksdb_mutable_db_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_mutable_db_options_set_delayed_write_rate(rocksdb_mutable_db_options_t*, + uint64_t bytes_per_sec); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_mutable_db_options_get_delayed_write_rate( + const rocksdb_mutable_db_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_mutable_db_options_set_max_total_wal_size(rocksdb_mutable_db_options_t*, + uint64_t bytes); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_mutable_db_options_get_max_total_wal_size( + const rocksdb_mutable_db_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_mutable_db_options_set_delete_obsolete_files_period_micros( + rocksdb_mutable_db_options_t*, uint64_t micros); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_mutable_db_options_get_delete_obsolete_files_period_micros( + const rocksdb_mutable_db_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_mutable_db_options_set_stats_dump_period_sec( + rocksdb_mutable_db_options_t*, int seconds); +extern ROCKSDB_LIBRARY_API int +rocksdb_mutable_db_options_get_stats_dump_period_sec( + const rocksdb_mutable_db_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_mutable_db_options_set_stats_persist_period_sec( + rocksdb_mutable_db_options_t*, int seconds); +extern ROCKSDB_LIBRARY_API int +rocksdb_mutable_db_options_get_stats_persist_period_sec( + const rocksdb_mutable_db_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_mutable_db_options_set_stats_history_buffer_size( + rocksdb_mutable_db_options_t*, uint64_t bytes); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_mutable_db_options_get_stats_history_buffer_size( + const rocksdb_mutable_db_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_mutable_db_options_set_max_open_files( + rocksdb_mutable_db_options_t*, int files); +extern ROCKSDB_LIBRARY_API int rocksdb_mutable_db_options_get_max_open_files( + const rocksdb_mutable_db_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_mutable_db_options_set_bytes_per_sync( + rocksdb_mutable_db_options_t*, uint64_t bytes); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_mutable_db_options_get_bytes_per_sync( + const rocksdb_mutable_db_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_mutable_db_options_set_wal_bytes_per_sync(rocksdb_mutable_db_options_t*, + uint64_t bytes); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_mutable_db_options_get_wal_bytes_per_sync( + const rocksdb_mutable_db_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_mutable_db_options_set_strict_bytes_per_sync( + rocksdb_mutable_db_options_t*, unsigned char strict); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_mutable_db_options_get_strict_bytes_per_sync( + const rocksdb_mutable_db_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_mutable_db_options_set_compaction_readahead_size( + rocksdb_mutable_db_options_t*, uint64_t bytes); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_mutable_db_options_get_compaction_readahead_size( + const rocksdb_mutable_db_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_mutable_db_options_set_daily_offpeak_time_utc( + rocksdb_mutable_db_options_t*, const char* offpeak_time); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_mutable_db_options_get_daily_offpeak_time_utc( + const rocksdb_mutable_db_options_t*); + #ifdef __cplusplus } /* end extern "C" */ #endif