// Copyright 2014 Tyler Neely // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // extern crate libc; use self::libc::{c_char, c_uchar, c_int, c_void, size_t}; use std::ffi::CStr; use std::str::from_utf8; pub enum DBOptionsOpaque {} pub type DBOptions = *const DBOptionsOpaque; pub enum DBInstanceOpaque {} pub type DBInstance = *const DBInstanceOpaque; pub enum DBWriteOptionsOpaque {} pub type DBWriteOptions = *const DBWriteOptionsOpaque; pub enum DBReadOptionsOpaque {} pub type DBReadOptions = *const DBReadOptionsOpaque; pub enum DBMergeOperatorOpaque {} pub type DBMergeOperator = *const DBMergeOperatorOpaque; pub enum DBBlockBasedTableOptionsOpaque {} pub type DBBlockBasedTableOptions = *const DBBlockBasedTableOptionsOpaque; pub enum DBCacheOpaque {} pub type DBCache = *const DBCacheOpaque; pub enum DBFilterPolicyOpaque {} pub type DBFilterPolicy = *const DBFilterPolicyOpaque; pub enum DBSnapshotOpaque {} pub type DBSnapshot = *const DBSnapshotOpaque; pub enum DBIteratorOpaque {} pub type DBIterator = *const DBIteratorOpaque; pub enum DBCFHandleOpaque {} pub type DBCFHandle = *const DBCFHandleOpaque; pub enum DBWriteBatchOpaque {} pub type DBWriteBatch = *const DBWriteBatchOpaque; pub enum DBComparatorOpaque {} pub type DBComparator = *const DBComparatorOpaque; pub enum DBSliceTransformOpaque {} pub type DBSliceTransform = *const DBSliceTransformOpaque; pub const BLOCK_BASED_INDEX_TYPE_BINARY_SEARCH: c_int = 0; pub const BLOCK_BASED_INDEX_TYPE_HASH_SEARCH: c_int = 1; pub fn new_bloom_filter(bits: c_int) -> DBFilterPolicy { unsafe { rocksdb_filterpolicy_create_bloom(bits) } } pub fn new_cache(capacity: size_t) -> DBCache { unsafe { rocksdb_cache_create_lru(capacity) } } #[derive(Copy, Clone)] #[repr(C)] pub enum DBCompressionType { None = 0, Snappy = 1, Zlib = 2, Bz2 = 3, Lz4 = 4, Lz4hc = 5, } #[repr(C)] pub enum DBCompactionStyle { Level = 0, Universal = 1, Fifo = 2, } #[repr(C)] pub enum DBUniversalCompactionStyle { rocksdb_similar_size_compaction_stop_style = 0, rocksdb_total_size_compaction_stop_style = 1, } #[derive(Copy, Clone, PartialEq)] #[repr(C)] pub enum DBRecoveryMode { TolerateCorruptedTailRecords = 0, AbsoluteConsistency = 1, PointInTime = 2, SkipAnyCorruptedRecords = 3, } pub fn error_message(ptr: *const i8) -> String { let c_str = unsafe { CStr::from_ptr(ptr as *const _) }; let s = from_utf8(c_str.to_bytes()).unwrap().to_owned(); unsafe { libc::free(ptr as *mut libc::c_void); } s } // TODO audit the use of boolean arguments, b/c I think they need to be u8 // instead... #[link(name = "rocksdb")] extern "C" { pub fn rocksdb_options_create() -> DBOptions; pub fn rocksdb_options_destroy(opts: DBOptions); pub fn rocksdb_cache_create_lru(capacity: size_t) -> DBCache; pub fn rocksdb_cache_destroy(cache: DBCache); pub fn rocksdb_block_based_options_create() -> DBBlockBasedTableOptions; pub fn rocksdb_block_based_options_destroy(opts: DBBlockBasedTableOptions); pub fn rocksdb_block_based_options_set_block_size( block_options: DBBlockBasedTableOptions, block_size: size_t); pub fn rocksdb_block_based_options_set_block_size_deviation( block_options: DBBlockBasedTableOptions, block_size_deviation: c_int); pub fn rocksdb_block_based_options_set_block_restart_interval( block_options: DBBlockBasedTableOptions, block_restart_interval: c_int); pub fn rocksdb_block_based_options_set_cache_index_and_filter_blocks( block_options: DBBlockBasedTableOptions, v: c_uchar); pub fn rocksdb_block_based_options_set_filter_policy( block_options: DBBlockBasedTableOptions, filter_policy: DBFilterPolicy); pub fn rocksdb_block_based_options_set_no_block_cache( block_options: DBBlockBasedTableOptions, no_block_cache: bool); pub fn rocksdb_block_based_options_set_block_cache( block_options: DBBlockBasedTableOptions, block_cache: DBCache); pub fn rocksdb_block_based_options_set_block_cache_compressed( block_options: DBBlockBasedTableOptions, block_cache_compressed: DBCache); pub fn rocksdb_block_based_options_set_whole_key_filtering( ck_options: DBBlockBasedTableOptions, doit: bool); pub fn rocksdb_options_set_block_based_table_factory( options: DBOptions, block_options: DBBlockBasedTableOptions); pub fn rocksdb_options_increase_parallelism(options: DBOptions, threads: c_int); pub fn rocksdb_options_optimize_level_style_compaction( options: DBOptions, memtable_memory_budget: c_int); pub fn rocksdb_options_set_create_if_missing(options: DBOptions, v: bool); pub fn rocksdb_options_set_max_open_files(options: DBOptions, files: c_int); pub fn rocksdb_options_set_use_fsync(options: DBOptions, v: c_int); pub fn rocksdb_options_set_bytes_per_sync(options: DBOptions, bytes: u64); pub fn rocksdb_options_set_disable_data_sync(options: DBOptions, v: c_int); pub fn rocksdb_options_set_allow_os_buffer(options: DBOptions, is_allow: bool); pub fn rocksdb_options_optimize_for_point_lookup(options: DBOptions, block_cache_size_mb: u64); pub fn rocksdb_options_set_table_cache_numshardbits(options: DBOptions, bits: c_int); pub fn rocksdb_options_set_max_write_buffer_number(options: DBOptions, bufno: c_int); pub fn rocksdb_options_set_min_write_buffer_number_to_merge( options: DBOptions, bufno: c_int); pub fn rocksdb_options_set_level0_file_num_compaction_trigger( options: DBOptions, no: c_int); pub fn rocksdb_options_set_level0_slowdown_writes_trigger( options: DBOptions, no: c_int); pub fn rocksdb_options_set_level0_stop_writes_trigger(options: DBOptions, no: c_int); pub fn rocksdb_options_set_write_buffer_size(options: DBOptions, bytes: usize); pub fn rocksdb_options_set_target_file_size_base(options: DBOptions, bytes: u64); pub fn rocksdb_options_set_target_file_size_multiplier(options: DBOptions, mul: c_int); pub fn rocksdb_options_set_max_bytes_for_level_base(options: DBOptions, bytes: u64); pub fn rocksdb_options_set_max_bytes_for_level_multiplier(options: DBOptions, mul: c_int); pub fn rocksdb_options_set_max_log_file_size(options: DBOptions, bytes: usize); pub fn rocksdb_options_set_max_manifest_file_size(options: DBOptions, bytes: usize); pub fn rocksdb_options_set_hash_skip_list_rep(options: DBOptions, bytes: usize, a1: i32, a2: i32); pub fn rocksdb_options_set_compaction_style(options: DBOptions, cs: DBCompactionStyle); pub fn rocksdb_options_set_compression(options: DBOptions, compression_style_no: DBCompressionType); pub fn rocksdb_options_set_compression_per_level(options: DBOptions, level_values: *const DBCompressionType, num_levels: size_t); pub fn rocksdb_options_set_max_background_compactions( options: DBOptions, max_bg_compactions: c_int); pub fn rocksdb_options_set_max_background_flushes(options: DBOptions, max_bg_flushes: c_int); pub fn rocksdb_options_set_filter_deletes(options: DBOptions, v: bool); pub fn rocksdb_options_set_disable_auto_compactions(options: DBOptions, v: c_int); pub fn rocksdb_options_set_report_bg_io_stats(options: DBOptions, v: c_int); pub fn rocksdb_options_set_wal_recovery_mode(options: DBOptions, mode: DBRecoveryMode); pub fn rocksdb_options_enable_statistics(options: DBOptions); pub fn rocksdb_options_statistics_get_string(options: DBOptions) -> *const c_char; pub fn rocksdb_options_set_stats_dump_period_sec(options: DBOptions, v: usize); pub fn rocksdb_options_set_num_levels(options: DBOptions, v: c_int); pub fn rocksdb_filterpolicy_create_bloom_full(bits_per_key: c_int) -> DBFilterPolicy; pub fn rocksdb_filterpolicy_create_bloom(bits_per_key: c_int) -> DBFilterPolicy; pub fn rocksdb_open(options: DBOptions, path: *const i8, err: *mut *const i8) -> DBInstance; pub fn rocksdb_writeoptions_create() -> DBWriteOptions; pub fn rocksdb_writeoptions_destroy(writeopts: DBWriteOptions); pub fn rocksdb_writeoptions_set_sync(writeopts: DBWriteOptions, v: bool); pub fn rocksdb_writeoptions_disable_WAL(writeopts: DBWriteOptions, v: c_int); pub fn rocksdb_put(db: DBInstance, writeopts: DBWriteOptions, k: *const u8, kLen: size_t, v: *const u8, vLen: size_t, err: *mut *const i8); pub fn rocksdb_put_cf(db: DBInstance, writeopts: DBWriteOptions, cf: DBCFHandle, k: *const u8, kLen: size_t, v: *const u8, vLen: size_t, err: *mut *const i8); pub fn rocksdb_readoptions_create() -> DBReadOptions; pub fn rocksdb_readoptions_destroy(readopts: DBReadOptions); pub fn rocksdb_readoptions_set_verify_checksums(readopts: DBReadOptions, v: bool); pub fn rocksdb_readoptions_set_fill_cache(readopts: DBReadOptions, v: bool); pub fn rocksdb_readoptions_set_snapshot(readopts: DBReadOptions, snapshot: DBSnapshot); //TODO how do I make this a const ref? pub fn rocksdb_readoptions_set_iterate_upper_bound(readopts: DBReadOptions, k: *const u8, kLen: size_t); pub fn rocksdb_readoptions_set_read_tier(readopts: DBReadOptions, tier: c_int); pub fn rocksdb_readoptions_set_tailing(readopts: DBReadOptions, v: bool); pub fn rocksdb_get(db: DBInstance, readopts: DBReadOptions, k: *const u8, kLen: size_t, valLen: *const size_t, err: *mut *const i8) -> *mut c_void; pub fn rocksdb_get_cf(db: DBInstance, readopts: DBReadOptions, cf_handle: DBCFHandle, k: *const u8, kLen: size_t, valLen: *const size_t, err: *mut *const i8) -> *mut c_void; pub fn rocksdb_create_iterator(db: DBInstance, readopts: DBReadOptions) -> DBIterator; pub fn rocksdb_create_iterator_cf(db: DBInstance, readopts: DBReadOptions, cf_handle: DBCFHandle) -> DBIterator; pub fn rocksdb_create_snapshot(db: DBInstance) -> DBSnapshot; pub fn rocksdb_release_snapshot(db: DBInstance, snapshot: DBSnapshot); pub fn rocksdb_delete(db: DBInstance, writeopts: DBWriteOptions, k: *const u8, kLen: size_t, err: *mut *const i8) -> *mut c_void; pub fn rocksdb_delete_cf(db: DBInstance, writeopts: DBWriteOptions, cf: DBCFHandle, k: *const u8, kLen: size_t, err: *mut *const i8) -> *mut c_void; pub fn rocksdb_close(db: DBInstance); pub fn rocksdb_destroy_db(options: DBOptions, path: *const i8, err: *mut *const i8); pub fn rocksdb_repair_db(options: DBOptions, path: *const i8, err: *mut *const i8); // Merge pub fn rocksdb_merge(db: DBInstance, writeopts: DBWriteOptions, k: *const u8, kLen: size_t, v: *const u8, vLen: size_t, err: *mut *const i8); pub fn rocksdb_merge_cf(db: DBInstance, writeopts: DBWriteOptions, cf: DBCFHandle, k: *const u8, kLen: size_t, v: *const u8, vLen: size_t, err: *mut *const i8); 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: size_t, existing_value: *const c_char, existing_value_len: size_t, operands_list: *const *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(arg: *mut c_void, key: *const c_char, key_len: size_t, operands_list: *const *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: Option ()>, name_fn: extern fn(*mut c_void) -> *const c_char, ) -> DBMergeOperator; pub fn rocksdb_mergeoperator_destroy(mo: DBMergeOperator); pub fn rocksdb_options_set_merge_operator(options: DBOptions, mo: DBMergeOperator); // Iterator pub fn rocksdb_iter_destroy(iter: DBIterator); pub fn rocksdb_iter_valid(iter: DBIterator) -> bool; pub fn rocksdb_iter_seek_to_first(iter: DBIterator); pub fn rocksdb_iter_seek_to_last(iter: DBIterator); pub fn rocksdb_iter_seek(iter: DBIterator, key: *const u8, klen: size_t); pub fn rocksdb_iter_next(iter: DBIterator); pub fn rocksdb_iter_prev(iter: DBIterator); pub fn rocksdb_iter_key(iter: DBIterator, klen: *mut size_t) -> *mut u8; pub fn rocksdb_iter_value(iter: DBIterator, vlen: *mut size_t) -> *mut u8; pub fn rocksdb_iter_get_error(iter: DBIterator, err: *mut *const u8); // Write batch pub fn rocksdb_write(db: DBInstance, writeopts: DBWriteOptions, batch: DBWriteBatch, err: *mut *const i8); pub fn rocksdb_writebatch_create() -> DBWriteBatch; pub fn rocksdb_writebatch_create_from(rep: *const u8, size: size_t) -> DBWriteBatch; pub fn rocksdb_writebatch_destroy(batch: DBWriteBatch); pub fn rocksdb_writebatch_clear(batch: DBWriteBatch); pub fn rocksdb_writebatch_count(batch: DBWriteBatch) -> c_int; pub fn rocksdb_writebatch_put(batch: DBWriteBatch, key: *const u8, klen: size_t, val: *const u8, vlen: size_t); pub fn rocksdb_writebatch_put_cf(batch: DBWriteBatch, cf: DBCFHandle, key: *const u8, klen: size_t, val: *const u8, vlen: size_t); pub fn rocksdb_writebatch_merge(batch: DBWriteBatch, key: *const u8, klen: size_t, val: *const u8, vlen: size_t); pub fn rocksdb_writebatch_merge_cf(batch: DBWriteBatch, cf: DBCFHandle, key: *const u8, klen: size_t, val: *const u8, vlen: size_t); pub fn rocksdb_writebatch_delete(batch: DBWriteBatch, key: *const u8, klen: size_t); pub fn rocksdb_writebatch_delete_cf(batch: DBWriteBatch, cf: DBCFHandle, key: *const u8, klen: size_t); pub fn rocksdb_writebatch_iterate( batch: DBWriteBatch, state: *mut c_void, put_fn: extern fn(state: *mut c_void, k: *const u8, klen: size_t, v: *const u8, vlen: size_t), deleted_fn: extern fn(state: *mut c_void, k: *const u8, klen: size_t)); pub fn rocksdb_writebatch_data(batch: DBWriteBatch, size: *mut size_t) -> *const u8; // Comparator pub fn rocksdb_options_set_comparator(options: DBOptions, cb: DBComparator); pub fn rocksdb_comparator_create(state: *mut c_void, destroy: extern "C" fn(*mut c_void) -> (), compare: extern "C" fn(arg: *mut c_void, a: *const c_char, alen: size_t, b: *const c_char, blen: size_t) -> c_int, name_fn: extern "C" fn(*mut c_void) -> *const c_char) -> DBComparator; pub fn rocksdb_comparator_destroy(cmp: DBComparator); // Column Family pub fn rocksdb_open_column_families(options: DBOptions, path: *const i8, num_column_families: c_int, column_family_names: *const *const i8, column_family_options: *const DBOptions, column_family_handles: *const DBCFHandle, err: *mut *const i8 ) -> DBInstance; pub fn rocksdb_create_column_family(db: DBInstance, column_family_options: DBOptions, column_family_name: *const i8, err: *mut *const i8) -> DBCFHandle; pub fn rocksdb_drop_column_family(db: DBInstance, column_family_handle: DBCFHandle, err: *mut *const i8); pub fn rocksdb_column_family_handle_destroy(column_family_handle: DBCFHandle); } #[test] fn internal() { unsafe { use std::ffi::CString; let opts = rocksdb_options_create(); assert!(!opts.is_null()); rocksdb_options_increase_parallelism(opts, 0); rocksdb_options_optimize_level_style_compaction(opts, 0); rocksdb_options_set_create_if_missing(opts, true); let rustpath = "_rust_rocksdb_internaltest"; let cpath = CString::new(rustpath).unwrap(); let cpath_ptr = cpath.as_ptr(); let mut err: *const i8 = 0 as *const i8; let err_ptr: *mut *const i8 = &mut err; let db = rocksdb_open(opts, cpath_ptr as *const _, err_ptr); if !err.is_null() { println!("failed to open rocksdb: {}", error_message(err)); } assert!(err.is_null()); let writeopts = rocksdb_writeoptions_create(); assert!(!writeopts.is_null()); let key = b"name\x00"; let val = b"spacejam\x00"; rocksdb_put(db, writeopts.clone(), key.as_ptr(), 4, val.as_ptr(), 8, err_ptr); rocksdb_writeoptions_destroy(writeopts); assert!(err.is_null()); let readopts = rocksdb_readoptions_create(); assert!(!readopts.is_null()); let val_len: size_t = 0; let val_len_ptr = &val_len as *const size_t; rocksdb_get(db, readopts.clone(), key.as_ptr(), 4, val_len_ptr, err_ptr); rocksdb_readoptions_destroy(readopts); assert!(err.is_null()); rocksdb_close(db); rocksdb_destroy_db(opts, cpath_ptr as *const _, err_ptr); assert!(err.is_null()); } }