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

*: Fix clippy warnings.

Browse Source
master
ngaut 8 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 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,

3
src/ffi.rs
Unescape View File

@ -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());

90
src/main.rs
Unescape View File

@ -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<u8> {
let mut result: Vec<u8> = 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();
// }
//
}

18
src/merge_operator.rs
Unescape View File

@ -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<u8> {
let nops = operands.size_hint().0;
let mut result: Vec<u8> = 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") {

70
src/rocksdb.rs
Unescape View File

@ -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<DBIterator<'a>, String> {
-> Result<DBIterator, String> {
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<rocksdb_ffi::DBCFHandle> =
let cfhandles: Vec<rocksdb_ffi::DBCFHandle> =
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<Option<DBVector>, 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(),

17
test/test_column_family.rs
Unescape View File

@ -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!"),
}

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]> {
input.iter().cloned().collect::<Vec<_>>().into_boxed_slice()
@ -99,14 +99,16 @@ pub fn test_iterator() {
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)),
(cba(&k3), cba(&v3)),
(cba(&k4), cba(&v4))];
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))];
assert_eq!(iterator1.collect::<Vec<_>>(), expected);
}

Write Preview
Loading…
Cancel
Save