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

2->4 spacing

Browse Source
master
Tyler Neely 10 years ago
parent 3fba236e37
commit e585d23e27
4 changed files with 396 additions and 388 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. 279
      src/ffi.rs
  2. 4
      src/lib.rs
  3. 71
      src/main.rs
  4. 430
      src/rocksdb.rs

279
src/ffi.rs
Unescape View File

@ -18,169 +18,170 @@ 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)]
pub enum RocksDBUniversalCompactionStyle { pub enum RocksDBUniversalCompactionStyle {
rocksdb_similar_size_compaction_stop_style = 0, rocksdb_similar_size_compaction_stop_style = 0,
rocksdb_total_size_compaction_stop_style = 1 rocksdb_total_size_compaction_stop_style = 1
} }
#[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_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_delete(db: RocksDBInstance, writeopts: RocksDBWriteOptions, pub fn rocksdb_delete(db: RocksDBInstance, writeopts: RocksDBWriteOptions,
k: *const u8, kLen: size_t, err: *mut i8) -> *mut c_void; k: *const u8, kLen: 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);
// Merge Operator // Merge Operator
pub fn rocksdb_mergeoperator_create( pub fn rocksdb_mergeoperator_create(
state: *mut c_void, state: *mut c_void,
destroy: extern fn(*mut c_void) -> (), destroy: extern fn(*mut c_void) -> (),
full_merge: extern fn ( full_merge: extern fn (
arg: *mut c_void, key: *const c_char, key_len: *mut size_t, arg: *mut c_void, key: *const c_char, key_len: *mut size_t,
existing_value: *const c_char, existing_value_len: *mut size_t, existing_value: *const c_char, existing_value_len: *mut size_t,
operands_list: &[*const c_char], operands_list_len: *const size_t, operands_list: &[*const c_char], operands_list_len: *const size_t,
num_operands: c_int, num_operands: c_int,
success: *mut u8, new_value_length: *mut size_t success: *mut u8, new_value_length: *mut size_t
) -> *const c_char, ) -> *const c_char,
partial_merge: extern fn( partial_merge: extern fn(
*mut c_void, key: *const c_char, key_len: *mut size_t, *mut c_void, key: *const c_char, key_len: *mut size_t,
operands_list: &[*const c_char], operands_list_len: *const size_t, operands_list: &[*const c_char], operands_list_len: *const size_t,
num_operands: c_int, num_operands: c_int,
success: *mut u8, new_value_length: *mut size_t success: *mut u8, new_value_length: *mut size_t
) -> *const c_char, ) -> *const c_char,
delete_value: extern fn(*mut c_void, value: *const c_char, value_len: *mut size_t) -> (), delete_value: extern fn(*mut c_void, value: *const c_char,
name_fn: extern fn(*mut c_void) -> *const c_char, value_len: *mut size_t) -> (),
) -> RocksDBMergeOperator; name_fn: extern fn(*mut c_void) -> *const c_char,
pub fn rocksdb_mergeoperator_destroy(mo: RocksDBMergeOperator); ) -> RocksDBMergeOperator;
pub fn rocksdb_options_set_merge_operator( pub fn rocksdb_mergeoperator_destroy(mo: RocksDBMergeOperator);
options: RocksDBOptions, pub fn rocksdb_options_set_merge_operator(
mo: RocksDBMergeOperator); options: RocksDBOptions,
mo: RocksDBMergeOperator);
} }
#[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);
} }
} }

4
src/lib.rs
Unescape View File

@ -4,8 +4,8 @@
pub use ffi as rocksdb_ffi; pub use ffi as rocksdb_ffi;
pub use rocksdb::{ pub use rocksdb::{
RocksDB, RocksDB,
RocksDBResult, RocksDBResult,
}; };
pub mod rocksdb; pub mod rocksdb;
pub mod ffi; pub mod ffi;

71
src/main.rs
Unescape View File

@ -5,53 +5,52 @@ use test::Bencher;
#[allow(dead_code)] #[allow(dead_code)]
fn main() { fn main() {
match RocksDB::open_default("/tmp/rust-rocksdb") { match RocksDB::open_default("/tmp/rust-rocksdb") {
Ok(db) => { Ok(db) => {
assert!(db.put(b"my key", b"my value").is_ok()); assert!(db.put(b"my key", b"my value").is_ok());
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"),
} }
}) })
.on_absent( || { println!("value not found") }) .on_absent( || { println!("value not found") })
.on_error( |e| { println!("error retrieving value: {}", e) }); .on_error( |e| { println!("error retrieving value: {}", e) });
assert!(db.delete(b"my key").is_ok()); assert!(db.delete(b"my key").is_ok());
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 = RocksDB::open_default("testdb").unwrap(); let db = RocksDB::open_default("testdb").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 = RocksDB::open_default("testdb").unwrap(); let db = RocksDB::open_default("testdb").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();
} }

430
src/rocksdb.rs
Unescape View File

@ -8,284 +8,292 @@ use std::str::from_utf8;
use rocksdb_ffi; use rocksdb_ffi;
pub struct RocksDBOptions { pub struct RocksDBOptions {
inner: rocksdb_ffi::RocksDBOptions, inner: rocksdb_ffi::RocksDBOptions,
} }
impl RocksDBOptions { impl RocksDBOptions {
pub fn new() -> RocksDBOptions { pub fn new() -> RocksDBOptions {
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() {
panic!("Could not create rocksdb options".to_string()); panic!("Could not create rocksdb options".to_string());
} }
RocksDBOptions{inner: opts} RocksDBOptions{inner: opts}
}
} }
}
pub fn increase_parallelism(&self, parallelism: i32) { pub fn increase_parallelism(&self, parallelism: i32) {
unsafe { unsafe {
rocksdb_ffi::rocksdb_options_increase_parallelism(self.inner, parallelism); rocksdb_ffi::rocksdb_options_increase_parallelism(
self.inner, parallelism);
}
} }
}
pub fn optimize_level_style_compaction(&self, memtable_memory_budget: i32) { pub fn optimize_level_style_compaction(&self,
unsafe { memtable_memory_budget: i32) {
rocksdb_ffi::rocksdb_options_optimize_level_style_compaction(self.inner, memtable_memory_budget); unsafe {
rocksdb_ffi::rocksdb_options_optimize_level_style_compaction(
self.inner, memtable_memory_budget);
}
} }
}
pub fn create_if_missing(&self, create_if_missing: bool) { pub fn create_if_missing(&self, create_if_missing: bool) {
unsafe { unsafe {
match create_if_missing { match create_if_missing {
true => rocksdb_ffi::rocksdb_options_set_create_if_missing(self.inner, 1), true => rocksdb_ffi::rocksdb_options_set_create_if_missing(
false => rocksdb_ffi::rocksdb_options_set_create_if_missing(self.inner, 0), self.inner, 1),
} false => rocksdb_ffi::rocksdb_options_set_create_if_missing(
self.inner, 0),
}
}
} }
}
pub fn set_merge_operator(&self, mo: rocksdb_ffi::RocksDBMergeOperator) { pub fn set_merge_operator(&self, mo: rocksdb_ffi::RocksDBMergeOperator) {
unsafe { unsafe {
rocksdb_ffi::rocksdb_options_set_merge_operator(self.inner, mo); rocksdb_ffi::rocksdb_options_set_merge_operator(self.inner, mo);
}
} }
}
} }
pub struct RocksDB { pub struct RocksDB {
inner: rocksdb_ffi::RocksDBInstance, inner: rocksdb_ffi::RocksDBInstance,
} }
impl RocksDB { impl RocksDB {
pub fn open_default(path: &str) -> Result<RocksDB, String> { pub fn open_default(path: &str) -> Result<RocksDB, String> {
let opts = RocksDBOptions::new(); let opts = RocksDBOptions::new();
opts.create_if_missing(true); opts.create_if_missing(true);
RocksDB::open(opts, path) RocksDB::open(opts, path)
} }
pub fn open(opts: RocksDBOptions, path: &str) -> Result<RocksDB, String> { pub fn open(opts: RocksDBOptions, path: &str) -> Result<RocksDB, String> {
unsafe { unsafe {
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.inner, cpath_ptr, err); let db = rocksdb_ffi::rocksdb_open(opts.inner, 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() {
return Err("Could not initialize database.".to_string());
}
Ok(RocksDB{inner: db})
} }
}
if db_ptr.is_null() {
return Err("Could not initialize database.".to_string());
}
Ok(RocksDB{inner: db})
} }
}
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]) ->
unsafe { RocksDBResult<'a, RocksDBVector, String> {
let readopts = rocksdb_ffi::rocksdb_readoptions_create(); unsafe {
let rocksdb_ffi::RocksDBReadOptions(read_opts_ptr) = readopts; let readopts = rocksdb_ffi::rocksdb_readoptions_create();
if read_opts_ptr.is_null() { let rocksdb_ffi::RocksDBReadOptions(read_opts_ptr) = readopts;
return RocksDBResult::Error("Unable to create rocksdb read \ if read_opts_ptr.is_null() {
options. This is a fairly trivial call, and its failure \ return RocksDBResult::Error("Unable to create rocksdb read \
may be indicative of a mis-compiled or mis-loaded rocksdb \ options. This is a fairly trivial call, and its failure \
library.".to_string()); may be indicative of a mis-compiled or mis-loaded rocksdb \
} 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.len() as size_t, val_len_ptr, err) as *mut u8; key.as_ptr(), 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() { match val.is_null() {
true => RocksDBResult::None, true => RocksDBResult::None,
false => { false => {
RocksDBResult::Some(RocksDBVector::from_c(val, val_len)) RocksDBResult::Some(RocksDBVector::from_c(val, val_len))
}
}
} }
}
} }
}
pub fn delete(&self, key: &[u8]) -> Result<(),String> { pub fn delete(&self, key: &[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_delete(self.inner, writeopts, key.as_ptr(), rocksdb_ffi::rocksdb_delete(self.inner, writeopts, key.as_ptr(),
key.len() as size_t, err); key.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 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 =>
RocksDBResult::Error(_) => panic!("Attempted unwrap on RocksDBResult::Error"), panic!("Attempted unwrap on RocksDBResult::None"),
RocksDBResult::Error(_) =>
panic!("Attempted unwrap on RocksDBResult::Error"),
}
} }
}
#[unstable = "waiting for unboxed closures"] #[unstable = "waiting for unboxed closures"]
pub fn on_error<U>(self, f: |E| -> U) -> RocksDBResult<T,U> { pub fn on_error<U>(self, f: |E| -> U) -> RocksDBResult<T,U> {
match self { match self {
RocksDBResult::Some(x) => RocksDBResult::Some(x), RocksDBResult::Some(x) => RocksDBResult::Some(x),
RocksDBResult::None => RocksDBResult::None, RocksDBResult::None => RocksDBResult::None,
RocksDBResult::Error(e) => RocksDBResult::Error(f(e)), RocksDBResult::Error(e) => RocksDBResult::Error(f(e)),
}
} }
}
#[unstable = "waiting for unboxed closures"] #[unstable = "waiting for unboxed closures"]
pub fn on_absent(self, f: || -> ()) -> RocksDBResult<T,E> { pub fn on_absent(self, f: || -> ()) -> RocksDBResult<T,E> {
match self { match self {
RocksDBResult::Some(x) => RocksDBResult::Some(x), RocksDBResult::Some(x) => RocksDBResult::Some(x),
RocksDBResult::None => { RocksDBResult::None => {
f(); f();
RocksDBResult::None 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 {
pub fn is_none(self) -> bool { match self {
match self { RocksDBResult::Some(_) => false,
RocksDBResult::Some(_) => false, RocksDBResult::None => true,
RocksDBResult::None => true, RocksDBResult::Error(_) => false,
RocksDBResult::Error(_) => false, }
} }
} pub fn is_error(self) -> bool {
pub fn is_error(self) -> bool { match self {
match self { RocksDBResult::Some(_) => false,
RocksDBResult::Some(_) => false, RocksDBResult::None => false,
RocksDBResult::None => false, RocksDBResult::Error(_) => true,
RocksDBResult::Error(_) => true, }
} }
}
} }
#[allow(dead_code)] #[allow(dead_code)]
#[test] #[test]
fn external() { fn external() {
let db = RocksDB::open_default("externaltest").unwrap(); let db = RocksDB::open_default("externaltest").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.unwrap().to_utf8().unwrap() == "v1111"); assert!(r.unwrap().to_utf8().unwrap() == "v1111");
assert!(db.delete(b"k1").is_ok()); assert!(db.delete(b"k1").is_ok());
assert!(db.get(b"k1").is_none()); assert!(db.get(b"k1").is_none());
db.close(); db.close();
} }

Write Preview
Loading…
Cancel
Save