Skip to content

R
rust-rocksdb
Commit e585d23e authored by Tyler Neely's avatar Tyler Neely
Browse files
Options

2->4 spacing

parent 3fba236e
Hide whitespace changes
Inline Side-by-side
Showing with 396 additions and 388 deletions
src/ffi.rs
View file @ e585d23e
......@@ -18,169 +18,170 @@ pub struct RocksDBFilterPolicy(pub *const c_void);
#[repr(C)]
pub enum RocksDBCompressionType {
RocksDBNoCompression = 0,
RocksDBSnappyCompression = 1,
RocksDBZlibCompression = 2,
RocksDBBz2Compression = 3,
RocksDBLz4Compression = 4,
RocksDBLz4hcCompression = 5
RocksDBNoCompression = 0,
RocksDBSnappyCompression = 1,
RocksDBZlibCompression = 2,
RocksDBBz2Compression = 3,
RocksDBLz4Compression = 4,
RocksDBLz4hcCompression = 5
}
#[repr(C)]
pub enum RocksDBCompactionStyle {
RocksDBLevelCompaction = 0,
RocksDBUniversalCompaction = 1,
RocksDBFifoCompaction = 2
RocksDBLevelCompaction = 0,
RocksDBUniversalCompaction = 1,
RocksDBFifoCompaction = 2
}
#[repr(C)]
pub enum RocksDBUniversalCompactionStyle {
rocksdb_similar_size_compaction_stop_style = 0,
rocksdb_total_size_compaction_stop_style = 1
rocksdb_similar_size_compaction_stop_style = 0,
rocksdb_total_size_compaction_stop_style = 1
}
#[link(name = "rocksdb")]
extern {
pub fn rocksdb_options_create() -> RocksDBOptions;
pub fn rocksdb_options_increase_parallelism(
options: RocksDBOptions, threads: c_int);
pub fn rocksdb_options_optimize_level_style_compaction(
options: RocksDBOptions, memtable_memory_budget: c_int);
pub fn rocksdb_options_set_create_if_missing(
options: RocksDBOptions, v: c_int);
pub fn rocksdb_options_set_max_open_files(
options: RocksDBOptions, files: c_int);
pub fn rocksdb_options_set_use_fsync(
options: RocksDBOptions, v: c_int);
pub fn rocksdb_options_set_bytes_per_sync(
options: RocksDBOptions, bytes: u64);
pub fn rocksdb_options_set_disable_data_sync(
options: RocksDBOptions, v: c_int);
pub fn rocksdb_options_optimize_for_point_lookup(
options: RocksDBOptions, block_cache_size_mb: u64);
pub fn rocksdb_options_set_table_cache_numshardbits(
options: RocksDBOptions, bits: u64);
pub fn rocksdb_options_set_max_write_buffer_number(
options: RocksDBOptions, bufno: c_int);
pub fn rocksdb_options_set_min_write_buffer_number_to_merge(
options: RocksDBOptions, bufno: c_int);
pub fn rocksdb_options_set_level0_file_num_compaction_trigger(
options: RocksDBOptions, no: c_int);
pub fn rocksdb_options_set_level0_slowdown_writes_trigger(
options: RocksDBOptions, no: c_int);
pub fn rocksdb_options_set_level0_stop_writes_trigger(
options: RocksDBOptions, no: c_int);
pub fn rocksdb_options_set_write_buffer_size(
options: RocksDBOptions, bytes: u64);
pub fn rocksdb_options_set_target_file_size_base(
options: RocksDBOptions, bytes: u64);
pub fn rocksdb_options_set_target_file_size_multiplier(
options: RocksDBOptions, mul: c_int);
pub fn rocksdb_options_set_max_log_file_size(
options: RocksDBOptions, bytes: u64);
pub fn rocksdb_options_set_max_manifest_file_size(
options: RocksDBOptions, bytes: u64);
pub fn rocksdb_options_set_hash_skip_list_rep(
options: RocksDBOptions, bytes: u64, a1: i32, a2: i32);
pub fn rocksdb_options_set_compaction_style(
options: RocksDBOptions, cs: RocksDBCompactionStyle);
pub fn rocksdb_options_set_compression(
options: RocksDBOptions, compression_style_no: c_int);
pub fn rocksdb_options_set_max_background_compactions(
options: RocksDBOptions, max_bg_compactions: c_int);
pub fn rocksdb_options_set_max_background_flushes(
options: RocksDBOptions, max_bg_flushes: c_int);
pub fn rocksdb_options_set_filter_deletes(
options: RocksDBOptions, v: u8);
//pub fn rocksdb_compactionfilter_create() -> RocksDBCompactionFilter;
pub fn rocksdb_filterpolicy_create_bloom(
bits_per_key: c_int) -> RocksDBFilterPolicy;
pub fn rocksdb_open(options: RocksDBOptions,
path: *const i8, err: *mut i8) -> RocksDBInstance;
pub fn rocksdb_writeoptions_create() -> RocksDBWriteOptions;
pub fn rocksdb_put(db: RocksDBInstance, writeopts: RocksDBWriteOptions,
k: *const u8, kLen: size_t, v: *const u8,
vLen: size_t, err: *mut i8);
pub fn rocksdb_readoptions_create() -> RocksDBReadOptions;
pub fn rocksdb_get(db: RocksDBInstance, readopts: RocksDBReadOptions,
k: *const u8, kLen: size_t,
valLen: *const size_t, err: *mut i8) -> *mut c_void;
pub fn rocksdb_delete(db: RocksDBInstance, writeopts: RocksDBWriteOptions,
k: *const u8, kLen: size_t, err: *mut i8) -> *mut c_void;
pub fn rocksdb_close(db: RocksDBInstance);
pub fn rocksdb_destroy_db(
options: RocksDBOptions, path: *const i8, err: *mut i8);
pub fn rocksdb_repair_db(
options: RocksDBOptions, path: *const i8, err: *mut i8);
pub fn rocksdb_options_create() -> RocksDBOptions;
pub fn rocksdb_options_increase_parallelism(
options: RocksDBOptions, threads: c_int);
pub fn rocksdb_options_optimize_level_style_compaction(
options: RocksDBOptions, memtable_memory_budget: c_int);
pub fn rocksdb_options_set_create_if_missing(
options: RocksDBOptions, v: c_int);
pub fn rocksdb_options_set_max_open_files(
options: RocksDBOptions, files: c_int);
pub fn rocksdb_options_set_use_fsync(
options: RocksDBOptions, v: c_int);
pub fn rocksdb_options_set_bytes_per_sync(
options: RocksDBOptions, bytes: u64);
pub fn rocksdb_options_set_disable_data_sync(
options: RocksDBOptions, v: c_int);
pub fn rocksdb_options_optimize_for_point_lookup(
options: RocksDBOptions, block_cache_size_mb: u64);
pub fn rocksdb_options_set_table_cache_numshardbits(
options: RocksDBOptions, bits: u64);
pub fn rocksdb_options_set_max_write_buffer_number(
options: RocksDBOptions, bufno: c_int);
pub fn rocksdb_options_set_min_write_buffer_number_to_merge(
options: RocksDBOptions, bufno: c_int);
pub fn rocksdb_options_set_level0_file_num_compaction_trigger(
options: RocksDBOptions, no: c_int);
pub fn rocksdb_options_set_level0_slowdown_writes_trigger(
options: RocksDBOptions, no: c_int);
pub fn rocksdb_options_set_level0_stop_writes_trigger(
options: RocksDBOptions, no: c_int);
pub fn rocksdb_options_set_write_buffer_size(
options: RocksDBOptions, bytes: u64);
pub fn rocksdb_options_set_target_file_size_base(
options: RocksDBOptions, bytes: u64);
pub fn rocksdb_options_set_target_file_size_multiplier(
options: RocksDBOptions, mul: c_int);
pub fn rocksdb_options_set_max_log_file_size(
options: RocksDBOptions, bytes: u64);
pub fn rocksdb_options_set_max_manifest_file_size(
options: RocksDBOptions, bytes: u64);
pub fn rocksdb_options_set_hash_skip_list_rep(
options: RocksDBOptions, bytes: u64, a1: i32, a2: i32);
pub fn rocksdb_options_set_compaction_style(
options: RocksDBOptions, cs: RocksDBCompactionStyle);
pub fn rocksdb_options_set_compression(
options: RocksDBOptions, compression_style_no: c_int);
pub fn rocksdb_options_set_max_background_compactions(
options: RocksDBOptions, max_bg_compactions: c_int);
pub fn rocksdb_options_set_max_background_flushes(
options: RocksDBOptions, max_bg_flushes: c_int);
pub fn rocksdb_options_set_filter_deletes(
options: RocksDBOptions, v: u8);
//pub fn rocksdb_compactionfilter_create() -> RocksDBCompactionFilter;
pub fn rocksdb_filterpolicy_create_bloom(
bits_per_key: c_int) -> RocksDBFilterPolicy;
pub fn rocksdb_open(options: RocksDBOptions,
path: *const i8, err: *mut i8) -> RocksDBInstance;
pub fn rocksdb_writeoptions_create() -> RocksDBWriteOptions;
pub fn rocksdb_put(db: RocksDBInstance, writeopts: RocksDBWriteOptions,
k: *const u8, kLen: size_t, v: *const u8,
vLen: size_t, err: *mut i8);
pub fn rocksdb_readoptions_create() -> RocksDBReadOptions;
pub fn rocksdb_get(db: RocksDBInstance, readopts: RocksDBReadOptions,
k: *const u8, kLen: size_t,
valLen: *const size_t, err: *mut i8) -> *mut c_void;
pub fn rocksdb_delete(db: RocksDBInstance, writeopts: RocksDBWriteOptions,
k: *const u8, kLen: size_t, err: *mut i8) -> *mut c_void;
pub fn rocksdb_close(db: RocksDBInstance);
pub fn rocksdb_destroy_db(
options: RocksDBOptions, path: *const i8, err: *mut i8);
pub fn rocksdb_repair_db(
options: RocksDBOptions, path: *const i8, err: *mut i8);
// Merge Operator
pub fn rocksdb_mergeoperator_create(
state: *mut c_void,
destroy: extern fn(*mut c_void) -> (),
full_merge: extern fn (
arg: *mut c_void, key: *const c_char, key_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,
num_operands: c_int,
success: *mut u8, new_value_length: *mut size_t
) -> *const c_char,
partial_merge: extern fn(
*mut c_void, key: *const c_char, key_len: *mut size_t,
operands_list: &[*const c_char], operands_list_len: *const size_t,
num_operands: c_int,
success: *mut u8, new_value_length: *mut size_t
) -> *const c_char,
delete_value: extern fn(*mut c_void, value: *const c_char, value_len: *mut size_t) -> (),
name_fn: extern fn(*mut c_void) -> *const c_char,
) -> RocksDBMergeOperator;
pub fn rocksdb_mergeoperator_destroy(mo: RocksDBMergeOperator);
pub fn rocksdb_options_set_merge_operator(
options: RocksDBOptions,
mo: RocksDBMergeOperator);
// Merge Operator
pub fn rocksdb_mergeoperator_create(
state: *mut c_void,
destroy: extern fn(*mut c_void) -> (),
full_merge: extern fn (
arg: *mut c_void, key: *const c_char, key_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,
num_operands: c_int,
success: *mut u8, new_value_length: *mut size_t
) -> *const c_char,
partial_merge: extern fn(
*mut c_void, key: *const c_char, key_len: *mut size_t,
operands_list: &[*const c_char], operands_list_len: *const size_t,
num_operands: c_int,
success: *mut u8, new_value_length: *mut size_t
) -> *const c_char,
delete_value: extern fn(*mut c_void, value: *const c_char,
value_len: *mut size_t) -> (),
name_fn: extern fn(*mut c_void) -> *const c_char,
) -> RocksDBMergeOperator;
pub fn rocksdb_mergeoperator_destroy(mo: RocksDBMergeOperator);
pub fn rocksdb_options_set_merge_operator(
options: RocksDBOptions,
mo: RocksDBMergeOperator);
}
#[allow(dead_code)]
#[test]
fn internal() {
unsafe {
let opts = rocksdb_options_create();
let RocksDBOptions(opt_ptr) = opts;
assert!(opt_ptr.is_not_null());
unsafe {
let opts = rocksdb_options_create();
let RocksDBOptions(opt_ptr) = opts;
assert!(opt_ptr.is_not_null());
rocksdb_options_increase_parallelism(opts, 0);
rocksdb_options_optimize_level_style_compaction(opts, 0);
rocksdb_options_set_create_if_missing(opts, 1);
rocksdb_options_increase_parallelism(opts, 0);
rocksdb_options_optimize_level_style_compaction(opts, 0);
rocksdb_options_set_create_if_missing(opts, 1);
let rustpath = "internaltest";
let cpath = rustpath.to_c_str();
let cpath_ptr = cpath.as_ptr();
let rustpath = "internaltest";
let cpath = rustpath.to_c_str();
let cpath_ptr = cpath.as_ptr();
let err = 0 as *mut i8;
let db = rocksdb_open(opts, cpath_ptr, err);
assert!(err.is_null());
libc::free(err as *mut c_void);
let err = 0 as *mut i8;
let db = rocksdb_open(opts, cpath_ptr, err);
assert!(err.is_null());
libc::free(err as *mut c_void);
let writeopts = rocksdb_writeoptions_create();
let RocksDBWriteOptions(write_opt_ptr) = writeopts;
assert!(write_opt_ptr.is_not_null());
let writeopts = rocksdb_writeoptions_create();
let RocksDBWriteOptions(write_opt_ptr) = writeopts;
assert!(write_opt_ptr.is_not_null());
let key = b"name\x00";
let val = b"spacejam\x00";
let key = b"name\x00";
let val = b"spacejam\x00";
rocksdb_put(db, writeopts, key.as_ptr(), 4, val.as_ptr(), 8, err);
assert!(err.is_null());
libc::free(err as *mut c_void);
rocksdb_put(db, writeopts, key.as_ptr(), 4, val.as_ptr(), 8, err);
assert!(err.is_null());
libc::free(err as *mut c_void);
let readopts = rocksdb_readoptions_create();
let RocksDBReadOptions(read_opts_ptr) = readopts;
assert!(read_opts_ptr.is_not_null());
libc::free(err as *mut c_void);
let readopts = rocksdb_readoptions_create();
let RocksDBReadOptions(read_opts_ptr) = readopts;
assert!(read_opts_ptr.is_not_null());
libc::free(err as *mut c_void);
let val_len: size_t = 0;
let val_len_ptr = &val_len as *const size_t;
rocksdb_get(db, readopts, key.as_ptr(), 4, val_len_ptr, err);
assert!(err.is_null());
libc::free(err as *mut c_void);
rocksdb_close(db);
}
let val_len: size_t = 0;
let val_len_ptr = &val_len as *const size_t;
rocksdb_get(db, readopts, key.as_ptr(), 4, val_len_ptr, err);
assert!(err.is_null());
libc::free(err as *mut c_void);
rocksdb_close(db);
}
}
src/lib.rs
View file @ e585d23e
......@@ -4,8 +4,8 @@
pub use ffi as rocksdb_ffi;
pub use rocksdb::{
RocksDB,
RocksDBResult,
RocksDB,
RocksDBResult,
};
pub mod rocksdb;
pub mod ffi;
src/main.rs
View file @ e585d23e
......@@ -5,53 +5,52 @@ use test::Bencher;
#[allow(dead_code)]
fn main() {
match RocksDB::open_default("/tmp/rust-rocksdb") {
Ok(db) => {
assert!(db.put(b"my key", b"my value").is_ok());
match RocksDB::open_default("/tmp/rust-rocksdb") {
Ok(db) => {
assert!(db.put(b"my key", b"my value").is_ok());
db.get(b"my key").map( |value| {
match value.to_utf8() {
Some(v) =>
println!("retrieved utf8 value: {}", v),
None =>
println!("did not read valid utf-8 out of the db"),
}
})
.on_absent( || { println!("value not found") })
.on_error( |e| { println!("error retrieving value: {}", e) });
db.get(b"my key").map( |value| {
match value.to_utf8() {
Some(v) =>
println!("retrieved utf8 value: {}", v),
None =>
println!("did not read valid utf-8 out of the db"),
}
})
.on_absent( || { println!("value not found") })
.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();
},
Err(e) => panic!(e),
}
db.close();
},
Err(e) => panic!(e),
}
}
#[allow(dead_code)]
#[bench]
fn writes(b: &mut Bencher) {
let db = RocksDB::open_default("testdb").unwrap();
let mut i = 0 as u64;
b.iter(|| {
db.put(i.to_string().as_bytes(), b"v1111");
i += 1;
});
db.close();
let db = RocksDB::open_default("testdb").unwrap();
let mut i = 0 as u64;
b.iter(|| {
db.put(i.to_string().as_bytes(), b"v1111");
i += 1;
});
db.close();
}
#[allow(dead_code)]
#[bench]
fn reads(b: &mut Bencher) {
let db = RocksDB::open_default("testdb").unwrap();
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.close();
let db = RocksDB::open_default("testdb").unwrap();
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.close();
}
src/rocksdb.rs
View file @ e585d23e
......@@ -8,284 +8,292 @@ use std::str::from_utf8;
use rocksdb_ffi;
pub struct RocksDBOptions {
inner: rocksdb_ffi::RocksDBOptions,
inner: rocksdb_ffi::RocksDBOptions,
}
impl RocksDBOptions {
pub fn new() -> RocksDBOptions {
unsafe {
let opts = rocksdb_ffi::rocksdb_options_create();
let rocksdb_ffi::RocksDBOptions(opt_ptr) = opts;
if opt_ptr.is_null() {
panic!("Could not create rocksdb options".to_string());
}
pub fn new() -> RocksDBOptions {
unsafe {
let opts = rocksdb_ffi::rocksdb_options_create();
let rocksdb_ffi::RocksDBOptions(opt_ptr) = opts;
if opt_ptr.is_null() {
panic!("Could not create rocksdb options".to_string());
}
RocksDBOptions{inner: opts}
RocksDBOptions{inner: opts}
}
}
}
pub fn increase_parallelism(&self, parallelism: i32) {
unsafe {
rocksdb_ffi::rocksdb_options_increase_parallelism(self.inner, parallelism);
pub fn increase_parallelism(&self, parallelism: i32) {
unsafe {
rocksdb_ffi::rocksdb_options_increase_parallelism(
self.inner, parallelism);
}
}
}
pub fn optimize_level_style_compaction(&self, memtable_memory_budget: i32) {
unsafe {
rocksdb_ffi::rocksdb_options_optimize_level_style_compaction(self.inner, memtable_memory_budget);
pub fn optimize_level_style_compaction(&self,
memtable_memory_budget: i32) {
unsafe {
rocksdb_ffi::rocksdb_options_optimize_level_style_compaction(
self.inner, memtable_memory_budget);
}
}
}
pub fn create_if_missing(&self, create_if_missing: bool) {
unsafe {
match create_if_missing {
true => rocksdb_ffi::rocksdb_options_set_create_if_missing(self.inner, 1),
false => rocksdb_ffi::rocksdb_options_set_create_if_missing(self.inner, 0),
}
pub fn create_if_missing(&self, create_if_missing: bool) {
unsafe {
match create_if_missing {
true => rocksdb_ffi::rocksdb_options_set_create_if_missing(
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) {
unsafe {
rocksdb_ffi::rocksdb_options_set_merge_operator(self.inner, mo);
pub fn set_merge_operator(&self, mo: rocksdb_ffi::RocksDBMergeOperator) {
unsafe {
rocksdb_ffi::rocksdb_options_set_merge_operator(self.inner, mo);
}
}
}
}
pub struct RocksDB {
inner: rocksdb_ffi::RocksDBInstance,
inner: rocksdb_ffi::RocksDBInstance,
}
impl RocksDB {
pub fn open_default(path: &str) -> Result<RocksDB, String> {
let opts = RocksDBOptions::new();
opts.create_if_missing(true);
RocksDB::open(opts, path)
}
pub fn open_default(path: &str) -> Result<RocksDB, String> {
let opts = RocksDBOptions::new();
opts.create_if_missing(true);
RocksDB::open(opts, path)
}
pub fn open(opts: RocksDBOptions, path: &str) -> Result<RocksDB, String> {
unsafe {
let cpath = path.to_c_str();
let cpath_ptr = cpath.as_ptr();
pub fn open(opts: RocksDBOptions, path: &str) -> Result<RocksDB, String> {
unsafe {
let cpath = path.to_c_str();
let cpath_ptr = cpath.as_ptr();
//TODO test path here, as if rocksdb fails it will just crash the
// process currently
//TODO test path here, as if rocksdb fails it will just crash the
// process currently
let err = 0 as *mut i8;
let db = rocksdb_ffi::rocksdb_open(opts.inner, cpath_ptr, err);
let rocksdb_ffi::RocksDBInstance(db_ptr) = db;
if err.is_not_null() {
let cs = CString::new(err as *const i8, true);
match cs.as_str() {
Some(error_string) =>
return Err(error_string.to_string()),
None =>
return Err("Could not initialize database.".to_string()),
let err = 0 as *mut i8;
let db = rocksdb_ffi::rocksdb_open(opts.inner, cpath_ptr, err);
let rocksdb_ffi::RocksDBInstance(db_ptr) = db;
if err.is_not_null() {
let cs = CString::new(err as *const i8, true);
match cs.as_str() {
Some(error_string) =>
return Err(error_string.to_string()),
None =>
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> {
unsafe {
let writeopts = rocksdb_ffi::rocksdb_writeoptions_create();
let err = 0 as *mut i8;
rocksdb_ffi::rocksdb_put(self.inner, writeopts, key.as_ptr(),
key.len() as size_t, value.as_ptr(),
value.len() as size_t, err);
if err.is_not_null() {
let cs = CString::new(err as *const i8, true);
match cs.as_str() {
Some(error_string) =>
return Err(error_string.to_string()),
None => {
let ie = IoError::last_error();
return Err(format!(
"ERROR: desc:{}, details:{}",
ie.desc,
ie.detail.unwrap_or_else(
|| {"none provided by OS".to_string()})))
}
pub fn put(&self, key: &[u8], value: &[u8]) -> Result<(), String> {
unsafe {
let writeopts = rocksdb_ffi::rocksdb_writeoptions_create();
let err = 0 as *mut i8;
rocksdb_ffi::rocksdb_put(self.inner, writeopts, key.as_ptr(),
key.len() as size_t, value.as_ptr(),
value.len() as size_t, err);
if err.is_not_null() {
let cs = CString::new(err as *const i8, true);
match cs.as_str() {
Some(error_string) =>
return Err(error_string.to_string()),
None => {
let ie = IoError::last_error();
return Err(format!(
"ERROR: desc:{}, details:{}",
ie.desc,
ie.detail.unwrap_or_else(
|| {"none provided by OS".to_string()})))
}
}
}
return Ok(())
}
}
return Ok(())
}
}
pub fn get<'a>(&self, key: &[u8]) -> RocksDBResult<'a, RocksDBVector, String> {
unsafe {
let readopts = rocksdb_ffi::rocksdb_readoptions_create();
let rocksdb_ffi::RocksDBReadOptions(read_opts_ptr) = readopts;
if read_opts_ptr.is_null() {
return RocksDBResult::Error("Unable to create rocksdb read \
options. This is a fairly trivial call, and its failure \
may be indicative of a mis-compiled or mis-loaded rocksdb \
library.".to_string());
}
pub fn get<'a>(&self, key: &[u8]) ->
RocksDBResult<'a, RocksDBVector, String> {
unsafe {
let readopts = rocksdb_ffi::rocksdb_readoptions_create();
let rocksdb_ffi::RocksDBReadOptions(read_opts_ptr) = readopts;
if read_opts_ptr.is_null() {
return RocksDBResult::Error("Unable to create rocksdb read \
options. This is a fairly trivial call, and its failure \
may be indicative of a mis-compiled or mis-loaded rocksdb \
library.".to_string());
}
let val_len: size_t = 0;
let val_len_ptr = &val_len as *const size_t;
let err = 0 as *mut i8;
let val = rocksdb_ffi::rocksdb_get(self.inner, readopts, key.as_ptr(),
key.len() as size_t, val_len_ptr, err) as *mut u8;
if err.is_not_null() {
let cs = CString::new(err as *const i8, true);
match cs.as_str() {
Some(error_string) =>
return RocksDBResult::Error(error_string.to_string()),
None =>
return RocksDBResult::Error("Unable to get value from \
rocksdb. (non-utf8 error received from underlying \
library)".to_string()),
}
}
match val.is_null() {
true => RocksDBResult::None,
false => {
RocksDBResult::Some(RocksDBVector::from_c(val, val_len))
let val_len: size_t = 0;
let val_len_ptr = &val_len as *const size_t;
let err = 0 as *mut i8;
let val = rocksdb_ffi::rocksdb_get(self.inner, readopts,
key.as_ptr(), key.len() as size_t, val_len_ptr, err) as *mut u8;
if err.is_not_null() {
let cs = CString::new(err as *const i8, true);
match cs.as_str() {
Some(error_string) =>
return RocksDBResult::Error(error_string.to_string()),
None =>
return RocksDBResult::Error("Unable to get value from \
rocksdb. (non-utf8 error received from underlying \
library)".to_string()),
}
}
match val.is_null() {
true => RocksDBResult::None,
false => {
RocksDBResult::Some(RocksDBVector::from_c(val, val_len))
}
}
}
}
}
}
pub fn delete(&self, key: &[u8]) -> Result<(),String> {
unsafe {
let writeopts = rocksdb_ffi::rocksdb_writeoptions_create();
let err = 0 as *mut i8;
rocksdb_ffi::rocksdb_delete(self.inner, writeopts, key.as_ptr(),
key.len() as size_t, err);
if err.is_not_null() {
let cs = CString::new(err as *const i8, true);
match cs.as_str() {
Some(error_string) =>
return Err(error_string.to_string()),
None => {
let ie = IoError::last_error();
return Err(format!(
"ERROR: desc:{}, details:{}",
ie.desc,
ie.detail.unwrap_or_else(
|| {"none provided by OS".to_string()})))
}
pub fn delete(&self, key: &[u8]) -> Result<(),String> {
unsafe {
let writeopts = rocksdb_ffi::rocksdb_writeoptions_create();
let err = 0 as *mut i8;
rocksdb_ffi::rocksdb_delete(self.inner, writeopts, key.as_ptr(),
key.len() as size_t, err);
if err.is_not_null() {
let cs = CString::new(err as *const i8, true);
match cs.as_str() {
Some(error_string) =>
return Err(error_string.to_string()),
None => {
let ie = IoError::last_error();
return Err(format!(
"ERROR: desc:{}, details:{}",
ie.desc,
ie.detail.unwrap_or_else(
|| {"none provided by OS".to_string()})))
}
}
}
return Ok(())
}
}
return Ok(())
}
}
pub fn close(&self) {
unsafe { rocksdb_ffi::rocksdb_close(self.inner); }
}
pub fn close(&self) {
unsafe { rocksdb_ffi::rocksdb_close(self.inner); }
}
}
pub struct RocksDBVector {
inner: CVec<u8>,
inner: CVec<u8>,
}
impl RocksDBVector {
pub fn from_c(val: *mut u8, val_len: size_t) -> RocksDBVector {
unsafe {
RocksDBVector {
inner:
CVec::new_with_dtor(val, val_len as uint,
proc(){ libc::free(val as *mut c_void); })
}
pub fn from_c(val: *mut u8, val_len: size_t) -> RocksDBVector {
unsafe {
RocksDBVector {
inner:
CVec::new_with_dtor(val, val_len as uint,
proc(){ libc::free(val as *mut c_void); })
}
}
}
}
pub fn as_slice<'a>(&'a self) -> &'a [u8] {
self.inner.as_slice()
}
pub fn as_slice<'a>(&'a self) -> &'a [u8] {
self.inner.as_slice()
}
pub fn to_utf8<'a>(&'a self) -> Option<&'a str> {
from_utf8(self.inner.as_slice())
}
pub fn to_utf8<'a>(&'a self) -> Option<&'a str> {
from_utf8(self.inner.as_slice())
}
}
// RocksDBResult exists because of the inherent difference between
// an operational failure and the absence of a possible result.
#[deriving(Clone, PartialEq, PartialOrd, Eq, Ord, Show)]
pub enum RocksDBResult<'a,T,E> {
Some(T),
None,
Error(E),
Some(T),
None,
Error(E),
}
impl <'a,T,E> RocksDBResult<'a,T,E> {
#[unstable = "waiting for unboxed closures"]
pub fn map<U>(self, f: |T| -> U) -> RocksDBResult<U,E> {
match self {
RocksDBResult::Some(x) => RocksDBResult::Some(f(x)),
RocksDBResult::None => RocksDBResult::None,
RocksDBResult::Error(e) => RocksDBResult::Error(e),
#[unstable = "waiting for unboxed closures"]
pub fn map<U>(self, f: |T| -> U) -> RocksDBResult<U,E> {
match self {
RocksDBResult::Some(x) => RocksDBResult::Some(f(x)),
RocksDBResult::None => RocksDBResult::None,
RocksDBResult::Error(e) => RocksDBResult::Error(e),
}
}
}
pub fn unwrap(self) -> T {
match self {
RocksDBResult::Some(x) => x,
RocksDBResult::None => panic!("Attempted unwrap on RocksDBResult::None"),
RocksDBResult::Error(_) => panic!("Attempted unwrap on RocksDBResult::Error"),
pub fn unwrap(self) -> T {
match self {
RocksDBResult::Some(x) => x,
RocksDBResult::None =>
panic!("Attempted unwrap on RocksDBResult::None"),
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> {
match self {
RocksDBResult::Some(x) => RocksDBResult::Some(x),
RocksDBResult::None => RocksDBResult::None,
RocksDBResult::Error(e) => RocksDBResult::Error(f(e)),
#[unstable = "waiting for unboxed closures"]
pub fn on_error<U>(self, f: |E| -> U) -> RocksDBResult<T,U> {
match self {
RocksDBResult::Some(x) => RocksDBResult::Some(x),
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> {
match self {
RocksDBResult::Some(x) => RocksDBResult::Some(x),
RocksDBResult::None => {
f();
RocksDBResult::None
},
RocksDBResult::Error(e) => RocksDBResult::Error(e),
#[unstable = "waiting for unboxed closures"]
pub fn on_absent(self, f: || -> ()) -> RocksDBResult<T,E> {
match self {
RocksDBResult::Some(x) => RocksDBResult::Some(x),
RocksDBResult::None => {
f();
RocksDBResult::None
},
RocksDBResult::Error(e) => RocksDBResult::Error(e),
}
}
}
pub fn is_some(self) -> bool {
match self {
RocksDBResult::Some(_) => true,
RocksDBResult::None => false,
RocksDBResult::Error(_) => false,
pub fn is_some(self) -> bool {
match self {
RocksDBResult::Some(_) => true,
RocksDBResult::None => false,
RocksDBResult::Error(_) => false,
}
}
}
pub fn is_none(self) -> bool {
match self {
RocksDBResult::Some(_) => false,
RocksDBResult::None => true,
RocksDBResult::Error(_) => false,
pub fn is_none(self) -> bool {
match self {
RocksDBResult::Some(_) => false,
RocksDBResult::None => true,
RocksDBResult::Error(_) => false,
}
}
}
pub fn is_error(self) -> bool {
match self {
RocksDBResult::Some(_) => false,
RocksDBResult::None => false,
RocksDBResult::Error(_) => true,
pub fn is_error(self) -> bool {
match self {
RocksDBResult::Some(_) => false,
RocksDBResult::None => false,
RocksDBResult::Error(_) => true,
}
}
}
}
#[allow(dead_code)]
#[test]
fn external() {
let db = RocksDB::open_default("externaltest").unwrap();
let p = db.put(b"k1", b"v1111");
assert!(p.is_ok());
let r: RocksDBResult<RocksDBVector, String> = db.get(b"k1");
assert!(r.unwrap().to_utf8().unwrap() == "v1111");
assert!(db.delete(b"k1").is_ok());
assert!(db.get(b"k1").is_none());
db.close();
let db = RocksDB::open_default("externaltest").unwrap();
let p = db.put(b"k1", b"v1111");
assert!(p.is_ok());
let r: RocksDBResult<RocksDBVector, String> = db.get(b"k1");
assert!(r.unwrap().to_utf8().unwrap() == "v1111");
assert!(db.delete(b"k1").is_ok());
assert!(db.get(b"k1").is_none());
db.close();
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment