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

*: Fix clippy warnings.

Browse Source
master
ngaut 9 years ago
parent 5616f81d03
commit bb0ca27556
7 changed files with 104 additions and 106 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. 4
      src/comparator.rs
  2. 3
      src/ffi.rs
  3. 90
      src/main.rs
  4. 18
      src/merge_operator.rs
  5. 70
      src/rocksdb.rs
  6. 17
      test/test_column_family.rs
  7. 8
      test/test_iterator.rs

4
src/comparator.rs
Unescape View File

@ -16,12 +16,8 @@ extern crate libc;
use self::libc::{c_char, c_int, c_void, size_t}; use self::libc::{c_char, c_int, c_void, size_t};
use std::ffi::CString; use std::ffi::CString;
use std::mem; use std::mem;
use std::ptr;
use std::slice; use std::slice;
use rocksdb_options::Options;
use rocksdb::DB;
pub struct ComparatorCallback { pub struct ComparatorCallback {
pub name: CString, pub name: CString,
pub f: fn(&[u8], &[u8]) -> i32, pub f: fn(&[u8], &[u8]) -> i32,

3
src/ffi.rs
Unescape View File

@ -14,7 +14,7 @@
// //
extern crate libc; extern crate libc;
use self::libc::{c_char, c_int, c_void, size_t}; 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; use std::str::from_utf8;
#[derive(Copy, Clone)] #[derive(Copy, Clone)]
@ -412,6 +412,7 @@ extern "C" {
#[test] #[test]
fn internal() { fn internal() {
unsafe { unsafe {
use std::ffi::CString;
let opts = rocksdb_options_create(); let opts = rocksdb_options_create();
assert!(!opts.0.is_null()); assert!(!opts.0.is_null());

90
src/main.rs
Unescape View File

@ -1,4 +1,3 @@
//
// Copyright 2014 Tyler Neely // Copyright 2014 Tyler Neely
// //
// Licensed under the Apache License, Version 2.0 (the "License"); // Licensed under the Apache License, Version 2.0 (the "License");
@ -57,7 +56,7 @@ fn main() {
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"),
} }
}, }
Ok(None) => panic!("value not present!"), Ok(None) => panic!("value not present!"),
Err(e) => println!("error retrieving value: {}", e), Err(e) => println!("error retrieving value: {}", e),
} }
@ -73,9 +72,11 @@ fn concat_merge(_: &[u8],
-> Vec<u8> { -> Vec<u8> {
let mut result: Vec<u8> = Vec::with_capacity(operands.size_hint().0); let mut result: Vec<u8> = Vec::with_capacity(operands.size_hint().0);
match existing_val { match existing_val {
Some(v) => for e in v { Some(v) => {
result.push(*e) for e in v {
}, result.push(*e)
}
}
None => (), None => (),
} }
for op in operands { for op in operands {
@ -141,11 +142,8 @@ fn main() {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::thread::sleep_ms; use rocksdb::{BlockBasedOptions, DB, Options};
use rocksdb::{BlockBasedOptions, DB, MergeOperands, Options, Writable,
new_bloom_filter};
use rocksdb::DBCompactionStyle::DBUniversalCompaction; use rocksdb::DBCompactionStyle::DBUniversalCompaction;
fn tuned_for_somebody_elses_disk(path: &str, fn tuned_for_somebody_elses_disk(path: &str,
@ -173,45 +171,45 @@ mod tests {
opts.set_block_based_table_factory(blockopts); opts.set_block_based_table_factory(blockopts);
opts.set_disable_auto_compactions(true); opts.set_disable_auto_compactions(true);
let filter = new_bloom_filter(10); // let filter = new_bloom_filter(10);
// opts.set_filter(filter); // opts.set_filter(filter);
DB::open(&opts, path).unwrap() DB::open(&opts, path).unwrap()
} }
// TODO(tyler) unstable // TODO(tyler) unstable
// #[bench] // #[bench]
// fn a_writes(b: &mut Bencher) { // fn a_writes(b: &mut Bencher) {
// dirty hack due to parallel tests causing contention. // dirty hack due to parallel tests causing contention.
// sleep_ms(1000); // sleep_ms(1000);
// let path = "_rust_rocksdb_optimizetest"; // let path = "_rust_rocksdb_optimizetest";
// let mut opts = Options::new(); // let mut opts = Options::new();
// let mut blockopts = BlockBasedOptions::new(); // let mut blockopts = BlockBasedOptions::new();
// let mut db = tuned_for_somebody_elses_disk(path, &mut opts, &mut blockopts); // let mut db = tuned_for_somebody_elses_disk(path, &mut opts, &mut blockopts);
// let mut i = 0 as u64; // let mut i = 0 as u64;
// b.iter(|| { // b.iter(|| {
// db.put(i.to_string().as_bytes(), b"v1111"); // db.put(i.to_string().as_bytes(), b"v1111");
// i += 1; // i += 1;
// }); // });
// } // }
// //
// #[bench] // #[bench]
// fn b_reads(b: &mut Bencher) { // fn b_reads(b: &mut Bencher) {
// let path = "_rust_rocksdb_optimizetest"; // let path = "_rust_rocksdb_optimizetest";
// let mut opts = Options::new(); // let mut opts = Options::new();
// let mut blockopts = BlockBasedOptions::new(); // let mut blockopts = BlockBasedOptions::new();
// { // {
// let db = tuned_for_somebody_elses_disk(path, &mut opts, &mut blockopts); // let db = tuned_for_somebody_elses_disk(path, &mut opts, &mut blockopts);
// let mut i = 0 as u64; // let mut i = 0 as u64;
// b.iter(|| { // b.iter(|| {
// db.get(i.to_string().as_bytes()).on_error( |e| { // db.get(i.to_string().as_bytes()).on_error( |e| {
// println!("error: {}", e); // println!("error: {}", e);
// e // e
// }); // });
// i += 1; // i += 1;
// }); // });
// } // }
// DB::destroy(&opts, path).is_ok(); // DB::destroy(&opts, path).is_ok();
// } // }
// //
} }

18
src/merge_operator.rs
Unescape View File

@ -19,8 +19,6 @@ use std::mem;
use std::ptr; use std::ptr;
use std::slice; use std::slice;
use rocksdb_options::Options;
use rocksdb::{DB, DBVector, Writable};
pub struct MergeOperatorCallback { pub struct MergeOperatorCallback {
pub name: CString, pub name: CString,
@ -156,7 +154,7 @@ impl<'a> Iterator for &'a mut MergeOperands {
fn test_provided_merge(new_key: &[u8], fn test_provided_merge(new_key: &[u8],
existing_val: Option<&[u8]>, existing_val: Option<&[u8]>,
mut operands: &mut MergeOperands) operands: &mut MergeOperands)
-> Vec<u8> { -> 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);
@ -178,19 +176,23 @@ fn test_provided_merge(new_key: &[u8],
#[allow(dead_code)] #[allow(dead_code)]
#[test] #[test]
fn mergetest() { fn mergetest() {
use rocksdb_options::Options;
use rocksdb::{DB, DBVector, Writable};
let path = "_rust_rocksdb_mergetest"; let path = "_rust_rocksdb_mergetest";
let mut opts = Options::new(); let mut opts = Options::new();
opts.create_if_missing(true); opts.create_if_missing(true);
opts.add_merge_operator("test operator", test_provided_merge); 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"); let p = db.put(b"k1", b"a");
assert!(p.is_ok()); assert!(p.is_ok());
db.merge(b"k1", b"b"); let _ = db.merge(b"k1", b"b");
db.merge(b"k1", b"c"); let _ = db.merge(b"k1", b"c");
db.merge(b"k1", b"d"); let _ = db.merge(b"k1", b"d");
db.merge(b"k1", b"efg"); let _ = db.merge(b"k1", b"efg");
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") {

70
src/rocksdb.rs
Unescape View File

@ -16,9 +16,8 @@
extern crate libc; extern crate libc;
use std::collections::BTreeMap; use std::collections::BTreeMap;
use std::ffi::{CStr, CString}; use std::ffi::CString;
use std::fs; use std::fs;
use std::io;
use std::ops::Deref; use std::ops::Deref;
use std::path::Path; use std::path::Path;
use std::slice; use std::slice;
@ -50,29 +49,28 @@ pub struct Snapshot<'a> {
inner: rocksdb_ffi::DBSnapshot, inner: rocksdb_ffi::DBSnapshot,
} }
pub struct DBIterator<'a> { pub struct DBIterator {
db: &'a DB,
inner: rocksdb_ffi::DBIterator, inner: rocksdb_ffi::DBIterator,
direction: Direction, direction: Direction,
just_seeked: bool, just_seeked: bool,
} }
pub enum Direction { pub enum Direction {
forward, Forward,
reverse, Reverse,
} }
impl<'a> Iterator for DBIterator<'a> { impl Iterator for DBIterator {
type Item = (Box<[u8]>, Box<[u8]>); type Item = (Box<[u8]>, Box<[u8]>);
fn next(&mut self) -> Option<(Box<[u8]>, Box<[u8]>)> { fn next(&mut self) -> Option<(Box<[u8]>, Box<[u8]>)> {
let native_iter = self.inner; let native_iter = self.inner;
if !self.just_seeked { if !self.just_seeked {
match self.direction { match self.direction {
Direction::forward => unsafe { Direction::Forward => unsafe {
rocksdb_ffi::rocksdb_iter_next(native_iter) rocksdb_ffi::rocksdb_iter_next(native_iter)
}, },
Direction::reverse => unsafe { Direction::Reverse => unsafe {
rocksdb_ffi::rocksdb_iter_prev(native_iter) rocksdb_ffi::rocksdb_iter_prev(native_iter)
}, },
} }
@ -112,19 +110,18 @@ pub enum IteratorMode<'a> {
} }
impl<'a> DBIterator<'a> { impl DBIterator {
fn new<'b>(db: &'a DB, fn new<'b>(db: &DB,
readopts: &'b ReadOptions, readopts: &'b ReadOptions,
mode: IteratorMode) mode: IteratorMode)
-> DBIterator<'a> { -> DBIterator {
unsafe { unsafe {
let iterator = rocksdb_ffi::rocksdb_create_iterator(db.inner, let iterator = rocksdb_ffi::rocksdb_create_iterator(db.inner,
readopts.inner); readopts.inner);
let mut rv = DBIterator { let mut rv = DBIterator {
db: db,
inner: iterator, inner: iterator,
direction: Direction::forward, // blown away by set_mode() direction: Direction::Forward, // blown away by set_mode()
just_seeked: false, just_seeked: false,
}; };
@ -139,11 +136,11 @@ impl<'a> DBIterator<'a> {
match mode { match mode {
IteratorMode::Start => { IteratorMode::Start => {
rocksdb_ffi::rocksdb_iter_seek_to_first(self.inner); rocksdb_ffi::rocksdb_iter_seek_to_first(self.inner);
self.direction = Direction::forward; self.direction = Direction::Forward;
} }
IteratorMode::End => { IteratorMode::End => {
rocksdb_ffi::rocksdb_iter_seek_to_last(self.inner); rocksdb_ffi::rocksdb_iter_seek_to_last(self.inner);
self.direction = Direction::reverse; self.direction = Direction::Reverse;
} }
IteratorMode::From(key, dir) => { IteratorMode::From(key, dir) => {
rocksdb_ffi::rocksdb_iter_seek(self.inner, 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, cf_handle: DBCFHandle,
readopts: &ReadOptions, readopts: &ReadOptions,
mode: IteratorMode) mode: IteratorMode)
-> Result<DBIterator<'a>, String> { -> Result<DBIterator, String> {
unsafe { unsafe {
let iterator = let iterator =
rocksdb_ffi::rocksdb_create_iterator_cf(db.inner, rocksdb_ffi::rocksdb_create_iterator_cf(db.inner,
@ -168,9 +165,8 @@ impl<'a> DBIterator<'a> {
cf_handle); cf_handle);
let mut rv = DBIterator { let mut rv = DBIterator {
db: db,
inner: iterator, inner: iterator,
direction: Direction::forward, // blown away by set_mode() direction: Direction::Forward, // blown away by set_mode()
just_seeked: false, 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) { fn drop(&mut self) {
unsafe { unsafe {
rocksdb_ffi::rocksdb_iter_destroy(self.inner); rocksdb_ffi::rocksdb_iter_destroy(self.inner);
@ -261,7 +257,9 @@ impl DB {
let ospath = Path::new(path); let ospath = Path::new(path);
match fs::create_dir_all(&ospath) { match fs::create_dir_all(&ospath) {
Err(e) => { Err(e) => {
return Err("Failed to create rocksdb directory.".to_string()) return Err(format!("Failed to create rocksdb directory: \
{:?}",
e))
} }
Ok(_) => (), Ok(_) => (),
} }
@ -269,7 +267,7 @@ impl DB {
let mut err: *const i8 = 0 as *const i8; let mut err: *const i8 = 0 as *const i8;
let err_ptr: *mut *const i8 = &mut err; let err_ptr: *mut *const i8 = &mut err;
let db: rocksdb_ffi::DBInstance; let db: rocksdb_ffi::DBInstance;
let mut cfMap = BTreeMap::new(); let mut cf_map = BTreeMap::new();
if cfs.len() == 0 { if cfs.len() == 0 {
unsafe { unsafe {
@ -298,7 +296,7 @@ impl DB {
.collect(); .collect();
// These handles will be populated by DB. // These handles will be populated by DB.
let mut cfhandles: Vec<rocksdb_ffi::DBCFHandle> = let cfhandles: Vec<rocksdb_ffi::DBCFHandle> =
cfs_v.iter() cfs_v.iter()
.map(|_| rocksdb_ffi::DBCFHandle(0 as *mut c_void)) .map(|_| rocksdb_ffi::DBCFHandle(0 as *mut c_void))
.collect(); .collect();
@ -328,7 +326,7 @@ impl DB {
} }
for (n, h) in cfs_v.iter().zip(cfhandles) { 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 { Ok(DB {
inner: db, inner: db,
cfs: cfMap, cfs: cf_map,
}) })
} }
@ -349,7 +347,6 @@ impl DB {
let cpath = CString::new(path.as_bytes()).unwrap(); let cpath = CString::new(path.as_bytes()).unwrap();
let cpath_ptr = cpath.as_ptr(); let cpath_ptr = cpath.as_ptr();
let ospath = Path::new(path);
let mut err: *const i8 = 0 as *const i8; let mut err: *const i8 = 0 as *const i8;
let err_ptr: *mut *const i8 = &mut err; let err_ptr: *mut *const i8 = &mut err;
unsafe { unsafe {
@ -367,7 +364,6 @@ impl DB {
let cpath = CString::new(path.as_bytes()).unwrap(); let cpath = CString::new(path.as_bytes()).unwrap();
let cpath_ptr = cpath.as_ptr(); let cpath_ptr = cpath.as_ptr();
let ospath = Path::new(path);
let mut err: *const i8 = 0 as *const i8; let mut err: *const i8 = 0 as *const i8;
let err_ptr: *mut *const i8 = &mut err; let err_ptr: *mut *const i8 = &mut err;
unsafe { unsafe {
@ -837,7 +833,7 @@ impl DBVector {
fn external() { fn external() {
let path = "_rust_rocksdb_externaltest"; 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"); let p = db.put(b"k1", b"v1111");
assert!(p.is_ok()); assert!(p.is_ok());
let r: Result<Option<DBVector>, String> = db.get(b"k1"); let r: Result<Option<DBVector>, String> = db.get(b"k1");
@ -853,7 +849,7 @@ fn external() {
#[test] #[test]
fn errors_do_stuff() { fn errors_do_stuff() {
let path = "_rust_rocksdb_error"; let path = "_rust_rocksdb_error";
let mut db = DB::open_default(path).unwrap(); let db = DB::open_default(path).unwrap();
let opts = Options::new(); let opts = Options::new();
// The DB will still be open when we try to destroy and the lock should fail // The DB will still be open when we try to destroy and the lock should fail
match DB::destroy(&opts, path) { match DB::destroy(&opts, path) {
@ -870,12 +866,12 @@ fn errors_do_stuff() {
fn writebatch_works() { fn writebatch_works() {
let path = "_rust_rocksdb_writebacktest"; let path = "_rust_rocksdb_writebacktest";
{ {
let mut db = DB::open_default(path).unwrap(); let db = DB::open_default(path).unwrap();
{ {
// test put // test put
let mut batch = WriteBatch::new(); let batch = WriteBatch::new();
assert!(db.get(b"k1").unwrap().is_none()); 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()); assert!(db.get(b"k1").unwrap().is_none());
let p = db.write(batch); let p = db.write(batch);
assert!(p.is_ok()); assert!(p.is_ok());
@ -884,8 +880,8 @@ fn writebatch_works() {
} }
{ {
// test delete // test delete
let mut batch = WriteBatch::new(); let batch = WriteBatch::new();
batch.delete(b"k1"); let _ = batch.delete(b"k1");
let p = db.write(batch); let p = db.write(batch);
assert!(p.is_ok()); assert!(p.is_ok());
assert!(db.get(b"k1").unwrap().is_none()); assert!(db.get(b"k1").unwrap().is_none());
@ -899,14 +895,14 @@ fn writebatch_works() {
fn iterator_test() { fn iterator_test() {
let path = "_rust_rocksdb_iteratortest"; 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"); let p = db.put(b"k1", b"v1111");
assert!(p.is_ok()); assert!(p.is_ok());
let p = db.put(b"k2", b"v2222"); let p = db.put(b"k2", b"v2222");
assert!(p.is_ok()); assert!(p.is_ok());
let p = db.put(b"k3", b"v3333"); let p = db.put(b"k3", b"v3333");
assert!(p.is_ok()); assert!(p.is_ok());
let mut iter = db.iterator(IteratorMode::Start); let iter = db.iterator(IteratorMode::Start);
for (k, v) in iter { for (k, v) in iter {
println!("Hello {}: {}", println!("Hello {}: {}",
from_utf8(&*k).unwrap(), from_utf8(&*k).unwrap(),

17
test/test_column_family.rs
Unescape View File

@ -1,4 +1,3 @@
//
// Copyright 2014 Tyler Neely // Copyright 2014 Tyler Neely
// //
// Licensed under the Apache License, Version 2.0 (the "License"); // Licensed under the Apache License, Version 2.0 (the "License");
@ -39,11 +38,15 @@ pub fn test_column_family() {
let mut opts = Options::new(); let mut opts = Options::new();
opts.add_merge_operator("test operator", test_provided_merge); opts.add_merge_operator("test operator", test_provided_merge);
match DB::open(&opts, path) { match DB::open(&opts, path) {
Ok(_) => panic!("should not have opened DB successfully without \ Ok(_) => {
specifying column panic!("should not have opened DB successfully without \
families"), specifying column
Err(e) => assert!(e.starts_with("Invalid argument: You have to \ families")
open all 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"), 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!"), _ => panic!("value not present!"),
} }

8
test/test_iterator.rs
Unescape View File

@ -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]> { fn cba(input: &Box<[u8]>) -> Box<[u8]> {
input.iter().cloned().collect::<Vec<_>>().into_boxed_slice() input.iter().cloned().collect::<Vec<_>>().into_boxed_slice()
@ -99,14 +99,16 @@ pub fn test_iterator() {
assert_eq!(iterator1.collect::<Vec<_>>(), expected2); assert_eq!(iterator1.collect::<Vec<_>>(), 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)), let expected = vec![(cba(&k2), cba(&v2)),
(cba(&k3), cba(&v3)), (cba(&k3), cba(&v3)),
(cba(&k4), cba(&v4))]; (cba(&k4), cba(&v4))];
assert_eq!(iterator1.collect::<Vec<_>>(), expected); assert_eq!(iterator1.collect::<Vec<_>>(), 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))]; let expected = vec![(cba(&k2), cba(&v2)), (cba(&k1), cba(&v1))];
assert_eq!(iterator1.collect::<Vec<_>>(), expected); assert_eq!(iterator1.collect::<Vec<_>>(), expected);
} }

Write Preview
Loading…
Cancel
Save