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

Fixing rustfmt.toml and applying formatting...

Browse Source
master
Jordan Terrell 6 years ago
parent 60dbdc92dc
commit e565d68852
18 changed files with 578 additions and 554 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 3
      rustfmt.toml
  2. 6
      src/backup.rs
  3. 22
      src/checkpoint.rs
  4. 7
      src/compaction_filter.rs
  5. 1
      src/comparator.rs
  6. 70
      src/db.rs
  7. 61
      src/db_options.rs
  8. 22
      src/lib.rs
  9. 74
      src/merge_operator.rs
  10. 24
      src/slice_transform.rs
  11. 2
      tests/test_checkpoint.rs
  12. 49
      tests/test_column_family.rs
  13. 24
      tests/test_iterator.rs
  14. 3
      tests/test_multithreaded.rs
  15. 3
      tests/test_raw_iterator.rs
  16. 2
      tests/test_rocksdb_options.rs
  17. 6
      tests/test_slice_transform.rs
  18. 11
      tests/util/mod.rs

3
rustfmt.toml
Unescape View File

@ -1,4 +1 @@
reorder_imports = true reorder_imports = true
max_width = 100
ideal_width = 100
trailing_comma = always

6
src/backup.rs
Unescape View File

@ -13,9 +13,8 @@
// limitations under the License. // limitations under the License.
// //
use {DB, Error};
use ffi; use ffi;
use {Error, DB};
use libc::{c_int, uint32_t}; use libc::{c_int, uint32_t};
use std::ffi::CString; use std::ffi::CString;
@ -64,8 +63,7 @@ impl BackupEngine {
pub fn create_new_backup(&mut self, db: &DB) -> Result<(), Error> { pub fn create_new_backup(&mut self, db: &DB) -> Result<(), Error> {
unsafe { unsafe {
ffi_try!(ffi::rocksdb_backup_engine_create_new_backup( ffi_try!(ffi::rocksdb_backup_engine_create_new_backup(
self.inner, self.inner, db.inner,
db.inner,
)); ));
Ok(()) Ok(())
} }

22
src/checkpoint.rs
Unescape View File

@ -13,14 +13,13 @@
// limitations under the License. // limitations under the License.
// //
///! Implementation of bindings to RocksDB Checkpoint[1] API
///
/// [1]: https://github.com/facebook/rocksdb/wiki/Checkpoints
use {DB, Error};
use ffi; use ffi;
use std::ffi::CString; use std::ffi::CString;
use std::path::Path; use std::path::Path;
///! Implementation of bindings to RocksDB Checkpoint[1] API
///
/// [1]: https://github.com/facebook/rocksdb/wiki/Checkpoints
use {Error, DB};
/// Undocumented parameter for `ffi::rocksdb_checkpoint_create` function. Zero by default. /// Undocumented parameter for `ffi::rocksdb_checkpoint_create` function. Zero by default.
const LOG_SIZE_FOR_FLUSH: u64 = 0_u64; const LOG_SIZE_FOR_FLUSH: u64 = 0_u64;
@ -45,9 +44,7 @@ impl Checkpoint {
return Err(Error::new("Could not create checkpoint object.".to_owned())); return Err(Error::new("Could not create checkpoint object.".to_owned()));
} }
Ok(Checkpoint { Ok(Checkpoint { inner: checkpoint })
inner: checkpoint,
})
} }
/// Creates new physical DB checkpoint in directory specified by `path`. /// Creates new physical DB checkpoint in directory specified by `path`.
@ -57,14 +54,17 @@ impl Checkpoint {
Ok(c) => c, Ok(c) => c,
Err(_) => { Err(_) => {
return Err(Error::new( return Err(Error::new(
"Failed to convert path to CString when creating DB checkpoint" "Failed to convert path to CString when creating DB checkpoint".to_owned(),
.to_owned(),
)); ));
} }
}; };
unsafe { unsafe {
ffi_try!(ffi::rocksdb_checkpoint_create(self.inner, cpath.as_ptr(), LOG_SIZE_FOR_FLUSH,)); ffi_try!(ffi::rocksdb_checkpoint_create(
self.inner,
cpath.as_ptr(),
LOG_SIZE_FOR_FLUSH,
));
Ok(()) Ok(())
} }

7
src/compaction_filter.rs
Unescape View File

@ -32,7 +32,6 @@ pub enum Decision {
Change(&'static [u8]), Change(&'static [u8]),
} }
/// Function to filter compaction with. /// Function to filter compaction with.
/// ///
/// This function takes the level of compaction, the key, and the existing value /// This function takes the level of compaction, the key, and the existing value
@ -46,8 +45,7 @@ impl<F> CompactionFilterFn for F
where where
F: FnMut(u32, &[u8], &[u8]) -> Decision, F: FnMut(u32, &[u8], &[u8]) -> Decision,
F: Send + 'static, F: Send + 'static,
{ {}
}
pub struct CompactionFilterCallback<F> pub struct CompactionFilterCallback<F>
where where
@ -117,7 +115,7 @@ fn test_filter(level: u32, key: &[u8], value: &[u8]) -> Decision {
#[test] #[test]
fn compaction_filter_test() { fn compaction_filter_test() {
use {DB, Options}; use {Options, DB};
let path = "_rust_rocksdb_filtertest"; let path = "_rust_rocksdb_filtertest";
let mut opts = Options::default(); let mut opts = Options::default();
@ -133,5 +131,4 @@ fn compaction_filter_test() {
assert!(db.get(b"_k").unwrap().is_none()); assert!(db.get(b"_k").unwrap().is_none());
assert_eq!(&*db.get(b"%k").unwrap().unwrap(), b"secret"); assert_eq!(&*db.get(b"%k").unwrap().unwrap(), b"secret");
} }
} }

1
src/comparator.rs
Unescape View File

@ -13,7 +13,6 @@
// limitations under the License. // limitations under the License.
// //
use libc::{c_char, c_int, c_void, size_t}; use libc::{c_char, c_int, c_void, size_t};
use std::cmp::Ordering; use std::cmp::Ordering;
use std::ffi::CString; use std::ffi::CString;

70
src/db.rs
Unescape View File

@ -13,13 +13,13 @@
// limitations under the License. // limitations under the License.
// //
use {DB, Error, Options, WriteOptions, ColumnFamily, ColumnFamilyDescriptor};
use ffi; use ffi;
use ffi_util::opt_bytes_to_ptr; use ffi_util::opt_bytes_to_ptr;
use {ColumnFamily, ColumnFamilyDescriptor, Error, Options, WriteOptions, DB};
use libc::{self, c_char, c_int, c_uchar, c_void, size_t}; use libc::{self, c_char, c_int, c_uchar, c_void, size_t};
use std::collections::BTreeMap; use std::collections::BTreeMap;
use std::ffi::CStr;
use std::ffi::CString; use std::ffi::CString;
use std::fmt; use std::fmt;
use std::fs; use std::fs;
@ -28,7 +28,6 @@ use std::path::Path;
use std::ptr; use std::ptr;
use std::slice; use std::slice;
use std::str; use std::str;
use std::ffi::CStr;
pub fn new_bloom_filter(bits: c_int) -> *mut ffi::rocksdb_filterpolicy_t { pub fn new_bloom_filter(bits: c_int) -> *mut ffi::rocksdb_filterpolicy_t {
unsafe { ffi::rocksdb_filterpolicy_create_bloom(bits) } unsafe { ffi::rocksdb_filterpolicy_create_bloom(bits) }
@ -150,7 +149,6 @@ pub struct DBRawIterator {
inner: *mut ffi::rocksdb_iterator_t, inner: *mut ffi::rocksdb_iterator_t,
} }
/// An iterator over a database or column family, with specifiable /// An iterator over a database or column family, with specifiable
/// ranges and direction. /// ranges and direction.
/// ///
@ -201,7 +199,11 @@ pub enum IteratorMode<'a> {
impl DBRawIterator { impl DBRawIterator {
fn new(db: &DB, readopts: &ReadOptions) -> DBRawIterator { fn new(db: &DB, readopts: &ReadOptions) -> DBRawIterator {
unsafe { DBRawIterator { inner: ffi::rocksdb_create_iterator(db.inner, readopts.inner) } } unsafe {
DBRawIterator {
inner: ffi::rocksdb_create_iterator(db.inner, readopts.inner),
}
}
} }
fn new_cf( fn new_cf(
@ -581,10 +583,13 @@ impl<'a> Drop for Snapshot<'a> {
impl ColumnFamilyDescriptor { impl ColumnFamilyDescriptor {
// Create a new column family descriptor with the specified name and options. // Create a new column family descriptor with the specified name and options.
pub fn new<S>(name: S, options: Options) -> Self where S: Into<String> { pub fn new<S>(name: S, options: Options) -> Self
where
S: Into<String>,
{
ColumnFamilyDescriptor { ColumnFamilyDescriptor {
name: name.into(), name: name.into(),
options options,
} }
} }
} }
@ -606,13 +611,21 @@ impl DB {
/// ///
/// Column families opened using this function will be created with default `Options`. /// Column families opened using this function will be created with default `Options`.
pub fn open_cf<P: AsRef<Path>>(opts: &Options, path: P, cfs: &[&str]) -> Result<DB, Error> { pub fn open_cf<P: AsRef<Path>>(opts: &Options, path: P, cfs: &[&str]) -> Result<DB, Error> {
let cfs_v = cfs.to_vec().iter().map(|name| ColumnFamilyDescriptor::new(*name, Options::default())).collect(); let cfs_v = cfs
.to_vec()
.iter()
.map(|name| ColumnFamilyDescriptor::new(*name, Options::default()))
.collect();
DB::open_cf_descriptors(opts, path, cfs_v) DB::open_cf_descriptors(opts, path, cfs_v)
} }
/// Open a database with the given database options and column family names/options. /// Open a database with the given database options and column family names/options.
pub fn open_cf_descriptors<P: AsRef<Path>>(opts: &Options, path: P, cfs: Vec<ColumnFamilyDescriptor>) -> Result<DB, Error> { pub fn open_cf_descriptors<P: AsRef<Path>>(
opts: &Options,
path: P,
cfs: Vec<ColumnFamilyDescriptor>,
) -> Result<DB, Error> {
let path = path.as_ref(); let path = path.as_ref();
let cpath = match CString::new(path.to_string_lossy().as_bytes()) { let cpath = match CString::new(path.to_string_lossy().as_bytes()) {
Ok(c) => c, Ok(c) => c,
@ -646,7 +659,7 @@ impl DB {
if !cfs_v.iter().any(|cf| cf.name == "default") { if !cfs_v.iter().any(|cf| cf.name == "default") {
cfs_v.push(ColumnFamilyDescriptor { cfs_v.push(ColumnFamilyDescriptor {
name: String::from("default"), name: String::from("default"),
options: Options::default() options: Options::default(),
}); });
} }
// We need to store our CStrings in an intermediate vector // We need to store our CStrings in an intermediate vector
@ -661,7 +674,8 @@ impl DB {
// These handles will be populated by DB. // These handles will be populated by DB.
let mut cfhandles: Vec<_> = cfs_v.iter().map(|_| ptr::null_mut()).collect(); let mut cfhandles: Vec<_> = cfs_v.iter().map(|_| ptr::null_mut()).collect();
let mut cfopts: Vec<_> = cfs_v.iter() let mut cfopts: Vec<_> = cfs_v
.iter()
.map(|cf| cf.options.inner as *const _) .map(|cf| cf.options.inner as *const _)
.collect(); .collect();
@ -672,7 +686,8 @@ impl DB {
cfs_v.len() as c_int, cfs_v.len() as c_int,
cfnames.as_mut_ptr(), cfnames.as_mut_ptr(),
cfopts.as_mut_ptr(), cfopts.as_mut_ptr(),
cfhandles.as_mut_ptr(),)); cfhandles.as_mut_ptr(),
));
} }
for handle in &cfhandles { for handle in &cfhandles {
@ -731,7 +746,6 @@ impl DB {
} }
} }
pub fn destroy<P: AsRef<Path>>(opts: &Options, path: P) -> Result<(), Error> { pub fn destroy<P: AsRef<Path>>(opts: &Options, path: P) -> Result<(), Error> {
let cpath = CString::new(path.as_ref().to_string_lossy().as_bytes()).unwrap(); let cpath = CString::new(path.as_ref().to_string_lossy().as_bytes()).unwrap();
unsafe { unsafe {
@ -929,11 +943,16 @@ impl DB {
pub fn prefix_iterator_cf<'a>( pub fn prefix_iterator_cf<'a>(
&self, &self,
cf_handle: ColumnFamily, cf_handle: ColumnFamily,
prefix: &'a [u8] prefix: &'a [u8],
) -> Result<DBIterator, Error> { ) -> Result<DBIterator, Error> {
let mut opts = ReadOptions::default(); let mut opts = ReadOptions::default();
opts.set_prefix_same_as_start(true); opts.set_prefix_same_as_start(true);
DBIterator::new_cf(self, cf_handle, &opts, IteratorMode::From(prefix, Direction::Forward)) DBIterator::new_cf(
self,
cf_handle,
&opts,
IteratorMode::From(prefix, Direction::Forward),
)
} }
pub fn raw_iterator(&self) -> DBRawIterator { pub fn raw_iterator(&self) -> DBRawIterator {
@ -1207,7 +1226,9 @@ impl WriteBatch {
impl Default for WriteBatch { impl Default for WriteBatch {
fn default() -> WriteBatch { fn default() -> WriteBatch {
WriteBatch { inner: unsafe { ffi::rocksdb_writebatch_create() } } WriteBatch {
inner: unsafe { ffi::rocksdb_writebatch_create() },
}
} }
} }
@ -1268,21 +1289,21 @@ impl ReadOptions {
} }
pub fn set_prefix_same_as_start(&mut self, v: bool) { pub fn set_prefix_same_as_start(&mut self, v: bool) {
unsafe { unsafe { ffi::rocksdb_readoptions_set_prefix_same_as_start(self.inner, v as c_uchar) }
ffi::rocksdb_readoptions_set_prefix_same_as_start(self.inner, v as c_uchar)
}
} }
pub fn set_total_order_seek(&mut self, v:bool) { pub fn set_total_order_seek(&mut self, v: bool) {
unsafe { unsafe { ffi::rocksdb_readoptions_set_total_order_seek(self.inner, v as c_uchar) }
ffi::rocksdb_readoptions_set_total_order_seek(self.inner, v as c_uchar)
}
} }
} }
impl Default for ReadOptions { impl Default for ReadOptions {
fn default() -> ReadOptions { fn default() -> ReadOptions {
unsafe { ReadOptions { inner: ffi::rocksdb_readoptions_create() } } unsafe {
ReadOptions {
inner: ffi::rocksdb_readoptions_create(),
}
}
} }
} }
@ -1352,7 +1373,6 @@ fn test_db_vector() {
assert_eq!(&*v, &ctrl[..]); assert_eq!(&*v, &ctrl[..]);
} }
#[test] #[test]
fn external() { fn external() {
let path = "_rust_rocksdb_externaltest"; let path = "_rust_rocksdb_externaltest";

61
src/db_options.rs
Unescape View File

@ -18,14 +18,17 @@ use std::path::Path;
use libc::{self, c_int, c_uchar, c_uint, c_void, size_t, uint64_t}; use libc::{self, c_int, c_uchar, c_uint, c_void, size_t, uint64_t};
use ffi; use compaction_filter::{self, filter_callback, CompactionFilterCallback, CompactionFilterFn};
use {BlockBasedOptions, BlockBasedIndexType, DBCompactionStyle, DBCompressionType, DBRecoveryMode, MemtableFactory,
Options, WriteOptions};
use compaction_filter::{self, CompactionFilterCallback, CompactionFilterFn, filter_callback};
use comparator::{self, ComparatorCallback, CompareFn}; use comparator::{self, ComparatorCallback, CompareFn};
use merge_operator::{self, MergeFn, MergeOperatorCallback, full_merge_callback, use ffi;
partial_merge_callback}; use merge_operator::{
self, full_merge_callback, partial_merge_callback, MergeFn, MergeOperatorCallback,
};
use slice_transform::SliceTransform; use slice_transform::SliceTransform;
use {
BlockBasedIndexType, BlockBasedOptions, DBCompactionStyle, DBCompressionType, DBRecoveryMode,
MemtableFactory, Options, WriteOptions,
};
pub fn new_cache(capacity: size_t) -> *mut ffi::rocksdb_cache_t { pub fn new_cache(capacity: size_t) -> *mut ffi::rocksdb_cache_t {
unsafe { ffi::rocksdb_cache_create_lru(capacity) } unsafe { ffi::rocksdb_cache_create_lru(capacity) }
@ -189,7 +192,10 @@ impl Options {
/// ``` /// ```
pub fn create_missing_column_families(&mut self, create_missing_cfs: bool) { pub fn create_missing_column_families(&mut self, create_missing_cfs: bool) {
unsafe { unsafe {
ffi::rocksdb_options_set_create_missing_column_families(self.inner, create_missing_cfs as c_uchar); ffi::rocksdb_options_set_create_missing_column_families(
self.inner,
create_missing_cfs as c_uchar,
);
} }
} }
@ -256,14 +262,19 @@ impl Options {
/// Default: `0` /// Default: `0`
pub fn set_compaction_readahead_size(&mut self, compaction_readahead_size: usize) { pub fn set_compaction_readahead_size(&mut self, compaction_readahead_size: usize) {
unsafe { unsafe {
ffi::rocksdb_options_compaction_readahead_size(self.inner, compaction_readahead_size as usize); ffi::rocksdb_options_compaction_readahead_size(
self.inner,
compaction_readahead_size as usize,
);
} }
} }
pub fn set_merge_operator(&mut self, name: &str, pub fn set_merge_operator(
&mut self,
name: &str,
full_merge_fn: MergeFn, full_merge_fn: MergeFn,
partial_merge_fn: Option<MergeFn>) { partial_merge_fn: Option<MergeFn>,
) {
let cb = Box::new(MergeOperatorCallback { let cb = Box::new(MergeOperatorCallback {
name: CString::new(name.as_bytes()).unwrap(), name: CString::new(name.as_bytes()).unwrap(),
full_merge_fn: full_merge_fn, full_merge_fn: full_merge_fn,
@ -283,8 +294,10 @@ impl Options {
} }
} }
#[deprecated(since = "0.5.0", #[deprecated(
note = "add_merge_operator has been renamed to set_merge_operator")] since = "0.5.0",
note = "add_merge_operator has been renamed to set_merge_operator"
)]
pub fn add_merge_operator(&mut self, name: &str, merge_fn: MergeFn) { pub fn add_merge_operator(&mut self, name: &str, merge_fn: MergeFn) {
self.set_merge_operator(name, merge_fn, None); self.set_merge_operator(name, merge_fn, None);
} }
@ -343,14 +356,13 @@ impl Options {
} }
pub fn set_prefix_extractor(&mut self, prefix_extractor: SliceTransform) { pub fn set_prefix_extractor(&mut self, prefix_extractor: SliceTransform) {
unsafe { unsafe { ffi::rocksdb_options_set_prefix_extractor(self.inner, prefix_extractor.inner) }
ffi::rocksdb_options_set_prefix_extractor(
self.inner, prefix_extractor.inner
)
}
} }
#[deprecated(since = "0.5.0", note = "add_comparator has been renamed to set_comparator")] #[deprecated(
since = "0.5.0",
note = "add_comparator has been renamed to set_comparator"
)]
pub fn add_comparator(&mut self, name: &str, compare_fn: CompareFn) { pub fn add_comparator(&mut self, name: &str, compare_fn: CompareFn) {
self.set_comparator(name, compare_fn); self.set_comparator(name, compare_fn);
} }
@ -532,8 +544,10 @@ impl Options {
/// let mut opts = Options::default(); /// let mut opts = Options::default();
/// opts.set_allow_os_buffer(false); /// opts.set_allow_os_buffer(false);
/// ``` /// ```
#[deprecated(since = "0.7.0", #[deprecated(
note = "replaced with set_use_direct_reads/set_use_direct_io_for_flush_and_compaction methods")] since = "0.7.0",
note = "replaced with set_use_direct_reads/set_use_direct_io_for_flush_and_compaction methods"
)]
pub fn set_allow_os_buffer(&mut self, is_allow: bool) { pub fn set_allow_os_buffer(&mut self, is_allow: bool) {
self.set_use_direct_reads(!is_allow); self.set_use_direct_reads(!is_allow);
self.set_use_direct_io_for_flush_and_compaction(!is_allow); self.set_use_direct_io_for_flush_and_compaction(!is_allow);
@ -844,7 +858,6 @@ impl Options {
} }
} }
/// Sets the maximum number of concurrent background compaction jobs, submitted to /// Sets the maximum number of concurrent background compaction jobs, submitted to
/// the default LOW priority thread pool. /// the default LOW priority thread pool.
/// We first try to schedule compactions based on /// We first try to schedule compactions based on
@ -1049,9 +1062,7 @@ impl Options {
/// ///
/// Default: `true` /// Default: `true`
pub fn set_advise_random_on_open(&mut self, advise: bool) { pub fn set_advise_random_on_open(&mut self, advise: bool) {
unsafe { unsafe { ffi::rocksdb_options_set_advise_random_on_open(self.inner, advise as c_uchar) }
ffi::rocksdb_options_set_advise_random_on_open(self.inner, advise as c_uchar)
}
} }
/// Sets the number of levels for this database. /// Sets the number of levels for this database.

22
src/lib.rs
Unescape View File

@ -54,17 +54,18 @@ mod ffi_util;
pub mod backup; pub mod backup;
pub mod checkpoint; pub mod checkpoint;
mod comparator;
pub mod merge_operator;
pub mod compaction_filter; pub mod compaction_filter;
mod comparator;
mod db; mod db;
mod db_options; mod db_options;
pub mod merge_operator;
mod slice_transform; mod slice_transform;
pub use compaction_filter::Decision as CompactionDecision; pub use compaction_filter::Decision as CompactionDecision;
pub use db::{DBCompactionStyle, DBCompressionType, DBIterator, DBRawIterator, DBRecoveryMode, pub use db::{
DBVector, ReadOptions, Direction, IteratorMode, Snapshot, WriteBatch, new_bloom_filter, DBCompactionStyle, DBCompressionType, DBIterator, DBRawIterator,
new_bloom_filter}; DBRecoveryMode, DBVector, Direction, IteratorMode, ReadOptions, Snapshot, WriteBatch,
};
pub use slice_transform::SliceTransform; pub use slice_transform::SliceTransform;
@ -155,8 +156,14 @@ pub enum BlockBasedIndexType {
/// See https://github.com/facebook/rocksdb/wiki/MemTable for more information. /// See https://github.com/facebook/rocksdb/wiki/MemTable for more information.
pub enum MemtableFactory { pub enum MemtableFactory {
Vector, Vector,
HashSkipList { bucket_count: usize, height: i32, branching_factor: i32 }, HashSkipList {
HashLinkList { bucket_count: usize } bucket_count: usize,
height: i32,
branching_factor: i32,
},
HashLinkList {
bucket_count: usize,
},
} }
/// Database-wide options around performance and behavior. /// Database-wide options around performance and behavior.
@ -222,7 +229,6 @@ pub struct WriteOptions {
inner: *mut ffi::rocksdb_writeoptions_t, inner: *mut ffi::rocksdb_writeoptions_t,
} }
/// An opaque type used to represent a column family. Returned from some functions, and used /// An opaque type used to represent a column family. Returned from some functions, and used
/// in others /// in others
#[derive(Copy, Clone)] #[derive(Copy, Clone)]

74
src/merge_operator.rs
Unescape View File

@ -53,7 +53,6 @@
//! } //! }
//! ``` //! ```
use libc::{self, c_char, c_int, c_void, size_t}; use libc::{self, c_char, c_int, c_void, size_t};
use std::ffi::CString; use std::ffi::CString;
use std::mem; use std::mem;
@ -88,15 +87,17 @@ pub unsafe extern "C" fn full_merge_callback(
num_operands: c_int, num_operands: c_int,
success: *mut u8, success: *mut u8,
new_value_length: *mut size_t, new_value_length: *mut size_t,
) -> *mut c_char { ) -> *mut c_char {
let cb = &mut *(raw_cb as *mut MergeOperatorCallback); let cb = &mut *(raw_cb as *mut MergeOperatorCallback);
let operands = &mut MergeOperands::new(operands_list, operands_list_len, num_operands); let operands = &mut MergeOperands::new(operands_list, operands_list_len, num_operands);
let key = slice::from_raw_parts(raw_key as *const u8, key_len as usize); let key = slice::from_raw_parts(raw_key as *const u8, key_len as usize);
let oldval = let oldval = if existing_value == ptr::null() {
if existing_value == ptr::null() {
None None
} else { } else {
Some(slice::from_raw_parts(existing_value as *const u8, existing_value_len as usize)) Some(slice::from_raw_parts(
existing_value as *const u8,
existing_value_len as usize,
))
}; };
if let Some(mut result) = (cb.full_merge_fn)(key, oldval, operands) { if let Some(mut result) = (cb.full_merge_fn)(key, oldval, operands) {
result.shrink_to_fit(); result.shrink_to_fit();
@ -122,7 +123,7 @@ pub unsafe extern "C" fn partial_merge_callback(
num_operands: c_int, num_operands: c_int,
success: *mut u8, success: *mut u8,
new_value_length: *mut size_t, new_value_length: *mut size_t,
) -> *mut c_char { ) -> *mut c_char {
let cb = &mut *(raw_cb as *mut MergeOperatorCallback); let cb = &mut *(raw_cb as *mut MergeOperatorCallback);
let operands = &mut MergeOperands::new(operands_list, operands_list_len, num_operands); let operands = &mut MergeOperands::new(operands_list, operands_list_len, num_operands);
let key = slice::from_raw_parts(raw_key as *const u8, key_len as usize); let key = slice::from_raw_parts(raw_key as *const u8, key_len as usize);
@ -141,7 +142,6 @@ pub unsafe extern "C" fn partial_merge_callback(
} }
} }
pub struct MergeOperands { pub struct MergeOperands {
operands_list: *const *const c_char, operands_list: *const *const c_char,
operands_list_len: *const size_t, operands_list_len: *const size_t,
@ -220,9 +220,9 @@ mod test {
Some(result) Some(result)
} }
#[test] #[test]
fn mergetest() { fn mergetest() {
use {DB, Options}; use {Options, DB};
let path = "_rust_rocksdb_mergetest"; let path = "_rust_rocksdb_mergetest";
let mut opts = Options::default(); let mut opts = Options::default();
@ -239,12 +239,10 @@ mod test {
let m = db.merge(b"k1", b"h"); let m = db.merge(b"k1", b"h");
assert!(m.is_ok()); assert!(m.is_ok());
match db.get(b"k1") { match db.get(b"k1") {
Ok(Some(value)) => { Ok(Some(value)) => match value.to_utf8() {
match value.to_utf8() {
Some(v) => println!("retrieved utf8 value: {}", v), Some(v) => println!("retrieved utf8 value: {}", v),
None => println!("did not read valid utf-8 out of the db"), None => println!("did not read valid utf-8 out of the db"),
} },
}
Err(_) => println!("error reading value"), Err(_) => println!("error reading value"),
_ => panic!("value not present"), _ => panic!("value not present"),
} }
@ -259,25 +257,24 @@ mod test {
} }
unsafe fn to_slice<T: Sized>(p: &T) -> &[u8] { unsafe fn to_slice<T: Sized>(p: &T) -> &[u8] {
::std::slice::from_raw_parts( ::std::slice::from_raw_parts((p as *const T) as *const u8, ::std::mem::size_of::<T>())
(p as *const T) as *const u8,
::std::mem::size_of::<T>(),
)
} }
fn from_slice<T: Sized>(s: &[u8]) -> Option<&T> { fn from_slice<T: Sized>(s: &[u8]) -> Option<&T> {
if ::std::mem::size_of::<T>() != s.len() { if ::std::mem::size_of::<T>() != s.len() {
println!("slice {:?} is len {}, but T is size {}", s, s.len(), ::std::mem::size_of::<T>()); println!(
"slice {:?} is len {}, but T is size {}",
s,
s.len(),
::std::mem::size_of::<T>()
);
None None
} else { } else {
unsafe { unsafe { Some(::std::mem::transmute(s.as_ptr())) }
Some(::std::mem::transmute(s.as_ptr()))
}
} }
} }
#[repr(packed)] #[repr(packed)]
#[derive(Copy, Clone, Debug)] #[derive(Copy, Clone, Debug)]
struct ValueCounts { struct ValueCounts {
num_a: u32, num_a: u32,
@ -306,16 +303,15 @@ mod test {
existing_val: Option<&[u8]>, existing_val: Option<&[u8]>,
operands: &mut MergeOperands, operands: &mut MergeOperands,
) -> Option<Vec<u8>> { ) -> Option<Vec<u8>> {
let mut counts: ValueCounts = if let Some(v) = existing_val {
let mut counts : ValueCounts =
if let Some(v) = existing_val {
from_slice::<ValueCounts>(v).unwrap().clone() from_slice::<ValueCounts>(v).unwrap().clone()
} else { } else {
ValueCounts { ValueCounts {
num_a: 0, num_a: 0,
num_b: 0, num_b: 0,
num_c: 0, num_c: 0,
num_d: 0 } num_d: 0,
}
}; };
for op in operands { for op in operands {
@ -333,11 +329,11 @@ mod test {
Some(slc.to_vec()) Some(slc.to_vec())
} }
#[test] #[test]
fn counting_mergetest() { fn counting_mergetest() {
use std::thread;
use std::sync::Arc; use std::sync::Arc;
use {DB, Options, DBCompactionStyle}; use std::thread;
use {DBCompactionStyle, Options, DB};
let path = "_rust_rocksdb_partial_mergetest"; let path = "_rust_rocksdb_partial_mergetest";
let mut opts = Options::default(); let mut opts = Options::default();
@ -345,7 +341,11 @@ mod test {
opts.set_compaction_style(DBCompactionStyle::Universal); opts.set_compaction_style(DBCompactionStyle::Universal);
opts.set_min_write_buffer_number_to_merge(10); opts.set_min_write_buffer_number_to_merge(10);
opts.set_merge_operator("sort operator", test_counting_full_merge, Some(test_counting_partial_merge)); opts.set_merge_operator(
"sort operator",
test_counting_full_merge,
Some(test_counting_partial_merge),
);
{ {
let db = Arc::new(DB::open(&opts, path).unwrap()); let db = Arc::new(DB::open(&opts, path).unwrap());
let _ = db.delete(b"k1"); let _ = db.delete(b"k1");
@ -421,8 +421,7 @@ mod test {
h3.join().unwrap(); h3.join().unwrap();
h1.join().unwrap(); h1.join().unwrap();
match db.get(b"k2") { match db.get(b"k2") {
Ok(Some(value)) => { Ok(Some(value)) => match from_slice::<ValueCounts>(&*value) {
match from_slice::<ValueCounts>(&*value) {
Some(v) => unsafe { Some(v) => unsafe {
assert_eq!(v.num_a, 1000); assert_eq!(v.num_a, 1000);
assert_eq!(v.num_b, 500); assert_eq!(v.num_b, 500);
@ -430,14 +429,12 @@ mod test {
assert_eq!(v.num_d, 500); assert_eq!(v.num_d, 500);
}, },
None => panic!("Failed to get ValueCounts from db"), None => panic!("Failed to get ValueCounts from db"),
} },
}
Err(e) => panic!("error reading value {:?}", e), Err(e) => panic!("error reading value {:?}", e),
_ => panic!("value not present"), _ => panic!("value not present"),
} }
match db.get(b"k1") { match db.get(b"k1") {
Ok(Some(value)) => { Ok(Some(value)) => match from_slice::<ValueCounts>(&*value) {
match from_slice::<ValueCounts>(&*value) {
Some(v) => unsafe { Some(v) => unsafe {
assert_eq!(v.num_a, 3); assert_eq!(v.num_a, 3);
assert_eq!(v.num_b, 2); assert_eq!(v.num_b, 2);
@ -445,8 +442,7 @@ mod test {
assert_eq!(v.num_d, 1); assert_eq!(v.num_d, 1);
}, },
None => panic!("Failed to get ValueCounts from db"), None => panic!("Failed to get ValueCounts from db"),
} },
}
Err(e) => panic!("error reading value {:?}", e), Err(e) => panic!("error reading value {:?}", e),
_ => panic!("value not present"), _ => panic!("value not present"),
} }

24
src/slice_transform.rs
Unescape View File

@ -40,7 +40,7 @@ impl SliceTransform {
name: &str, name: &str,
transform_fn: TransformFn, transform_fn: TransformFn,
in_domain_fn: Option<InDomainFn>, in_domain_fn: Option<InDomainFn>,
) -> SliceTransform{ ) -> SliceTransform {
let cb = Box::new(TransformCallback { let cb = Box::new(TransformCallback {
name: CString::new(name.as_bytes()).unwrap(), name: CString::new(name.as_bytes()).unwrap(),
transform_fn: transform_fn, transform_fn: transform_fn,
@ -52,7 +52,6 @@ impl SliceTransform {
mem::transmute(cb), mem::transmute(cb),
Some(slice_transform_destructor_callback), Some(slice_transform_destructor_callback),
Some(transform_callback), Some(transform_callback),
// this is ugly, but I can't get the compiler // this is ugly, but I can't get the compiler
// not to barf with "expected fn pointer, found fn item" // not to barf with "expected fn pointer, found fn item"
// without this. sorry. // without this. sorry.
@ -61,31 +60,24 @@ impl SliceTransform {
} else { } else {
None None
}, },
// this None points to the deprecated InRange callback // this None points to the deprecated InRange callback
None, None,
Some(slice_transform_name_callback), Some(slice_transform_name_callback),
) )
}; };
SliceTransform { SliceTransform { inner: st }
inner: st
}
} }
pub fn create_fixed_prefix(len: size_t) -> SliceTransform { pub fn create_fixed_prefix(len: size_t) -> SliceTransform {
SliceTransform { SliceTransform {
inner: unsafe { inner: unsafe { ffi::rocksdb_slicetransform_create_fixed_prefix(len) },
ffi::rocksdb_slicetransform_create_fixed_prefix(len)
},
} }
} }
pub fn create_noop() -> SliceTransform { pub fn create_noop() -> SliceTransform {
SliceTransform { SliceTransform {
inner: unsafe { inner: unsafe { ffi::rocksdb_slicetransform_create_noop() },
ffi::rocksdb_slicetransform_create_noop()
},
} }
} }
} }
@ -99,16 +91,12 @@ pub struct TransformCallback {
pub in_domain_fn: Option<InDomainFn>, pub in_domain_fn: Option<InDomainFn>,
} }
pub unsafe extern "C" fn slice_transform_destructor_callback( pub unsafe extern "C" fn slice_transform_destructor_callback(raw_cb: *mut c_void) {
raw_cb: *mut c_void
) {
let transform: Box<TransformCallback> = mem::transmute(raw_cb); let transform: Box<TransformCallback> = mem::transmute(raw_cb);
drop(transform); drop(transform);
} }
pub unsafe extern "C" fn slice_transform_name_callback( pub unsafe extern "C" fn slice_transform_name_callback(raw_cb: *mut c_void) -> *const c_char {
raw_cb: *mut c_void
) -> *const c_char {
let cb = &mut *(raw_cb as *mut TransformCallback); let cb = &mut *(raw_cb as *mut TransformCallback);
cb.name.as_ptr() cb.name.as_ptr()
} }

2
tests/test_checkpoint.rs
Unescape View File

@ -14,7 +14,7 @@
// //
extern crate rocksdb; extern crate rocksdb;
use rocksdb::{checkpoint::Checkpoint, DB, Options}; use rocksdb::{checkpoint::Checkpoint, Options, DB};
use std::fs::remove_dir_all; use std::fs::remove_dir_all;
#[test] #[test]

49
tests/test_column_family.rs
Unescape View File

@ -15,7 +15,7 @@
extern crate rocksdb; extern crate rocksdb;
mod util; mod util;
use rocksdb::{DB, MergeOperands, Options, ColumnFamilyDescriptor}; use rocksdb::{ColumnFamilyDescriptor, MergeOperands, Options, DB};
use util::DBPath; use util::DBPath;
#[test] #[test]
@ -42,16 +42,15 @@ pub fn test_column_family() {
let mut opts = Options::default(); let mut opts = Options::default();
opts.set_merge_operator("test operator", test_provided_merge, None); opts.set_merge_operator("test operator", test_provided_merge, None);
match DB::open(&opts, &n) { match DB::open(&opts, &n) {
Ok(_db) => { Ok(_db) => panic!(
panic!("should not have opened DB successfully without \ "should not have opened DB successfully without \
specifying column specifying column
families") families"
} ),
Err(e) => { Err(e) => assert!(e.to_string().starts_with(
assert!(e.to_string() "Invalid argument: You have to open all \
.starts_with("Invalid argument: You have to open all \ column families."
column families.")) )),
}
} }
} }
@ -76,11 +75,9 @@ pub fn test_column_family() {
} }
// TODO should be able to use writebatch ops with a cf // TODO should be able to use writebatch ops with a cf
{ {}
}
// TODO should be able to iterate over a cf // TODO should be able to iterate over a cf
{ {}
}
// should b able to drop a cf // should b able to drop a cf
{ {
let mut db = DB::open_cf(&Options::default(), &n, &["cf1"]).unwrap(); let mut db = DB::open_cf(&Options::default(), &n, &["cf1"]).unwrap();
@ -136,12 +133,10 @@ fn test_merge_operator() {
println!("m is {:?}", m); println!("m is {:?}", m);
// TODO assert!(m.is_ok()); // TODO assert!(m.is_ok());
match db.get(b"k1") { match db.get(b"k1") {
Ok(Some(value)) => { Ok(Some(value)) => match value.to_utf8() {
match value.to_utf8() {
Some(v) => println!("retrieved utf8 value: {}", v), Some(v) => println!("retrieved utf8 value: {}", v),
None => println!("did not read valid utf-8 out of the db"), None => println!("did not read valid utf-8 out of the db"),
} },
}
Err(_) => println!("error reading value"), Err(_) => println!("error reading value"),
_ => panic!("value not present!"), _ => panic!("value not present!"),
} }
@ -151,13 +146,13 @@ fn test_merge_operator() {
assert!(db.delete(b"k1").is_ok()); assert!(db.delete(b"k1").is_ok());
assert!(db.get(b"k1").unwrap().is_none()); assert!(db.get(b"k1").unwrap().is_none());
} }
} }
fn test_provided_merge(_: &[u8], fn test_provided_merge(
_: &[u8],
existing_val: Option<&[u8]>, existing_val: Option<&[u8]>,
operands: &mut MergeOperands) operands: &mut MergeOperands,
-> Option<Vec<u8>> { ) -> Option<Vec<u8>> {
let nops = operands.size_hint().0; let nops = operands.size_hint().0;
let mut result: Vec<u8> = Vec::with_capacity(nops); let mut result: Vec<u8> = Vec::with_capacity(nops);
match existing_val { match existing_val {
@ -192,7 +187,10 @@ pub fn test_column_family_with_options() {
match DB::open_cf_descriptors(&opts, &n, cfs) { match DB::open_cf_descriptors(&opts, &n, cfs) {
Ok(_db) => println!("created db with column family descriptors succesfully"), Ok(_db) => println!("created db with column family descriptors succesfully"),
Err(e) => { Err(e) => {
panic!("could not create new database with column family descriptors: {}", e); panic!(
"could not create new database with column family descriptors: {}",
e
);
} }
} }
} }
@ -208,7 +206,10 @@ pub fn test_column_family_with_options() {
match DB::open_cf_descriptors(&opts, &n, cfs) { match DB::open_cf_descriptors(&opts, &n, cfs) {
Ok(_db) => println!("succesfully re-opened database with column family descriptors"), Ok(_db) => println!("succesfully re-opened database with column family descriptors"),
Err(e) => { Err(e) => {
panic!("unable to re-open database with column family descriptors: {}", e); panic!(
"unable to re-open database with column family descriptors: {}",
e
);
} }
} }
} }

24
tests/test_iterator.rs
Unescape View File

@ -15,7 +15,7 @@
extern crate rocksdb; extern crate rocksdb;
mod util; mod util;
use rocksdb::{DB, Direction, IteratorMode, MemtableFactory, Options}; use rocksdb::{Direction, IteratorMode, MemtableFactory, Options, DB};
use util::DBPath; use util::DBPath;
fn cba(input: &Box<[u8]>) -> Box<[u8]> { fn cba(input: &Box<[u8]>) -> Box<[u8]> {
@ -41,7 +41,11 @@ pub fn test_iterator() {
assert!(p.is_ok()); assert!(p.is_ok());
let p = db.put(&*k3, &*v3); let p = db.put(&*k3, &*v3);
assert!(p.is_ok()); assert!(p.is_ok());
let expected = vec![(cba(&k1), cba(&v1)), (cba(&k2), cba(&v2)), (cba(&k3), cba(&v3))]; let expected = vec![
(cba(&k1), cba(&v1)),
(cba(&k2), cba(&v2)),
(cba(&k3), cba(&v3)),
];
{ {
let iterator1 = db.iterator(IteratorMode::Start); let iterator1 = db.iterator(IteratorMode::Start);
assert_eq!(iterator1.collect::<Vec<_>>(), expected); assert_eq!(iterator1.collect::<Vec<_>>(), expected);
@ -103,10 +107,12 @@ pub fn test_iterator() {
let old_iterator = db.iterator(IteratorMode::Start); let old_iterator = db.iterator(IteratorMode::Start);
let p = db.put(&*k4, &*v4); let p = db.put(&*k4, &*v4);
assert!(p.is_ok()); assert!(p.is_ok());
let expected2 = vec![(cba(&k1), cba(&v1)), let expected2 = vec![
(cba(&k1), cba(&v1)),
(cba(&k2), cba(&v2)), (cba(&k2), cba(&v2)),
(cba(&k3), cba(&v3)), (cba(&k3), cba(&v3)),
(cba(&k4), cba(&v4))]; (cba(&k4), cba(&v4)),
];
{ {
assert_eq!(old_iterator.collect::<Vec<_>>(), expected); assert_eq!(old_iterator.collect::<Vec<_>>(), expected);
} }
@ -116,7 +122,11 @@ pub fn test_iterator() {
} }
{ {
let iterator1 = db.iterator(IteratorMode::From(b"k2", Direction::Forward)); let iterator1 = db.iterator(IteratorMode::From(b"k2", Direction::Forward));
let expected = vec![(cba(&k2), cba(&v2)), (cba(&k3), cba(&v3)), (cba(&k4), cba(&v4))]; let expected = vec![
(cba(&k2), cba(&v2)),
(cba(&k3), cba(&v3)),
(cba(&k4), cba(&v4)),
];
assert_eq!(iterator1.collect::<Vec<_>>(), expected); assert_eq!(iterator1.collect::<Vec<_>>(), expected);
} }
{ {
@ -157,7 +167,9 @@ pub fn test_iterator() {
} }
} }
fn key(k: &[u8]) -> Box<[u8]> { k.to_vec().into_boxed_slice() } fn key(k: &[u8]) -> Box<[u8]> {
k.to_vec().into_boxed_slice()
}
#[test] #[test]
pub fn test_prefix_iterator() { pub fn test_prefix_iterator() {

3
tests/test_multithreaded.rs
Unescape View File

@ -16,11 +16,10 @@ extern crate rocksdb;
mod util; mod util;
use rocksdb::DB; use rocksdb::DB;
use std::thread;
use std::sync::Arc; use std::sync::Arc;
use std::thread;
use util::DBPath; use util::DBPath;
const N: usize = 100_000; const N: usize = 100_000;
#[test] #[test]

3
tests/test_raw_iterator.rs
Unescape View File

@ -51,7 +51,6 @@ pub fn test_forwards_iteration() {
} }
} }
#[test] #[test]
pub fn test_seek_last() { pub fn test_seek_last() {
let n = DBPath::new("backwards_iteration"); let n = DBPath::new("backwards_iteration");
@ -85,7 +84,6 @@ pub fn test_seek_last() {
} }
} }
#[test] #[test]
pub fn test_seek() { pub fn test_seek() {
let n = DBPath::new("seek"); let n = DBPath::new("seek");
@ -111,7 +109,6 @@ pub fn test_seek() {
} }
} }
#[test] #[test]
pub fn test_seek_to_nonexistant() { pub fn test_seek_to_nonexistant() {
let n = DBPath::new("seek_to_nonexistant"); let n = DBPath::new("seek_to_nonexistant");

2
tests/test_rocksdb_options.rs
Unescape View File

@ -15,7 +15,7 @@
extern crate rocksdb; extern crate rocksdb;
mod util; mod util;
use rocksdb::{DB, Options}; use rocksdb::{Options, DB};
use util::DBPath; use util::DBPath;
#[test] #[test]

6
tests/test_slice_transform.rs
Unescape View File

@ -1,7 +1,7 @@
extern crate rocksdb; extern crate rocksdb;
mod util; mod util;
use rocksdb::{DB, Options, SliceTransform}; use rocksdb::{Options, SliceTransform, DB};
use util::DBPath; use util::DBPath;
#[test] #[test]
@ -34,7 +34,9 @@ pub fn test_slice_transform() {
input.iter().cloned().collect::<Vec<_>>().into_boxed_slice() input.iter().cloned().collect::<Vec<_>>().into_boxed_slice()
} }
fn key(k: &[u8]) -> Box<[u8]> { k.to_vec().into_boxed_slice() } fn key(k: &[u8]) -> Box<[u8]> {
k.to_vec().into_boxed_slice()
}
{ {
let expected = vec![(cba(&a1), cba(&a1)), (cba(&a2), cba(&a2))]; let expected = vec![(cba(&a1), cba(&a1)), (cba(&a2), cba(&a2))];

11
tests/util/mod.rs
Unescape View File

@ -1,13 +1,13 @@
extern crate rocksdb; extern crate rocksdb;
use std::path::{Path, PathBuf};
use std::time::{SystemTime, UNIX_EPOCH}; use std::time::{SystemTime, UNIX_EPOCH};
use std::path::{PathBuf, Path};
use rocksdb::{DB, Options}; use rocksdb::{Options, DB};
/// Ensures that DB::Destroy is called for this database when DBPath is dropped. /// Ensures that DB::Destroy is called for this database when DBPath is dropped.
pub struct DBPath { pub struct DBPath {
path: PathBuf path: PathBuf,
} }
impl DBPath { impl DBPath {
@ -22,7 +22,9 @@ impl DBPath {
current_time.subsec_nanos() current_time.subsec_nanos()
); );
DBPath { path: PathBuf::from(path) } DBPath {
path: PathBuf::from(path),
}
} }
} }
@ -38,4 +40,3 @@ impl AsRef<Path> for DBPath {
&self.path &self.path
} }
} }

Write Preview
Loading…
Cancel
Save