master
Tyler Neely 10 years ago
parent 8b24b6304f
commit 325476aad8
  1. 76
      rocksdb-sys/build.rs
  2. 232
      rocksdb-sys/lib.rs
  3. 8
      src/lib.rs
  4. 66
      src/main.rs
  5. 338
      src/rocksdb.rs

@ -7,49 +7,49 @@ use std::io::process::InheritFd;
//TODO windows support //TODO windows support
fn main() { fn main() {
// Next, fall back and try to use pkg-config if its available. // Next, fall back and try to use pkg-config if its available.
match pkg_config::find_library("librocksdb") { match pkg_config::find_library("librocksdb") {
Ok(()) => return, Ok(()) => return,
Err(..) => {} Err(..) => {}
} }
let src = os::getcwd().unwrap(); let src = os::getcwd().unwrap();
let dst = Path::new(os::getenv("OUT_DIR").unwrap()); let dst = Path::new(os::getenv("OUT_DIR").unwrap());
let _ = fs::mkdir(&dst.join("build"), io::USER_DIR); let _ = fs::mkdir(&dst.join("build"), io::USER_DIR);
println!("cwd: {}", src.join("rocksdb").as_str()); println!("cwd: {}", src.join("rocksdb").as_str());
run(Command::new(make()) run(Command::new(make())
.arg("shared_lib") .arg("shared_lib")
.arg(format!("-j{}", os::getenv("NUM_JOBS").unwrap())) .arg(format!("-j{}", os::getenv("NUM_JOBS").unwrap()))
.cwd(&src.join("rocksdb"))); .cwd(&src.join("rocksdb")));
// Don't run `make install` because apparently it's a little buggy on mingw // Don't run `make install` because apparently it's a little buggy on mingw
// for windows. // for windows.
fs::mkdir_recursive(&dst.join("lib/pkgconfig"), io::USER_DIR).unwrap(); fs::mkdir_recursive(&dst.join("lib/pkgconfig"), io::USER_DIR).unwrap();
let target = os::getenv("TARGET").unwrap(); let target = os::getenv("TARGET").unwrap();
if target.contains("apple") { if target.contains("apple") {
fs::rename(&src.join("rocksdb/librocksdb.dylib"), &dst.join("lib/librocksdb.dylib")).unwrap(); fs::rename(&src.join("rocksdb/librocksdb.dylib"), &dst.join("lib/librocksdb.dylib")).unwrap();
} else { } else {
fs::rename(&src.join("rocksdb/librocksdb.so"), &dst.join("lib/librocksdb.so")).unwrap(); fs::rename(&src.join("rocksdb/librocksdb.so"), &dst.join("lib/librocksdb.so")).unwrap();
} }
println!("cargo:rustc-flags=-L {}/lib -l rocksdb:dylib", dst.display()); println!("cargo:rustc-flags=-L {}/lib -l rocksdb:dylib", dst.display());
println!("cargo:root={}", dst.display()); println!("cargo:root={}", dst.display());
println!("cargo:include={}/include", src.join("rocksdb").display()); println!("cargo:include={}/include", src.join("rocksdb").display());
} }
fn run(cmd: &mut Command) { fn run(cmd: &mut Command) {
println!("running: {}", cmd); println!("running: {}", cmd);
assert!(cmd.stdout(InheritFd(1)) assert!(cmd.stdout(InheritFd(1))
.stderr(InheritFd(2)) .stderr(InheritFd(2))
.status() .status()
.unwrap() .unwrap()
.success()); .success());
} }
fn make() -> &'static str { fn make() -> &'static str {
if cfg!(target_os = "freebsd") {"gmake"} else {"make"} if cfg!(target_os = "freebsd") {"gmake"} else {"make"}
} }

@ -18,19 +18,19 @@ pub struct RocksdbFilterPolicy(pub *const c_void);
#[repr(C)] #[repr(C)]
pub enum RocksdbCompressionType { pub enum RocksdbCompressionType {
RocksdbNoCompression = 0, RocksdbNoCompression = 0,
RocksdbSnappyCompression = 1, RocksdbSnappyCompression = 1,
RocksdbZlibCompression = 2, RocksdbZlibCompression = 2,
RocksdbBz2Compression = 3, RocksdbBz2Compression = 3,
RocksdbLz4Compression = 4, RocksdbLz4Compression = 4,
RocksdbLz4hcCompression = 5 RocksdbLz4hcCompression = 5
} }
#[repr(C)] #[repr(C)]
pub enum RocksdbCompactionStyle { pub enum RocksdbCompactionStyle {
RocksdbLevelCompaction = 0, RocksdbLevelCompaction = 0,
RocksdbUniversalCompaction = 1, RocksdbUniversalCompaction = 1,
RocksdbFifoCompaction = 2 RocksdbFifoCompaction = 2
} }
#[repr(C)] #[repr(C)]
@ -41,76 +41,76 @@ pub enum RocksdbUniversalCompactionStyle {
#[link(name = "rocksdb")] #[link(name = "rocksdb")]
extern { extern {
pub fn rocksdb_options_create() -> RocksdbOptions; pub fn rocksdb_options_create() -> RocksdbOptions;
pub fn rocksdb_options_increase_parallelism( pub fn rocksdb_options_increase_parallelism(
options: RocksdbOptions, threads: c_int); options: RocksdbOptions, threads: c_int);
pub fn rocksdb_options_optimize_level_style_compaction( pub fn rocksdb_options_optimize_level_style_compaction(
options: RocksdbOptions, memtable_memory_budget: c_int); options: RocksdbOptions, memtable_memory_budget: c_int);
pub fn rocksdb_options_set_create_if_missing( pub fn rocksdb_options_set_create_if_missing(
options: RocksdbOptions, v: c_int); options: RocksdbOptions, v: c_int);
pub fn rocksdb_options_set_max_open_files( pub fn rocksdb_options_set_max_open_files(
options: RocksdbOptions, files: c_int); options: RocksdbOptions, files: c_int);
pub fn rocksdb_options_set_use_fsync( pub fn rocksdb_options_set_use_fsync(
options: RocksdbOptions, v: c_int); options: RocksdbOptions, v: c_int);
pub fn rocksdb_options_set_bytes_per_sync( pub fn rocksdb_options_set_bytes_per_sync(
options: RocksdbOptions, bytes: u64); options: RocksdbOptions, bytes: u64);
pub fn rocksdb_options_set_disable_data_sync( pub fn rocksdb_options_set_disable_data_sync(
options: RocksdbOptions, v: c_int); options: RocksdbOptions, v: c_int);
pub fn rocksdb_options_optimize_for_point_lookup( pub fn rocksdb_options_optimize_for_point_lookup(
options: RocksdbOptions, block_cache_size_mb: u64); options: RocksdbOptions, block_cache_size_mb: u64);
pub fn rocksdb_options_set_table_cache_numshardbits( pub fn rocksdb_options_set_table_cache_numshardbits(
options: RocksdbOptions, bits: u64); options: RocksdbOptions, bits: u64);
pub fn rocksdb_options_set_max_write_buffer_number( pub fn rocksdb_options_set_max_write_buffer_number(
options: RocksdbOptions, bufno: c_int); options: RocksdbOptions, bufno: c_int);
pub fn rocksdb_options_set_min_write_buffer_number_to_merge( pub fn rocksdb_options_set_min_write_buffer_number_to_merge(
options: RocksdbOptions, bufno: c_int); options: RocksdbOptions, bufno: c_int);
pub fn rocksdb_options_set_level0_file_num_compaction_trigger( pub fn rocksdb_options_set_level0_file_num_compaction_trigger(
options: RocksdbOptions, no: c_int); options: RocksdbOptions, no: c_int);
pub fn rocksdb_options_set_level0_slowdown_writes_trigger( pub fn rocksdb_options_set_level0_slowdown_writes_trigger(
options: RocksdbOptions, no: c_int); options: RocksdbOptions, no: c_int);
pub fn rocksdb_options_set_level0_stop_writes_trigger( pub fn rocksdb_options_set_level0_stop_writes_trigger(
options: RocksdbOptions, no: c_int); options: RocksdbOptions, no: c_int);
pub fn rocksdb_options_set_write_buffer_size( pub fn rocksdb_options_set_write_buffer_size(
options: RocksdbOptions, bytes: u64); options: RocksdbOptions, bytes: u64);
pub fn rocksdb_options_set_target_file_size_base( pub fn rocksdb_options_set_target_file_size_base(
options: RocksdbOptions, bytes: u64); options: RocksdbOptions, bytes: u64);
pub fn rocksdb_options_set_target_file_size_multiplier( pub fn rocksdb_options_set_target_file_size_multiplier(
options: RocksdbOptions, mul: c_int); options: RocksdbOptions, mul: c_int);
pub fn rocksdb_options_set_max_log_file_size( pub fn rocksdb_options_set_max_log_file_size(
options: RocksdbOptions, bytes: u64); options: RocksdbOptions, bytes: u64);
pub fn rocksdb_options_set_max_manifest_file_size( pub fn rocksdb_options_set_max_manifest_file_size(
options: RocksdbOptions, bytes: u64); options: RocksdbOptions, bytes: u64);
pub fn rocksdb_options_set_hash_skip_list_rep( pub fn rocksdb_options_set_hash_skip_list_rep(
options: RocksdbOptions, bytes: u64, a1: i32, a2: i32); options: RocksdbOptions, bytes: u64, a1: i32, a2: i32);
pub fn rocksdb_options_set_compaction_style( pub fn rocksdb_options_set_compaction_style(
options: RocksdbOptions, cs: RocksdbCompactionStyle); options: RocksdbOptions, cs: RocksdbCompactionStyle);
pub fn rocksdb_options_set_compression( pub fn rocksdb_options_set_compression(
options: RocksdbOptions, compression_style_no: c_int); options: RocksdbOptions, compression_style_no: c_int);
pub fn rocksdb_options_set_max_background_compactions( pub fn rocksdb_options_set_max_background_compactions(
options: RocksdbOptions, max_bg_compactions: c_int); options: RocksdbOptions, max_bg_compactions: c_int);
pub fn rocksdb_options_set_max_background_flushes( pub fn rocksdb_options_set_max_background_flushes(
options: RocksdbOptions, max_bg_flushes: c_int); options: RocksdbOptions, max_bg_flushes: c_int);
pub fn rocksdb_options_set_filter_deletes( pub fn rocksdb_options_set_filter_deletes(
options: RocksdbOptions, v: u8); options: RocksdbOptions, v: u8);
//pub fn rocksdb_compactionfilter_create() -> RocksdbCompactionFilter; //pub fn rocksdb_compactionfilter_create() -> RocksdbCompactionFilter;
//pub fn rocksdb_mergeoperator_create() -> RocksdbMergeOperator; //pub fn rocksdb_mergeoperator_create() -> RocksdbMergeOperator;
pub fn rocksdb_filterpolicy_create_bloom( pub fn rocksdb_filterpolicy_create_bloom(
bits_per_key: c_int) -> RocksdbFilterPolicy; bits_per_key: c_int) -> RocksdbFilterPolicy;
pub fn rocksdb_open(options: RocksdbOptions, pub fn rocksdb_open(options: RocksdbOptions,
path: *const i8, err: *mut i8) -> RocksdbInstance; path: *const i8, err: *mut i8) -> RocksdbInstance;
pub fn rocksdb_writeoptions_create() -> RocksdbWriteOptions; pub fn rocksdb_writeoptions_create() -> RocksdbWriteOptions;
pub fn rocksdb_put(db: RocksdbInstance, writeopts: RocksdbWriteOptions, pub fn rocksdb_put(db: RocksdbInstance, writeopts: RocksdbWriteOptions,
k: *const u8, kLen: size_t, v: *const u8, k: *const u8, kLen: size_t, v: *const u8,
vLen: size_t, err: *mut i8); vLen: size_t, err: *mut i8);
pub fn rocksdb_readoptions_create() -> RocksdbReadOptions; pub fn rocksdb_readoptions_create() -> RocksdbReadOptions;
pub fn rocksdb_get(db: RocksdbInstance, readopts: RocksdbReadOptions, pub fn rocksdb_get(db: RocksdbInstance, readopts: RocksdbReadOptions,
k: *const u8, kLen: size_t, k: *const u8, kLen: size_t,
valLen: *const size_t, err: *mut i8) -> *mut c_void; valLen: *const size_t, err: *mut i8) -> *mut c_void;
pub fn rocksdb_close(db: RocksdbInstance); pub fn rocksdb_close(db: RocksdbInstance);
pub fn rocksdb_destroy_db( pub fn rocksdb_destroy_db(
options: RocksdbOptions, path: *const i8, err: *mut i8); options: RocksdbOptions, path: *const i8, err: *mut i8);
pub fn rocksdb_repair_db( pub fn rocksdb_repair_db(
options: RocksdbOptions, path: *const i8, err: *mut i8); options: RocksdbOptions, path: *const i8, err: *mut i8);
} }
@ -118,45 +118,45 @@ extern {
#[allow(dead_code)] #[allow(dead_code)]
#[test] #[test]
fn internal() { fn internal() {
unsafe { unsafe {
let opts = rocksdb_options_create(); let opts = rocksdb_options_create();
let RocksdbOptions(opt_ptr) = opts; let RocksdbOptions(opt_ptr) = opts;
assert!(opt_ptr.is_not_null()); assert!(opt_ptr.is_not_null());
rocksdb_options_increase_parallelism(opts, 0); rocksdb_options_increase_parallelism(opts, 0);
rocksdb_options_optimize_level_style_compaction(opts, 0); rocksdb_options_optimize_level_style_compaction(opts, 0);
rocksdb_options_set_create_if_missing(opts, 1); rocksdb_options_set_create_if_missing(opts, 1);
let rustpath = "internaltest"; let rustpath = "internaltest";
let cpath = rustpath.to_c_str(); let cpath = rustpath.to_c_str();
let cpath_ptr = cpath.as_ptr(); let cpath_ptr = cpath.as_ptr();
let err = 0 as *mut i8; let err = 0 as *mut i8;
let db = rocksdb_open(opts, cpath_ptr, err); let db = rocksdb_open(opts, cpath_ptr, err);
assert!(err.is_null()); assert!(err.is_null());
libc::free(err as *mut c_void); libc::free(err as *mut c_void);
let writeopts = rocksdb_writeoptions_create(); let writeopts = rocksdb_writeoptions_create();
let RocksdbWriteOptions(write_opt_ptr) = writeopts; let RocksdbWriteOptions(write_opt_ptr) = writeopts;
assert!(write_opt_ptr.is_not_null()); assert!(write_opt_ptr.is_not_null());
let key = b"name\x00"; let key = b"name\x00";
let val = b"spacejam\x00"; let val = b"spacejam\x00";
rocksdb_put(db, writeopts, key.as_ptr(), 4, val.as_ptr(), 8, err); rocksdb_put(db, writeopts, key.as_ptr(), 4, val.as_ptr(), 8, err);
assert!(err.is_null()); assert!(err.is_null());
libc::free(err as *mut c_void); libc::free(err as *mut c_void);
let readopts = rocksdb_readoptions_create(); let readopts = rocksdb_readoptions_create();
let RocksdbReadOptions(read_opts_ptr) = readopts; let RocksdbReadOptions(read_opts_ptr) = readopts;
assert!(read_opts_ptr.is_not_null()); assert!(read_opts_ptr.is_not_null());
libc::free(err as *mut c_void); libc::free(err as *mut c_void);
let val_len: size_t = 0; let val_len: size_t = 0;
let val_len_ptr = &val_len as *const size_t; let val_len_ptr = &val_len as *const size_t;
rocksdb_get(db, readopts, key.as_ptr(), 4, val_len_ptr, err); rocksdb_get(db, readopts, key.as_ptr(), 4, val_len_ptr, err);
assert!(err.is_null()); assert!(err.is_null());
libc::free(err as *mut c_void); libc::free(err as *mut c_void);
rocksdb_close(db); rocksdb_close(db);
} }
} }

@ -5,9 +5,9 @@
extern crate "rocksdb-sys" as rocksdb_ffi; extern crate "rocksdb-sys" as rocksdb_ffi;
pub use rocksdb::{ pub use rocksdb::{
create_or_open, create_or_open,
open, open,
Rocksdb, Rocksdb,
RocksdbResult, RocksdbResult,
}; };
pub mod rocksdb; pub mod rocksdb;

@ -5,50 +5,50 @@ use test::Bencher;
#[allow(dead_code)] #[allow(dead_code)]
fn main() { fn main() {
match rocksdb::create_or_open("/tmp/rust-rocksdb".to_string()) { match rocksdb::create_or_open("/tmp/rust-rocksdb".to_string()) {
Ok(db) => { Ok(db) => {
db.put(b"my key", b"my value"); db.put(b"my key", b"my value");
db.get(b"my key").map( |value| { db.get(b"my key").map( |value| {
match value.to_utf8() { match value.to_utf8() {
Some(v) => Some(v) =>
println!("retrieved utf8 value {}", v), println!("retrieved utf8 value {}", v),
None => None =>
println!("did not read valid utf-8 out of the db"), println!("did not read valid utf-8 out of the db"),
}}); }});
db.get(b"NOT my key").on_absent(|| { println!("value not found") }); db.get(b"NOT my key").on_absent(|| { println!("value not found") });
db.close(); db.close();
}, },
Err(e) => panic!(e), Err(e) => panic!(e),
} }
} }
#[allow(dead_code)] #[allow(dead_code)]
#[bench] #[bench]
fn writes(b: &mut Bencher) { fn writes(b: &mut Bencher) {
let db = open("testdb".to_string(), true).unwrap(); let db = open("testdb".to_string(), true).unwrap();
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;
}); });
db.close(); db.close();
} }
#[allow(dead_code)] #[allow(dead_code)]
#[bench] #[bench]
fn reads(b: &mut Bencher) { fn reads(b: &mut Bencher) {
let db = open("testdb".to_string(), true).unwrap(); let db = open("testdb".to_string(), true).unwrap();
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( db.get(i.to_string().as_bytes()).on_error(
|e| { |e| {
println!("error: {}", e); println!("error: {}", e);
e e
}); });
i += 1; i += 1;
}); });
db.close(); db.close();
} }

@ -8,171 +8,171 @@ use std::str::from_utf8;
use rocksdb_ffi; use rocksdb_ffi;
pub struct Rocksdb { pub struct Rocksdb {
inner: rocksdb_ffi::RocksdbInstance, inner: rocksdb_ffi::RocksdbInstance,
} }
impl Rocksdb { impl Rocksdb {
pub fn put(&self, key: &[u8], value: &[u8]) -> Result<(), String> { pub fn put(&self, key: &[u8], value: &[u8]) -> Result<(), String> {
unsafe { unsafe {
let writeopts = rocksdb_ffi::rocksdb_writeoptions_create(); let writeopts = rocksdb_ffi::rocksdb_writeoptions_create();
let err = 0 as *mut i8; let err = 0 as *mut i8;
rocksdb_ffi::rocksdb_put(self.inner, writeopts, key.as_ptr(), rocksdb_ffi::rocksdb_put(self.inner, writeopts, key.as_ptr(),
key.len() as size_t, value.as_ptr(), key.len() as size_t, value.as_ptr(),
value.len() as size_t, err); value.len() as size_t, err);
if err.is_not_null() { if err.is_not_null() {
let cs = CString::new(err as *const i8, true); let cs = CString::new(err as *const i8, true);
match cs.as_str() { match cs.as_str() {
Some(error_string) => Some(error_string) =>
return Err(error_string.to_string()), return Err(error_string.to_string()),
None => { None => {
let ie = IoError::last_error(); let ie = IoError::last_error();
return Err(format!( return Err(format!(
"ERROR: desc:{}, details:{}", "ERROR: desc:{}, details:{}",
ie.desc, ie.desc,
ie.detail.unwrap_or_else( ie.detail.unwrap_or_else(
|| {"none provided by OS".to_string()}))) || {"none provided by OS".to_string()})))
} }
}
}
return Ok(())
} }
}
return Ok(())
} }
}
pub fn get<'a>(&self, key: &[u8]) -> RocksdbResult<'a, RocksdbVector, String> { pub fn get<'a>(&self, key: &[u8]) -> RocksdbResult<'a, RocksdbVector, String> {
unsafe { unsafe {
let readopts = rocksdb_ffi::rocksdb_readoptions_create(); let readopts = rocksdb_ffi::rocksdb_readoptions_create();
let rocksdb_ffi::RocksdbReadOptions(read_opts_ptr) = readopts; let rocksdb_ffi::RocksdbReadOptions(read_opts_ptr) = readopts;
if read_opts_ptr.is_null() { if read_opts_ptr.is_null() {
return RocksdbResult::Error("Unable to create rocksdb read \ return RocksdbResult::Error("Unable to create rocksdb read \
options. This is a fairly trivial call, and its failure \ options. This is a fairly trivial call, and its failure \
may be indicative of a mis-compiled or mis-loaded rocksdb \ may be indicative of a mis-compiled or mis-loaded rocksdb \
library.".to_string()); library.".to_string());
} }
let val_len: size_t = 0; let val_len: size_t = 0;
let val_len_ptr = &val_len as *const size_t; let val_len_ptr = &val_len as *const size_t;
let err = 0 as *mut i8; let err = 0 as *mut i8;
let val = rocksdb_ffi::rocksdb_get(self.inner, readopts, key.as_ptr(), let val = rocksdb_ffi::rocksdb_get(self.inner, readopts, key.as_ptr(),
key.len() as size_t, val_len_ptr, err) as *mut u8; key.len() as size_t, val_len_ptr, err) as *mut u8;
if err.is_not_null() { if err.is_not_null() {
let cs = CString::new(err as *const i8, true); let cs = CString::new(err as *const i8, true);
match cs.as_str() { match cs.as_str() {
Some(error_string) => Some(error_string) =>
return RocksdbResult::Error(error_string.to_string()), return RocksdbResult::Error(error_string.to_string()),
None => None =>
return RocksdbResult::Error("Unable to get value from \ return RocksdbResult::Error("Unable to get value from \
rocksdb. (non-utf8 error received from underlying \ rocksdb. (non-utf8 error received from underlying \
library)".to_string()), library)".to_string()),
}
}
match val.is_null() {
true => RocksdbResult::None,
false => {
RocksdbResult::Some(RocksdbVector::from_c(val, val_len))
}
}
} }
}
match val.is_null() {
true => RocksdbResult::None,
false => {
RocksdbResult::Some(RocksdbVector::from_c(val, val_len))
}
}
} }
}
pub fn close(&self) { pub fn close(&self) {
unsafe { rocksdb_ffi::rocksdb_close(self.inner); } unsafe { rocksdb_ffi::rocksdb_close(self.inner); }
} }
} }
pub struct RocksdbVector { pub struct RocksdbVector {
inner: CVec<u8>, inner: CVec<u8>,
} }
impl RocksdbVector { impl RocksdbVector {
pub fn from_c(val: *mut u8, val_len: size_t) -> RocksdbVector { pub fn from_c(val: *mut u8, val_len: size_t) -> RocksdbVector {
unsafe { unsafe {
RocksdbVector { RocksdbVector {
inner: inner:
CVec::new_with_dtor(val, val_len as uint, CVec::new_with_dtor(val, val_len as uint,
proc(){ libc::free(val as *mut c_void); }) proc(){ libc::free(val as *mut c_void); })
} }
}
} }
}
pub fn as_slice<'a>(&'a self) -> &'a [u8] { pub fn as_slice<'a>(&'a self) -> &'a [u8] {
self.inner.as_slice() self.inner.as_slice()
} }
pub fn to_utf8<'a>(&'a self) -> Option<&'a str> { pub fn to_utf8<'a>(&'a self) -> Option<&'a str> {
from_utf8(self.inner.as_slice()) from_utf8(self.inner.as_slice())
} }
} }
// RocksdbResult exists because of the inherent difference between // RocksdbResult exists because of the inherent difference between
// an operational failure and the absence of a possible result. // an operational failure and the absence of a possible result.
#[deriving(Clone, PartialEq, PartialOrd, Eq, Ord, Show)] #[deriving(Clone, PartialEq, PartialOrd, Eq, Ord, Show)]
pub enum RocksdbResult<'a,T,E> { pub enum RocksdbResult<'a,T,E> {
Some(T), Some(T),
None, None,
Error(E), Error(E),
} }
impl <'a,T,E> RocksdbResult<'a,T,E> { impl <'a,T,E> RocksdbResult<'a,T,E> {
#[unstable = "waiting for unboxed closures"] #[unstable = "waiting for unboxed closures"]
pub fn map<U>(self, f: |T| -> U) -> RocksdbResult<U,E> { pub fn map<U>(self, f: |T| -> U) -> RocksdbResult<U,E> {
match self { match self {
RocksdbResult::Some(x) => RocksdbResult::Some(f(x)), RocksdbResult::Some(x) => RocksdbResult::Some(f(x)),
RocksdbResult::None => RocksdbResult::None, RocksdbResult::None => RocksdbResult::None,
RocksdbResult::Error(e) => RocksdbResult::Error(e), RocksdbResult::Error(e) => RocksdbResult::Error(e),
}
} }
}
pub fn unwrap(self) -> T { pub fn unwrap(self) -> T {
match self { match self {
RocksdbResult::Some(x) => x, RocksdbResult::Some(x) => x,
RocksdbResult::None => panic!("Attempted unwrap on RocksdbResult::None"), RocksdbResult::None => panic!("Attempted unwrap on RocksdbResult::None"),
RocksdbResult::Error(_) => panic!("Attempted unwrap on RocksdbResult::Error"), RocksdbResult::Error(_) => panic!("Attempted unwrap on RocksdbResult::Error"),
}
} }
}
#[unstable = "waiting for unboxed closures"]
pub fn on_error<U>(self, f: |E| -> U) -> RocksdbResult<T,U> { #[unstable = "waiting for unboxed closures"]
match self { pub fn on_error<U>(self, f: |E| -> U) -> RocksdbResult<T,U> {
RocksdbResult::Some(x) => RocksdbResult::Some(x), match self {
RocksdbResult::None => RocksdbResult::None, RocksdbResult::Some(x) => RocksdbResult::Some(x),
RocksdbResult::Error(e) => RocksdbResult::Error(f(e)), RocksdbResult::None => RocksdbResult::None,
} RocksdbResult::Error(e) => RocksdbResult::Error(f(e)),
} }
}
#[unstable = "waiting for unboxed closures"]
pub fn on_absent(self, f: || -> ()) -> RocksdbResult<T,E> { #[unstable = "waiting for unboxed closures"]
match self { pub fn on_absent(self, f: || -> ()) -> RocksdbResult<T,E> {
RocksdbResult::Some(x) => RocksdbResult::Some(x), match self {
RocksdbResult::None => { RocksdbResult::Some(x) => RocksdbResult::Some(x),
f(); RocksdbResult::None => {
RocksdbResult::None f();
}, RocksdbResult::None
RocksdbResult::Error(e) => RocksdbResult::Error(e), },
} RocksdbResult::Error(e) => RocksdbResult::Error(e),
} }
}
pub fn is_some(self) -> bool { pub fn is_some(self) -> bool {
match self { match self {
RocksdbResult::Some(_) => true, RocksdbResult::Some(_) => true,
RocksdbResult::None => false, RocksdbResult::None => false,
RocksdbResult::Error(_) => false, RocksdbResult::Error(_) => false,
}
} }
pub fn is_none(self) -> bool { }
match self { pub fn is_none(self) -> bool {
RocksdbResult::Some(_) => false, match self {
RocksdbResult::None => true, RocksdbResult::Some(_) => false,
RocksdbResult::Error(_) => false, RocksdbResult::None => true,
} RocksdbResult::Error(_) => false,
} }
pub fn is_error(self) -> bool { }
match self { pub fn is_error(self) -> bool {
RocksdbResult::Some(_) => false, match self {
RocksdbResult::None => false, RocksdbResult::Some(_) => false,
RocksdbResult::Error(_) => true, RocksdbResult::None => false,
} RocksdbResult::Error(_) => true,
} }
}
} }
pub fn create_or_open(path: String) -> Result<Rocksdb, String> { pub fn create_or_open(path: String) -> Result<Rocksdb, String> {
@ -180,54 +180,54 @@ pub fn create_or_open(path: String) -> Result<Rocksdb, String> {
} }
pub fn open(path: String, create_if_missing: bool) -> Result<Rocksdb, String> { pub fn open(path: String, create_if_missing: bool) -> Result<Rocksdb, String> {
unsafe { unsafe {
let opts = rocksdb_ffi::rocksdb_options_create(); let opts = rocksdb_ffi::rocksdb_options_create();
let rocksdb_ffi::RocksdbOptions(opt_ptr) = opts; let rocksdb_ffi::RocksdbOptions(opt_ptr) = opts;
if opt_ptr.is_null() { if opt_ptr.is_null() {
return Err("Could not create options".to_string()); return Err("Could not create options".to_string());
} }
//rocksdb_ffi::rocksdb_options_increase_parallelism(opts, 2); //rocksdb_ffi::rocksdb_options_increase_parallelism(opts, 2);
//rocksdb_ffi::rocksdb_options_optimize_level_style_compaction(opts, 0); //rocksdb_ffi::rocksdb_options_optimize_level_style_compaction(opts, 0);
match create_if_missing { match create_if_missing {
true => rocksdb_ffi::rocksdb_options_set_create_if_missing(opts, 1), true => rocksdb_ffi::rocksdb_options_set_create_if_missing(opts, 1),
false => rocksdb_ffi::rocksdb_options_set_create_if_missing(opts, 0), false => rocksdb_ffi::rocksdb_options_set_create_if_missing(opts, 0),
} }
let cpath = path.to_c_str(); let cpath = path.to_c_str();
let cpath_ptr = cpath.as_ptr(); let cpath_ptr = cpath.as_ptr();
//TODO test path here, as if rocksdb fails it will just crash the //TODO test path here, as if rocksdb fails it will just crash the
// process currently // process currently
let err = 0 as *mut i8; let err = 0 as *mut i8;
let db = rocksdb_ffi::rocksdb_open(opts, cpath_ptr, err); let db = rocksdb_ffi::rocksdb_open(opts, cpath_ptr, err);
let rocksdb_ffi::RocksdbInstance(db_ptr) = db; let rocksdb_ffi::RocksdbInstance(db_ptr) = db;
if err.is_not_null() { if err.is_not_null() {
let cs = CString::new(err as *const i8, true); let cs = CString::new(err as *const i8, true);
match cs.as_str() { match cs.as_str() {
Some(error_string) => Some(error_string) =>
return Err(error_string.to_string()), return Err(error_string.to_string()),
None => None =>
return Err("Could not initialize database.".to_string()), return Err("Could not initialize database.".to_string()),
} }
} }
if db_ptr.is_null() { if db_ptr.is_null() {
return Err("Could not initialize database.".to_string()); return Err("Could not initialize database.".to_string());
}
Ok(Rocksdb{inner: db})
} }
Ok(Rocksdb{inner: db})
}
} }
#[allow(dead_code)] #[allow(dead_code)]
#[test] #[test]
fn external() { fn external() {
let db = open("externaltest".to_string(), true).unwrap(); let db = open("externaltest".to_string(), true).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: RocksdbResult<RocksdbVector, String> = db.get(b"k1"); let r: RocksdbResult<RocksdbVector, String> = db.get(b"k1");
//assert!(r.is_some()); //assert!(r.is_some());
r.map(|v| { assert!(v.as_slice().len() == 5); } ); r.map(|v| { assert!(v.as_slice().len() == 5); } );
db.close(); db.close();
} }

Loading…
Cancel
Save