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

some more scratchings, rudimentary structuring, added more 'features' (bugs)

Browse Source
master
Tyler Neely 10 years ago
parent e3b7fbd052
commit 55a67bee83
6 changed files with 298 additions and 182 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. 3
      .gitignore
  2. 4
      Cargo.lock
  3. 2
      Cargo.toml
  4. 185
      src/lib.rs
  5. 30
      src/main.rs
  6. 256
      src/rocksdb.rs

3
.gitignore vendored
Unescape View File

@ -0,0 +1,3 @@
*.swp
target
Cargo.lock

4
Cargo.lock generated
Unescape View File

@ -1,4 +0,0 @@
[root]
name = "rust-rocksdb"
version = "0.0.1"

2
Cargo.toml
Unescape View File

@ -1,5 +1,5 @@
[package]
name = "rust-rocksdb"
name = "rocksdb"
version = "0.0.1"
authors = ["Tyler Neely <t@jujit.su>"]

185
src/lib.rs
Unescape View File

@ -1,177 +1,8 @@
extern crate libc;
use libc::{c_int, c_void, size_t};
use std::io::{IoResult, IoError, BufferedStream};
use std::c_vec::CVec;
#[repr(C)]
struct RocksdbOptions(*const c_void);
#[repr(C)]
struct RocksdbInstance(*const c_void);
#[repr(C)]
struct RocksdbWriteOptions(*const c_void);
#[repr(C)]
struct RocksdbReadOptions(*const c_void);
#[link(name = "rocksdb")]
extern {
fn rocksdb_options_create() -> RocksdbOptions;
fn rocksdb_options_increase_parallelism(
options: RocksdbOptions, threads: c_int);
fn rocksdb_options_optimize_level_style_compaction(
options: RocksdbOptions, memtable_memory_budget: c_int);
fn rocksdb_options_set_create_if_missing(
options: RocksdbOptions, v: c_int);
fn rocksdb_open(options: RocksdbOptions,
path: *const i8, err: *mut i8) -> RocksdbInstance;
fn rocksdb_writeoptions_create() -> RocksdbWriteOptions;
fn rocksdb_put(db: RocksdbInstance, writeopts: RocksdbWriteOptions,
k: *const u8, kLen: size_t, v: *const u8,
vLen: size_t, err: *mut i8);
fn rocksdb_readoptions_create() -> RocksdbReadOptions;
fn rocksdb_get(db: RocksdbInstance, readopts: RocksdbReadOptions,
k: *const u8, kLen: size_t,
valLen: *const size_t, err: *mut i8) -> *mut u8;
fn rocksdb_close(db: RocksdbInstance);
}
pub struct Rocksdb {
inner: RocksdbInstance,
}
impl Rocksdb {
pub fn open(path: &str, create_if_missing: bool) -> IoResult<Rocksdb> {
unsafe {
let opts = rocksdb_options_create();
let RocksdbOptions(opt_ptr) = opts;
if opt_ptr.is_null() {
return Err(IoError::last_error());
}
rocksdb_options_increase_parallelism(opts, 0);
rocksdb_options_optimize_level_style_compaction(opts, 0);
match create_if_missing {
true => rocksdb_options_set_create_if_missing(opts, 1),
false => rocksdb_options_set_create_if_missing(opts, 0),
}
let cpath = path.to_c_str();
let cpath_ptr = cpath.as_ptr();
let err = 0 as *mut i8;
let db = rocksdb_open(opts, cpath_ptr, err);
let RocksdbInstance(db_ptr) = db;
if err.is_not_null() {
libc::free(err as *mut c_void);
return Err(IoError::last_error());
}
libc::free(err as *mut c_void);
if db_ptr.is_null() {
return Err(IoError::last_error());
}
Ok(Rocksdb{inner: db})
}
}
pub fn put(&self, key: &[u8], value: &[u8]) -> IoResult<bool> {
unsafe {
let writeopts = rocksdb_writeoptions_create();
let err = 0 as *mut i8;
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() {
libc::free(err as *mut c_void);
return Err(IoError::last_error());
}
libc::free(err as *mut c_void);
return Ok(true)
}
}
pub fn get(&self, key: &[u8]) -> IoResult<CVec<u8>> {
unsafe {
let readopts = rocksdb_readoptions_create();
let RocksdbReadOptions(read_opts_ptr) = readopts;
if read_opts_ptr.is_null() {
return Err(IoError::last_error());
}
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_get(self.inner, readopts, key.as_ptr(),
key.len() as size_t, val_len_ptr, err);
if err.is_not_null() {
libc::free(err as *mut c_void);
return Err(IoError::last_error());
}
libc::free(err as *mut c_void);
return Ok(CVec::new_with_dtor(val, val_len as uint,
proc(){
libc::free(val as *mut c_void);
}))
}
}
pub fn close(&self) {
unsafe { rocksdb_close(self.inner); }
}
}
#[test]
fn external() {
let db = Rocksdb::open("testdb", true).unwrap();
db.put(b"k1", b"v1111");
let r = db.get(b"k1").unwrap();
assert!(r.len() == 5);
let v = r.get(0).unwrap();
db.close();
}
#[test]
fn internal() {
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);
let rustpath = "datadir";
let cpath = rustpath.to_c_str();
let cpath_ptr = cpath.as_ptr();
//TODO this will SIGSEGV
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 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);
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 mut 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);
}
}
#![crate_id = "rocksdb"]
#![crate_type = "lib"]
pub use rocksdb::{
open,
Rocksdb,
};
pub mod rocksdb;

30
src/main.rs
Unescape View File

@ -0,0 +1,30 @@
extern crate rocksdb;
extern crate test;
use rocksdb::open;
use test::Bencher;
fn main() {
println!("test");
}
#[bench]
fn writes(b: &mut Bencher) {
let db = open("testdb".to_string(), true).unwrap();
let mut i = 0 as u64;
b.iter(|| {
db.put(i.to_string().as_bytes(), b"v1111");
i += 1;
});
db.close();
}
#[bench]
fn reads(b: &mut Bencher) {
let db = open("testdb".to_string(), true).unwrap();
let mut i = 0 as u64;
b.iter(|| {
db.get(i.to_string().as_bytes());
i += 1;
});
db.close();
}

256
src/rocksdb.rs
Unescape View File

@ -0,0 +1,256 @@
extern crate libc;
use self::libc::{c_int, c_void, size_t};
use std::io::{IoResult, IoError, BufferedStream};
use std::c_vec::CVec;
#[repr(C)]
struct RocksdbOptions(*const c_void);
#[repr(C)]
struct RocksdbInstance(*const c_void);
#[repr(C)]
struct RocksdbWriteOptions(*const c_void);
#[repr(C)]
struct RocksdbReadOptions(*const c_void);
#[repr(C)]
struct RocksdbCompactionFilter(*const c_void);
#[repr(C)]
struct RocksdbMergeOperator(*const c_void);
#[repr(C)]
struct RocksdbFilterPolicy(*const c_void);
#[repr(C)]
enum RocksdbCompressionType {
RocksdbNoCompression = 0,
RocksdbSnappyCompression = 1,
RocksdbZlibCompression = 2,
RocksdbBz2Compression = 3,
RocksdbLz4Compression = 4,
RocksdbLz4hcCompression = 5
}
#[repr(C)]
enum RocksdbCompactionStyle {
RocksdbLevelCompaction = 0,
RocksdbUniversalCompaction = 1,
RocksdbFifoCompaction = 2
}
#[repr(C)]
enum RocksdbUniversalCompactionStyle {
rocksdb_similar_size_compaction_stop_style = 0,
rocksdb_total_size_compaction_stop_style = 1
}
#[link(name = "rocksdb")]
extern {
fn rocksdb_options_create() -> RocksdbOptions;
fn rocksdb_options_increase_parallelism(
options: RocksdbOptions, threads: c_int);
fn rocksdb_options_optimize_level_style_compaction(
options: RocksdbOptions, memtable_memory_budget: c_int);
fn rocksdb_options_set_create_if_missing(
options: RocksdbOptions, v: c_int);
fn rocksdb_options_set_max_open_files(
options: RocksdbOptions, files: c_int);
fn rocksdb_options_set_use_fsync(
options: RocksdbOptions, v: c_int);
fn rocksdb_options_set_bytes_per_sync(
options: RocksdbOptions, bytes: u64);
fn rocksdb_options_set_disable_data_sync(
options: RocksdbOptions, v: c_int);
fn rocksdb_options_optimize_for_point_lookup(
options: RocksdbOptions, block_cache_size_mb: u64);
fn rocksdb_options_set_table_cache_numshardbits(
options: RocksdbOptions, bits: u64);
fn rocksdb_options_set_max_write_buffer_number(
options: RocksdbOptions, bufno: c_int);
fn rocksdb_options_set_min_write_buffer_number_to_merge(
options: RocksdbOptions, bufno: c_int);
fn rocksdb_options_set_level0_file_num_compaction_trigger(
options: RocksdbOptions, no: c_int);
fn rocksdb_options_set_level0_slowdown_writes_trigger(
options: RocksdbOptions, no: c_int);
fn rocksdb_options_set_level0_stop_writes_trigger(
options: RocksdbOptions, no: c_int);
fn rocksdb_options_set_write_buffer_size(
options: RocksdbOptions, bytes: u64);
fn rocksdb_options_set_target_file_size_base(
options: RocksdbOptions, bytes: u64);
fn rocksdb_options_set_target_file_size_multiplier(
options: RocksdbOptions, mul: c_int);
fn rocksdb_options_set_max_log_file_size(
options: RocksdbOptions, bytes: u64);
fn rocksdb_options_set_max_manifest_file_size(
options: RocksdbOptions, bytes: u64);
fn rocksdb_options_set_hash_skip_list_rep(
options: RocksdbOptions, bytes: u64, a1: i32, a2: i32);
fn rocksdb_options_set_compaction_style(
options: RocksdbOptions, cs: RocksdbCompactionStyle);
fn rocksdb_options_set_compression(
options: RocksdbOptions, compression_style_no: c_int);
fn rocksdb_options_set_max_background_compactions(
options: RocksdbOptions, max_bg_compactions: c_int);
fn rocksdb_options_set_max_background_flushes(
options: RocksdbOptions, max_bg_flushes: c_int);
fn rocksdb_options_set_filter_deletes(
options: RocksdbOptions, v: u8);
//fn rocksdb_compactionfilter_create() -> RocksdbCompactionFilter;
//fn rocksdb_mergeoperator_create() -> RocksdbMergeOperator;
fn rocksdb_filterpolicy_create_bloom(
bits_per_key: c_int) -> RocksdbFilterPolicy;
fn rocksdb_open(options: RocksdbOptions,
path: *const i8, err: *mut i8) -> RocksdbInstance;
fn rocksdb_writeoptions_create() -> RocksdbWriteOptions;
fn rocksdb_put(db: RocksdbInstance, writeopts: RocksdbWriteOptions,
k: *const u8, kLen: size_t, v: *const u8,
vLen: size_t, err: *mut i8);
fn rocksdb_readoptions_create() -> RocksdbReadOptions;
fn rocksdb_get(db: RocksdbInstance, readopts: RocksdbReadOptions,
k: *const u8, kLen: size_t,
valLen: *const size_t, err: *mut i8) -> *mut u8;
fn rocksdb_close(db: RocksdbInstance);
}
pub struct Rocksdb {
inner: RocksdbInstance,
path: String,
}
impl Rocksdb {
pub fn put(&self, key: &[u8], value: &[u8]) -> IoResult<bool> {
unsafe {
let writeopts = rocksdb_writeoptions_create();
let err = 0 as *mut i8;
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() {
libc::free(err as *mut c_void);
return Err(IoError::last_error());
}
libc::free(err as *mut c_void);
return Ok(true)
}
}
pub fn get(&self, key: &[u8]) -> IoResult<CVec<u8>> {
unsafe {
let readopts = rocksdb_readoptions_create();
let RocksdbReadOptions(read_opts_ptr) = readopts;
if read_opts_ptr.is_null() {
return Err(IoError::last_error());
}
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_get(self.inner, readopts, key.as_ptr(),
key.len() as size_t, val_len_ptr, err);
if err.is_not_null() {
libc::free(err as *mut c_void);
return Err(IoError::last_error());
}
libc::free(err as *mut c_void);
return Ok(CVec::new_with_dtor(val, val_len as uint,
proc(){
libc::free(val as *mut c_void);
}))
}
}
pub fn close(&self) {
unsafe { rocksdb_close(self.inner); }
}
}
pub fn open(path: String, create_if_missing: bool) -> Result<Rocksdb, String> {
unsafe {
let opts = rocksdb_options_create();
let RocksdbOptions(opt_ptr) = opts;
if opt_ptr.is_null() {
return Err("Could not create options".to_string());
}
rocksdb_options_increase_parallelism(opts, 0);
rocksdb_options_optimize_level_style_compaction(opts, 0);
match create_if_missing {
true => rocksdb_options_set_create_if_missing(opts, 1),
false => rocksdb_options_set_create_if_missing(opts, 0),
}
let cpath = path.to_c_str();
let cpath_ptr = cpath.as_ptr();
let err = 0 as *mut i8;
let db = rocksdb_open(opts, cpath_ptr, err);
let RocksdbInstance(db_ptr) = db;
if err.is_not_null() {
libc::free(err as *mut c_void);
return Err("Could not initialize database.".to_string());
}
libc::free(err as *mut c_void);
if db_ptr.is_null() {
return Err("Could not initialize database.".to_string());
}
Ok(Rocksdb{inner: db, path: path})
}
}
#[test]
fn internal() {
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);
let rustpath = "datadir";
let cpath = rustpath.to_c_str();
let cpath_ptr = cpath.as_ptr();
//TODO this will SIGSEGV
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 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);
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 mut 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);
}
}
#[test]
fn external() {
let db = open("testdb".to_string(), true).unwrap();
db.put(b"k1", b"v1111");
let r = db.get(b"k1").unwrap();
assert!(r.len() == 5);
let v = r.get(0).unwrap();
db.close();
}
Write Preview
Loading…
Cancel
Save