Skip to content

R
rust-rocksdb
Commit 130c764e authored by follitude's avatar follitude Committed by zhangjinpeng1987
Browse files
Options

refactor options (#102)

parent 240e5b66
Show whitespace changes
Inline Side-by-side
Showing with 756 additions and 618 deletions
librocksdb_sys/src/lib.rs
View file @ 130c764e
......@@ -20,7 +20,7 @@ extern crate tempdir;
use libc::{c_char, c_uchar, c_int, c_void, size_t, uint8_t, uint32_t, uint64_t, c_double};
use std::ffi::CStr;
pub enum DBOptions {}
pub enum Options {}
pub enum DBInstance {}
pub enum DBWriteOptions {}
pub enum DBReadOptions {}
......@@ -241,10 +241,10 @@ macro_rules! ffi_try {
// TODO audit the use of boolean arguments, b/c I think they need to be u8
// instead...
extern "C" {
pub fn crocksdb_get_options_cf(db: *mut DBInstance, cf: *mut DBCFHandle) -> *mut DBOptions;
pub fn crocksdb_options_create() -> *mut DBOptions;
pub fn crocksdb_options_copy(opts: *const DBOptions) -> *mut DBOptions;
pub fn crocksdb_options_destroy(opts: *mut DBOptions);
pub fn crocksdb_get_options_cf(db: *mut DBInstance, cf: *mut DBCFHandle) -> *mut Options;
pub fn crocksdb_options_create() -> *mut Options;
pub fn crocksdb_options_copy(opts: *const Options) -> *mut Options;
pub fn crocksdb_options_destroy(opts: *mut Options);
pub fn crocksdb_cache_create_lru(capacity: size_t) -> *mut DBCache;
pub fn crocksdb_cache_destroy(cache: *mut DBCache);
pub fn crocksdb_block_based_options_create() -> *mut DBBlockBasedTableOptions;
......@@ -273,86 +273,84 @@ extern "C" {
pub fn crocksdb_block_based_options_set_whole_key_filtering(
ck_options: *mut DBBlockBasedTableOptions, doit: bool);
pub fn crocksdb_options_set_block_based_table_factory(
options: *mut DBOptions,
options: *mut Options,
block_options: *mut DBBlockBasedTableOptions);
pub fn crocksdb_block_based_options_set_pin_l0_filter_and_index_blocks_in_cache(
block_options: *mut DBBlockBasedTableOptions, v: c_uchar);
pub fn crocksdb_options_increase_parallelism(options: *mut DBOptions, threads: c_int);
pub fn crocksdb_options_optimize_level_style_compaction(options: *mut DBOptions,
pub fn crocksdb_options_increase_parallelism(options: *mut Options, threads: c_int);
pub fn crocksdb_options_optimize_level_style_compaction(options: *mut Options,
memtable_memory_budget: c_int);
pub fn crocksdb_options_set_compaction_filter(options: *mut DBOptions,
pub fn crocksdb_options_set_compaction_filter(options: *mut Options,
filter: *mut DBCompactionFilter);
pub fn crocksdb_options_set_create_if_missing(options: *mut DBOptions, v: bool);
pub fn crocksdb_options_set_max_open_files(options: *mut DBOptions, files: c_int);
pub fn crocksdb_options_set_max_total_wal_size(options: *mut DBOptions, size: u64);
pub fn crocksdb_options_set_use_fsync(options: *mut DBOptions, v: c_int);
pub fn crocksdb_options_set_bytes_per_sync(options: *mut DBOptions, bytes: u64);
pub fn crocksdb_options_set_enable_pipelined_write(options: *mut DBOptions, v: bool);
pub fn crocksdb_options_set_allow_concurrent_memtable_write(options: *mut DBOptions, v: bool);
pub fn crocksdb_options_optimize_for_point_lookup(options: *mut DBOptions,
pub fn crocksdb_options_set_create_if_missing(options: *mut Options, v: bool);
pub fn crocksdb_options_set_max_open_files(options: *mut Options, files: c_int);
pub fn crocksdb_options_set_max_total_wal_size(options: *mut Options, size: u64);
pub fn crocksdb_options_set_use_fsync(options: *mut Options, v: c_int);
pub fn crocksdb_options_set_bytes_per_sync(options: *mut Options, bytes: u64);
pub fn crocksdb_options_set_enable_pipelined_write(options: *mut Options, v: bool);
pub fn crocksdb_options_set_allow_concurrent_memtable_write(options: *mut Options, v: bool);
pub fn crocksdb_options_optimize_for_point_lookup(options: *mut Options,
block_cache_size_mb: u64);
pub fn crocksdb_options_set_table_cache_numshardbits(options: *mut DBOptions, bits: c_int);
pub fn crocksdb_options_set_writable_file_max_buffer_size(options: *mut DBOptions,
pub fn crocksdb_options_set_table_cache_numshardbits(options: *mut Options, bits: c_int);
pub fn crocksdb_options_set_writable_file_max_buffer_size(options: *mut Options,
nbytes: c_int);
pub fn crocksdb_options_set_max_write_buffer_number(options: *mut DBOptions, bufno: c_int);
pub fn crocksdb_options_set_min_write_buffer_number_to_merge(options: *mut DBOptions,
pub fn crocksdb_options_set_max_write_buffer_number(options: *mut Options, bufno: c_int);
pub fn crocksdb_options_set_min_write_buffer_number_to_merge(options: *mut Options,
bufno: c_int);
pub fn crocksdb_options_set_level0_file_num_compaction_trigger(options: *mut DBOptions,
pub fn crocksdb_options_set_level0_file_num_compaction_trigger(options: *mut Options,
no: c_int);
pub fn crocksdb_options_set_level0_slowdown_writes_trigger(options: *mut DBOptions,
no: c_int);
pub fn crocksdb_options_set_level0_stop_writes_trigger(options: *mut DBOptions, no: c_int);
pub fn crocksdb_options_set_write_buffer_size(options: *mut DBOptions, bytes: u64);
pub fn crocksdb_options_set_target_file_size_base(options: *mut DBOptions, bytes: u64);
pub fn crocksdb_options_set_target_file_size_multiplier(options: *mut DBOptions, mul: c_int);
pub fn crocksdb_options_set_max_bytes_for_level_base(options: *mut DBOptions, bytes: u64);
pub fn crocksdb_options_set_max_bytes_for_level_multiplier(options: *mut DBOptions,
mul: c_int);
pub fn crocksdb_options_set_max_compaction_bytes(options: *mut DBOptions, bytes: uint64_t);
pub fn crocksdb_options_set_max_log_file_size(options: *mut DBOptions, bytes: size_t);
pub fn crocksdb_options_set_log_file_time_to_roll(options: *mut DBOptions, bytes: size_t);
pub fn crocksdb_options_set_info_log_level(options: *mut DBOptions, level: DBInfoLogLevel);
pub fn crocksdb_options_set_keep_log_file_num(options: *mut DBOptions, num: size_t);
pub fn crocksdb_options_set_max_manifest_file_size(options: *mut DBOptions, bytes: u64);
pub fn crocksdb_options_set_hash_skip_list_rep(options: *mut DBOptions,
pub fn crocksdb_options_set_level0_slowdown_writes_trigger(options: *mut Options, no: c_int);
pub fn crocksdb_options_set_level0_stop_writes_trigger(options: *mut Options, no: c_int);
pub fn crocksdb_options_set_write_buffer_size(options: *mut Options, bytes: u64);
pub fn crocksdb_options_set_target_file_size_base(options: *mut Options, bytes: u64);
pub fn crocksdb_options_set_target_file_size_multiplier(options: *mut Options, mul: c_int);
pub fn crocksdb_options_set_max_bytes_for_level_base(options: *mut Options, bytes: u64);
pub fn crocksdb_options_set_max_bytes_for_level_multiplier(options: *mut Options, mul: c_int);
pub fn crocksdb_options_set_max_compaction_bytes(options: *mut Options, bytes: uint64_t);
pub fn crocksdb_options_set_max_log_file_size(options: *mut Options, bytes: size_t);
pub fn crocksdb_options_set_log_file_time_to_roll(options: *mut Options, bytes: size_t);
pub fn crocksdb_options_set_info_log_level(options: *mut Options, level: DBInfoLogLevel);
pub fn crocksdb_options_set_keep_log_file_num(options: *mut Options, num: size_t);
pub fn crocksdb_options_set_max_manifest_file_size(options: *mut Options, bytes: u64);
pub fn crocksdb_options_set_hash_skip_list_rep(options: *mut Options,
bytes: u64,
a1: i32,
a2: i32);
pub fn crocksdb_options_set_compaction_style(options: *mut DBOptions, cs: DBCompactionStyle);
pub fn crocksdb_options_set_compression(options: *mut DBOptions,
pub fn crocksdb_options_set_compaction_style(options: *mut Options, cs: DBCompactionStyle);
pub fn crocksdb_options_set_compression(options: *mut Options,
compression_style_no: DBCompressionType);
pub fn crocksdb_options_get_compression(options: *mut DBOptions) -> DBCompressionType;
pub fn crocksdb_options_set_compression_per_level(options: *mut DBOptions,
pub fn crocksdb_options_get_compression(options: *mut Options) -> DBCompressionType;
pub fn crocksdb_options_set_compression_per_level(options: *mut Options,
level_values: *const DBCompressionType,
num_levels: size_t);
pub fn crocksdb_options_get_compression_level_number(options: *mut DBOptions) -> size_t;
pub fn crocksdb_options_get_compression_per_level(options: *mut DBOptions,
pub fn crocksdb_options_get_compression_level_number(options: *mut Options) -> size_t;
pub fn crocksdb_options_get_compression_per_level(options: *mut Options,
level_values: *mut DBCompressionType);
pub fn crocksdb_set_bottommost_compression(options: *mut DBOptions, c: DBCompressionType);
pub fn crocksdb_options_set_base_background_compactions(optinos: *mut DBOptions,
pub fn crocksdb_set_bottommost_compression(options: *mut Options, c: DBCompressionType);
pub fn crocksdb_options_set_base_background_compactions(optinos: *mut Options,
base_bg_compactions: c_int);
pub fn crocksdb_options_set_max_background_compactions(options: *mut DBOptions,
pub fn crocksdb_options_set_max_background_compactions(options: *mut Options,
max_bg_compactions: c_int);
pub fn crocksdb_options_set_max_background_flushes(options: *mut DBOptions,
pub fn crocksdb_options_set_max_background_flushes(options: *mut Options,
max_bg_flushes: c_int);
pub fn crocksdb_options_set_disable_auto_compactions(options: *mut DBOptions, v: c_int);
pub fn crocksdb_options_set_report_bg_io_stats(options: *mut DBOptions, v: c_int);
pub fn crocksdb_options_set_compaction_readahead_size(options: *mut DBOptions, v: size_t);
pub fn crocksdb_options_set_wal_recovery_mode(options: *mut DBOptions, mode: DBRecoveryMode);
pub fn crocksdb_options_set_max_subcompactions(options: *mut DBOptions, v: u32);
pub fn crocksdb_options_set_wal_bytes_per_sync(options: *mut DBOptions, v: u64);
pub fn crocksdb_options_enable_statistics(options: *mut DBOptions);
pub fn crocksdb_options_statistics_get_string(options: *mut DBOptions) -> *const c_char;
pub fn crocksdb_options_statistics_get_ticker_count(options: *mut DBOptions,
pub fn crocksdb_options_set_disable_auto_compactions(options: *mut Options, v: c_int);
pub fn crocksdb_options_set_report_bg_io_stats(options: *mut Options, v: c_int);
pub fn crocksdb_options_set_compaction_readahead_size(options: *mut Options, v: size_t);
pub fn crocksdb_options_set_wal_recovery_mode(options: *mut Options, mode: DBRecoveryMode);
pub fn crocksdb_options_set_max_subcompactions(options: *mut Options, v: u32);
pub fn crocksdb_options_set_wal_bytes_per_sync(options: *mut Options, v: u64);
pub fn crocksdb_options_enable_statistics(options: *mut Options);
pub fn crocksdb_options_statistics_get_string(options: *mut Options) -> *const c_char;
pub fn crocksdb_options_statistics_get_ticker_count(options: *mut Options,
ticker_type: DBStatisticsTickerType)
-> u64;
pub fn crocksdb_options_statistics_get_and_reset_ticker_count(options: *mut DBOptions,
pub fn crocksdb_options_statistics_get_and_reset_ticker_count(options: *mut Options,
ticker_type: DBStatisticsTickerType)
-> u64;
pub fn crocksdb_options_statistics_get_histogram_string(options: *mut DBOptions,
pub fn crocksdb_options_statistics_get_histogram_string(options: *mut Options,
hist_type: DBStatisticsHistogramType)
-> *const c_char;
pub fn crocksdb_options_statistics_get_histogram(options: *mut DBOptions,
pub fn crocksdb_options_statistics_get_histogram(options: *mut Options,
hist_type: DBStatisticsHistogramType,
median: *mut c_double,
percentile95: *mut c_double,
......@@ -360,42 +358,41 @@ extern "C" {
average: *mut c_double,
standard_deviation: *mut c_double)
-> bool;
pub fn crocksdb_options_set_stats_dump_period_sec(options: *mut DBOptions, v: usize);
pub fn crocksdb_options_set_num_levels(options: *mut DBOptions, v: c_int);
pub fn crocksdb_options_set_db_log_dir(options: *mut DBOptions, path: *const c_char);
pub fn crocksdb_options_set_wal_dir(options: *mut DBOptions, path: *const c_char);
pub fn crocksdb_options_set_wal_ttl_seconds(options: *mut DBOptions, ttl: u64);
pub fn crocksdb_options_set_wal_size_limit_mb(options: *mut DBOptions, limit: u64);
pub fn crocksdb_options_set_use_direct_reads(options: *mut DBOptions, v: bool);
pub fn crocksdb_options_set_use_direct_io_for_flush_and_compaction(options: *mut DBOptions,
pub fn crocksdb_options_set_stats_dump_period_sec(options: *mut Options, v: usize);
pub fn crocksdb_options_set_num_levels(options: *mut Options, v: c_int);
pub fn crocksdb_options_set_db_log_dir(options: *mut Options, path: *const c_char);
pub fn crocksdb_options_set_wal_dir(options: *mut Options, path: *const c_char);
pub fn crocksdb_options_set_wal_ttl_seconds(options: *mut Options, ttl: u64);
pub fn crocksdb_options_set_wal_size_limit_mb(options: *mut Options, limit: u64);
pub fn crocksdb_options_set_use_direct_reads(options: *mut Options, v: bool);
pub fn crocksdb_options_set_use_direct_io_for_flush_and_compaction(options: *mut Options,
v: bool);
pub fn crocksdb_options_set_prefix_extractor(options: *mut DBOptions,
pub fn crocksdb_options_set_prefix_extractor(options: *mut Options,
prefix_extractor: *mut DBSliceTransform);
pub fn crocksdb_options_set_optimize_filters_for_hits(options: *mut DBOptions, v: bool);
pub fn crocksdb_options_set_level_compaction_dynamic_level_bytes(options: *mut DBOptions,
pub fn crocksdb_options_set_optimize_filters_for_hits(options: *mut Options, v: bool);
pub fn crocksdb_options_set_level_compaction_dynamic_level_bytes(options: *mut Options,
v: bool);
pub fn crocksdb_options_set_memtable_insert_with_hint_prefix_extractor(options: *mut DBOptions,
pub fn crocksdb_options_set_memtable_insert_with_hint_prefix_extractor(options: *mut Options,
prefix_extractor: *mut DBSliceTransform);
pub fn crocksdb_options_set_memtable_prefix_bloom_size_ratio(options: *mut DBOptions,
pub fn crocksdb_options_set_memtable_prefix_bloom_size_ratio(options: *mut Options,
ratio: c_double);
pub fn crocksdb_options_set_delayed_write_rate(options: *mut DBOptions, rate: u64);
pub fn crocksdb_options_set_ratelimiter(options: *mut DBOptions, limiter: *mut DBRateLimiter);
pub fn crocksdb_options_set_info_log(options: *mut DBOptions, logger: *mut DBLogger);
pub fn crocksdb_options_get_block_cache_usage(options: *const DBOptions) -> usize;
pub fn crocksdb_options_set_delayed_write_rate(options: *mut Options, rate: u64);
pub fn crocksdb_options_set_ratelimiter(options: *mut Options, limiter: *mut DBRateLimiter);
pub fn crocksdb_options_set_info_log(options: *mut Options, logger: *mut DBLogger);
pub fn crocksdb_options_get_block_cache_usage(options: *const Options) -> usize;
pub fn crocksdb_ratelimiter_create(rate_bytes_per_sec: i64,
refill_period_us: i64,
fairness: i32)
-> *mut DBRateLimiter;
pub fn crocksdb_ratelimiter_destroy(limiter: *mut DBRateLimiter);
pub fn crocksdb_options_set_soft_pending_compaction_bytes_limit(options: *mut DBOptions,
pub fn crocksdb_options_set_soft_pending_compaction_bytes_limit(options: *mut Options,
v: u64);
pub fn crocksdb_options_set_hard_pending_compaction_bytes_limit(options: *mut DBOptions,
pub fn crocksdb_options_set_hard_pending_compaction_bytes_limit(options: *mut Options,
v: u64);
pub fn crocksdb_options_set_compaction_priority(options: *mut DBOptions,
v: CompactionPriority);
pub fn crocksdb_options_set_compaction_priority(options: *mut Options, v: CompactionPriority);
pub fn crocksdb_filterpolicy_create_bloom_full(bits_per_key: c_int) -> *mut DBFilterPolicy;
pub fn crocksdb_filterpolicy_create_bloom(bits_per_key: c_int) -> *mut DBFilterPolicy;
pub fn crocksdb_open(options: *mut DBOptions,
pub fn crocksdb_open(options: *mut Options,
path: *const c_char,
err: *mut *mut c_char)
-> *mut DBInstance;
......@@ -490,10 +487,10 @@ extern "C" {
pub fn crocksdb_close(db: *mut DBInstance);
pub fn crocksdb_pause_bg_work(db: *mut DBInstance);
pub fn crocksdb_continue_bg_work(db: *mut DBInstance);
pub fn crocksdb_destroy_db(options: *const DBOptions,
pub fn crocksdb_destroy_db(options: *const Options,
path: *const c_char,
err: *mut *mut c_char);
pub fn crocksdb_repair_db(options: *const DBOptions,
pub fn crocksdb_repair_db(options: *const Options,
path: *const c_char,
err: *mut *mut c_char);
// Merge
......@@ -538,7 +535,7 @@ extern "C" {
name_fn: extern fn(*mut c_void) -> *const c_char,
) -> *mut DBMergeOperator;
pub fn crocksdb_mergeoperator_destroy(mo: *mut DBMergeOperator);
pub fn crocksdb_options_set_merge_operator(options: *mut DBOptions, mo: *mut DBMergeOperator);
pub fn crocksdb_options_set_merge_operator(options: *mut Options, mo: *mut DBMergeOperator);
// Iterator
pub fn crocksdb_iter_destroy(iter: *mut DBIterator);
pub fn crocksdb_iter_valid(iter: *const DBIterator) -> bool;
......@@ -623,7 +620,7 @@ extern "C" {
err: *mut *mut c_char);
// Comparator
pub fn crocksdb_options_set_comparator(options: *mut DBOptions, cb: *mut DBComparator);
pub fn crocksdb_options_set_comparator(options: *mut Options, cb: *mut DBComparator);
pub fn crocksdb_comparator_create(state: *mut c_void,
destroy: extern "C" fn(*mut c_void) -> (),
compare: extern "C" fn(arg: *mut c_void,
......@@ -637,16 +634,16 @@ extern "C" {
pub fn crocksdb_comparator_destroy(cmp: *mut DBComparator);
// Column Family
pub fn crocksdb_open_column_families(options: *const DBOptions,
pub fn crocksdb_open_column_families(options: *const Options,
path: *const c_char,
num_column_families: c_int,
column_family_names: *const *const c_char,
column_family_options: *const *const DBOptions,
column_family_options: *const *const Options,
column_family_handles: *const *mut DBCFHandle,
err: *mut *mut c_char)
-> *mut DBInstance;
pub fn crocksdb_create_column_family(db: *mut DBInstance,
column_family_options: *const DBOptions,
column_family_options: *const Options,
column_family_name: *const c_char,
err: *mut *mut c_char)
-> *mut DBCFHandle;
......@@ -655,7 +652,7 @@ extern "C" {
err: *mut *mut c_char);
pub fn crocksdb_column_family_handle_id(column_family_handle: *mut DBCFHandle) -> u32;
pub fn crocksdb_column_family_handle_destroy(column_family_handle: *mut DBCFHandle);
pub fn crocksdb_list_column_families(db: *const DBOptions,
pub fn crocksdb_list_column_families(db: *const Options,
path: *const c_char,
lencf: *mut size_t,
err: *mut *mut c_char)
......@@ -768,14 +765,14 @@ extern "C" {
// SstFileWriter
pub fn crocksdb_sstfilewriter_create(env: *mut EnvOptions,
io_options: *const DBOptions)
io_options: *const Options)
-> *mut SstFileWriter;
pub fn crocksdb_sstfilewriter_create_cf(env: *mut EnvOptions,
io_options: *const DBOptions,
io_options: *const Options,
cf: *mut DBCFHandle)
-> *mut SstFileWriter;
pub fn crocksdb_sstfilewriter_create_with_comparator(env: *mut EnvOptions,
io_options: *const DBOptions,
io_options: *const Options,
comparator: *const DBComparator,
cf: *mut DBCFHandle)
-> *mut SstFileWriter;
......@@ -810,7 +807,7 @@ extern "C" {
// Backup engine
// TODO: add more ffis about backup engine.
pub fn crocksdb_backup_engine_open(options: *const DBOptions,
pub fn crocksdb_backup_engine_open(options: *const Options,
path: *const c_char,
err: *mut *mut c_char)
-> *mut DBBackupEngine;
......@@ -841,7 +838,7 @@ extern "C" {
-> *mut DBSliceTransform;
pub fn crocksdb_slicetransform_destroy(transform: *mut DBSliceTransform);
pub fn crocksdb_create_log_from_options(path: *const c_char,
options: *mut DBOptions,
options: *mut Options,
err: *mut *mut c_char)
-> *mut DBLogger;
pub fn crocksdb_log_destroy(logger: *mut DBLogger);
......@@ -968,7 +965,7 @@ extern "C" {
f: *mut DBTablePropertiesCollectorFactory);
pub fn crocksdb_options_add_table_properties_collector_factory(
options: *mut DBOptions, f: *mut DBTablePropertiesCollectorFactory);
options: *mut Options, f: *mut DBTablePropertiesCollectorFactory);
pub fn crocksdb_get_properties_of_all_tables(db: *mut DBInstance,
errptr: *mut *mut c_char)
......@@ -1038,7 +1035,7 @@ extern "C" {
*const DBIngestionInfo))
-> *mut DBEventListener;
pub fn crocksdb_eventlistener_destroy(et: *mut DBEventListener);
pub fn crocksdb_options_add_eventlistener(opt: *mut DBOptions, et: *mut DBEventListener);
pub fn crocksdb_options_add_eventlistener(opt: *mut Options, et: *mut DBEventListener);
// Get All Key Versions
pub fn crocksdb_keyversions_destroy(kvs: *mut DBKeyVersions);
......
src/lib.rs
View file @ 130c764e
......@@ -39,8 +39,9 @@ pub use librocksdb_sys::{DBCompactionStyle, DBCompressionType, DBRecoveryMode, D
pub use merge_operator::MergeOperands;
pub use rocksdb::{DB, DBIterator, DBVector, Kv, SeekKey, Writable, WriteBatch, CFHandle, Range,
BackupEngine, SstFileWriter};
pub use rocksdb_options::{BlockBasedOptions, Options, ReadOptions, WriteOptions, RestoreOptions,
IngestExternalFileOptions, EnvOptions, HistogramData, CompactOptions};
pub use rocksdb_options::{BlockBasedOptions, DBOptions, ColumnFamilyOptions, ReadOptions,
WriteOptions, RestoreOptions, IngestExternalFileOptions, EnvOptions,
HistogramData, CompactOptions};
pub use slice_transform::SliceTransform;
pub use table_properties::{TableProperties, TablePropertiesCollection,
TablePropertiesCollectionView, UserCollectedProperties};
......
src/main.rs
View file @ 130c764e
......@@ -14,7 +14,7 @@
//
extern crate rocksdb;
use rocksdb::{DB, MergeOperands, Options, Writable};
use rocksdb::{DB, MergeOperands, DBOptions, Writable, ColumnFamilyOptions};
// fn snapshot_test() {
// let path = "_rust_rocksdb_iteratortest";
......@@ -87,11 +87,12 @@ fn concat_merge(_: &[u8], existing_val: Option<&[u8]>, operands: &mut MergeOpera
fn custom_merge() {
let path = "_rust_rocksdb_mergetest";
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
opts.add_merge_operator("test operator", concat_merge);
let mut cf_opts = ColumnFamilyOptions::new();
cf_opts.add_merge_operator("test operator", concat_merge);
{
let db = DB::open(opts, path).unwrap();
let db = DB::open_cf(opts, path, vec!["default"], vec![cf_opts]).unwrap();
db.put(b"k1", b"a").unwrap();
db.merge(b"k1", b"b").unwrap();
db.merge(b"k1", b"c").unwrap();
......@@ -109,19 +110,19 @@ fn custom_merge() {
Err(e) => println!("error retrieving value: {}", e),
}
}
let opts = Options::new();
let opts = DBOptions::new();
DB::destroy(&opts, path).is_ok();
}
#[cfg(test)]
mod tests {
use rocksdb::{BlockBasedOptions, DB, DBCompressionType, Options};
use rocksdb::{BlockBasedOptions, DB, DBCompressionType, ColumnFamilyOptions, DBOptions};
use rocksdb::DBCompactionStyle;
use rocksdb::DBRecoveryMode;
#[allow(dead_code)]
fn tuned_for_somebody_elses_disk(path: &str,
mut opts: Options,
mut opts: DBOptions,
blockopts: &mut BlockBasedOptions)
-> DB {
let per_level_compression: [DBCompressionType; 7] = [DBCompressionType::No,
......@@ -131,39 +132,39 @@ mod tests {
DBCompressionType::Lz4,
DBCompressionType::Lz4,
DBCompressionType::Lz4];
let mut cf_opts = ColumnFamilyOptions::new();
opts.create_if_missing(true);
opts.set_max_open_files(10000);
opts.set_use_fsync(false);
opts.set_bytes_per_sync(8388608);
opts.set_block_cache_size_mb(1024);
cf_opts.set_block_cache_size_mb(1024);
opts.set_table_cache_num_shard_bits(6);
opts.set_max_write_buffer_number(32);
opts.set_write_buffer_size(536870912);
opts.set_target_file_size_base(1073741824);
opts.set_min_write_buffer_number_to_merge(4);
opts.set_level_zero_file_num_compaction_trigger(4);
opts.set_level_zero_stop_writes_trigger(2000);
opts.set_level_zero_slowdown_writes_trigger(0);
opts.set_compaction_style(DBCompactionStyle::Universal);
cf_opts.set_max_write_buffer_number(32);
cf_opts.set_write_buffer_size(536870912);
cf_opts.set_target_file_size_base(1073741824);
cf_opts.set_min_write_buffer_number_to_merge(4);
cf_opts.set_level_zero_file_num_compaction_trigger(4);
cf_opts.set_level_zero_stop_writes_trigger(2000);
cf_opts.set_level_zero_slowdown_writes_trigger(0);
cf_opts.set_compaction_style(DBCompactionStyle::Universal);
opts.set_max_background_compactions(4);
opts.set_max_background_flushes(4);
opts.set_report_bg_io_stats(true);
cf_opts.set_report_bg_io_stats(true);
opts.set_wal_recovery_mode(DBRecoveryMode::PointInTime);
opts.enable_statistics();
opts.set_stats_dump_period_sec(60);
opts.compression_per_level(&per_level_compression);
cf_opts.compression_per_level(&per_level_compression);
blockopts.set_block_size(524288);
blockopts.set_cache_index_and_filter_blocks(true);
blockopts.set_bloom_filter(10, false);
opts.set_block_based_table_factory(blockopts);
opts.set_disable_auto_compactions(true);
opts.set_max_compaction_bytes(1073741824 * 25);
cf_opts.set_block_based_table_factory(blockopts);
cf_opts.set_disable_auto_compactions(true);
cf_opts.set_max_compaction_bytes(1073741824 * 25);
// let filter = new_bloom_filter(10);
// opts.set_filter(filter);
DB::open(opts, path).unwrap()
DB::open_cf(opts, path, vec!["default"], vec![cf_opts]).unwrap()
}
// TODO(tyler) unstable
......
src/merge_operator.rs
View file @ 130c764e
......@@ -148,7 +148,7 @@ impl<'a> Iterator for &'a mut MergeOperands {
#[cfg(test)]
mod test {
use rocksdb::{DB, DBVector, Writable};
use rocksdb_options::Options;
use rocksdb_options::{DBOptions, ColumnFamilyOptions};
use super::*;
use tempdir::TempDir;
......@@ -177,10 +177,15 @@ mod test {
#[test]
fn mergetest() {
let path = TempDir::new("_rust_rocksdb_mergetest").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
opts.add_merge_operator("test operator", test_provided_merge);
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
let mut cf_opts = ColumnFamilyOptions::new();
cf_opts.add_merge_operator("test operator", test_provided_merge);
let db = DB::open_cf(opts,
path.path().to_str().unwrap(),
vec!["default"],
vec![cf_opts])
.unwrap();
let p = db.put(b"k1", b"a");
assert!(p.is_ok());
let _ = db.merge(b"k1", b"b");
......
src/rocksdb.rs
View file @ 130c764e
......@@ -17,8 +17,9 @@ use crocksdb_ffi::{self, DBWriteBatch, DBCFHandle, DBInstance, DBBackupEngine,
DBStatisticsTickerType, DBStatisticsHistogramType, DBPinnableSlice,
DBCompressionType};
use libc::{self, c_int, c_void, size_t};
use rocksdb_options::{Options, ReadOptions, UnsafeSnap, WriteOptions, FlushOptions, EnvOptions,
RestoreOptions, IngestExternalFileOptions, HistogramData, CompactOptions};
use rocksdb_options::{DBOptions, ColumnFamilyOptions, ReadOptions, UnsafeSnap, WriteOptions,
FlushOptions, EnvOptions, RestoreOptions, IngestExternalFileOptions,
HistogramData, CompactOptions};
use std::{fs, ptr, slice};
use std::collections::BTreeMap;
use std::collections::btree_map::Entry;
......@@ -59,7 +60,8 @@ pub struct DB {
inner: *mut DBInstance,
cfs: BTreeMap<String, CFHandle>,
path: String,
opts: Options,
opts: DBOptions,
_cf_opts: Vec<ColumnFamilyOptions>,
}
impl Debug for DB {
......@@ -315,19 +317,19 @@ pub struct KeyVersion {
impl DB {
pub fn open_default(path: &str) -> Result<DB, String> {
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
DB::open(opts, path)
}
pub fn open(opts: Options, path: &str) -> Result<DB, String> {
DB::open_cf(opts, path, &[], &[])
pub fn open(opts: DBOptions, path: &str) -> Result<DB, String> {
DB::open_cf(opts, path, vec![], vec![])
}
pub fn open_cf(opts: Options,
pub fn open_cf(opts: DBOptions,
path: &str,
cfs: &[&str],
cf_opts: &[&Options])
cfs: Vec<&str>,
cf_opts: Vec<ColumnFamilyOptions>)
-> Result<DB, String> {
let cpath = match CString::new(path.as_bytes()) {
Ok(c) => c,
......@@ -341,18 +343,17 @@ impl DB {
{:?}",
e));
}
if cfs.len() != cf_opts.len() {
return Err(format!("cfs.len() and cf_opts.len() not match."));
}
let mut cfs_v = cfs;
let mut cf_opts_v = cf_opts;
let (db, cf_map) = {
let mut cfs_v = cfs.to_vec();
let mut cf_opts_v = cf_opts.to_vec();
// Always open the default column family
if !cfs_v.contains(&DEFAULT_COLUMN_FAMILY) {
cfs_v.push(DEFAULT_COLUMN_FAMILY);
cf_opts_v.push(&opts);
cf_opts_v.push(ColumnFamilyOptions::new());
}
// We need to store our CStrings in an intermediate vector
......@@ -365,7 +366,7 @@ impl DB {
let cfhandles: Vec<_> = cfs_v.iter().map(|_| ptr::null_mut()).collect();
let cfopts: Vec<_> = cf_opts_v.iter()
.map(|x| x.inner as *const crocksdb_ffi::DBOptions)
.map(|x| x.inner as *const crocksdb_ffi::Options)
.collect();
let db = unsafe {
......@@ -400,10 +401,11 @@ impl DB {
cfs: cf_map,
path: path.to_owned(),
opts: opts,
_cf_opts: cf_opts_v,
})
}
pub fn destroy(opts: &Options, path: &str) -> Result<(), String> {
pub fn destroy(opts: &DBOptions, path: &str) -> Result<(), String> {
let cpath = CString::new(path.as_bytes()).unwrap();
unsafe {
ffi_try!(crocksdb_destroy_db(opts.inner, cpath.as_ptr()));
......@@ -411,7 +413,7 @@ impl DB {
Ok(())
}
pub fn repair(opts: Options, path: &str) -> Result<(), String> {
pub fn repair(opts: DBOptions, path: &str) -> Result<(), String> {
let cpath = CString::new(path.as_bytes()).unwrap();
unsafe {
ffi_try!(crocksdb_repair_db(opts.inner, cpath.as_ptr()));
......@@ -419,7 +421,7 @@ impl DB {
Ok(())
}
pub fn list_column_families(opts: &Options, path: &str) -> Result<Vec<String>, String> {
pub fn list_column_families(opts: &DBOptions, path: &str) -> Result<Vec<String>, String> {
let cpath = match CString::new(path.as_bytes()) {
Ok(c) => c,
Err(_) => {
......@@ -522,7 +524,10 @@ impl DB {
self.get_cf_opt(cf, key, &ReadOptions::new())
}
pub fn create_cf(&mut self, name: &str, opts: &Options) -> Result<&CFHandle, String> {
pub fn create_cf(&mut self,
name: &str,
cf_opts: ColumnFamilyOptions)
-> Result<&CFHandle, String> {
let cname = match CString::new(name.as_bytes()) {
Ok(c) => c,
Err(_) => {
......@@ -532,8 +537,9 @@ impl DB {
let cname_ptr = cname.as_ptr();
unsafe {
let cf_handler =
ffi_try!(crocksdb_create_column_family(self.inner, opts.inner, cname_ptr));
ffi_try!(crocksdb_create_column_family(self.inner, cf_opts.inner, cname_ptr));
let handle = CFHandle { inner: cf_handler };
self._cf_opts.push(cf_opts);
Ok(match self.cfs.entry(name.to_owned()) {
Entry::Occupied(mut e) => {
e.insert(handle);
......@@ -959,18 +965,18 @@ impl DB {
self.opts.get_statistics_histogram(hist_type)
}
pub fn get_options(&self) -> Options {
pub fn get_options(&self) -> ColumnFamilyOptions {
let cf = self.cf_handle("default").unwrap();
unsafe {
let inner = crocksdb_ffi::crocksdb_get_options_cf(self.inner, cf.inner);
Options::from_raw(inner)
ColumnFamilyOptions::from_raw(inner)
}
}
pub fn get_options_cf(&self, cf: &CFHandle) -> Options {
pub fn get_options_cf(&self, cf: &CFHandle) -> ColumnFamilyOptions {
unsafe {
let inner = crocksdb_ffi::crocksdb_get_options_cf(self.inner, cf.inner);
Options::from_raw(inner)
ColumnFamilyOptions::from_raw(inner)
}
}
......@@ -1007,7 +1013,7 @@ impl DB {
}
pub fn backup_at(&self, path: &str) -> Result<BackupEngine, String> {
let backup_engine = BackupEngine::open(Options::new(), path).unwrap();
let backup_engine = BackupEngine::open(DBOptions::new(), path).unwrap();
unsafe {
ffi_try!(crocksdb_backup_engine_create_new_backup(backup_engine.inner, self.inner))
}
......@@ -1394,7 +1400,7 @@ pub struct BackupEngine {
}
impl BackupEngine {
pub fn open(opts: Options, path: &str) -> Result<BackupEngine, String> {
pub fn open(opts: DBOptions, path: &str) -> Result<BackupEngine, String> {
let cpath = match CString::new(path.as_bytes()) {
Ok(c) => c,
Err(_) => {
......@@ -1427,13 +1433,13 @@ impl Drop for BackupEngine {
pub struct SstFileWriter {
inner: *mut crocksdb_ffi::SstFileWriter,
_env_opt: EnvOptions,
_opt: Options,
_opt: ColumnFamilyOptions,
}
unsafe impl Send for SstFileWriter {}
impl SstFileWriter {
pub fn new(env_opt: EnvOptions, opt: Options) -> SstFileWriter {
pub fn new(env_opt: EnvOptions, opt: ColumnFamilyOptions) -> SstFileWriter {
unsafe {
SstFileWriter {
inner: crocksdb_ffi::crocksdb_sstfilewriter_create(env_opt.inner, opt.inner),
......@@ -1443,7 +1449,7 @@ impl SstFileWriter {
}
}
pub fn new_cf(env_opt: EnvOptions, opt: Options, cf: &CFHandle) -> SstFileWriter {
pub fn new_cf(env_opt: EnvOptions, opt: ColumnFamilyOptions, cf: &CFHandle) -> SstFileWriter {
unsafe {
SstFileWriter {
inner: crocksdb_ffi::crocksdb_sstfilewriter_create_cf(env_opt.inner,
......@@ -1532,7 +1538,7 @@ mod test {
let path = TempDir::new("_rust_rocksdb_error").expect("");
let path_str = path.path().to_str().unwrap();
let db = DB::open_default(path_str).unwrap();
let opts = Options::new();
let opts = DBOptions::new();
// The DB will still be open when we try to destroy and the lock should fail
match DB::destroy(&opts, path_str) {
Err(ref s) => {
......@@ -1676,21 +1682,20 @@ mod test {
{
let mut cfs_opts = vec![];
for _ in 0..cfs.len() {
cfs_opts.push(Options::new());
cfs_opts.push(ColumnFamilyOptions::new());
}
let cfs_ref_opts: Vec<&Options> = cfs_opts.iter().collect();
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
let mut db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
for (&cf, &cf_opts) in cfs.iter().zip(&cfs_ref_opts) {
if cf == "default" {
for (cf, cf_opts) in cfs.iter().zip(cfs_opts) {
if *cf == "default" {
continue;
}
db.create_cf(cf, cf_opts).unwrap();
}
}
let opts_list_cfs = Options::new();
let opts_list_cfs = DBOptions::new();
let mut cfs_vec = DB::list_column_families(&opts_list_cfs, path.path().to_str().unwrap())
.unwrap();
cfs_vec.sort();
......@@ -1738,7 +1743,7 @@ mod test {
let log_path = format!("{}", Path::new(&db_path).join("log_path").display());
fs::create_dir_all(&log_path).unwrap();
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
opts.set_db_log_dir(&log_path);
......@@ -1839,7 +1844,7 @@ mod test {
assert!(db.get(b"k2").unwrap().is_some());
assert!(snap.get(b"k2").unwrap().is_none());
}
let opts = Options::new();
let opts = DBOptions::new();
assert!(DB::destroy(&opts, path).is_ok());
}
......@@ -1864,11 +1869,11 @@ mod test {
#[test]
fn flush_cf() {
let path = TempDir::new("_rust_rocksdb_flush_cf").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
let mut db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
let opts = Options::new();
db.create_cf("cf", &opts).unwrap();
let cf_opts = ColumnFamilyOptions::new();
db.create_cf("cf", cf_opts).unwrap();
let cf_handle = db.cf_handle("cf").unwrap();
for i in 0..200 {
......@@ -1901,7 +1906,7 @@ mod test {
#[test]
fn test_get_all_key_versions() {
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
let path = TempDir::new("_rust_rocksdb_get_all_key_version_test").expect("");
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
......
src/rocksdb_options.rs
View file @ 130c764e
......@@ -16,7 +16,7 @@
use compaction_filter::{CompactionFilter, new_compaction_filter, CompactionFilterHandle};
use comparator::{self, ComparatorCallback, compare_callback};
use crocksdb_ffi::{self, DBOptions, DBWriteOptions, DBBlockBasedTableOptions, DBReadOptions,
use crocksdb_ffi::{self, Options, DBWriteOptions, DBBlockBasedTableOptions, DBReadOptions,
DBRestoreOptions, DBCompressionType, DBRecoveryMode, DBSnapshot, DBInstance,
DBFlushOptions, DBStatisticsTickerType, DBStatisticsHistogramType,
DBRateLimiter, DBInfoLogLevel, DBCompactOptions};
......@@ -294,12 +294,347 @@ impl Drop for CompactOptions {
}
}
pub struct Options {
pub inner: *mut DBOptions,
pub struct DBOptions {
pub inner: *mut Options,
}
impl Drop for DBOptions {
fn drop(&mut self) {
unsafe {
crocksdb_ffi::crocksdb_options_destroy(self.inner);
}
}
}
impl Default for DBOptions {
fn default() -> DBOptions {
unsafe {
let opts = crocksdb_ffi::crocksdb_options_create();
assert!(!opts.is_null(), "Could not create rocksdb db options");
DBOptions { inner: opts }
}
}
}
impl Clone for DBOptions {
fn clone(&self) -> Self {
unsafe {
let opts = crocksdb_ffi::crocksdb_options_copy(self.inner);
assert!(!opts.is_null());
DBOptions { inner: opts }
}
}
}
impl DBOptions {
pub fn new() -> DBOptions {
DBOptions::default()
}
pub fn increase_parallelism(&mut self, parallelism: i32) {
unsafe {
crocksdb_ffi::crocksdb_options_increase_parallelism(self.inner, parallelism);
}
}
pub fn add_event_listener<L: EventListener>(&mut self, l: L) {
let handle = new_event_listener(l);
unsafe { crocksdb_ffi::crocksdb_options_add_eventlistener(self.inner, handle) }
}
pub fn create_if_missing(&mut self, create_if_missing: bool) {
unsafe {
crocksdb_ffi::crocksdb_options_set_create_if_missing(self.inner, create_if_missing);
}
}
pub fn set_max_open_files(&mut self, nfiles: c_int) {
unsafe {
crocksdb_ffi::crocksdb_options_set_max_open_files(self.inner, nfiles);
}
}
pub fn set_max_total_wal_size(&mut self, size: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_max_total_wal_size(self.inner, size);
}
}
pub fn set_use_fsync(&mut self, useit: bool) {
unsafe {
if useit {
crocksdb_ffi::crocksdb_options_set_use_fsync(self.inner, 1)
} else {
crocksdb_ffi::crocksdb_options_set_use_fsync(self.inner, 0)
}
}
}
pub fn set_bytes_per_sync(&mut self, nbytes: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_bytes_per_sync(self.inner, nbytes);
}
}
pub fn set_table_cache_num_shard_bits(&mut self, nbits: c_int) {
unsafe {
crocksdb_ffi::crocksdb_options_set_table_cache_numshardbits(self.inner, nbits);
}
}
pub fn set_writable_file_max_buffer_size(&mut self, nbytes: c_int) {
unsafe {
crocksdb_ffi::crocksdb_options_set_writable_file_max_buffer_size(self.inner, nbytes);
}
}
pub fn set_use_direct_reads(&mut self, v: bool) {
unsafe {
crocksdb_ffi::crocksdb_options_set_use_direct_reads(self.inner, v);
}
}
pub fn set_use_direct_io_for_flush_and_compaction(&mut self, v: bool) {
unsafe {
crocksdb_ffi::crocksdb_options_set_use_direct_io_for_flush_and_compaction(self.inner,
v);
}
}
pub fn set_max_manifest_file_size(&mut self, size: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_max_manifest_file_size(self.inner, size);
}
}
pub fn set_max_background_flushes(&mut self, n: c_int) {
unsafe {
crocksdb_ffi::crocksdb_options_set_max_background_flushes(self.inner, n);
}
}
pub fn set_max_subcompactions(&mut self, n: u32) {
unsafe {
crocksdb_ffi::crocksdb_options_set_max_subcompactions(self.inner, n);
}
}
pub fn set_wal_bytes_per_sync(&mut self, n: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_wal_bytes_per_sync(self.inner, n);
}
}
pub fn set_base_background_compactions(&mut self, n: c_int) {
unsafe {
crocksdb_ffi::crocksdb_options_set_base_background_compactions(self.inner, n);
}
}
pub fn set_max_background_compactions(&mut self, n: c_int) {
unsafe {
crocksdb_ffi::crocksdb_options_set_max_background_compactions(self.inner, n);
}
}
pub fn set_wal_recovery_mode(&mut self, mode: DBRecoveryMode) {
unsafe {
crocksdb_ffi::crocksdb_options_set_wal_recovery_mode(self.inner, mode);
}
}
pub fn set_delayed_write_rate(&mut self, rate: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_delayed_write_rate(self.inner, rate);
}
}
pub fn enable_statistics(&mut self) {
unsafe {
crocksdb_ffi::crocksdb_options_enable_statistics(self.inner);
}
}
pub fn get_statistics_ticker_count(&self, ticker_type: DBStatisticsTickerType) -> u64 {
unsafe {
crocksdb_ffi::crocksdb_options_statistics_get_ticker_count(self.inner, ticker_type)
}
}
pub fn get_and_reset_statistics_ticker_count(&self,
ticker_type: DBStatisticsTickerType)
-> u64 {
unsafe {
crocksdb_ffi::crocksdb_options_statistics_get_and_reset_ticker_count(self.inner,
ticker_type)
}
}
pub fn get_statistics_histogram(&self,
hist_type: DBStatisticsHistogramType)
-> Option<HistogramData> {
unsafe {
let mut data = HistogramData::default();
let ret = crocksdb_ffi::crocksdb_options_statistics_get_histogram(self.inner,
hist_type,
&mut data.median,
&mut data.percentile95,
&mut data.percentile99,
&mut data.average,
&mut data.standard_deviation);
if !ret {
return None;
}
Some(data)
}
}
pub fn get_statistics_histogram_string(&self,
hist_type: DBStatisticsHistogramType)
-> Option<String> {
unsafe {
let value = crocksdb_ffi::crocksdb_options_statistics_get_histogram_string(self.inner,
hist_type);
if value.is_null() {
return None;
}
let s = CStr::from_ptr(value).to_str().unwrap().to_owned();
libc::free(value as *mut c_void);
Some(s)
}
}
pub fn get_statistics(&self) -> Option<String> {
unsafe {
let value = crocksdb_ffi::crocksdb_options_statistics_get_string(self.inner);
if value.is_null() {
return None;
}
// Must valid UTF-8 format.
let s = CStr::from_ptr(value).to_str().unwrap().to_owned();
libc::free(value as *mut c_void);
Some(s)
}
}
pub fn set_stats_dump_period_sec(&mut self, period: usize) {
unsafe {
crocksdb_ffi::crocksdb_options_set_stats_dump_period_sec(self.inner, period);
}
}
pub fn set_db_log_dir(&mut self, path: &str) {
let path = CString::new(path.as_bytes()).unwrap();
unsafe {
crocksdb_ffi::crocksdb_options_set_db_log_dir(self.inner, path.as_ptr());
}
}
pub fn set_wal_dir(&mut self, path: &str) {
let path = CString::new(path.as_bytes()).unwrap();
unsafe {
crocksdb_ffi::crocksdb_options_set_wal_dir(self.inner, path.as_ptr());
}
}
pub fn set_wal_ttl_seconds(&mut self, ttl: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_wal_ttl_seconds(self.inner, ttl as u64);
}
}
pub fn set_wal_size_limit_mb(&mut self, limit: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_wal_size_limit_mb(self.inner, limit as u64);
}
}
pub fn set_max_log_file_size(&mut self, size: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_max_log_file_size(self.inner, size as size_t);
}
}
pub fn set_log_file_time_to_roll(&mut self, ttl: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_log_file_time_to_roll(self.inner, ttl as size_t);
}
}
pub fn set_info_log_level(&mut self, level: DBInfoLogLevel) {
unsafe {
crocksdb_ffi::crocksdb_options_set_info_log_level(self.inner, level);
}
}
pub fn set_keep_log_file_num(&mut self, num: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_keep_log_file_num(self.inner, num as size_t);
}
}
pub fn set_compaction_readahead_size(&mut self, size: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_compaction_readahead_size(self.inner,
size as size_t);
}
}
pub fn set_ratelimiter(&mut self, rate_bytes_per_sec: i64) {
let rate_limiter = RateLimiter::new(rate_bytes_per_sec,
DEFAULT_REFILL_PERIOD_US,
DEFAULT_FAIRNESS);
unsafe {
crocksdb_ffi::crocksdb_options_set_ratelimiter(self.inner, rate_limiter.inner);
}
}
// Create a info log with `path` and save to options logger field directly.
// TODO: export more logger options like level, roll size, time, etc...
pub fn create_info_log(&self, path: &str) -> Result<(), String> {
let cpath = match CString::new(path.as_bytes()) {
Ok(c) => c,
Err(_) => {
return Err("Failed to convert path to CString when creating rocksdb info log"
.to_owned())
}
};
unsafe {
let logger = ffi_try!(crocksdb_create_log_from_options(cpath.as_ptr(), self.inner));
crocksdb_ffi::crocksdb_options_set_info_log(self.inner, logger);
// logger uses shared_ptr, it is OK to destroy here.
crocksdb_ffi::crocksdb_log_destroy(logger);
}
Ok(())
}
pub fn enable_pipelined_write(&self, v: bool) {
unsafe {
crocksdb_ffi::crocksdb_options_set_enable_pipelined_write(self.inner, v);
}
}
pub fn allow_concurrent_memtable_write(&self, v: bool) {
unsafe {
crocksdb_ffi::crocksdb_options_set_allow_concurrent_memtable_write(self.inner, v);
}
}
}
pub struct ColumnFamilyOptions {
pub inner: *mut Options,
filter: Option<CompactionFilterHandle>,
}
impl Drop for Options {
impl Drop for ColumnFamilyOptions {
fn drop(&mut self) {
unsafe {
crocksdb_ffi::crocksdb_options_destroy(self.inner);
......@@ -307,12 +642,13 @@ impl Drop for Options {
}
}
impl Default for Options {
fn default() -> Options {
impl Default for ColumnFamilyOptions {
fn default() -> ColumnFamilyOptions {
unsafe {
let opts = crocksdb_ffi::crocksdb_options_create();
assert!(!opts.is_null(), "Could not create rocksdb options");
Options {
assert!(!opts.is_null(),
"Could not create rocksdb column family options");
ColumnFamilyOptions {
inner: opts,
filter: None,
}
......@@ -320,13 +656,13 @@ impl Default for Options {
}
}
impl Clone for Options {
impl Clone for ColumnFamilyOptions {
fn clone(&self) -> Self {
assert!(self.filter.is_none());
unsafe {
let opts = crocksdb_ffi::crocksdb_options_copy(self.inner);
assert!(!opts.is_null());
Options {
ColumnFamilyOptions {
inner: opts,
filter: None,
}
......@@ -334,26 +670,20 @@ impl Clone for Options {
}
}
impl Options {
pub fn new() -> Options {
Options::default()
impl ColumnFamilyOptions {
pub fn new() -> ColumnFamilyOptions {
ColumnFamilyOptions::default()
}
pub unsafe fn from_raw(inner: *mut DBOptions) -> Options {
pub unsafe fn from_raw(inner: *mut Options) -> ColumnFamilyOptions {
assert!(!inner.is_null(),
"could not new rocksdb options with null inner");
Options {
ColumnFamilyOptions {
inner: inner,
filter: None,
}
}
pub fn increase_parallelism(&mut self, parallelism: i32) {
unsafe {
crocksdb_ffi::crocksdb_options_increase_parallelism(self.inner, parallelism);
}
}
pub fn optimize_level_style_compaction(&mut self, memtable_memory_budget: i32) {
unsafe {
crocksdb_ffi::crocksdb_options_optimize_level_style_compaction(self.inner,
......@@ -395,11 +725,6 @@ impl Options {
}
}
pub fn add_event_listener<L: EventListener>(&mut self, l: L) {
let handle = new_event_listener(l);
unsafe { crocksdb_ffi::crocksdb_options_add_eventlistener(self.inner, handle) }
}
pub fn add_table_properties_collector_factory(&mut self,
fname: &str,
factory: Box<TablePropertiesCollectorFactory>) {
......@@ -409,11 +734,6 @@ impl Options {
}
}
pub fn create_if_missing(&mut self, create_if_missing: bool) {
unsafe {
crocksdb_ffi::crocksdb_options_set_create_if_missing(self.inner, create_if_missing);
}
}
pub fn compression(&mut self, t: DBCompressionType) {
unsafe {
......@@ -471,61 +791,21 @@ impl Options {
let cb = Box::new(ComparatorCallback {
name: CString::new(name.as_bytes()).unwrap(),
f: compare_fn,
});
unsafe {
let cmp = crocksdb_ffi::crocksdb_comparator_create(mem::transmute(cb),
comparator::destructor_callback,
compare_callback,
comparator::name_callback);
crocksdb_ffi::crocksdb_options_set_comparator(self.inner, cmp);
}
}
pub fn set_block_cache_size_mb(&mut self, cache_size: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_optimize_for_point_lookup(self.inner, cache_size);
}
}
pub fn set_max_open_files(&mut self, nfiles: c_int) {
unsafe {
crocksdb_ffi::crocksdb_options_set_max_open_files(self.inner, nfiles);
}
}
pub fn set_max_total_wal_size(&mut self, size: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_max_total_wal_size(self.inner, size);
}
}
pub fn set_use_fsync(&mut self, useit: bool) {
unsafe {
if useit {
crocksdb_ffi::crocksdb_options_set_use_fsync(self.inner, 1)
} else {
crocksdb_ffi::crocksdb_options_set_use_fsync(self.inner, 0)
}
}
}
});
pub fn set_bytes_per_sync(&mut self, nbytes: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_bytes_per_sync(self.inner, nbytes);
let cmp = crocksdb_ffi::crocksdb_comparator_create(mem::transmute(cb),
comparator::destructor_callback,
compare_callback,
comparator::name_callback);
crocksdb_ffi::crocksdb_options_set_comparator(self.inner, cmp);
}
}
pub fn set_table_cache_num_shard_bits(&mut self, nbits: c_int) {
unsafe {
crocksdb_ffi::crocksdb_options_set_table_cache_numshardbits(self.inner, nbits);
}
}
pub fn set_writable_file_max_buffer_size(&mut self, nbytes: c_int) {
pub fn set_block_cache_size_mb(&mut self, cache_size: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_writable_file_max_buffer_size(self.inner, nbytes);
crocksdb_ffi::crocksdb_options_optimize_for_point_lookup(self.inner, cache_size);
}
}
......@@ -571,19 +851,6 @@ impl Options {
}
}
pub fn set_use_direct_reads(&mut self, v: bool) {
unsafe {
crocksdb_ffi::crocksdb_options_set_use_direct_reads(self.inner, v);
}
}
pub fn set_use_direct_io_for_flush_and_compaction(&mut self, v: bool) {
unsafe {
crocksdb_ffi::crocksdb_options_set_use_direct_io_for_flush_and_compaction(self.inner,
v);
}
}
pub fn set_soft_pending_compaction_bytes_limit(&mut self, size: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_soft_pending_compaction_bytes_limit(self.inner,
......@@ -598,12 +865,6 @@ impl Options {
}
}
pub fn set_max_manifest_file_size(&mut self, size: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_max_manifest_file_size(self.inner, size);
}
}
pub fn set_target_file_size_base(&mut self, size: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_target_file_size_base(self.inner, size);
......@@ -647,36 +908,6 @@ impl Options {
}
}
pub fn set_base_background_compactions(&mut self, n: c_int) {
unsafe {
crocksdb_ffi::crocksdb_options_set_base_background_compactions(self.inner, n);
}
}
pub fn set_max_background_compactions(&mut self, n: c_int) {
unsafe {
crocksdb_ffi::crocksdb_options_set_max_background_compactions(self.inner, n);
}
}
pub fn set_max_background_flushes(&mut self, n: c_int) {
unsafe {
crocksdb_ffi::crocksdb_options_set_max_background_flushes(self.inner, n);
}
}
pub fn set_max_subcompactions(&mut self, n: u32) {
unsafe {
crocksdb_ffi::crocksdb_options_set_max_subcompactions(self.inner, n);
}
}
pub fn set_wal_bytes_per_sync(&mut self, n: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_wal_bytes_per_sync(self.inner, n);
}
}
pub fn set_disable_auto_compactions(&mut self, disable: bool) {
unsafe {
if disable {
......@@ -703,153 +934,12 @@ impl Options {
}
}
pub fn set_wal_recovery_mode(&mut self, mode: DBRecoveryMode) {
unsafe {
crocksdb_ffi::crocksdb_options_set_wal_recovery_mode(self.inner, mode);
}
}
pub fn set_delayed_write_rate(&mut self, rate: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_delayed_write_rate(self.inner, rate);
}
}
pub fn enable_statistics(&mut self) {
unsafe {
crocksdb_ffi::crocksdb_options_enable_statistics(self.inner);
}
}
pub fn get_statistics_ticker_count(&self, ticker_type: DBStatisticsTickerType) -> u64 {
unsafe {
crocksdb_ffi::crocksdb_options_statistics_get_ticker_count(self.inner, ticker_type)
}
}
pub fn get_and_reset_statistics_ticker_count(&self,
ticker_type: DBStatisticsTickerType)
-> u64 {
unsafe {
crocksdb_ffi::crocksdb_options_statistics_get_and_reset_ticker_count(self.inner,
ticker_type)
}
}
pub fn get_statistics_histogram(&self,
hist_type: DBStatisticsHistogramType)
-> Option<HistogramData> {
unsafe {
let mut data = HistogramData::default();
let ret = crocksdb_ffi::crocksdb_options_statistics_get_histogram(self.inner,
hist_type,
&mut data.median,
&mut data.percentile95,
&mut data.percentile99,
&mut data.average,
&mut data.standard_deviation);
if !ret {
return None;
}
Some(data)
}
}
pub fn get_statistics_histogram_string(&self,
hist_type: DBStatisticsHistogramType)
-> Option<String> {
unsafe {
let value = crocksdb_ffi::crocksdb_options_statistics_get_histogram_string(self.inner,
hist_type);
if value.is_null() {
return None;
}
let s = CStr::from_ptr(value).to_str().unwrap().to_owned();
libc::free(value as *mut c_void);
Some(s)
}
}
pub fn get_statistics(&self) -> Option<String> {
unsafe {
let value = crocksdb_ffi::crocksdb_options_statistics_get_string(self.inner);
if value.is_null() {
return None;
}
// Must valid UTF-8 format.
let s = CStr::from_ptr(value).to_str().unwrap().to_owned();
libc::free(value as *mut c_void);
Some(s)
}
}
pub fn set_stats_dump_period_sec(&mut self, period: usize) {
unsafe {
crocksdb_ffi::crocksdb_options_set_stats_dump_period_sec(self.inner, period);
}
}
pub fn set_num_levels(&mut self, n: c_int) {
unsafe {
crocksdb_ffi::crocksdb_options_set_num_levels(self.inner, n);
}
}
pub fn set_db_log_dir(&mut self, path: &str) {
let path = CString::new(path.as_bytes()).unwrap();
unsafe {
crocksdb_ffi::crocksdb_options_set_db_log_dir(self.inner, path.as_ptr());
}
}
pub fn set_wal_dir(&mut self, path: &str) {
let path = CString::new(path.as_bytes()).unwrap();
unsafe {
crocksdb_ffi::crocksdb_options_set_wal_dir(self.inner, path.as_ptr());
}
}
pub fn set_wal_ttl_seconds(&mut self, ttl: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_wal_ttl_seconds(self.inner, ttl as u64);
}
}
pub fn set_wal_size_limit_mb(&mut self, limit: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_wal_size_limit_mb(self.inner, limit as u64);
}
}
pub fn set_max_log_file_size(&mut self, size: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_max_log_file_size(self.inner, size as size_t);
}
}
pub fn set_log_file_time_to_roll(&mut self, ttl: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_log_file_time_to_roll(self.inner, ttl as size_t);
}
}
pub fn set_info_log_level(&mut self, level: DBInfoLogLevel) {
unsafe {
crocksdb_ffi::crocksdb_options_set_info_log_level(self.inner, level);
}
}
pub fn set_keep_log_file_num(&mut self, num: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_keep_log_file_num(self.inner, num as size_t);
}
}
pub fn set_prefix_extractor<S>(&mut self,
name: S,
transform: Box<SliceTransform>)
......@@ -897,58 +987,9 @@ impl Options {
}
}
pub fn set_compaction_readahead_size(&mut self, size: u64) {
unsafe {
crocksdb_ffi::crocksdb_options_set_compaction_readahead_size(self.inner,
size as size_t);
}
}
pub fn set_ratelimiter(&mut self, rate_bytes_per_sec: i64) {
let rate_limiter = RateLimiter::new(rate_bytes_per_sec,
DEFAULT_REFILL_PERIOD_US,
DEFAULT_FAIRNESS);
unsafe {
crocksdb_ffi::crocksdb_options_set_ratelimiter(self.inner, rate_limiter.inner);
}
}
// Create a info log with `path` and save to options logger field directly.
// TODO: export more logger options like level, roll size, time, etc...
pub fn create_info_log(&self, path: &str) -> Result<(), String> {
let cpath = match CString::new(path.as_bytes()) {
Ok(c) => c,
Err(_) => {
return Err("Failed to convert path to CString when creating rocksdb info log"
.to_owned())
}
};
unsafe {
let logger = ffi_try!(crocksdb_create_log_from_options(cpath.as_ptr(), self.inner));
crocksdb_ffi::crocksdb_options_set_info_log(self.inner, logger);
// logger uses shared_ptr, it is OK to destroy here.
crocksdb_ffi::crocksdb_log_destroy(logger);
}
Ok(())
}
pub fn get_block_cache_usage(&self) -> u64 {
unsafe { crocksdb_ffi::crocksdb_options_get_block_cache_usage(self.inner) as u64 }
}
pub fn enable_pipelined_write(&self, v: bool) {
unsafe {
crocksdb_ffi::crocksdb_options_set_enable_pipelined_write(self.inner, v);
}
}
pub fn allow_concurrent_memtable_write(&self, v: bool) {
unsafe {
crocksdb_ffi::crocksdb_options_set_allow_concurrent_memtable_write(self.inner, v);
}
}
}
pub struct FlushOptions {
......
tests/test_column_family.rs
View file @ 130c764e
......@@ -13,7 +13,7 @@
// limitations under the License.
//
use rocksdb::{DB, MergeOperands, Options, Writable};
use rocksdb::{DB, MergeOperands, DBOptions, ColumnFamilyOptions, Writable};
use tempdir::TempDir;
#[test]
......@@ -23,12 +23,13 @@ pub fn test_column_family() {
// should be able to create column families
{
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
opts.add_merge_operator("test operator", test_provided_merge);
let mut db = DB::open(opts, path_str).unwrap();
let opts = Options::new();
match db.create_cf("cf1", &opts) {
let mut cf_opts = ColumnFamilyOptions::new();
cf_opts.add_merge_operator("test operator", test_provided_merge);
let mut db = DB::open_cf(opts, path_str, vec!["default"], vec![cf_opts]).unwrap();
let cf_opts = ColumnFamilyOptions::new();
match db.create_cf("cf1", cf_opts) {
Ok(_) => println!("cf1 created successfully"),
Err(e) => {
panic!("could not create column family: {}", e);
......@@ -39,9 +40,9 @@ pub fn test_column_family() {
// should fail to open db without specifying same column families
{
let mut opts = Options::new();
opts.add_merge_operator("test operator", test_provided_merge);
match DB::open(opts, path_str) {
let mut cf_opts = ColumnFamilyOptions::new();
cf_opts.add_merge_operator("test operator", test_provided_merge);
match DB::open_cf(DBOptions::new(), path_str, vec!["default"], vec![cf_opts]) {
Ok(_) => {
panic!("should not have opened DB successfully without \
specifying column
......@@ -56,18 +57,18 @@ pub fn test_column_family() {
// should properly open db when specifying all column families
{
let mut opts = Options::new();
opts.add_merge_operator("test operator", test_provided_merge);
match DB::open_cf(Options::new(), path_str, &["cf1"], &[&opts]) {
let mut cf_opts = ColumnFamilyOptions::new();
cf_opts.add_merge_operator("test operator", test_provided_merge);
match DB::open_cf(DBOptions::new(), path_str, vec!["cf1"], vec![cf_opts]) {
Ok(_) => println!("successfully opened db with column family"),
Err(e) => panic!("failed to open db with column family: {}", e),
}
}
// TODO should be able to write, read, merge, batch, and iterate over a cf
{
let mut opts = Options::new();
opts.add_merge_operator("test operator", test_provided_merge);
let db = match DB::open_cf(Options::new(), path_str, &["cf1"], &[&opts]) {
let mut cf_opts = ColumnFamilyOptions::new();
cf_opts.add_merge_operator("test operator", test_provided_merge);
let db = match DB::open_cf(DBOptions::new(), path_str, vec!["cf1"], vec![cf_opts]) {
Ok(db) => {
println!("successfully opened db with column family");
db
......@@ -114,9 +115,13 @@ pub fn test_column_family() {
{}
// TODO should be able to iterate over a cf
{}
// should b able to drop a cf
// should be able to drop a cf
{
let mut db = DB::open_cf(Options::new(), path_str, &["cf1"], &[&Options::new()]).unwrap();
let mut db = DB::open_cf(DBOptions::new(),
path_str,
vec!["cf1"],
vec![ColumnFamilyOptions::new()])
.unwrap();
match db.drop_cf("cf1") {
Ok(_) => println!("cf1 successfully dropped."),
Err(e) => panic!("failed to drop column family: {}", e),
......
tests/test_compact_range.rs
View file @ 130c764e
......@@ -11,14 +11,14 @@
// See the License for the specific language governing permissions and
// limitations under the License.
use rocksdb::{DB, Options, Range, Writable};
use rocksdb::{DB, DBOptions, Range, Writable};
use tempdir::TempDir;
#[test]
fn test_compact_range() {
let path = TempDir::new("_rust_rocksdb_test_compact_range").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
let samples = vec![(b"k1".to_vec(), b"value--------1".to_vec()),
......
tests/test_compaction_filter.rs
View file @ 130c764e
......@@ -11,7 +11,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
use rocksdb::{Writable, DB, CompactionFilter, Options};
use rocksdb::{Writable, DB, CompactionFilter, DBOptions, ColumnFamilyOptions};
use std::sync::{Arc, RwLock};
use std::sync::atomic::{AtomicBool, Ordering};
use tempdir::TempDir;
......@@ -40,19 +40,24 @@ impl Drop for Filter {
#[test]
fn test_compaction_filter() {
let path = TempDir::new("_rust_rocksdb_writebacktest").expect("");
let mut opts = Options::new();
let mut cf_opts = ColumnFamilyOptions::new();
let drop_called = Arc::new(AtomicBool::new(false));
let filtered_kvs = Arc::new(RwLock::new(vec![]));
// set ignore_snapshots to false
opts.set_compaction_filter("test",
cf_opts.set_compaction_filter("test",
false,
Box::new(Filter {
drop_called: drop_called.clone(),
filtered_kvs: filtered_kvs.clone(),
}))
.unwrap();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
let db = DB::open_cf(opts,
path.path().to_str().unwrap(),
vec!["default"],
vec![cf_opts])
.unwrap();
let samples = vec![(b"key1".to_vec(), b"value1".to_vec()),
(b"key2".to_vec(), b"value2".to_vec())];
for &(ref k, ref v) in &samples {
......@@ -71,10 +76,10 @@ fn test_compaction_filter() {
}
drop(db);
// reregister with ignore_snapshots set to true
let mut opts = Options::new();
opts.set_compaction_filter("test",
let mut cf_opts = ColumnFamilyOptions::new();
let opts = DBOptions::new();
cf_opts.set_compaction_filter("test",
true,
Box::new(Filter {
drop_called: drop_called.clone(),
......@@ -84,7 +89,11 @@ fn test_compaction_filter() {
assert!(drop_called.load(Ordering::Relaxed));
drop_called.store(false, Ordering::Relaxed);
{
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
let db = DB::open_cf(opts,
path.path().to_str().unwrap(),
vec!["default"],
vec![cf_opts])
.unwrap();
let _snap = db.snapshot();
// Because ignore_snapshots is true, so all the keys will be compacted.
db.compact_range(Some(b"key1"), Some(b"key3"));
......@@ -93,6 +102,5 @@ fn test_compaction_filter() {
}
assert_eq!(*filtered_kvs.read().unwrap(), samples);
}
assert!(drop_called.load(Ordering::Relaxed));
}
tests/test_delete_range.rs
View file @ 130c764e
......@@ -15,7 +15,7 @@ use rocksdb::*;
use std::fs;
use tempdir::TempDir;
fn gen_sst(opt: Options, cf: Option<&CFHandle>, path: &str) {
fn gen_sst(opt: ColumnFamilyOptions, cf: Option<&CFHandle>, path: &str) {
let _ = fs::remove_file(path);
let env_opt = EnvOptions::new();
let mut writer = if cf.is_some() {
......@@ -157,7 +157,7 @@ fn test_delete_range_sst_files() {
fn test_delete_range_ingest_file() {
let path = TempDir::new("_rust_rocksdb_test_delete_range_ingest_file").expect("");
let path_str = path.path().to_str().unwrap();
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
let mut db = DB::open(opts, path_str).unwrap();
let gen_path = TempDir::new("_rust_rocksdb_ingest_sst_gen").expect("");
......@@ -183,10 +183,10 @@ fn test_delete_range_ingest_file() {
db.cf_handle("default"),
&[(b"key1", None), (b"key2", None), (b"key3", None), (b"key4", Some(b"value4"))]);
let cf_opts = Options::new();
db.create_cf("cf1", &cf_opts).unwrap();
let cf_opts = ColumnFamilyOptions::new();
db.create_cf("cf1", cf_opts).unwrap();
let handle = db.cf_handle("cf1").unwrap();
gen_sst(cf_opts, None, test_sstfile_str);
gen_sst(ColumnFamilyOptions::new(), None, test_sstfile_str);
db.ingest_external_file_cf(handle, &ingest_opt, &[test_sstfile_str])
.unwrap();
......
tests/test_event_listener.rs
View file @ 130c764e
......@@ -77,7 +77,7 @@ fn test_event_listener_basic() {
let path = TempDir::new("_rust_rocksdb_event_listener_flush").expect("");
let path_str = path.path().to_str().unwrap();
let mut opts = Options::new();
let mut opts = DBOptions::new();
let counter = EventCounter::default();
opts.add_event_listener(counter.clone());
opts.create_if_missing(true);
......@@ -111,7 +111,7 @@ fn test_event_listener_ingestion() {
let path = TempDir::new("_rust_rocksdb_event_listener_ingestion").expect("");
let path_str = path.path().to_str().unwrap();
let mut opts = Options::new();
let mut opts = DBOptions::new();
let counter = EventCounter::default();
opts.add_event_listener(counter.clone());
opts.create_if_missing(true);
......
tests/test_ingest_external_file.rs
View file @ 130c764e
......@@ -16,7 +16,10 @@ use rocksdb::*;
use std::fs;
use tempdir::TempDir;
pub fn gen_sst(opt: Options, cf: Option<&CFHandle>, path: &str, data: &[(&[u8], &[u8])]) {
pub fn gen_sst(opt: ColumnFamilyOptions,
cf: Option<&CFHandle>,
path: &str,
data: &[(&[u8], &[u8])]) {
let _ = fs::remove_file(path);
let env_opt = EnvOptions::new();
let mut writer = if cf.is_some() {
......@@ -36,11 +39,11 @@ fn test_ingest_external_file() {
let path = TempDir::new("_rust_rocksdb_ingest_sst").expect("");
let path_str = path.path().to_str().unwrap();
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
let mut db = DB::open(opts, path_str).unwrap();
let cf_opts = Options::new();
db.create_cf("cf1", &cf_opts).unwrap();
let cf_opts = ColumnFamilyOptions::new();
db.create_cf("cf1", cf_opts).unwrap();
let handle = db.cf_handle("cf1").unwrap();
let gen_path = TempDir::new("_rust_rocksdb_ingest_sst_gen").expect("");
......@@ -60,7 +63,7 @@ fn test_ingest_external_file() {
assert_eq!(db.get(b"k1").unwrap().unwrap(), b"v1");
assert_eq!(db.get(b"k2").unwrap().unwrap(), b"v2");
gen_sst(cf_opts,
gen_sst(ColumnFamilyOptions::new(),
None,
test_sstfile_str,
&[(b"k1", b"v3"), (b"k2", b"v4")]);
......@@ -71,8 +74,7 @@ fn test_ingest_external_file() {
let snap = db.snapshot();
let opt = Options::new();
gen_sst(opt,
gen_sst(ColumnFamilyOptions::new(),
None,
test_sstfile_str,
&[(b"k2", b"v5"), (b"k3", b"v6")]);
......
tests/test_iterator.rs
View file @ 130c764e
......@@ -165,7 +165,7 @@ pub fn test_iterator() {
#[test]
fn test_seek_for_prev() {
let path = TempDir::new("_rust_rocksdb_seek_for_prev").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
{
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
......@@ -213,7 +213,7 @@ fn test_seek_for_prev() {
#[test]
fn read_with_upper_bound() {
let path = TempDir::new("_rust_rocksdb_read_with_upper_bound_test").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
{
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
......@@ -237,18 +237,23 @@ fn test_total_order_seek() {
let mut bbto = BlockBasedOptions::new();
bbto.set_bloom_filter(10, false);
bbto.set_whole_key_filtering(false);
let mut opts = Options::new();
let mut cf_opts = ColumnFamilyOptions::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
opts.set_block_based_table_factory(&bbto);
opts.set_prefix_extractor("FixedPrefixTransform",
cf_opts.set_block_based_table_factory(&bbto);
cf_opts.set_prefix_extractor("FixedPrefixTransform",
Box::new(FixedPrefixTransform { prefix_len: 2 }))
.unwrap();
// also create prefix bloom for memtable
opts.set_memtable_prefix_bloom_size_ratio(0.1 as f64);
cf_opts.set_memtable_prefix_bloom_size_ratio(0.1 as f64);
let keys = vec![b"k1-1", b"k1-2", b"k1-3", b"k2-1", b"k2-2", b"k2-3", b"k3-1", b"k3-2",
b"k3-3"];
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
let db = DB::open_cf(opts,
path.path().to_str().unwrap(),
vec!["default"],
vec![cf_opts])
.unwrap();
let wopts = WriteOptions::new();
// sst1
......@@ -315,14 +320,19 @@ fn test_fixed_suffix_seek() {
let mut bbto = BlockBasedOptions::new();
bbto.set_bloom_filter(10, false);
bbto.set_whole_key_filtering(false);
let mut opts = Options::new();
let mut opts = DBOptions::new();
let mut cf_opts = ColumnFamilyOptions::new();
opts.create_if_missing(true);
opts.set_block_based_table_factory(&bbto);
opts.set_prefix_extractor("FixedSuffixTransform",
cf_opts.set_block_based_table_factory(&bbto);
cf_opts.set_prefix_extractor("FixedSuffixTransform",
Box::new(FixedSuffixTransform { suffix_len: 2 }))
.unwrap();
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
let db = DB::open_cf(opts,
path.path().to_str().unwrap(),
vec!["default"],
vec![cf_opts])
.unwrap();
db.put(b"k-eghe-5", b"a").unwrap();
db.put(b"k-24yfae-6", b"a").unwrap();
db.put(b"k-h1fwd-7", b"a").unwrap();
......
tests/test_prefix_extractor.rs
View file @ 130c764e
......@@ -36,7 +36,7 @@ fn test_prefix_extractor_compatibility() {
// create db with no prefix extractor, and insert data
{
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
let wopts = WriteOptions::new();
......@@ -53,15 +53,20 @@ fn test_prefix_extractor_compatibility() {
let mut bbto = BlockBasedOptions::new();
bbto.set_bloom_filter(10, false);
bbto.set_whole_key_filtering(false);
let mut opts = Options::new();
let mut opts = DBOptions::new();
let mut cf_opts = ColumnFamilyOptions::new();
opts.create_if_missing(false);
opts.set_block_based_table_factory(&bbto);
opts.set_prefix_extractor("FixedPrefixTransform",
cf_opts.set_block_based_table_factory(&bbto);
cf_opts.set_prefix_extractor("FixedPrefixTransform",
Box::new(FixedPrefixTransform { prefix_len: 2 }))
.unwrap();
// also create prefix bloom for memtable
opts.set_memtable_prefix_bloom_size_ratio(0.1 as f64);
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
cf_opts.set_memtable_prefix_bloom_size_ratio(0.1 as f64);
let db = DB::open_cf(opts,
path.path().to_str().unwrap(),
vec!["default"],
vec![cf_opts])
.unwrap();
let wopts = WriteOptions::new();
// sst2 with prefix bloom.
......
tests/test_rocksdb_options.rs
View file @ 130c764e
......@@ -11,8 +11,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
use rocksdb::{DB, Options, BlockBasedOptions, WriteOptions, SliceTransform, Writable,
CompactOptions};
use rocksdb::{DB, ColumnFamilyOptions, DBOptions, BlockBasedOptions, WriteOptions, SliceTransform,
Writable, CompactOptions};
use rocksdb::crocksdb_ffi::{DBStatisticsHistogramType as HistogramType,
DBStatisticsTickerType as TickerType, DBInfoLogLevel as InfoLogLevel,
CompactionPriority, DBCompressionType};
......@@ -25,17 +25,22 @@ use tempdir::TempDir;
#[test]
fn test_set_num_levels() {
let path = TempDir::new("_rust_rocksdb_test_set_num_levels").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
let mut cf_opts = ColumnFamilyOptions::new();
opts.create_if_missing(true);
opts.set_num_levels(2);
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
cf_opts.set_num_levels(2);
let db = DB::open_cf(opts,
path.path().to_str().unwrap(),
vec!["default"],
vec![cf_opts])
.unwrap();
drop(db);
}
#[test]
fn test_log_file_opt() {
let path = TempDir::new("_rust_rocksdb_log_file_opt").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
opts.set_max_log_file_size(100 * 1024 * 1024);
opts.set_keep_log_file_num(10);
......@@ -46,7 +51,7 @@ fn test_log_file_opt() {
#[test]
fn test_compaction_readahead_size() {
let path = TempDir::new("_rust_rocksdb_compaction_readahead_size").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
opts.set_compaction_readahead_size(2048);
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
......@@ -55,14 +60,14 @@ fn test_compaction_readahead_size() {
#[test]
fn test_set_max_manifest_file_size() {
let mut opts = Options::new();
let mut opts = DBOptions::new();
let size = 20 * 1024 * 1024;
opts.set_max_manifest_file_size(size)
}
#[test]
fn test_enable_statistics() {
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.enable_statistics();
opts.set_stats_dump_period_sec(60);
assert!(opts.get_statistics().is_some());
......@@ -75,7 +80,7 @@ fn test_enable_statistics() {
assert_eq!(opts.get_statistics_ticker_count(TickerType::BlockCacheMiss),
0);
let opts = Options::new();
let opts = DBOptions::new();
assert!(opts.get_statistics().is_none());
}
......@@ -96,14 +101,19 @@ impl SliceTransform for FixedPrefixTransform {
#[test]
fn test_memtable_insert_hint_prefix_extractor() {
let path = TempDir::new("_rust_rocksdb_memtable_insert_hint_prefix_extractor").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
let mut cf_opts = ColumnFamilyOptions::new();
opts.create_if_missing(true);
opts.set_memtable_insert_hint_prefix_extractor("FixedPrefixTransform",
cf_opts.set_memtable_insert_hint_prefix_extractor("FixedPrefixTransform",
Box::new(FixedPrefixTransform {
prefix_len: 2,
}))
.unwrap();
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
let db = DB::open_cf(opts,
path.path().to_str().unwrap(),
vec!["default"],
vec![cf_opts])
.unwrap();
let wopts = WriteOptions::new();
db.put_opt(b"k0-1", b"a", &wopts).unwrap();
......@@ -117,7 +127,7 @@ fn test_memtable_insert_hint_prefix_extractor() {
#[test]
fn test_set_delayed_write_rate() {
let path = TempDir::new("_rust_rocksdb_test_set_delayed_write_rate").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
opts.set_delayed_write_rate(2 * 1024 * 1024);
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
......@@ -127,7 +137,7 @@ fn test_set_delayed_write_rate() {
#[test]
fn test_set_ratelimiter() {
let path = TempDir::new("_rust_rocksdb_test_set_rate_limiter").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
// compaction and flush rate limited below 100MB/sec
opts.set_ratelimiter(100 * 1024 * 1024);
......@@ -138,7 +148,7 @@ fn test_set_ratelimiter() {
#[test]
fn test_set_wal_opt() {
let path = TempDir::new("_rust_rocksdb_test_set_wal_opt").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
opts.set_wal_ttl_seconds(86400);
opts.set_wal_size_limit_mb(10);
......@@ -152,7 +162,7 @@ fn test_set_wal_opt() {
#[test]
fn test_sync_wal() {
let path = TempDir::new("_rust_rocksdb_test_sync_wal").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
db.put(b"key", b"value").unwrap();
......@@ -163,7 +173,7 @@ fn test_sync_wal() {
#[test]
fn test_create_info_log() {
let path = TempDir::new("_rust_rocksdb_test_create_info_log_opt").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
opts.set_info_log_level(InfoLogLevel::Debug);
opts.set_log_file_time_to_roll(1);
......@@ -192,7 +202,7 @@ fn test_create_info_log() {
#[test]
fn test_auto_roll_max_size_info_log() {
let path = TempDir::new("_rust_rocksdb_test_max_size_info_log_opt").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
opts.set_max_log_file_size(10);
......@@ -213,27 +223,37 @@ fn test_auto_roll_max_size_info_log() {
#[test]
fn test_set_pin_l0_filter_and_index_blocks_in_cache() {
let path = TempDir::new("_rust_rocksdb_set_cache_and_index").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
let mut cf_opts = ColumnFamilyOptions::new();
opts.create_if_missing(true);
let mut block_opts = BlockBasedOptions::new();
block_opts.set_pin_l0_filter_and_index_blocks_in_cache(true);
opts.set_block_based_table_factory(&block_opts);
DB::open(opts, path.path().to_str().unwrap()).unwrap();
cf_opts.set_block_based_table_factory(&block_opts);
DB::open_cf(opts,
path.path().to_str().unwrap(),
vec!["default"],
vec![cf_opts])
.unwrap();
}
#[test]
fn test_pending_compaction_bytes_limit() {
let path = TempDir::new("_rust_rocksdb_pending_compaction_bytes_limit").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
let mut cf_opts = ColumnFamilyOptions::new();
opts.create_if_missing(true);
opts.set_soft_pending_compaction_bytes_limit(64 * 1024 * 1024 * 1024);
opts.set_hard_pending_compaction_bytes_limit(256 * 1024 * 1024 * 1024);
DB::open(opts, path.path().to_str().unwrap()).unwrap();
cf_opts.set_soft_pending_compaction_bytes_limit(64 * 1024 * 1024 * 1024);
cf_opts.set_hard_pending_compaction_bytes_limit(256 * 1024 * 1024 * 1024);
DB::open_cf(opts,
path.path().to_str().unwrap(),
vec!["default"],
vec![cf_opts])
.unwrap();
}
#[test]
fn test_set_max_subcompactions() {
let path = TempDir::new("_rust_rocksdb_max_subcompactions").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
opts.set_max_subcompactions(4);
DB::open(opts, path.path().to_str().unwrap()).unwrap();
......@@ -242,7 +262,7 @@ fn test_set_max_subcompactions() {
#[test]
fn test_set_bytes_per_sync() {
let path = TempDir::new("_rust_rocksdb_bytes_per_sync").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
opts.set_bytes_per_sync(1024 * 1024);
opts.set_wal_bytes_per_sync(1024 * 1024);
......@@ -252,24 +272,34 @@ fn test_set_bytes_per_sync() {
#[test]
fn test_set_optimize_filters_for_hits() {
let path = TempDir::new("_rust_rocksdb_optimize_filters_for_hits").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
let mut cf_opts = ColumnFamilyOptions::new();
opts.create_if_missing(true);
opts.set_optimize_filters_for_hits(true);
DB::open(opts, path.path().to_str().unwrap()).unwrap();
cf_opts.set_optimize_filters_for_hits(true);
DB::open_cf(opts,
path.path().to_str().unwrap(),
vec!["default"],
vec![cf_opts])
.unwrap();
}
#[test]
fn test_get_block_cache_usage() {
let path = TempDir::new("_rust_rocksdb_set_cache_and_index").expect("");
let mut opts = Options::new();
assert_eq!(opts.get_block_cache_usage(), 0);
let mut opts = DBOptions::new();
let mut cf_opts = ColumnFamilyOptions::new();
assert_eq!(cf_opts.get_block_cache_usage(), 0);
opts.create_if_missing(true);
let mut block_opts = BlockBasedOptions::new();
block_opts.set_lru_cache(16 * 1024 * 1024);
opts.set_block_based_table_factory(&block_opts);
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
cf_opts.set_block_based_table_factory(&block_opts);
let db = DB::open_cf(opts,
path.path().to_str().unwrap(),
vec!["default"],
vec![cf_opts])
.unwrap();
for i in 0..200 {
db.put(format!("k_{}", i).as_bytes(), b"v").unwrap();
......@@ -285,10 +315,15 @@ fn test_get_block_cache_usage() {
#[test]
fn test_set_level_compaction_dynamic_level_bytes() {
let path = TempDir::new("_rust_rocksdb_level_compaction_dynamic_level_bytes").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
let mut cf_opts = ColumnFamilyOptions::new();
opts.create_if_missing(true);
opts.set_level_compaction_dynamic_level_bytes(true);
DB::open(opts, path.path().to_str().unwrap()).unwrap();
cf_opts.set_level_compaction_dynamic_level_bytes(true);
DB::open_cf(opts,
path.path().to_str().unwrap(),
vec!["default"],
vec![cf_opts])
.unwrap();
}
#[test]
......@@ -308,7 +343,7 @@ fn test_compact_options() {
#[test]
fn test_direct_read_write() {
let path = TempDir::new("_rust_rocksdb_direct_read_write").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
opts.set_use_direct_reads(true);
opts.set_use_direct_io_for_flush_and_compaction(true);
......@@ -318,7 +353,7 @@ fn test_direct_read_write() {
#[test]
fn test_writable_file_max_buffer_size() {
let path = TempDir::new("_rust_rocksdb_writable_file_max_buffer_size").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
opts.set_writable_file_max_buffer_size(1024 * 1024);
DB::open(opts, path.path().to_str().unwrap()).unwrap();
......@@ -327,7 +362,7 @@ fn test_writable_file_max_buffer_size() {
#[test]
fn test_set_base_background_compactions() {
let path = TempDir::new("_rust_rocksdb_base_background_compactions").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
opts.set_base_background_compactions(4);
DB::open(opts, path.path().to_str().unwrap()).unwrap();
......@@ -336,16 +371,21 @@ fn test_set_base_background_compactions() {
#[test]
fn test_set_compaction_pri() {
let path = TempDir::new("_rust_rocksdb_compaction_pri").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
let mut cf_opts = ColumnFamilyOptions::new();
opts.create_if_missing(true);
opts.compaction_priority(CompactionPriority::MinOverlappingRatio);
DB::open(opts, path.path().to_str().unwrap()).unwrap();
cf_opts.compaction_priority(CompactionPriority::MinOverlappingRatio);
DB::open_cf(opts,
path.path().to_str().unwrap(),
vec!["default"],
vec![cf_opts])
.unwrap();
}
#[test]
fn test_allow_concurrent_memtable_write() {
let path = TempDir::new("_rust_rocksdb_allow_concurrent_memtable_write").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
opts.allow_concurrent_memtable_write(false);
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
......@@ -357,7 +397,7 @@ fn test_allow_concurrent_memtable_write() {
#[test]
fn test_enable_pipelined_write() {
let path = TempDir::new("_rust_rocksdb_enable_pipelined_write").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
opts.enable_pipelined_write(true);
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
......@@ -368,41 +408,47 @@ fn test_enable_pipelined_write() {
#[test]
fn test_get_compression() {
let mut opts = Options::new();
let mut opts = DBOptions::new();
let mut cf_opts = ColumnFamilyOptions::new();
opts.create_if_missing(true);
opts.compression(DBCompressionType::Snappy);
assert_eq!(opts.get_compression(), DBCompressionType::Snappy);
cf_opts.compression(DBCompressionType::Snappy);
assert_eq!(cf_opts.get_compression(), DBCompressionType::Snappy);
}
#[test]
fn test_get_compression_per_level() {
let mut opts = Options::new();
let mut cf_opts = ColumnFamilyOptions::new();
let compressions = &[DBCompressionType::No, DBCompressionType::Snappy];
opts.compression_per_level(compressions);
let v = opts.get_compression_per_level();
cf_opts.compression_per_level(compressions);
let v = cf_opts.get_compression_per_level();
assert_eq!(v.len(), 2);
assert_eq!(v[0], DBCompressionType::No);
assert_eq!(v[1], DBCompressionType::Snappy);
let mut opts2 = Options::new();
let mut cf_opts2 = ColumnFamilyOptions::new();
let empty: &[DBCompressionType] = &[];
opts2.compression_per_level(empty);
let v2 = opts2.get_compression_per_level();
cf_opts2.compression_per_level(empty);
let v2 = cf_opts2.get_compression_per_level();
assert_eq!(v2.len(), 0);
}
#[test]
fn test_bottommost_compression() {
let path = TempDir::new("_rust_rocksdb_bottommost_compression").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
let cf_opts = ColumnFamilyOptions::new();
opts.create_if_missing(true);
opts.bottommost_compression(DBCompressionType::No);
DB::open(opts, path.path().to_str().unwrap()).unwrap();
cf_opts.bottommost_compression(DBCompressionType::No);
DB::open_cf(opts,
path.path().to_str().unwrap(),
vec!["default"],
vec![cf_opts])
.unwrap();
}
#[test]
fn test_clone_options() {
let mut opts = Options::new();
opts.compression(DBCompressionType::Snappy);
let opts2 = opts.clone();
assert_eq!(opts.get_compression(), opts2.get_compression());
let mut cf_opts = ColumnFamilyOptions::new();
cf_opts.compression(DBCompressionType::Snappy);
let cf_opts2 = cf_opts.clone();
assert_eq!(cf_opts.get_compression(), cf_opts2.get_compression());
}
tests/test_slice_transform.rs
View file @ 130c764e
......@@ -11,7 +11,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
use rocksdb::{Writable, DB, SliceTransform, Options, SeekKey, BlockBasedOptions};
use rocksdb::{Writable, DB, SliceTransform, ColumnFamilyOptions, DBOptions, SeekKey,
BlockBasedOptions};
use tempdir::TempDir;
struct FixedPostfixTransform {
......@@ -32,20 +33,25 @@ impl SliceTransform for FixedPostfixTransform {
#[test]
fn test_slice_transform() {
let path = TempDir::new("_rust_rocksdb_slice_transform_test").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
let mut cf_opts = ColumnFamilyOptions::new();
let mut block_opts = BlockBasedOptions::new();
block_opts.set_bloom_filter(10, false);
block_opts.set_whole_key_filtering(false);
opts.set_block_based_table_factory(&block_opts);
opts.set_memtable_prefix_bloom_size_ratio(0.25);
cf_opts.set_block_based_table_factory(&block_opts);
cf_opts.set_memtable_prefix_bloom_size_ratio(0.25);
opts.set_prefix_extractor("test", Box::new(FixedPostfixTransform { postfix_len: 2 }))
cf_opts.set_prefix_extractor("test", Box::new(FixedPostfixTransform { postfix_len: 2 }))
.unwrap();
opts.create_if_missing(true);
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
let db = DB::open_cf(opts,
path.path().to_str().unwrap(),
vec!["default"],
vec![cf_opts])
.unwrap();
let samples = vec![(b"key_01".to_vec(), b"1".to_vec()),
(b"key_02".to_vec(), b"2".to_vec()),
(b"key_0303".to_vec(), b"3".to_vec()),
......
tests/test_statistics.rs
View file @ 130c764e
......@@ -18,7 +18,7 @@ use tempdir::TempDir;
#[test]
fn test_db_statistics() {
let path = TempDir::new("_rust_rocksdb_statistics").expect("");
let mut opts = Options::new();
let mut opts = DBOptions::new();
opts.create_if_missing(true);
opts.enable_statistics();
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
......
tests/test_table_properties.rs
View file @ 130c764e
......@@ -12,8 +12,9 @@
// limitations under the License.
use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
use rocksdb::{DB, Range, Options, Writable, DBEntryType, TablePropertiesCollection,
TablePropertiesCollector, TablePropertiesCollectorFactory, UserCollectedProperties};
use rocksdb::{DB, Range, ColumnFamilyOptions, DBOptions, Writable, DBEntryType,
TablePropertiesCollection, TablePropertiesCollector,
TablePropertiesCollectorFactory, UserCollectedProperties};
use std::collections::HashMap;
use std::fmt;
use tempdir::TempDir;
......@@ -159,12 +160,17 @@ fn check_collection(collection: &TablePropertiesCollection,
#[test]
fn test_table_properties_collector_factory() {
let f = ExampleFactory::new();
let mut opts = Options::new();
let mut opts = DBOptions::new();
let mut cf_opts = ColumnFamilyOptions::new();
opts.create_if_missing(true);
opts.add_table_properties_collector_factory("example-collector", Box::new(f));
cf_opts.add_table_properties_collector_factory("example-collector", Box::new(f));
let path = TempDir::new("_rust_rocksdb_collectortest").expect("");
let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
let db = DB::open_cf(opts,
path.path().to_str().unwrap(),
vec!["default"],
vec![cf_opts])
.unwrap();
let samples = vec![(b"key1".to_vec(), b"value1".to_vec()),
(b"key2".to_vec(), b"value2".to_vec()),
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment