diff --git a/src/lib.rs b/src/lib.rs index eb1f9e5..bdbb56f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -13,9 +13,6 @@ See the License for the specific language governing permissions and limitations under the License. */ -#![crate_id = "rocksdb"] -#![crate_type = "lib"] - pub use ffi as rocksdb_ffi; pub use ffi::{new_bloom_filter, DBCompactionStyle, DBComparator}; pub use rocksdb::{DB, DBVector, WriteBatch, Writable, Direction}; diff --git a/src/main.rs b/src/main.rs index 42abc58..0de0e57 100644 --- a/src/main.rs +++ b/src/main.rs @@ -14,8 +14,7 @@ limitations under the License. */ extern crate rocksdb; -use rocksdb::{Options, DB, MergeOperands, new_bloom_filter, Writable, }; -use rocksdb::DBCompactionStyle::DBUniversalCompaction; +use rocksdb::{Options, DB, MergeOperands, Writable, }; //fn snapshot_test() { // let path = "_rust_rocksdb_iteratortest"; @@ -47,7 +46,7 @@ use rocksdb::DBCompactionStyle::DBUniversalCompaction; #[cfg(not(feature = "valgrind"))] fn main() { let path = "/tmp/rust-rocksdb"; - let mut db = DB::open_default(path).unwrap(); + let db = DB::open_default(path).unwrap(); assert!(db.put(b"my key", b"my value").is_ok()); match db.get(b"my key") { Ok(Some(value)) => { @@ -67,8 +66,8 @@ fn main() { custom_merge(); } -fn concat_merge(new_key: &[u8], existing_val: Option<&[u8]>, - mut operands: &mut MergeOperands) -> Vec { +fn concat_merge(_: &[u8], existing_val: Option<&[u8]>, + operands: &mut MergeOperands) -> Vec { let mut result: Vec = Vec::with_capacity(operands.size_hint().0); match existing_val { Some(v) => for e in v { diff --git a/test/test_column_family.rs b/test/test_column_family.rs index d779110..d509e77 100644 --- a/test/test_column_family.rs +++ b/test/test_column_family.rs @@ -13,7 +13,7 @@ See the License for the specific language governing permissions and limitations under the License. */ -use rocksdb::{Options, DB, Writable, Direction, MergeOperands}; +use rocksdb::{Options, DB, Writable, MergeOperands}; #[test] pub fn test_column_family() { @@ -58,7 +58,7 @@ pub fn test_column_family() { { let mut opts = Options::new(); opts.add_merge_operator("test operator", test_provided_merge); - let mut db = match DB::open_cf(&opts, path, &["cf1"]) { + let db = match DB::open_cf(&opts, path, &["cf1"]) { Ok(db) => { println!("successfully opened db with column family"); db @@ -70,10 +70,10 @@ pub fn test_column_family() { assert!(db.get_cf(cf1, b"k1").unwrap().unwrap().to_utf8().unwrap() == "v1"); let p = db.put_cf(cf1, b"k1", b"a"); assert!(p.is_ok()); - db.merge_cf(cf1, b"k1", b"b"); - db.merge_cf(cf1, b"k1", b"c"); - db.merge_cf(cf1, b"k1", b"d"); - db.merge_cf(cf1, b"k1", b"efg"); + db.merge_cf(cf1, b"k1", b"b").unwrap(); + db.merge_cf(cf1, b"k1", b"c").unwrap(); + db.merge_cf(cf1, b"k1", b"d").unwrap(); + db.merge_cf(cf1, b"k1", b"efg").unwrap(); let m = db.merge_cf(cf1, b"k1", b"h"); println!("m is {:?}", m); // TODO assert!(m.is_ok()); @@ -90,7 +90,7 @@ pub fn test_column_family() { _ => panic!("value not present!"), } - let r = db.get_cf(cf1, b"k1"); + let _ = db.get_cf(cf1, b"k1"); // TODO assert!(r.unwrap().to_utf8().unwrap() == "abcdefgh"); assert!(db.delete(b"k1").is_ok()); assert!(db.get(b"k1").unwrap().is_none()); @@ -113,9 +113,9 @@ pub fn test_column_family() { assert!(DB::destroy(&Options::new(), path).is_ok()); } -fn test_provided_merge(new_key: &[u8], +fn test_provided_merge(_: &[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); diff --git a/test/test_column_family.rs.orig b/test/test_column_family.rs.orig deleted file mode 100644 index 789ec80..0000000 --- a/test/test_column_family.rs.orig +++ /dev/null @@ -1,141 +0,0 @@ -/* - Copyright 2014 Tyler Neely - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. -*/ -use rocksdb::{Options, DB, DBResult, Writable, Direction, MergeOperands}; - -#[test] -pub fn test_column_family() { - let path = "_rust_rocksdb_cftest"; - - // should be able to create column families - { - 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 opts = Options::new(); - match db.create_cf("cf1", &opts) { - Ok(_) => println!("cf1 created successfully"), - Err(e) => { - panic!("could not create column family: {}", e); - }, - } - } - - // 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) { - 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.")), - } - } - - // should properly open db when specyfing all column families - { - let mut opts = Options::new(); - opts.add_merge_operator("test operator", test_provided_merge); - match DB::open_cf(&opts, path, &["cf1"]) { - 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 mut db = match DB::open_cf(&opts, path, &["cf1"]) { - Ok(db) => { - println!("successfully opened db with column family"); - db - }, - Err(e) => panic!("failed to open db with column family: {}", e), - }; - let cf1 = *db.cf_handle("cf1").unwrap(); - assert!(db.put_cf(cf1, b"k1", b"v1").is_ok()); - assert!(db.get_cf(cf1, b"k1").unwrap().unwrap().to_utf8().unwrap() == "v1"); - let p = db.put_cf(cf1, b"k1", b"a"); - assert!(p.is_ok()); - db.merge_cf(cf1, b"k1", b"b"); - db.merge_cf(cf1, b"k1", b"c"); - db.merge_cf(cf1, b"k1", b"d"); - db.merge_cf(cf1, b"k1", b"efg"); - let m = db.merge_cf(cf1, b"k1", b"h"); - println!("m is {:?}", m); - // TODO assert!(m.is_ok()); - match db.get(b"k1") { - Ok(Some(value)) => { - match value.to_utf8() { - Some(v) => - println!("retrieved utf8 value: {}", v), - None => - println!("did not read valid utf-8 out of the db"), - } -<<<<<<< Updated upstream - }).on_absent( || { println!("value not present!") }) - .on_error( |e| { println!("error reading value")}); //: {", e) }); -======= - }, - Err(e) => println!("error reading value"), - _ => panic!("value not present!"), - } ->>>>>>> Stashed changes - - let r = db.get_cf(cf1, b"k1"); - // TODO assert!(r.unwrap().to_utf8().unwrap() == "abcdefgh"); - assert!(db.delete(b"k1").is_ok()); - assert!(db.get(b"k1").unwrap().is_none()); - } - // TODO should be able to use writebatch ops with a cf - { - } - // TODO should be able to iterate over a cf - { - } - // should b able to drop a cf - { - let mut db = DB::open_cf(&Options::new(), path, &["cf1"]).unwrap(); - match db.drop_cf("cf1") { - Ok(_) => println!("cf1 successfully dropped."), - Err(e) => panic!("failed to drop column family: {}", e), - } - } - - assert!(DB::destroy(&Options::new(), path).is_ok()); -} - -fn test_provided_merge(new_key: &[u8], - existing_val: Option<&[u8]>, - mut operands: &mut MergeOperands) - -> Vec { - let nops = operands.size_hint().0; - let mut result: Vec = Vec::with_capacity(nops); - match existing_val { - Some(v) => { - for e in v { - result.push(*e); - } - }, - None => (), - } - for op in operands { - for e in op { - result.push(*e); - } - } - result -} diff --git a/test/test_iterator.rs b/test/test_iterator.rs index 6cefa33..f53bfcb 100644 --- a/test/test_iterator.rs +++ b/test/test_iterator.rs @@ -1,5 +1,4 @@ use rocksdb::{Options, DB, Writable, Direction}; -use std; fn cba(input: &Box<[u8]>) -> Box<[u8]> { input.iter().cloned().collect::>().into_boxed_slice() @@ -17,7 +16,7 @@ pub fn test_iterator() { let v2:Box<[u8]> = b"v2222".to_vec().into_boxed_slice(); let v3:Box<[u8]> = b"v3333".to_vec().into_boxed_slice(); let v4:Box<[u8]> = b"v4444".to_vec().into_boxed_slice(); - let mut db = DB::open_default(path).unwrap(); + let db = DB::open_default(path).unwrap(); let p = db.put(&*k1, &*v1); assert!(p.is_ok()); let p = db.put(&*k2, &*v2); @@ -27,83 +26,82 @@ pub fn test_iterator() { let mut view1 = db.iterator(); let expected = vec![(cba(&k1), cba(&v1)), (cba(&k2), cba(&v2)), (cba(&k3), cba(&v3))]; { - let mut iterator1 = view1.from_start(); + let iterator1 = view1.from_start(); assert_eq!(iterator1.collect::>(), expected); } // Test that it's reusable a few times { - let mut iterator1 = view1.from_start(); + let iterator1 = view1.from_start(); assert_eq!(iterator1.collect::>(), expected); } { - let mut iterator1 = view1.from_start(); + let iterator1 = view1.from_start(); assert_eq!(iterator1.collect::>(), expected); } { - let mut iterator1 = view1.from_start(); + let iterator1 = view1.from_start(); assert_eq!(iterator1.collect::>(), expected); } // Test it in reverse a few times { - let mut iterator1 = view1.from_end(); + let iterator1 = view1.from_end(); let mut tmp_vec = iterator1.collect::>(); tmp_vec.reverse(); assert_eq!(tmp_vec, expected); } { - let mut iterator1 = view1.from_end(); + let iterator1 = view1.from_end(); let mut tmp_vec = iterator1.collect::>(); tmp_vec.reverse(); assert_eq!(tmp_vec, expected); } { - let mut iterator1 = view1.from_end(); + let iterator1 = view1.from_end(); let mut tmp_vec = iterator1.collect::>(); tmp_vec.reverse(); assert_eq!(tmp_vec, expected); } { - let mut iterator1 = view1.from_end(); + let iterator1 = view1.from_end(); let mut tmp_vec = iterator1.collect::>(); tmp_vec.reverse(); assert_eq!(tmp_vec, expected); } { - let mut iterator1 = view1.from_end(); + let iterator1 = view1.from_end(); let mut tmp_vec = iterator1.collect::>(); tmp_vec.reverse(); assert_eq!(tmp_vec, expected); } // Try it forward again { - let mut iterator1 = view1.from_start(); + let iterator1 = view1.from_start(); assert_eq!(iterator1.collect::>(), expected); } { - let mut iterator1 = view1.from_start(); + let iterator1 = view1.from_start(); assert_eq!(iterator1.collect::>(), expected); } - let mut view2 = db.iterator(); let p = db.put(&*k4, &*v4); assert!(p.is_ok()); let mut view3 = db.iterator(); let expected2 = vec![(cba(&k1), cba(&v1)), (cba(&k2), cba(&v2)), (cba(&k3), cba(&v3)), (cba(&k4), cba(&v4))]; { - let mut iterator1 = view1.from_start(); + let iterator1 = view1.from_start(); assert_eq!(iterator1.collect::>(), expected); } { - let mut iterator1 = view3.from_start(); + let iterator1 = view3.from_start(); assert_eq!(iterator1.collect::>(), expected2); } { - let mut iterator1 = view3.from(b"k2", Direction::forward); + let iterator1 = view3.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 mut iterator1 = view3.from(b"k2", Direction::reverse); + let iterator1 = view3.from(b"k2", Direction::reverse); let expected = vec![(cba(&k2), cba(&v2)), (cba(&k1), cba(&v1))]; assert_eq!(iterator1.collect::>(), expected); } diff --git a/test/test_multithreaded.rs b/test/test_multithreaded.rs index 32f00f4..dfec8b3 100644 --- a/test/test_multithreaded.rs +++ b/test/test_multithreaded.rs @@ -11,25 +11,25 @@ pub fn test_multithreaded() { let db = DB::open_default(path).unwrap(); let db = Arc::new(db); - db.put(b"key", b"value1"); + db.put(b"key", b"value1").unwrap(); let db1 = db.clone(); let j1 = thread::spawn(move|| { - for i in 1..N { - db1.put(b"key", b"value1"); + for _ in 1..N { + db1.put(b"key", b"value1").unwrap(); } }); let db2 = db.clone(); let j2 = thread::spawn(move|| { - for i in 1..N { - db2.put(b"key", b"value2"); + for _ in 1..N { + db2.put(b"key", b"value2").unwrap(); } }); let db3 = db.clone(); let j3 = thread::spawn(move|| { - for i in 1..N { + for _ in 1..N { match db3.get(b"key") { Ok(Some(v)) => { if &v[..] != b"value1" && &v[..] != b"value2" { @@ -43,9 +43,9 @@ pub fn test_multithreaded() { } }); - j1.join(); - j2.join(); - j3.join(); + j1.join().unwrap(); + j2.join().unwrap(); + j3.join().unwrap(); } assert!(DB::destroy(&Options::new(), path).is_ok()); } diff --git a/test/test_multithreaded.rs.orig b/test/test_multithreaded.rs.orig deleted file mode 100644 index 141ed2e..0000000 --- a/test/test_multithreaded.rs.orig +++ /dev/null @@ -1,56 +0,0 @@ -<<<<<<< Updated upstream -use rocksdb::{Options, DB, Writable, Direction, DBResult}; -use std::thread::{self, Builder}; -======= -use rocksdb::{Options, DB, Writable}; -use std::thread; ->>>>>>> Stashed changes -use std::sync::Arc; - -const N: usize = 100_000; - -#[test] -pub fn test_multithreaded() { - let path = "_rust_rocksdb_multithreadtest"; - { - let db = DB::open_default(path).unwrap(); - let db = Arc::new(db); - - db.put(b"key", b"value1"); - - let db1 = db.clone(); - let j1 = thread::spawn(move|| { - for i in 1..N { - db1.put(b"key", b"value1"); - } - }); - - let db2 = db.clone(); - let j2 = thread::spawn(move|| { - for i in 1..N { - db2.put(b"key", b"value2"); - } - }); - - let db3 = db.clone(); - let j3 = thread::spawn(move|| { - for i in 1..N { - match db3.get(b"key") { - Ok(Some(v)) => { - if &v[..] != b"value1" && &v[..] != b"value2" { - assert!(false); - } - } - _ => { - assert!(false); - } - } - } - }); - - j1.join(); - j2.join(); - j3.join(); - } - assert!(DB::destroy(&Options::new(), path).is_ok()); -}