diff --git a/src/comparator.rs b/src/comparator.rs index 1e59ec4..56edcd4 100644 --- a/src/comparator.rs +++ b/src/comparator.rs @@ -16,12 +16,8 @@ extern crate libc; use self::libc::{c_char, c_int, c_void, size_t}; use std::ffi::CString; use std::mem; -use std::ptr; use std::slice; -use rocksdb_options::Options; -use rocksdb::DB; - pub struct ComparatorCallback { pub name: CString, pub f: fn(&[u8], &[u8]) -> i32, diff --git a/src/ffi.rs b/src/ffi.rs index 62712d0..67f57b8 100644 --- a/src/ffi.rs +++ b/src/ffi.rs @@ -14,7 +14,7 @@ // extern crate libc; use self::libc::{c_char, c_int, c_void, size_t}; -use std::ffi::{CStr, CString}; +use std::ffi::CStr; use std::str::from_utf8; #[derive(Copy, Clone)] @@ -412,6 +412,7 @@ extern "C" { #[test] fn internal() { unsafe { + use std::ffi::CString; let opts = rocksdb_options_create(); assert!(!opts.0.is_null()); diff --git a/src/main.rs b/src/main.rs index 2a2d2dc..5cb5c96 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,4 +1,3 @@ -// // Copyright 2014 Tyler Neely // // Licensed under the Apache License, Version 2.0 (the "License"); @@ -57,7 +56,7 @@ fn main() { Some(v) => println!("retrieved utf8 value: {}", v), None => println!("did not read valid utf-8 out of the db"), } - }, + } Ok(None) => panic!("value not present!"), Err(e) => println!("error retrieving value: {}", e), } @@ -73,9 +72,11 @@ fn concat_merge(_: &[u8], -> Vec { let mut result: Vec = Vec::with_capacity(operands.size_hint().0); match existing_val { - Some(v) => for e in v { - result.push(*e) - }, + Some(v) => { + for e in v { + result.push(*e) + } + } None => (), } for op in operands { @@ -141,11 +142,8 @@ fn main() { #[cfg(test)] -mod tests { - use std::thread::sleep_ms; - - use rocksdb::{BlockBasedOptions, DB, MergeOperands, Options, Writable, - new_bloom_filter}; +mod tests { + use rocksdb::{BlockBasedOptions, DB, Options}; use rocksdb::DBCompactionStyle::DBUniversalCompaction; fn tuned_for_somebody_elses_disk(path: &str, @@ -173,45 +171,45 @@ mod tests { opts.set_block_based_table_factory(blockopts); opts.set_disable_auto_compactions(true); - let filter = new_bloom_filter(10); + // let filter = new_bloom_filter(10); // opts.set_filter(filter); DB::open(&opts, path).unwrap() } -// TODO(tyler) unstable -// #[bench] -// fn a_writes(b: &mut Bencher) { -// dirty hack due to parallel tests causing contention. -// sleep_ms(1000); -// let path = "_rust_rocksdb_optimizetest"; -// let mut opts = Options::new(); -// let mut blockopts = BlockBasedOptions::new(); -// let mut db = tuned_for_somebody_elses_disk(path, &mut opts, &mut blockopts); -// let mut i = 0 as u64; -// b.iter(|| { -// db.put(i.to_string().as_bytes(), b"v1111"); -// i += 1; -// }); -// } -// -// #[bench] -// fn b_reads(b: &mut Bencher) { -// let path = "_rust_rocksdb_optimizetest"; -// let mut opts = Options::new(); -// let mut blockopts = BlockBasedOptions::new(); -// { -// let db = tuned_for_somebody_elses_disk(path, &mut opts, &mut blockopts); -// let mut i = 0 as u64; -// b.iter(|| { -// db.get(i.to_string().as_bytes()).on_error( |e| { -// println!("error: {}", e); -// e -// }); -// i += 1; -// }); -// } -// DB::destroy(&opts, path).is_ok(); -// } -// + // TODO(tyler) unstable + // #[bench] + // fn a_writes(b: &mut Bencher) { + // dirty hack due to parallel tests causing contention. + // sleep_ms(1000); + // let path = "_rust_rocksdb_optimizetest"; + // let mut opts = Options::new(); + // let mut blockopts = BlockBasedOptions::new(); + // let mut db = tuned_for_somebody_elses_disk(path, &mut opts, &mut blockopts); + // let mut i = 0 as u64; + // b.iter(|| { + // db.put(i.to_string().as_bytes(), b"v1111"); + // i += 1; + // }); + // } + // + // #[bench] + // fn b_reads(b: &mut Bencher) { + // let path = "_rust_rocksdb_optimizetest"; + // let mut opts = Options::new(); + // let mut blockopts = BlockBasedOptions::new(); + // { + // let db = tuned_for_somebody_elses_disk(path, &mut opts, &mut blockopts); + // let mut i = 0 as u64; + // b.iter(|| { + // db.get(i.to_string().as_bytes()).on_error( |e| { + // println!("error: {}", e); + // e + // }); + // i += 1; + // }); + // } + // DB::destroy(&opts, path).is_ok(); + // } + // } diff --git a/src/merge_operator.rs b/src/merge_operator.rs index 1beed45..f747a8e 100644 --- a/src/merge_operator.rs +++ b/src/merge_operator.rs @@ -19,8 +19,6 @@ use std::mem; use std::ptr; use std::slice; -use rocksdb_options::Options; -use rocksdb::{DB, DBVector, Writable}; pub struct MergeOperatorCallback { pub name: CString, @@ -156,7 +154,7 @@ impl<'a> Iterator for &'a mut MergeOperands { fn test_provided_merge(new_key: &[u8], existing_val: Option<&[u8]>, - mut operands: &mut MergeOperands) + operands: &mut MergeOperands) -> Vec { let nops = operands.size_hint().0; let mut result: Vec = Vec::with_capacity(nops); @@ -178,19 +176,23 @@ fn test_provided_merge(new_key: &[u8], #[allow(dead_code)] #[test] + fn mergetest() { + use rocksdb_options::Options; + use rocksdb::{DB, DBVector, Writable}; + let path = "_rust_rocksdb_mergetest"; let mut opts = Options::new(); opts.create_if_missing(true); opts.add_merge_operator("test operator", test_provided_merge); { - let mut db = DB::open(&opts, path).unwrap(); + let db = DB::open(&opts, path).unwrap(); let p = db.put(b"k1", b"a"); assert!(p.is_ok()); - db.merge(b"k1", b"b"); - db.merge(b"k1", b"c"); - db.merge(b"k1", b"d"); - db.merge(b"k1", b"efg"); + let _ = db.merge(b"k1", b"b"); + let _ = db.merge(b"k1", b"c"); + let _ = db.merge(b"k1", b"d"); + let _ = db.merge(b"k1", b"efg"); let m = db.merge(b"k1", b"h"); assert!(m.is_ok()); match db.get(b"k1") { diff --git a/src/rocksdb.rs b/src/rocksdb.rs index cbb5bf6..d3952f0 100644 --- a/src/rocksdb.rs +++ b/src/rocksdb.rs @@ -16,9 +16,8 @@ extern crate libc; use std::collections::BTreeMap; -use std::ffi::{CStr, CString}; +use std::ffi::CString; use std::fs; -use std::io; use std::ops::Deref; use std::path::Path; use std::slice; @@ -50,29 +49,28 @@ pub struct Snapshot<'a> { inner: rocksdb_ffi::DBSnapshot, } -pub struct DBIterator<'a> { - db: &'a DB, +pub struct DBIterator { inner: rocksdb_ffi::DBIterator, direction: Direction, just_seeked: bool, } pub enum Direction { - forward, - reverse, + Forward, + Reverse, } -impl<'a> Iterator for DBIterator<'a> { +impl Iterator for DBIterator { type Item = (Box<[u8]>, Box<[u8]>); fn next(&mut self) -> Option<(Box<[u8]>, Box<[u8]>)> { let native_iter = self.inner; if !self.just_seeked { match self.direction { - Direction::forward => unsafe { + Direction::Forward => unsafe { rocksdb_ffi::rocksdb_iter_next(native_iter) }, - Direction::reverse => unsafe { + Direction::Reverse => unsafe { rocksdb_ffi::rocksdb_iter_prev(native_iter) }, } @@ -112,19 +110,18 @@ pub enum IteratorMode<'a> { } -impl<'a> DBIterator<'a> { - fn new<'b>(db: &'a DB, +impl DBIterator { + fn new<'b>(db: &DB, readopts: &'b ReadOptions, mode: IteratorMode) - -> DBIterator<'a> { + -> DBIterator { unsafe { let iterator = rocksdb_ffi::rocksdb_create_iterator(db.inner, readopts.inner); let mut rv = DBIterator { - db: db, inner: iterator, - direction: Direction::forward, // blown away by set_mode() + direction: Direction::Forward, // blown away by set_mode() just_seeked: false, }; @@ -139,11 +136,11 @@ impl<'a> DBIterator<'a> { match mode { IteratorMode::Start => { rocksdb_ffi::rocksdb_iter_seek_to_first(self.inner); - self.direction = Direction::forward; + self.direction = Direction::Forward; } IteratorMode::End => { rocksdb_ffi::rocksdb_iter_seek_to_last(self.inner); - self.direction = Direction::reverse; + self.direction = Direction::Reverse; } IteratorMode::From(key, dir) => { rocksdb_ffi::rocksdb_iter_seek(self.inner, @@ -156,11 +153,11 @@ impl<'a> DBIterator<'a> { } } - fn new_cf(db: &'a DB, + fn new_cf(db: &DB, cf_handle: DBCFHandle, readopts: &ReadOptions, mode: IteratorMode) - -> Result, String> { + -> Result { unsafe { let iterator = rocksdb_ffi::rocksdb_create_iterator_cf(db.inner, @@ -168,9 +165,8 @@ impl<'a> DBIterator<'a> { cf_handle); let mut rv = DBIterator { - db: db, inner: iterator, - direction: Direction::forward, // blown away by set_mode() + direction: Direction::Forward, // blown away by set_mode() just_seeked: false, }; @@ -181,7 +177,7 @@ impl<'a> DBIterator<'a> { } } -impl<'a> Drop for DBIterator<'a> { +impl Drop for DBIterator { fn drop(&mut self) { unsafe { rocksdb_ffi::rocksdb_iter_destroy(self.inner); @@ -261,7 +257,9 @@ impl DB { let ospath = Path::new(path); match fs::create_dir_all(&ospath) { Err(e) => { - return Err("Failed to create rocksdb directory.".to_string()) + return Err(format!("Failed to create rocksdb directory: \ + {:?}", + e)) } Ok(_) => (), } @@ -269,7 +267,7 @@ impl DB { let mut err: *const i8 = 0 as *const i8; let err_ptr: *mut *const i8 = &mut err; let db: rocksdb_ffi::DBInstance; - let mut cfMap = BTreeMap::new(); + let mut cf_map = BTreeMap::new(); if cfs.len() == 0 { unsafe { @@ -298,7 +296,7 @@ impl DB { .collect(); // These handles will be populated by DB. - let mut cfhandles: Vec = + let cfhandles: Vec = cfs_v.iter() .map(|_| rocksdb_ffi::DBCFHandle(0 as *mut c_void)) .collect(); @@ -328,7 +326,7 @@ impl DB { } for (n, h) in cfs_v.iter().zip(cfhandles) { - cfMap.insert(n.to_string(), h); + cf_map.insert(n.to_string(), h); } } @@ -341,7 +339,7 @@ impl DB { Ok(DB { inner: db, - cfs: cfMap, + cfs: cf_map, }) } @@ -349,7 +347,6 @@ impl DB { let cpath = CString::new(path.as_bytes()).unwrap(); let cpath_ptr = cpath.as_ptr(); - let ospath = Path::new(path); let mut err: *const i8 = 0 as *const i8; let err_ptr: *mut *const i8 = &mut err; unsafe { @@ -367,7 +364,6 @@ impl DB { let cpath = CString::new(path.as_bytes()).unwrap(); let cpath_ptr = cpath.as_ptr(); - let ospath = Path::new(path); let mut err: *const i8 = 0 as *const i8; let err_ptr: *mut *const i8 = &mut err; unsafe { @@ -837,7 +833,7 @@ impl DBVector { fn external() { let path = "_rust_rocksdb_externaltest"; { - let mut db = DB::open_default(path).unwrap(); + let db = DB::open_default(path).unwrap(); let p = db.put(b"k1", b"v1111"); assert!(p.is_ok()); let r: Result, String> = db.get(b"k1"); @@ -853,7 +849,7 @@ fn external() { #[test] fn errors_do_stuff() { let path = "_rust_rocksdb_error"; - let mut db = DB::open_default(path).unwrap(); + let db = DB::open_default(path).unwrap(); let opts = Options::new(); // The DB will still be open when we try to destroy and the lock should fail match DB::destroy(&opts, path) { @@ -870,12 +866,12 @@ fn errors_do_stuff() { fn writebatch_works() { let path = "_rust_rocksdb_writebacktest"; { - let mut db = DB::open_default(path).unwrap(); + let db = DB::open_default(path).unwrap(); { // test put - let mut batch = WriteBatch::new(); + let batch = WriteBatch::new(); assert!(db.get(b"k1").unwrap().is_none()); - batch.put(b"k1", b"v1111"); + let _ = batch.put(b"k1", b"v1111"); assert!(db.get(b"k1").unwrap().is_none()); let p = db.write(batch); assert!(p.is_ok()); @@ -884,8 +880,8 @@ fn writebatch_works() { } { // test delete - let mut batch = WriteBatch::new(); - batch.delete(b"k1"); + let batch = WriteBatch::new(); + let _ = batch.delete(b"k1"); let p = db.write(batch); assert!(p.is_ok()); assert!(db.get(b"k1").unwrap().is_none()); @@ -899,14 +895,14 @@ fn writebatch_works() { fn iterator_test() { let path = "_rust_rocksdb_iteratortest"; { - let mut db = DB::open_default(path).unwrap(); + let db = DB::open_default(path).unwrap(); let p = db.put(b"k1", b"v1111"); assert!(p.is_ok()); let p = db.put(b"k2", b"v2222"); assert!(p.is_ok()); let p = db.put(b"k3", b"v3333"); assert!(p.is_ok()); - let mut iter = db.iterator(IteratorMode::Start); + let iter = db.iterator(IteratorMode::Start); for (k, v) in iter { println!("Hello {}: {}", from_utf8(&*k).unwrap(), diff --git a/test/test_column_family.rs b/test/test_column_family.rs index 8a8ec88..b1b35c7 100644 --- a/test/test_column_family.rs +++ b/test/test_column_family.rs @@ -1,4 +1,3 @@ -// // Copyright 2014 Tyler Neely // // Licensed under the Apache License, Version 2.0 (the "License"); @@ -39,11 +38,15 @@ pub fn test_column_family() { let mut opts = Options::new(); opts.add_merge_operator("test operator", test_provided_merge); match DB::open(&opts, path) { - Ok(_) => panic!("should not have opened DB successfully without \ - specifying column - families"), - Err(e) => assert!(e.starts_with("Invalid argument: You have to \ - open all column families.")), + Ok(_) => { + panic!("should not have opened DB successfully without \ + specifying column + families") + } + Err(e) => { + assert!(e.starts_with("Invalid argument: You have to open \ + all column families.")) + } } } @@ -87,7 +90,7 @@ pub fn test_column_family() { None => println!("did not read valid utf-8 out of the db"), } } - Err(e) => println!("error reading value"), + Err(_) => println!("error reading value"), _ => panic!("value not present!"), } diff --git a/test/test_iterator.rs b/test/test_iterator.rs index ac8ea75..1efe809 100644 --- a/test/test_iterator.rs +++ b/test/test_iterator.rs @@ -1,4 +1,4 @@ -use rocksdb::{DB, Direction, Options, Writable, IteratorMode}; +use rocksdb::{DB, Direction, IteratorMode, Options, Writable}; fn cba(input: &Box<[u8]>) -> Box<[u8]> { input.iter().cloned().collect::>().into_boxed_slice() @@ -99,14 +99,16 @@ pub fn test_iterator() { assert_eq!(iterator1.collect::>(), expected2); } { - 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))]; assert_eq!(iterator1.collect::>(), expected); } { - let iterator1 = db.iterator(IteratorMode::From(b"k2", Direction::reverse)); + let iterator1 = db.iterator(IteratorMode::From(b"k2", + Direction::Reverse)); let expected = vec![(cba(&k2), cba(&v2)), (cba(&k1), cba(&v1))]; assert_eq!(iterator1.collect::>(), expected); }