diff --git a/Cargo.toml b/Cargo.toml index e7afeb8cd..6e0fa3b2b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -23,6 +23,9 @@ valgrind = [] [dependencies] libc = "0.2.11" +num = "0.2" +num-derive = "0.3" +num-traits = "0.2" [dependencies.librocksdb_sys] path = "librocksdb_sys" diff --git a/librocksdb_sys/bindings/x86_64-unknown-linux-gnu-bindings.rs b/librocksdb_sys/bindings/x86_64-unknown-linux-gnu-bindings.rs index 62145f602..e312e0295 100644 --- a/librocksdb_sys/bindings/x86_64-unknown-linux-gnu-bindings.rs +++ b/librocksdb_sys/bindings/x86_64-unknown-linux-gnu-bindings.rs @@ -416,14 +416,13 @@ pub struct crocksdb_writestallinfo_t { } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct crocksdb_writestallcondition_t { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] pub struct crocksdb_map_property_t { _unused: [u8; 0], } +pub const crocksdb_writestallcondition_t_Normal: crocksdb_writestallcondition_t = 0; +pub const crocksdb_writestallcondition_t_Delayed: crocksdb_writestallcondition_t = 1; +pub const crocksdb_writestallcondition_t_Stopped: crocksdb_writestallcondition_t = 2; +pub type crocksdb_writestallcondition_t = u32; pub const crocksdb_table_property_t_kDataSize: crocksdb_table_property_t = 1; pub const crocksdb_table_property_t_kIndexSize: crocksdb_table_property_t = 2; pub const crocksdb_table_property_t_kFilterSize: crocksdb_table_property_t = 3; @@ -451,6 +450,23 @@ pub const crocksdb_backgrounderrorreason_t_kCompaction: crocksdb_backgrounderror pub const crocksdb_backgrounderrorreason_t_kWriteCallback: crocksdb_backgrounderrorreason_t = 3; pub const crocksdb_backgrounderrorreason_t_kMemTable: crocksdb_backgrounderrorreason_t = 4; pub type crocksdb_backgrounderrorreason_t = u32; +pub const crocksdb_compaction_reason_t_Unknown: crocksdb_compaction_reason_t = 0; +pub const crocksdb_compaction_reason_t_LevelL0FilesNum: crocksdb_compaction_reason_t = 1; +pub const crocksdb_compaction_reason_t_LevelMaxLevelSize: crocksdb_compaction_reason_t = 2; +pub const crocksdb_compaction_reason_t_UniversalSizeAmplification: crocksdb_compaction_reason_t = 3; +pub const crocksdb_compaction_reason_t_UniversalSizeRatio: crocksdb_compaction_reason_t = 4; +pub const crocksdb_compaction_reason_t_UniversalSortedRunNum: crocksdb_compaction_reason_t = 5; +pub const crocksdb_compaction_reason_t_FIFOMaxSize: crocksdb_compaction_reason_t = 6; +pub const crocksdb_compaction_reason_t_FIFOReduceNumFiles: crocksdb_compaction_reason_t = 7; +pub const crocksdb_compaction_reason_t_FIFOTtl: crocksdb_compaction_reason_t = 8; +pub const crocksdb_compaction_reason_t_ManualCompaction: crocksdb_compaction_reason_t = 9; +pub const crocksdb_compaction_reason_t_FilesMarkedForCompaction: crocksdb_compaction_reason_t = 10; +pub const crocksdb_compaction_reason_t_BottommostFiles: crocksdb_compaction_reason_t = 11; +pub const crocksdb_compaction_reason_t_Ttl: crocksdb_compaction_reason_t = 12; +pub const crocksdb_compaction_reason_t_Flush: crocksdb_compaction_reason_t = 13; +pub const crocksdb_compaction_reason_t_ExternalSstIngestion: crocksdb_compaction_reason_t = 14; +pub const crocksdb_compaction_reason_t_NumOfReasons: crocksdb_compaction_reason_t = 15; +pub type crocksdb_compaction_reason_t = u32; extern "C" { pub fn crocksdb_open( options: *const crocksdb_options_t, @@ -1558,6 +1574,11 @@ extern "C" { info: *const crocksdb_compactionjobinfo_t, ) -> u64; } +extern "C" { + pub fn crocksdb_compactionjobinfo_compaction_reason( + info: *const crocksdb_compactionjobinfo_t, + ) -> *const crocksdb_compaction_reason_t; +} extern "C" { pub fn crocksdb_externalfileingestioninfo_cf_name( arg1: *const crocksdb_externalfileingestioninfo_t, diff --git a/librocksdb_sys/crocksdb/c.cc b/librocksdb_sys/crocksdb/c.cc index c6a275224..e12f87f98 100644 --- a/librocksdb_sys/crocksdb/c.cc +++ b/librocksdb_sys/crocksdb/c.cc @@ -233,9 +233,6 @@ struct crocksdb_pinnableslice_t { PinnableSlice rep; }; struct crocksdb_flushjobinfo_t { FlushJobInfo rep; }; -struct crocksdb_writestallcondition_t { - WriteStallCondition rep; -}; struct crocksdb_writestallinfo_t { WriteStallInfo rep; }; @@ -2003,9 +2000,11 @@ uint64_t crocksdb_compactionjobinfo_total_output_bytes( return info->rep.stats.total_output_bytes; } -CompactionReason crocksdb_compactionjobinfo_compaction_reason( +const crocksdb_compaction_reason_t* +crocksdb_compactionjobinfo_compaction_reason( const crocksdb_compactionjobinfo_t* info) { - return info->rep.compaction_reason; + return reinterpret_cast( + &info->rep.compaction_reason); } /* ExternalFileIngestionInfo */ diff --git a/librocksdb_sys/crocksdb/crocksdb/c.h b/librocksdb_sys/crocksdb/crocksdb/c.h index 95515051c..1d8da6a02 100644 --- a/librocksdb_sys/crocksdb/crocksdb/c.h +++ b/librocksdb_sys/crocksdb/crocksdb/c.h @@ -145,9 +145,14 @@ typedef struct crocksdb_compaction_options_t crocksdb_compaction_options_t; typedef struct crocksdb_perf_context_t crocksdb_perf_context_t; typedef struct crocksdb_iostats_context_t crocksdb_iostats_context_t; typedef struct crocksdb_writestallinfo_t crocksdb_writestallinfo_t; -typedef struct crocksdb_writestallcondition_t crocksdb_writestallcondition_t; typedef struct crocksdb_map_property_t crocksdb_map_property_t; +typedef enum crocksdb_writestallcondition_t { + Normal = 0, + Delayed = 1, + Stopped = 2, +} crocksdb_writestallcondition_t; + typedef enum crocksdb_table_property_t { kDataSize = 1, kIndexSize = 2, @@ -181,8 +186,26 @@ typedef enum crocksdb_backgrounderrorreason_t { kMemTable = 4, } crocksdb_backgrounderrorreason_t; -/* DB operations */ +typedef enum crocksdb_compaction_reason_t { + Unknown = 0, + LevelL0FilesNum = 1, + LevelMaxLevelSize = 2, + UniversalSizeAmplification = 3, + UniversalSizeRatio = 4, + UniversalSortedRunNum = 5, + FIFOMaxSize = 6, + FIFOReduceNumFiles = 7, + FIFOTtl = 8, + ManualCompaction = 9, + FilesMarkedForCompaction = 10, + BottommostFiles = 11, + Ttl = 12, + Flush = 13, + ExternalSstIngestion = 14, + NumOfReasons = 15, +} crocksdb_compaction_reason_t; +/* DB operations */ extern C_ROCKSDB_LIBRARY_API crocksdb_t* crocksdb_open( const crocksdb_options_t* options, const char* name, char** errptr); @@ -756,6 +779,9 @@ crocksdb_compactionjobinfo_total_input_bytes( extern C_ROCKSDB_LIBRARY_API uint64_t crocksdb_compactionjobinfo_total_output_bytes( const crocksdb_compactionjobinfo_t* info); +extern C_ROCKSDB_LIBRARY_API const crocksdb_compaction_reason_t* +crocksdb_compactionjobinfo_compaction_reason( + const crocksdb_compactionjobinfo_t* info); /* External file ingestion info */ extern C_ROCKSDB_LIBRARY_API const char* diff --git a/librocksdb_sys/src/lib.rs b/librocksdb_sys/src/lib.rs index 85b056e8c..e441e51df 100644 --- a/librocksdb_sys/src/lib.rs +++ b/librocksdb_sys/src/lib.rs @@ -13,151 +13,29 @@ // limitations under the License. // +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#[allow(clippy::all)] +mod bindings { + include!(env!("BINDING_PATH")); +} +pub use bindings::*; + extern crate bzip2_sys; extern crate libc; #[cfg(test)] extern crate tempfile; +use libc::{c_char, c_int, c_void}; use std::ffi::CStr; -use std::fmt; - -use libc::{c_char, c_double, c_int, c_uchar, c_void, size_t}; - -// FFI-safe opaque types. -// -// These represent opaque RocksDB types. They are used behind pointers, but are -// also wrapped in other types in the higher-level bindings. -// -// These use the strategy for opaque C types described in the nomicon [1]: -// but with the exception that they contain c_void instead of [u8; 0], thus -// making them uninstantiable sized types instead of ZSTs. -// -// The c_void documentation publicly recommends using the ZST pattern from the -// nomicon, but in private documentation [2] warns about UB from dereferencing -// pointers to uninhabited types, which these bindings do. -// -// Additionally, these bindings wrap some these types directly (not through -// pointers) and it's impossible to repr(transparent) a ZST, without which the -// unsafe casts within are dubious. -// -// [1]: https://doc.rust-lang.org/nomicon/ffi.html#representing-opaque-structs -// [2]: https://doc.rust-lang.org/nightly/src/core/ffi.rs.html#28 -#[repr(C)] -pub struct Options(c_void); -#[repr(C)] -pub struct ColumnFamilyDescriptor(c_void); -#[repr(C)] -pub struct DBInstance(c_void); -#[repr(C)] -pub struct DBWriteOptions(c_void); -#[repr(C)] -pub struct DBReadOptions(c_void); -#[repr(C)] -pub struct DBMergeOperator(c_void); -#[repr(C)] -pub struct DBBlockBasedTableOptions(c_void); -#[repr(C)] -pub struct DBMemoryAllocator(c_void); -#[repr(C)] -pub struct DBLRUCacheOptions(c_void); -#[repr(C)] -pub struct DBCache(c_void); -#[repr(C)] -pub struct DBFilterPolicy(c_void); -#[repr(C)] -pub struct DBSnapshot(c_void); -#[repr(C)] -pub struct DBIterator(c_void); -#[repr(C)] -pub struct DBCFHandle(c_void); -#[repr(C)] -pub struct DBWriteBatch(c_void); -#[repr(C)] -pub struct DBComparator(c_void); -#[repr(C)] -pub struct DBFlushOptions(c_void); -#[repr(C)] -pub struct DBCompactionFilter(c_void); -#[repr(C)] -pub struct EnvOptions(c_void); -#[repr(C)] -pub struct SstFileReader(c_void); -#[repr(C)] -pub struct SstFileWriter(c_void); -#[repr(C)] -pub struct ExternalSstFileInfo(c_void); -#[repr(C)] -pub struct IngestExternalFileOptions(c_void); -#[repr(C)] -pub struct DBBackupEngine(c_void); -#[repr(C)] -pub struct DBRestoreOptions(c_void); -#[repr(C)] -pub struct DBSliceTransform(c_void); -#[repr(C)] -pub struct DBRateLimiter(c_void); -#[repr(C)] -pub struct DBLogger(c_void); -#[repr(C)] -pub struct DBCompactOptions(c_void); -#[repr(C)] -pub struct DBFifoCompactionOptions(c_void); -#[repr(C)] -pub struct DBPinnableSlice(c_void); -#[repr(C)] -pub struct DBUserCollectedProperties(c_void); -#[repr(C)] -pub struct DBUserCollectedPropertiesIterator(c_void); -#[repr(C)] -pub struct DBTableProperties(c_void); -#[repr(C)] -pub struct DBTablePropertiesCollection(c_void); -#[repr(C)] -pub struct DBTablePropertiesCollectionIterator(c_void); -#[repr(C)] -pub struct DBTablePropertiesCollector(c_void); -#[repr(C)] -pub struct DBTablePropertiesCollectorFactory(c_void); -#[repr(C)] -pub struct DBFlushJobInfo(c_void); -#[repr(C)] -pub struct DBCompactionJobInfo(c_void); -#[repr(C)] -pub struct DBIngestionInfo(c_void); -#[repr(C)] -pub struct DBEventListener(c_void); -#[repr(C)] -pub struct DBKeyVersions(c_void); -#[repr(C)] -pub struct DBEnv(c_void); -#[repr(C)] -pub struct DBSequentialFile(c_void); -#[repr(C)] -pub struct DBColumnFamilyMetaData(c_void); -#[repr(C)] -pub struct DBLevelMetaData(c_void); -#[repr(C)] -pub struct DBSstFileMetaData(c_void); -#[repr(C)] -pub struct DBCompactionOptions(c_void); -#[repr(C)] -pub struct DBPerfContext(c_void); -#[repr(C)] -pub struct DBIOStatsContext(c_void); -#[repr(C)] -pub struct DBWriteStallInfo(c_void); -#[repr(C)] -pub struct DBStatusPtr(c_void); -#[repr(C)] -pub struct DBMapProperty(c_void); +pub fn new_bloom_filter(bits: c_int) -> *mut crocksdb_filterpolicy_t { + unsafe { crocksdb_filterpolicy_create_bloom(bits) } +} -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -#[repr(C)] -pub enum WriteStallCondition { - Normal = 0, - Delayed = 1, - Stopped = 2, +pub unsafe fn new_lru_cache(opt: *mut crocksdb_lru_cache_options_t) -> *mut crocksdb_cache_t { + crocksdb_cache_create_lru(opt) } mod generated; @@ -168,217 +46,6 @@ pub struct DBTitanDBOptions(c_void); #[repr(C)] pub struct DBTitanReadOptions(c_void); -#[derive(Clone, Debug, Default)] -#[repr(C)] -pub struct DBTitanBlobIndex { - pub file_number: u64, - pub blob_offset: u64, - pub blob_size: u64, -} - -pub fn new_bloom_filter(bits: c_int) -> *mut DBFilterPolicy { - unsafe { crocksdb_filterpolicy_create_bloom(bits) } -} - -pub unsafe fn new_lru_cache(opt: *mut DBLRUCacheOptions) -> *mut DBCache { - crocksdb_cache_create_lru(opt) -} - -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -#[repr(C)] -pub enum DBEntryType { - Put = 0, - Delete = 1, - SingleDelete = 2, - Merge = 3, - RangeDeletion = 4, - BlobIndex = 5, - Other = 6, -} - -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -#[repr(C)] -pub enum DBCompressionType { - No = 0, - Snappy = 1, - Zlib = 2, - Bz2 = 3, - Lz4 = 4, - Lz4hc = 5, - // DBXpress = 6, not support currently. - Zstd = 7, - ZstdNotFinal = 0x40, - Disable = 0xff, -} - -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -#[repr(C)] -pub enum DBCompactionStyle { - Level = 0, - Universal = 1, - Fifo = 2, - None = 3, -} - -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -#[repr(C)] -pub enum DBUniversalCompactionStyle { - SimilarSize = 0, - TotalSize = 1, -} - -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -#[repr(C)] -pub enum DBRecoveryMode { - TolerateCorruptedTailRecords = 0, - AbsoluteConsistency = 1, - PointInTime = 2, - SkipAnyCorruptedRecords = 3, -} - -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -#[repr(C)] -pub enum CompactionPriority { - // In Level-based compaction, it Determines which file from a level to be - // picked to merge to the next level. We suggest people try - // kMinOverlappingRatio first when you tune your database. - ByCompensatedSize = 0, - // First compact files whose data's latest update time is oldest. - // Try this if you only update some hot keys in small ranges. - OldestLargestSeqFirst = 1, - // First compact files whose range hasn't been compacted to the next level - // for the longest. If your updates are random across the key space, - // write amplification is slightly better with this option. - OldestSmallestSeqFirst = 2, - // First compact files whose ratio between overlapping size in next level - // and its size is the smallest. It in many cases can optimize write - // amplification. - MinOverlappingRatio = 3, -} - -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -#[repr(C)] -pub enum CompactionReason { - Unknown, - // [Level] number of L0 files > level0_file_num_compaction_trigger - LevelL0FilesNum, - // [Level] total size of level > MaxBytesForLevel() - LevelMaxLevelSize, - // [Universal] Compacting for size amplification - UniversalSizeAmplification, - // [Universal] Compacting for size ratio - UniversalSizeRatio, - // [Universal] number of sorted runs > level0_file_num_compaction_trigger - UniversalSortedRunNum, - // [FIFO] total size > max_table_files_size - FIFOMaxSize, - // [FIFO] reduce number of files. - FIFOReduceNumFiles, - // [FIFO] files with creation time < (current_time - interval) - FIFOTtl, - // Manual compaction - ManualCompaction, - // DB::SuggestCompactRange() marked files for compaction - FilesMarkedForCompaction, - // [Level] Automatic compaction within bottommost level to cleanup duplicate - // versions of same user key, usually due to a released snapshot. - BottommostFiles, - // Compaction based on TTL - Ttl, - // According to the comments in flush_job.cc, RocksDB treats flush as - // a level 0 compaction in internal stats. - Flush, - // Compaction caused by external sst file ingestion - ExternalSstIngestion, - // total number of compaction reasons, new reasons must be added above this. - NumOfReasons, -} - -impl fmt::Display for CompactionReason { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{:?}", self) - } -} - -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -#[repr(C)] -pub enum DBInfoLogLevel { - Debug = 0, - Info = 1, - Warn = 2, - Error = 3, - Fatal = 4, - Header = 5, - NumInfoLog = 6, -} - -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -#[repr(C)] -pub enum DBTableProperty { - DataSize = 1, - IndexSize = 2, - FilterSize = 3, - RawKeySize = 4, - RawValueSize = 5, - NumDataBlocks = 6, - NumEntries = 7, - FormatVersion = 8, - FixedKeyLen = 9, - ColumnFamilyId = 10, - ColumnFamilyName = 11, - FilterPolicyName = 12, - ComparatorName = 13, - MergeOperatorName = 14, - PrefixExtractorName = 15, - PropertyCollectorsNames = 16, - CompressionName = 17, -} - -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -#[repr(C)] -pub enum DBBottommostLevelCompaction { - // Skip bottommost level compaction - Skip = 0, - // Compact bottommost level if there is a compaction filter - // This is the default option - IfHaveCompactionFilter = 1, - // Force bottommost level compaction - Force = 2, -} - -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -#[repr(C)] -pub enum DBRateLimiterMode { - ReadOnly = 1, - WriteOnly = 2, - AllIo = 3, -} - -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -#[repr(C)] -pub enum DBTitanDBBlobRunMode { - Normal = 0, - ReadOnly = 1, - Fallback = 2, -} - -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -#[repr(C)] -pub enum IndexType { - BinarySearch = 0, - HashSearch = 1, - TwoLevelIndexSearch = 2, -} - -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -#[repr(C)] -pub enum DBBackgroundErrorReason { - Flush = 1, - Compaction = 2, - WriteCallback = 3, - MemTable = 4, -} - pub unsafe fn error_message(ptr: *mut c_char) -> String { let c_str = CStr::from_ptr(ptr); let s = format!("{}", c_str.to_string_lossy()); @@ -407,1912 +74,3 @@ macro_rules! ffi_try { res }) } - -// TODO audit the use of boolean arguments, b/c I think they need to be u8 -// instead... -extern "C" { - pub fn crocksdb_status_ptr_get_error(status: *mut DBStatusPtr, err: *mut *mut c_char); - pub fn crocksdb_get_db_options(db: *mut DBInstance) -> *mut Options; - pub fn crocksdb_set_db_options( - db: *mut DBInstance, - names: *const *const c_char, - values: *const *const c_char, - num_options: size_t, - errptr: *mut *mut c_char, - ); - pub fn crocksdb_get_options_cf(db: *mut DBInstance, cf: *mut DBCFHandle) -> *mut Options; - pub fn crocksdb_set_options_cf( - db: *mut DBInstance, - cf: *mut DBCFHandle, - names: *const *const c_char, - values: *const *const c_char, - num_options: size_t, - errptr: *mut *mut c_char, - ); - pub fn crocksdb_options_create() -> *mut Options; - pub fn crocksdb_options_copy(opts: *const Options) -> *mut Options; - pub fn crocksdb_options_destroy(opts: *mut Options); - pub fn crocksdb_options_set_paranoid_checks(opts: *mut Options, _: u8); - pub fn crocksdb_column_family_descriptor_destroy(cf_desc: *mut ColumnFamilyDescriptor); - pub fn crocksdb_name_from_column_family_descriptor( - cf_descs: *const ColumnFamilyDescriptor, - ) -> *const c_char; - pub fn crocksdb_options_from_column_family_descriptor( - cf_descs: *const ColumnFamilyDescriptor, - ) -> *mut Options; - - // Memory Allocator - pub fn crocksdb_jemalloc_nodump_allocator_create( - err: *mut *mut c_char, - ) -> *mut DBMemoryAllocator; - pub fn crocksdb_memory_allocator_destroy(allocator: *mut DBMemoryAllocator); - - // Cache - pub fn crocksdb_lru_cache_options_create() -> *mut DBLRUCacheOptions; - pub fn crocksdb_lru_cache_options_destroy(opt: *mut DBLRUCacheOptions); - pub fn crocksdb_lru_cache_options_set_capacity(opt: *mut DBLRUCacheOptions, capacity: size_t); - pub fn crocksdb_lru_cache_options_set_num_shard_bits( - opt: *mut DBLRUCacheOptions, - num_shard_bits: c_int, - ); - pub fn crocksdb_lru_cache_options_set_strict_capacity_limit( - opt: *mut DBLRUCacheOptions, - strict_capacity_limit: bool, - ); - pub fn crocksdb_lru_cache_options_set_high_pri_pool_ratio( - opt: *mut DBLRUCacheOptions, - high_pri_pool_ratio: c_double, - ); - pub fn crocksdb_lru_cache_options_set_memory_allocator( - opt: *mut DBLRUCacheOptions, - allocator: *mut DBMemoryAllocator, - ); - pub fn crocksdb_cache_create_lru(opt: *mut DBLRUCacheOptions) -> *mut DBCache; - pub fn crocksdb_cache_destroy(cache: *mut DBCache); - - pub fn crocksdb_block_based_options_create() -> *mut DBBlockBasedTableOptions; - pub fn crocksdb_block_based_options_destroy(opts: *mut DBBlockBasedTableOptions); - pub fn crocksdb_block_based_options_set_metadata_block_size( - block_options: *mut DBBlockBasedTableOptions, - block_size: size_t, - ); - pub fn crocksdb_block_based_options_set_block_size( - block_options: *mut DBBlockBasedTableOptions, - block_size: size_t, - ); - pub fn crocksdb_block_based_options_set_block_size_deviation( - block_options: *mut DBBlockBasedTableOptions, - block_size_deviation: c_int, - ); - pub fn crocksdb_block_based_options_set_block_restart_interval( - block_options: *mut DBBlockBasedTableOptions, - block_restart_interval: c_int, - ); - pub fn crocksdb_block_based_options_set_index_type( - block_options: *mut DBBlockBasedTableOptions, - v: IndexType, - ); - pub fn crocksdb_block_based_options_set_hash_index_allow_collision( - block_options: *mut DBBlockBasedTableOptions, - v: c_uchar, - ); - pub fn crocksdb_block_based_options_set_partition_filters( - block_options: *mut DBBlockBasedTableOptions, - v: c_uchar, - ); - pub fn crocksdb_block_based_options_set_cache_index_and_filter_blocks( - block_options: *mut DBBlockBasedTableOptions, - v: c_uchar, - ); - pub fn crocksdb_block_based_options_set_pin_top_level_index_and_filter( - block_options: *mut DBBlockBasedTableOptions, - v: c_uchar, - ); - pub fn crocksdb_block_based_options_set_cache_index_and_filter_blocks_with_high_priority( - block_options: *mut DBBlockBasedTableOptions, - v: c_uchar, - ); - pub fn crocksdb_block_based_options_set_filter_policy( - block_options: *mut DBBlockBasedTableOptions, - filter_policy: *mut DBFilterPolicy, - ); - pub fn crocksdb_block_based_options_set_no_block_cache( - block_options: *mut DBBlockBasedTableOptions, - no_block_cache: bool, - ); - pub fn crocksdb_block_based_options_set_block_cache( - block_options: *mut DBBlockBasedTableOptions, - block_cache: *mut DBCache, - ); - pub fn crocksdb_block_based_options_set_block_cache_compressed( - block_options: *mut DBBlockBasedTableOptions, - block_cache_compressed: *mut DBCache, - ); - pub fn crocksdb_block_based_options_set_whole_key_filtering( - ck_options: *mut DBBlockBasedTableOptions, - doit: bool, - ); - pub fn crocksdb_options_set_block_based_table_factory( - options: *mut Options, - block_options: *mut DBBlockBasedTableOptions, - ); - pub fn crocksdb_block_based_options_set_pin_l0_filter_and_index_blocks_in_cache( - block_options: *mut DBBlockBasedTableOptions, - v: c_uchar, - ); - pub fn crocksdb_block_based_options_set_read_amp_bytes_per_bit( - block_options: *mut DBBlockBasedTableOptions, - v: c_int, - ); - pub fn crocksdb_options_increase_parallelism(options: *mut Options, threads: c_int); - pub fn crocksdb_options_optimize_level_style_compaction( - options: *mut Options, - memtable_memory_budget: c_int, - ); - pub fn crocksdb_options_set_env(options: *mut Options, env: *mut DBEnv); - pub fn crocksdb_options_set_compaction_filter( - options: *mut Options, - filter: *mut DBCompactionFilter, - ); - pub fn crocksdb_options_set_create_if_missing(options: *mut Options, v: bool); - pub fn crocksdb_options_set_max_open_files(options: *mut Options, files: c_int); - pub fn crocksdb_options_set_max_total_wal_size(options: *mut Options, size: u64); - pub fn crocksdb_options_set_use_fsync(options: *mut Options, v: c_int); - pub fn crocksdb_options_set_bytes_per_sync(options: *mut Options, bytes: u64); - pub fn crocksdb_options_set_enable_pipelined_write(options: *mut Options, v: bool); - pub fn crocksdb_options_set_unordered_write(options: *mut Options, v: bool); - pub fn crocksdb_options_set_allow_concurrent_memtable_write(options: *mut Options, v: bool); - pub fn crocksdb_options_set_manual_wal_flush(options: *mut Options, v: bool); - pub fn crocksdb_options_optimize_for_point_lookup( - options: *mut Options, - block_cache_size_mb: u64, - ); - pub fn crocksdb_options_set_table_cache_numshardbits(options: *mut Options, bits: c_int); - pub fn crocksdb_options_set_writable_file_max_buffer_size(options: *mut Options, nbytes: c_int); - pub fn crocksdb_options_set_max_write_buffer_number(options: *mut Options, bufno: c_int); - pub fn crocksdb_options_set_min_write_buffer_number_to_merge( - options: *mut Options, - bufno: c_int, - ); - pub fn crocksdb_options_set_level0_file_num_compaction_trigger( - options: *mut Options, - no: c_int, - ); - pub fn crocksdb_options_set_level0_slowdown_writes_trigger(options: *mut Options, no: c_int); - pub fn crocksdb_options_get_level0_slowdown_writes_trigger(options: *mut Options) -> c_int; - pub fn crocksdb_options_set_level0_stop_writes_trigger(options: *mut Options, no: c_int); - pub fn crocksdb_options_get_level0_stop_writes_trigger(options: *mut Options) -> c_int; - pub fn crocksdb_options_set_write_buffer_size(options: *mut Options, bytes: u64); - pub fn crocksdb_options_set_target_file_size_base(options: *mut Options, bytes: u64); - pub fn crocksdb_options_get_target_file_size_base(options: *const Options) -> u64; - pub fn crocksdb_options_set_target_file_size_multiplier(options: *mut Options, mul: c_int); - pub fn crocksdb_options_set_max_bytes_for_level_base(options: *mut Options, bytes: u64); - pub fn crocksdb_options_set_max_bytes_for_level_multiplier(options: *mut Options, mul: f64); - pub fn crocksdb_options_get_max_bytes_for_level_multiplier(options: *mut Options) -> f64; - pub fn crocksdb_options_set_max_compaction_bytes(options: *mut Options, bytes: u64); - pub fn crocksdb_options_set_max_log_file_size(options: *mut Options, bytes: size_t); - pub fn crocksdb_options_set_log_file_time_to_roll(options: *mut Options, bytes: size_t); - pub fn crocksdb_options_set_info_log_level(options: *mut Options, level: DBInfoLogLevel); - pub fn crocksdb_options_set_keep_log_file_num(options: *mut Options, num: size_t); - pub fn crocksdb_options_set_recycle_log_file_num(options: *mut Options, num: size_t); - pub fn crocksdb_options_set_max_manifest_file_size(options: *mut Options, bytes: u64); - pub fn crocksdb_options_get_memtable_factory_name(options: *mut Options) -> *const c_char; - pub fn crocksdb_options_set_hash_skip_list_rep( - options: *mut Options, - bytes: u64, - a1: i32, - a2: i32, - ); - pub fn crocksdb_options_set_doubly_skip_list_rep(options: *mut Options); - pub fn crocksdb_options_set_compaction_style(options: *mut Options, cs: DBCompactionStyle); - pub fn crocksdb_options_set_fifo_compaction_options( - options: *mut Options, - fifo_opts: *mut DBFifoCompactionOptions, - ); - pub fn crocksdb_options_set_compression( - options: *mut Options, - compression_style_no: DBCompressionType, - ); - pub fn crocksdb_options_get_compression(options: *mut Options) -> DBCompressionType; - pub fn crocksdb_options_set_compression_per_level( - options: *mut Options, - level_values: *const DBCompressionType, - num_levels: size_t, - ); - pub fn crocksdb_options_get_compression_level_number(options: *mut Options) -> size_t; - pub fn crocksdb_options_get_compression_per_level( - options: *mut Options, - level_values: *mut DBCompressionType, - ); - pub fn crocksdb_set_bottommost_compression(options: *mut Options, c: DBCompressionType); - pub fn crocksdb_options_set_max_background_jobs(options: *mut Options, max_bg_jobs: c_int); - pub fn crocksdb_options_get_max_background_jobs(options: *const Options) -> c_int; - pub fn crocksdb_options_set_disable_auto_compactions(options: *mut Options, v: c_int); - pub fn crocksdb_options_get_disable_auto_compactions(options: *const Options) -> c_int; - pub fn crocksdb_options_set_report_bg_io_stats(options: *mut Options, v: c_int); - pub fn crocksdb_options_set_compaction_readahead_size(options: *mut Options, v: size_t); - pub fn crocksdb_options_set_wal_recovery_mode(options: *mut Options, mode: DBRecoveryMode); - pub fn crocksdb_options_set_max_subcompactions(options: *mut Options, v: u32); - pub fn crocksdb_options_set_wal_bytes_per_sync(options: *mut Options, v: u64); - pub fn crocksdb_options_enable_statistics(options: *mut Options, v: bool); - pub fn crocksdb_options_reset_statistics(options: *mut Options); - pub fn crocksdb_options_statistics_get_string(options: *mut Options) -> *const c_char; - pub fn crocksdb_options_statistics_get_ticker_count( - options: *mut Options, - ticker_type: DBStatisticsTickerType, - ) -> u64; - pub fn crocksdb_options_statistics_get_and_reset_ticker_count( - options: *mut Options, - ticker_type: DBStatisticsTickerType, - ) -> u64; - pub fn crocksdb_options_statistics_get_histogram_string( - options: *mut Options, - hist_type: DBStatisticsHistogramType, - ) -> *const c_char; - pub fn crocksdb_options_statistics_get_histogram( - options: *mut Options, - hist_type: DBStatisticsHistogramType, - median: *mut c_double, - percentile95: *mut c_double, - percentile99: *mut c_double, - average: *mut c_double, - standard_deviation: *mut c_double, - max: *mut c_double, - ) -> bool; - pub fn crocksdb_options_set_stats_dump_period_sec(options: *mut Options, v: usize); - pub fn crocksdb_options_set_num_levels(options: *mut Options, v: c_int); - pub fn crocksdb_options_get_num_levels(options: *mut Options) -> c_int; - pub fn crocksdb_options_set_db_log_dir(options: *mut Options, path: *const c_char); - pub fn crocksdb_options_set_wal_dir(options: *mut Options, path: *const c_char); - pub fn crocksdb_options_set_wal_ttl_seconds(options: *mut Options, ttl: u64); - pub fn crocksdb_options_set_wal_size_limit_mb(options: *mut Options, limit: u64); - pub fn crocksdb_options_set_use_direct_reads(options: *mut Options, v: bool); - pub fn crocksdb_options_set_use_direct_io_for_flush_and_compaction( - options: *mut Options, - v: bool, - ); - pub fn crocksdb_options_set_prefix_extractor( - options: *mut Options, - prefix_extractor: *mut DBSliceTransform, - ); - pub fn crocksdb_options_set_optimize_filters_for_hits(options: *mut Options, v: bool); - pub fn crocksdb_options_set_level_compaction_dynamic_level_bytes( - options: *mut Options, - v: bool, - ); - pub fn crocksdb_options_get_level_compaction_dynamic_level_bytes( - options: *const Options, - ) -> bool; - pub fn crocksdb_options_set_memtable_insert_with_hint_prefix_extractor( - options: *mut Options, - prefix_extractor: *mut DBSliceTransform, - ); - pub fn crocksdb_options_set_memtable_prefix_bloom_size_ratio( - options: *mut Options, - ratio: c_double, - ); - pub fn crocksdb_options_set_delayed_write_rate(options: *mut Options, rate: u64); - pub fn crocksdb_options_set_force_consistency_checks(options: *mut Options, v: bool); - pub fn crocksdb_options_set_ratelimiter(options: *mut Options, limiter: *mut DBRateLimiter); - pub fn crocksdb_options_set_info_log(options: *mut Options, logger: *mut DBLogger); - pub fn crocksdb_options_get_block_cache_usage(options: *const Options) -> usize; - pub fn crocksdb_options_set_block_cache_capacity( - options: *const Options, - capacity: usize, - err: *mut *mut c_char, - ); - pub fn crocksdb_options_get_block_cache_capacity(options: *const Options) -> usize; - pub fn crocksdb_load_latest_options( - dbpath: *const c_char, - env: *mut DBEnv, - db_options: *const Options, - cf_descs: *const *mut *mut ColumnFamilyDescriptor, - cf_descs_len: *mut size_t, - ignore_unknown_options: bool, - errptr: *mut *mut c_char, - ) -> bool; - pub fn crocksdb_ratelimiter_create( - rate_bytes_per_sec: i64, - refill_period_us: i64, - fairness: i32, - ) -> *mut DBRateLimiter; - pub fn crocksdb_ratelimiter_create_with_auto_tuned( - rate_bytes_per_sec: i64, - refill_period_us: i64, - fairness: i32, - mode: DBRateLimiterMode, - auto_tuned: bool, - ) -> *mut DBRateLimiter; - pub fn crocksdb_ratelimiter_destroy(limiter: *mut DBRateLimiter); - pub fn crocksdb_ratelimiter_set_bytes_per_second( - limiter: *mut DBRateLimiter, - bytes_per_sec: i64, - ); - pub fn crocksdb_ratelimiter_get_singleburst_bytes(limiter: *mut DBRateLimiter) -> i64; - pub fn crocksdb_ratelimiter_request(limiter: *mut DBRateLimiter, bytes: i64, pri: c_uchar); - pub fn crocksdb_ratelimiter_get_total_bytes_through( - limiter: *mut DBRateLimiter, - pri: c_uchar, - ) -> i64; - pub fn crocksdb_ratelimiter_get_bytes_per_second(limiter: *mut DBRateLimiter) -> i64; - pub fn crocksdb_ratelimiter_get_total_requests( - limiter: *mut DBRateLimiter, - pri: c_uchar, - ) -> i64; - pub fn crocksdb_options_set_soft_pending_compaction_bytes_limit(options: *mut Options, v: u64); - pub fn crocksdb_options_get_soft_pending_compaction_bytes_limit(options: *mut Options) -> u64; - pub fn crocksdb_options_set_hard_pending_compaction_bytes_limit(options: *mut Options, v: u64); - pub fn crocksdb_options_get_hard_pending_compaction_bytes_limit(options: *mut Options) -> u64; - pub fn crocksdb_options_set_compaction_priority(options: *mut Options, v: CompactionPriority); - pub fn crocksdb_options_set_db_paths( - options: *mut Options, - db_paths: *const *const c_char, - path_lens: *const usize, - target_size: *const u64, - num_paths: c_int, - ); - pub fn crocksdb_options_set_vector_memtable_factory(options: *mut Options, reserved_bytes: u64); - pub fn crocksdb_filterpolicy_create_bloom_full(bits_per_key: c_int) -> *mut DBFilterPolicy; - pub fn crocksdb_filterpolicy_create_bloom(bits_per_key: c_int) -> *mut DBFilterPolicy; - pub fn crocksdb_open( - options: *mut Options, - path: *const c_char, - err: *mut *mut c_char, - ) -> *mut DBInstance; - pub fn crocksdb_open_with_ttl( - options: *mut Options, - path: *const c_char, - ttl: c_int, - err: *mut *mut c_char, - ) -> *mut DBInstance; - pub fn crocksdb_open_for_read_only( - options: *mut Options, - path: *const c_char, - error_if_log_file_exist: bool, - err: *mut *mut c_char, - ) -> *mut DBInstance; - pub fn crocksdb_writeoptions_create() -> *mut DBWriteOptions; - pub fn crocksdb_writeoptions_destroy(writeopts: *mut DBWriteOptions); - pub fn crocksdb_writeoptions_set_sync(writeopts: *mut DBWriteOptions, v: bool); - pub fn crocksdb_writeoptions_disable_wal(writeopts: *mut DBWriteOptions, v: c_int); - pub fn crocksdb_writeoptions_set_ignore_missing_column_families( - writeopts: *mut DBWriteOptions, - v: bool, - ); - pub fn crocksdb_writeoptions_set_no_slowdown(writeopts: *mut DBWriteOptions, v: bool); - pub fn crocksdb_writeoptions_set_low_pri(writeopts: *mut DBWriteOptions, v: bool); - pub fn crocksdb_put( - db: *mut DBInstance, - writeopts: *mut DBWriteOptions, - k: *const u8, - kLen: size_t, - v: *const u8, - vLen: size_t, - err: *mut *mut c_char, - ); - pub fn crocksdb_put_cf( - db: *mut DBInstance, - writeopts: *mut DBWriteOptions, - cf: *mut DBCFHandle, - k: *const u8, - kLen: size_t, - v: *const u8, - vLen: size_t, - err: *mut *mut c_char, - ); - pub fn crocksdb_readoptions_create() -> *mut DBReadOptions; - pub fn crocksdb_readoptions_destroy(readopts: *mut DBReadOptions); - pub fn crocksdb_readoptions_set_verify_checksums(readopts: *mut DBReadOptions, v: bool); - pub fn crocksdb_readoptions_set_fill_cache(readopts: *mut DBReadOptions, v: bool); - pub fn crocksdb_readoptions_set_snapshot( - readopts: *mut DBReadOptions, - snapshot: *const DBSnapshot, - ); - pub fn crocksdb_readoptions_set_iterate_lower_bound( - readopts: *mut DBReadOptions, - k: *const u8, - kLen: size_t, - ); - pub fn crocksdb_readoptions_set_iterate_upper_bound( - readopts: *mut DBReadOptions, - k: *const u8, - kLen: size_t, - ); - pub fn crocksdb_readoptions_set_read_tier(readopts: *mut DBReadOptions, tier: c_int); - pub fn crocksdb_readoptions_set_tailing(readopts: *mut DBReadOptions, v: bool); - pub fn crocksdb_readoptions_set_managed(readopts: *mut DBReadOptions, v: bool); - pub fn crocksdb_readoptions_set_readahead_size(readopts: *mut DBReadOptions, size: size_t); - pub fn crocksdb_readoptions_set_max_skippable_internal_keys( - readopts: *mut DBReadOptions, - n: u64, - ); - pub fn crocksdb_readoptions_set_total_order_seek(readopts: *mut DBReadOptions, v: bool); - pub fn crocksdb_readoptions_set_prefix_same_as_start(readopts: *mut DBReadOptions, v: bool); - pub fn crocksdb_readoptions_set_pin_data(readopts: *mut DBReadOptions, v: bool); - pub fn crocksdb_readoptions_set_background_purge_on_iterator_cleanup( - readopts: *mut DBReadOptions, - v: bool, - ); - pub fn crocksdb_readoptions_set_ignore_range_deletions(readopts: *mut DBReadOptions, v: bool); - pub fn crocksdb_readoptions_set_table_filter( - readopts: *mut DBReadOptions, - ctx: *mut c_void, - filter: extern "C" fn(*mut c_void, *const DBTableProperties) -> c_int, - destroy: extern "C" fn(*mut c_void), - ); - - pub fn crocksdb_get( - db: *const DBInstance, - readopts: *const DBReadOptions, - k: *const u8, - kLen: size_t, - valLen: *const size_t, - err: *mut *mut c_char, - ) -> *mut u8; - pub fn crocksdb_get_cf( - db: *const DBInstance, - readopts: *const DBReadOptions, - cf_handle: *mut DBCFHandle, - k: *const u8, - kLen: size_t, - valLen: *const size_t, - err: *mut *mut c_char, - ) -> *mut u8; - pub fn crocksdb_create_iterator( - db: *mut DBInstance, - readopts: *const DBReadOptions, - ) -> *mut DBIterator; - pub fn crocksdb_create_iterator_cf( - db: *mut DBInstance, - readopts: *const DBReadOptions, - cf_handle: *mut DBCFHandle, - ) -> *mut DBIterator; - pub fn crocksdb_create_snapshot(db: *mut DBInstance) -> *const DBSnapshot; - pub fn crocksdb_release_snapshot(db: *mut DBInstance, snapshot: *const DBSnapshot); - pub fn crocksdb_get_snapshot_sequence_number(snapshot: *const DBSnapshot) -> u64; - - pub fn crocksdb_delete( - db: *mut DBInstance, - writeopts: *const DBWriteOptions, - k: *const u8, - kLen: size_t, - err: *mut *mut c_char, - ); - pub fn crocksdb_delete_cf( - db: *mut DBInstance, - writeopts: *const DBWriteOptions, - cf: *mut DBCFHandle, - k: *const u8, - kLen: size_t, - err: *mut *mut c_char, - ); - pub fn crocksdb_single_delete( - db: *mut DBInstance, - writeopts: *const DBWriteOptions, - k: *const u8, - kLen: size_t, - err: *mut *mut c_char, - ); - pub fn crocksdb_single_delete_cf( - db: *mut DBInstance, - writeopts: *const DBWriteOptions, - cf: *mut DBCFHandle, - k: *const u8, - kLen: size_t, - err: *mut *mut c_char, - ); - pub fn crocksdb_delete_range_cf( - db: *mut DBInstance, - writeopts: *const DBWriteOptions, - cf: *mut DBCFHandle, - begin_key: *const u8, - begin_keylen: size_t, - end_key: *const u8, - end_keylen: size_t, - err: *mut *mut c_char, - ); - pub fn crocksdb_close(db: *mut DBInstance); - pub fn crocksdb_pause_bg_work(db: *mut DBInstance); - pub fn crocksdb_continue_bg_work(db: *mut DBInstance); - pub fn crocksdb_destroy_db(options: *const Options, path: *const c_char, err: *mut *mut c_char); - pub fn crocksdb_repair_db(options: *const Options, path: *const c_char, err: *mut *mut c_char); - // Merge - pub fn crocksdb_merge( - db: *mut DBInstance, - writeopts: *const DBWriteOptions, - k: *const u8, - kLen: size_t, - v: *const u8, - vLen: size_t, - err: *mut *mut c_char, - ); - pub fn crocksdb_merge_cf( - db: *mut DBInstance, - writeopts: *const DBWriteOptions, - cf: *mut DBCFHandle, - k: *const u8, - kLen: size_t, - v: *const u8, - vLen: size_t, - err: *mut *mut c_char, - ); - pub fn crocksdb_mergeoperator_create( - state: *mut c_void, - destroy: unsafe extern "C" fn(*mut c_void) -> (), - full_merge: unsafe extern "C" 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: unsafe extern "C" 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< - unsafe extern "C" fn(*mut c_void, value: *const c_char, value_len: *mut size_t) -> (), - >, - name_fn: unsafe extern "C" fn(*mut c_void) -> *const c_char, - ) -> *mut DBMergeOperator; - pub fn crocksdb_mergeoperator_destroy(mo: *mut DBMergeOperator); - pub fn crocksdb_options_set_merge_operator(options: *mut Options, mo: *mut DBMergeOperator); - // Iterator - pub fn crocksdb_iter_destroy(iter: *mut DBIterator); - pub fn crocksdb_iter_valid(iter: *const DBIterator) -> bool; - pub fn crocksdb_iter_seek_to_first(iter: *mut DBIterator); - pub fn crocksdb_iter_seek_to_last(iter: *mut DBIterator); - pub fn crocksdb_iter_seek(iter: *mut DBIterator, key: *const u8, klen: size_t); - pub fn crocksdb_iter_seek_for_prev(iter: *mut DBIterator, key: *const u8, klen: size_t); - pub fn crocksdb_iter_next(iter: *mut DBIterator); - pub fn crocksdb_iter_prev(iter: *mut DBIterator); - pub fn crocksdb_iter_key(iter: *const DBIterator, klen: *mut size_t) -> *mut u8; - pub fn crocksdb_iter_value(iter: *const DBIterator, vlen: *mut size_t) -> *mut u8; - pub fn crocksdb_iter_get_error(iter: *const DBIterator, err: *mut *mut c_char); - // Write batch - pub fn crocksdb_write( - db: *mut DBInstance, - writeopts: *const DBWriteOptions, - batch: *mut DBWriteBatch, - err: *mut *mut c_char, - ); - pub fn crocksdb_writebatch_create() -> *mut DBWriteBatch; - pub fn crocksdb_writebatch_create_with_capacity(cap: size_t) -> *mut DBWriteBatch; - pub fn crocksdb_writebatch_create_from(rep: *const u8, size: size_t) -> *mut DBWriteBatch; - pub fn crocksdb_writebatch_destroy(batch: *mut DBWriteBatch); - pub fn crocksdb_writebatch_clear(batch: *mut DBWriteBatch); - pub fn crocksdb_writebatch_count(batch: *mut DBWriteBatch) -> c_int; - pub fn crocksdb_writebatch_put( - batch: *mut DBWriteBatch, - key: *const u8, - klen: size_t, - val: *const u8, - vlen: size_t, - ); - pub fn crocksdb_writebatch_put_cf( - batch: *mut DBWriteBatch, - cf: *mut DBCFHandle, - key: *const u8, - klen: size_t, - val: *const u8, - vlen: size_t, - ); - pub fn crocksdb_writebatch_merge( - batch: *mut DBWriteBatch, - key: *const u8, - klen: size_t, - val: *const u8, - vlen: size_t, - ); - pub fn crocksdb_writebatch_merge_cf( - batch: *mut DBWriteBatch, - cf: *mut DBCFHandle, - key: *const u8, - klen: size_t, - val: *const u8, - vlen: size_t, - ); - pub fn crocksdb_writebatch_delete(batch: *mut DBWriteBatch, key: *const u8, klen: size_t); - pub fn crocksdb_writebatch_delete_cf( - batch: *mut DBWriteBatch, - cf: *mut DBCFHandle, - key: *const u8, - klen: size_t, - ); - pub fn crocksdb_writebatch_single_delete( - batch: *mut DBWriteBatch, - key: *const u8, - klen: size_t, - ); - pub fn crocksdb_writebatch_single_delete_cf( - batch: *mut DBWriteBatch, - cf: *mut DBCFHandle, - key: *const u8, - klen: size_t, - ); - pub fn crocksdb_writebatch_delete_range( - batch: *mut DBWriteBatch, - begin_key: *const u8, - begin_keylen: size_t, - end_key: *const u8, - end_keylen: size_t, - ); - pub fn crocksdb_writebatch_delete_range_cf( - batch: *mut DBWriteBatch, - cf: *mut DBCFHandle, - begin_key: *const u8, - begin_keylen: size_t, - end_key: *const u8, - end_keylen: size_t, - ); - pub fn crocksdb_writebatch_iterate( - batch: *mut DBWriteBatch, - state: *mut c_void, - put_fn: extern "C" fn( - state: *mut c_void, - k: *const u8, - klen: size_t, - v: *const u8, - vlen: size_t, - ), - deleted_fn: extern "C" fn(state: *mut c_void, k: *const u8, klen: size_t), - ); - pub fn crocksdb_writebatch_data(batch: *mut DBWriteBatch, size: *mut size_t) -> *const u8; - pub fn crocksdb_writebatch_set_save_point(batch: *mut DBWriteBatch); - pub fn crocksdb_writebatch_pop_save_point(batch: *mut DBWriteBatch, err: *mut *mut c_char); - pub fn crocksdb_writebatch_rollback_to_save_point( - batch: *mut DBWriteBatch, - err: *mut *mut c_char, - ); - - // Comparator - pub fn crocksdb_options_set_comparator(options: *mut Options, cb: *mut DBComparator); - pub fn crocksdb_comparator_create( - state: *mut c_void, - destroy: unsafe extern "C" fn(*mut c_void) -> (), - compare: unsafe 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: unsafe extern "C" fn(*mut c_void) -> *const c_char, - ) -> *mut DBComparator; - pub fn crocksdb_comparator_destroy(cmp: *mut DBComparator); - - // Column Family - pub fn crocksdb_open_column_families( - options: *const Options, - path: *const c_char, - num_column_families: c_int, - column_family_names: *const *const c_char, - column_family_options: *const *const Options, - column_family_handles: *const *mut DBCFHandle, - err: *mut *mut c_char, - ) -> *mut DBInstance; - pub fn crocksdb_open_column_families_with_ttl( - options: *const Options, - path: *const c_char, - num_column_families: c_int, - column_family_names: *const *const c_char, - column_family_options: *const *const Options, - ttl_array: *const c_int, - read_only: bool, - column_family_handles: *const *mut DBCFHandle, - err: *mut *mut c_char, - ) -> *mut DBInstance; - pub fn crocksdb_open_for_read_only_column_families( - options: *const Options, - path: *const c_char, - num_column_families: c_int, - column_family_names: *const *const c_char, - column_family_options: *const *const Options, - column_family_handles: *const *mut DBCFHandle, - error_if_log_file_exist: bool, - err: *mut *mut c_char, - ) -> *mut DBInstance; - pub fn crocksdb_create_column_family( - db: *mut DBInstance, - column_family_options: *const Options, - column_family_name: *const c_char, - err: *mut *mut c_char, - ) -> *mut DBCFHandle; - pub fn crocksdb_drop_column_family( - db: *mut DBInstance, - column_family_handle: *mut DBCFHandle, - err: *mut *mut c_char, - ); - pub fn crocksdb_column_family_handle_id(column_family_handle: *mut DBCFHandle) -> u32; - pub fn crocksdb_column_family_handle_destroy(column_family_handle: *mut DBCFHandle); - pub fn crocksdb_list_column_families( - db: *const Options, - path: *const c_char, - lencf: *mut size_t, - err: *mut *mut c_char, - ) -> *mut *mut c_char; - pub fn crocksdb_list_column_families_destroy(list: *mut *mut c_char, len: size_t); - - // Flush options - pub fn crocksdb_flushoptions_create() -> *mut DBFlushOptions; - pub fn crocksdb_flushoptions_destroy(opt: *mut DBFlushOptions); - pub fn crocksdb_flushoptions_set_wait(opt: *mut DBFlushOptions, whether_wait: bool); - pub fn crocksdb_flushoptions_set_allow_write_stall(opt: *mut DBFlushOptions, allow: bool); - - pub fn crocksdb_flush( - db: *mut DBInstance, - options: *const DBFlushOptions, - err: *mut *mut c_char, - ); - pub fn crocksdb_flush_cf( - db: *mut DBInstance, - cf: *mut DBCFHandle, - options: *const DBFlushOptions, - err: *mut *mut c_char, - ); - pub fn crocksdb_flush_wal(db: *mut DBInstance, sync: bool, err: *mut *mut c_char); - pub fn crocksdb_sync_wal(db: *mut DBInstance, err: *mut *mut c_char); - - pub fn crocksdb_get_latest_sequence_number(db: *mut DBInstance) -> u64; - - pub fn crocksdb_approximate_sizes( - db: *mut DBInstance, - num_ranges: c_int, - range_start_key: *const *const u8, - range_start_key_len: *const size_t, - range_limit_key: *const *const u8, - range_limit_key_len: *const size_t, - sizes: *mut u64, - ); - pub fn crocksdb_approximate_sizes_cf( - db: *mut DBInstance, - cf: *mut DBCFHandle, - num_ranges: c_int, - range_start_key: *const *const u8, - range_start_key_len: *const size_t, - range_limit_key: *const *const u8, - range_limit_key_len: *const size_t, - sizes: *mut u64, - ); - pub fn crocksdb_approximate_memtable_stats( - db: *const DBInstance, - range_start_key: *const u8, - range_start_key_len: size_t, - range_limit_key: *const u8, - range_limit_key_len: size_t, - count: *mut u64, - size: *mut u64, - ); - pub fn crocksdb_approximate_memtable_stats_cf( - db: *const DBInstance, - cf: *const DBCFHandle, - range_start_key: *const u8, - range_start_key_len: size_t, - range_limit_key: *const u8, - range_limit_key_len: size_t, - count: *mut u64, - size: *mut u64, - ); - pub fn crocksdb_compactoptions_create() -> *mut DBCompactOptions; - pub fn crocksdb_compactoptions_destroy(opt: *mut DBCompactOptions); - pub fn crocksdb_compactoptions_set_exclusive_manual_compaction( - opt: *mut DBCompactOptions, - v: bool, - ); - pub fn crocksdb_compactoptions_set_change_level(opt: *mut DBCompactOptions, v: bool); - pub fn crocksdb_compactoptions_set_target_level(opt: *mut DBCompactOptions, v: i32); - pub fn crocksdb_compactoptions_set_max_subcompactions(opt: *mut DBCompactOptions, v: i32); - pub fn crocksdb_compactoptions_set_bottommost_level_compaction( - opt: *mut DBCompactOptions, - v: DBBottommostLevelCompaction, - ); - - pub fn crocksdb_fifo_compaction_options_create() -> *mut DBFifoCompactionOptions; - pub fn crocksdb_fifo_compaction_options_set_max_table_files_size( - fifo_opts: *mut DBFifoCompactionOptions, - size: u64, - ); - pub fn crocksdb_fifo_compaction_options_set_allow_compaction( - fifo_opts: *mut DBFifoCompactionOptions, - allow_compaction: bool, - ); - pub fn crocksdb_fifo_compaction_options_destroy(fifo_opts: *mut DBFifoCompactionOptions); - - pub fn crocksdb_compact_range( - db: *mut DBInstance, - start_key: *const u8, - start_key_len: size_t, - limit_key: *const u8, - limit_key_len: size_t, - ); - pub fn crocksdb_compact_range_cf( - db: *mut DBInstance, - cf: *mut DBCFHandle, - start_key: *const u8, - start_key_len: size_t, - limit_key: *const u8, - limit_key_len: size_t, - ); - pub fn crocksdb_compact_range_cf_opt( - db: *mut DBInstance, - cf: *mut DBCFHandle, - compact_options: *mut DBCompactOptions, - start_key: *const u8, - start_key_len: size_t, - limit_key: *const u8, - limit_key_len: size_t, - ); - pub fn crocksdb_delete_files_in_range( - db: *mut DBInstance, - range_start_key: *const u8, - range_start_key_len: size_t, - range_limit_key: *const u8, - range_limit_key_len: size_t, - include_end: bool, - err: *mut *mut c_char, - ); - pub fn crocksdb_delete_files_in_range_cf( - db: *mut DBInstance, - cf: *mut DBCFHandle, - range_start_key: *const u8, - range_start_key_len: size_t, - range_limit_key: *const u8, - range_limit_key_len: size_t, - include_end: bool, - err: *mut *mut c_char, - ); - pub fn crocksdb_delete_files_in_ranges_cf( - db: *mut DBInstance, - cf: *mut DBCFHandle, - start_keys: *const *const u8, - start_keys_lens: *const size_t, - limit_keys: *const *const u8, - limit_keys_lens: *const size_t, - num_ranges: size_t, - include_end: bool, - errptr: *mut *mut c_char, - ); - pub fn crocksdb_create_map_property() -> *mut DBMapProperty; - pub fn crocksdb_destroy_map_property(info: *mut DBMapProperty); - pub fn crocksdb_get_map_property_cf( - db: *mut DBInstance, - cf: *mut DBCFHandle, - name: *const c_char, - info: *mut DBMapProperty, - ) -> bool; - - pub fn crocksdb_map_property_value( - info: *const DBMapProperty, - propname: *const c_char, - ) -> *mut c_char; - - pub fn crocksdb_map_property_int_value( - info: *const DBMapProperty, - propname: *const c_char, - ) -> u64; - - pub fn crocksdb_property_value(db: *mut DBInstance, propname: *const c_char) -> *mut c_char; - pub fn crocksdb_property_value_cf( - db: *mut DBInstance, - cf: *mut DBCFHandle, - propname: *const c_char, - ) -> *mut c_char; - // Compaction filter - pub fn crocksdb_compactionfilter_create( - state: *mut c_void, - destructor: extern "C" fn(*mut c_void), - filter: extern "C" fn( - *mut c_void, - c_int, - *const u8, - size_t, - *const u8, - size_t, - *mut *mut u8, - *mut size_t, - *mut bool, - ) -> bool, - name: extern "C" fn(*mut c_void) -> *const c_char, - ) -> *mut DBCompactionFilter; - pub fn crocksdb_compactionfilter_set_ignore_snapshots( - filter: *mut DBCompactionFilter, - ignore_snapshot: bool, - ); - pub fn crocksdb_compactionfilter_destroy(filter: *mut DBCompactionFilter); - - // Env - pub fn crocksdb_default_env_create() -> *mut DBEnv; - pub fn crocksdb_mem_env_create() -> *mut DBEnv; - pub fn crocksdb_ctr_encrypted_env_create( - base_env: *mut DBEnv, - ciphertext: *const c_char, - ciphertext_len: size_t, - ) -> *mut DBEnv; - pub fn crocksdb_env_file_exists(env: *mut DBEnv, path: *const c_char, err: *mut *mut c_char); - pub fn crocksdb_env_delete_file(env: *mut DBEnv, path: *const c_char, err: *mut *mut c_char); - pub fn crocksdb_env_destroy(env: *mut DBEnv); - - // EnvOptions - pub fn crocksdb_envoptions_create() -> *mut EnvOptions; - pub fn crocksdb_envoptions_destroy(opt: *mut EnvOptions); - - // SequentialFile - pub fn crocksdb_sequential_file_create( - env: *mut DBEnv, - path: *const c_char, - opts: *mut EnvOptions, - err: *mut *mut c_char, - ) -> *mut DBSequentialFile; - pub fn crocksdb_sequential_file_read( - file: *mut DBSequentialFile, - n: size_t, - buf: *mut u8, - err: *mut *mut c_char, - ) -> size_t; - pub fn crocksdb_sequential_file_skip( - file: *mut DBSequentialFile, - n: size_t, - err: *mut *mut c_char, - ); - pub fn crocksdb_sequential_file_destroy(file: *mut DBSequentialFile); - - // IngestExternalFileOptions - pub fn crocksdb_ingestexternalfileoptions_create() -> *mut IngestExternalFileOptions; - pub fn crocksdb_ingestexternalfileoptions_set_move_files( - opt: *mut IngestExternalFileOptions, - move_files: bool, - ); - pub fn crocksdb_ingestexternalfileoptions_set_snapshot_consistency( - opt: *mut IngestExternalFileOptions, - snapshot_consistency: bool, - ); - pub fn crocksdb_ingestexternalfileoptions_set_allow_global_seqno( - opt: *mut IngestExternalFileOptions, - allow_global_seqno: bool, - ); - pub fn crocksdb_ingestexternalfileoptions_set_allow_blocking_flush( - opt: *mut IngestExternalFileOptions, - allow_blocking_flush: bool, - ); - pub fn crocksdb_ingestexternalfileoptions_destroy(opt: *mut IngestExternalFileOptions); - - // SstFileReader - pub fn crocksdb_sstfilereader_create(io_options: *const Options) -> *mut SstFileReader; - - pub fn crocksdb_sstfilereader_open( - reader: *mut SstFileReader, - name: *const c_char, - err: *mut *mut c_char, - ); - - pub fn crocksdb_sstfilereader_new_iterator( - reader: *mut SstFileReader, - options: *const DBReadOptions, - ) -> *mut DBIterator; - - pub fn crocksdb_sstfilereader_read_table_properties( - reader: *const SstFileReader, - ctx: *mut c_void, - callback: extern "C" fn(*mut c_void, *const DBTableProperties), - ); - - pub fn crocksdb_sstfilereader_verify_checksum( - reader: *mut SstFileReader, - errptr: *mut *mut c_char, - ); - - pub fn crocksdb_sstfilereader_destroy(reader: *mut SstFileReader); - - // SstFileWriter - pub fn crocksdb_sstfilewriter_create( - env: *mut EnvOptions, - io_options: *const Options, - ) -> *mut SstFileWriter; - pub fn crocksdb_sstfilewriter_create_cf( - env: *mut EnvOptions, - io_options: *const Options, - cf: *mut DBCFHandle, - ) -> *mut SstFileWriter; - pub fn crocksdb_sstfilewriter_open( - writer: *mut SstFileWriter, - name: *const c_char, - err: *mut *mut c_char, - ); - pub fn crocksdb_sstfilewriter_put( - writer: *mut SstFileWriter, - key: *const u8, - key_len: size_t, - val: *const u8, - val_len: size_t, - err: *mut *mut c_char, - ); - pub fn crocksdb_sstfilewriter_merge( - writer: *mut SstFileWriter, - key: *const u8, - key_len: size_t, - val: *const u8, - val_len: size_t, - err: *mut *mut c_char, - ); - pub fn crocksdb_sstfilewriter_delete( - writer: *mut SstFileWriter, - key: *const u8, - key_len: size_t, - err: *mut *mut c_char, - ); - pub fn crocksdb_sstfilewriter_delete_range( - writer: *mut SstFileWriter, - begin_key: *const u8, - begin_key_len: size_t, - end_key: *const u8, - end_key_len: size_t, - err: *mut *mut c_char, - ); - pub fn crocksdb_sstfilewriter_finish( - writer: *mut SstFileWriter, - info: *mut ExternalSstFileInfo, - err: *mut *mut c_char, - ); - pub fn crocksdb_sstfilewriter_file_size(writer: *mut SstFileWriter) -> u64; - pub fn crocksdb_sstfilewriter_destroy(writer: *mut SstFileWriter); - - // ExternalSstFileInfo - pub fn crocksdb_externalsstfileinfo_create() -> *mut ExternalSstFileInfo; - pub fn crocksdb_externalsstfileinfo_destroy(info: *mut ExternalSstFileInfo); - pub fn crocksdb_externalsstfileinfo_file_path( - info: *mut ExternalSstFileInfo, - size: *mut size_t, - ) -> *const u8; - pub fn crocksdb_externalsstfileinfo_smallest_key( - info: *mut ExternalSstFileInfo, - size: *mut size_t, - ) -> *const u8; - pub fn crocksdb_externalsstfileinfo_largest_key( - info: *mut ExternalSstFileInfo, - size: *mut size_t, - ) -> *const u8; - pub fn crocksdb_externalsstfileinfo_sequence_number(info: *mut ExternalSstFileInfo) -> u64; - pub fn crocksdb_externalsstfileinfo_file_size(info: *mut ExternalSstFileInfo) -> u64; - pub fn crocksdb_externalsstfileinfo_num_entries(info: *mut ExternalSstFileInfo) -> u64; - - pub fn crocksdb_ingest_external_file( - db: *mut DBInstance, - file_list: *const *const c_char, - list_len: size_t, - opt: *const IngestExternalFileOptions, - err: *mut *mut c_char, - ); - pub fn crocksdb_ingest_external_file_cf( - db: *mut DBInstance, - handle: *const DBCFHandle, - file_list: *const *const c_char, - list_len: size_t, - opt: *const IngestExternalFileOptions, - err: *mut *mut c_char, - ); - pub fn crocksdb_ingest_external_file_optimized( - db: *mut DBInstance, - handle: *const DBCFHandle, - file_list: *const *const c_char, - list_len: size_t, - opt: *const IngestExternalFileOptions, - err: *mut *mut c_char, - ) -> bool; - - // Restore Option - pub fn crocksdb_restore_options_create() -> *mut DBRestoreOptions; - pub fn crocksdb_restore_options_destroy(ropts: *mut DBRestoreOptions); - pub fn crocksdb_restore_options_set_keep_log_files(ropts: *mut DBRestoreOptions, v: c_int); - - // Backup engine - // TODO: add more ffis about backup engine. - pub fn crocksdb_backup_engine_open( - options: *const Options, - path: *const c_char, - err: *mut *mut c_char, - ) -> *mut DBBackupEngine; - pub fn crocksdb_backup_engine_create_new_backup( - be: *mut DBBackupEngine, - db: *mut DBInstance, - err: *mut *mut c_char, - ); - pub fn crocksdb_backup_engine_close(be: *mut DBBackupEngine); - pub fn crocksdb_backup_engine_restore_db_from_latest_backup( - be: *mut DBBackupEngine, - db_path: *const c_char, - wal_path: *const c_char, - ropts: *const DBRestoreOptions, - err: *mut *mut c_char, - ); - // SliceTransform - pub fn crocksdb_slicetransform_create( - state: *mut c_void, - destructor: extern "C" fn(*mut c_void), - transform: extern "C" fn(*mut c_void, *const u8, size_t, *mut size_t) -> *const u8, - in_domain: extern "C" fn(*mut c_void, *const u8, size_t) -> u8, - in_range: extern "C" fn(*mut c_void, *const u8, size_t) -> u8, - name: extern "C" fn(*mut c_void) -> *const c_char, - ) -> *mut DBSliceTransform; - pub fn crocksdb_slicetransform_destroy(transform: *mut DBSliceTransform); - pub fn crocksdb_create_log_from_options( - path: *const c_char, - options: *mut Options, - err: *mut *mut c_char, - ) -> *mut DBLogger; - pub fn crocksdb_log_destroy(logger: *mut DBLogger); - - pub fn crocksdb_get_pinned( - db: *mut DBInstance, - readopts: *const DBReadOptions, - k: *const u8, - kLen: size_t, - err: *mut *mut c_char, - ) -> *mut DBPinnableSlice; - pub fn crocksdb_get_pinned_cf( - db: *mut DBInstance, - readopts: *const DBReadOptions, - cf_handle: *mut DBCFHandle, - k: *const u8, - kLen: size_t, - err: *mut *mut c_char, - ) -> *mut DBPinnableSlice; - pub fn crocksdb_pinnableslice_value( - s: *const DBPinnableSlice, - valLen: *mut size_t, - ) -> *const u8; - pub fn crocksdb_pinnableslice_destroy(v: *mut DBPinnableSlice); - pub fn crocksdb_get_supported_compression_number() -> size_t; - pub fn crocksdb_get_supported_compression(v: *mut DBCompressionType, l: size_t); - - pub fn crocksdb_user_collected_properties_add( - props: *mut DBUserCollectedProperties, - key: *const u8, - key_len: size_t, - value: *const u8, - value_len: size_t, - ); - - pub fn crocksdb_user_collected_properties_iter_create( - props: *const DBUserCollectedProperties, - ) -> *mut DBUserCollectedPropertiesIterator; - - pub fn crocksdb_user_collected_properties_iter_destroy( - it: *mut DBUserCollectedPropertiesIterator, - ); - - pub fn crocksdb_user_collected_properties_iter_valid( - it: *const DBUserCollectedPropertiesIterator, - ) -> bool; - - pub fn crocksdb_user_collected_properties_iter_next(it: *mut DBUserCollectedPropertiesIterator); - - pub fn crocksdb_user_collected_properties_iter_key( - it: *const DBUserCollectedPropertiesIterator, - klen: *mut size_t, - ) -> *const u8; - - pub fn crocksdb_user_collected_properties_iter_value( - it: *const DBUserCollectedPropertiesIterator, - vlen: *mut size_t, - ) -> *const u8; - - pub fn crocksdb_table_properties_get_u64( - props: *const DBTableProperties, - prop: DBTableProperty, - ) -> u64; - - pub fn crocksdb_table_properties_get_str( - props: *const DBTableProperties, - prop: DBTableProperty, - slen: *mut size_t, - ) -> *const u8; - - pub fn crocksdb_table_properties_get_user_properties( - props: *const DBTableProperties, - ) -> *const DBUserCollectedProperties; - - pub fn crocksdb_user_collected_properties_get( - props: *const DBUserCollectedProperties, - key: *const u8, - klen: size_t, - vlen: *mut size_t, - ) -> *const u8; - - pub fn crocksdb_user_collected_properties_len( - props: *const DBUserCollectedProperties, - ) -> size_t; - - pub fn crocksdb_table_properties_collection_len( - props: *const DBTablePropertiesCollection, - ) -> size_t; - - pub fn crocksdb_table_properties_collection_destroy(props: *mut DBTablePropertiesCollection); - - pub fn crocksdb_table_properties_collection_iter_create( - props: *const DBTablePropertiesCollection, - ) -> *mut DBTablePropertiesCollectionIterator; - - pub fn crocksdb_table_properties_collection_iter_destroy( - it: *mut DBTablePropertiesCollectionIterator, - ); - - pub fn crocksdb_table_properties_collection_iter_valid( - it: *const DBTablePropertiesCollectionIterator, - ) -> bool; - - pub fn crocksdb_table_properties_collection_iter_next( - it: *mut DBTablePropertiesCollectionIterator, - ); - - pub fn crocksdb_table_properties_collection_iter_key( - it: *const DBTablePropertiesCollectionIterator, - klen: *mut size_t, - ) -> *const u8; - - pub fn crocksdb_table_properties_collection_iter_value( - it: *const DBTablePropertiesCollectionIterator, - ) -> *const DBTableProperties; - - pub fn crocksdb_table_properties_collector_create( - state: *mut c_void, - name: extern "C" fn(*mut c_void) -> *const c_char, - destruct: extern "C" fn(*mut c_void), - add_userkey: extern "C" fn( - *mut c_void, - *const u8, - size_t, - *const u8, - size_t, - c_int, - u64, - u64, - ), - finish: extern "C" fn(*mut c_void, *mut DBUserCollectedProperties), - ) -> *mut DBTablePropertiesCollector; - - pub fn crocksdb_table_properties_collector_destroy(c: *mut DBTablePropertiesCollector); - - pub fn crocksdb_table_properties_collector_factory_create( - state: *mut c_void, - name: extern "C" fn(*mut c_void) -> *const c_char, - destruct: extern "C" fn(*mut c_void), - create_table_properties_collector: extern "C" fn( - *mut c_void, - u32, - ) - -> *mut DBTablePropertiesCollector, - ) -> *mut DBTablePropertiesCollectorFactory; - - pub fn crocksdb_table_properties_collector_factory_destroy( - f: *mut DBTablePropertiesCollectorFactory, - ); - - pub fn crocksdb_options_add_table_properties_collector_factory( - options: *mut Options, - f: *mut DBTablePropertiesCollectorFactory, - ); - - pub fn crocksdb_get_properties_of_all_tables( - db: *mut DBInstance, - errptr: *mut *mut c_char, - ) -> *mut DBTablePropertiesCollection; - - pub fn crocksdb_get_properties_of_all_tables_cf( - db: *mut DBInstance, - cf: *mut DBCFHandle, - errptr: *mut *mut c_char, - ) -> *mut DBTablePropertiesCollection; - - pub fn crocksdb_get_properties_of_tables_in_range( - db: *mut DBInstance, - cf: *mut DBCFHandle, - num_ranges: c_int, - start_keys: *const *const u8, - start_keys_lens: *const size_t, - limit_keys: *const *const u8, - limit_keys_lens: *const size_t, - errptr: *mut *mut c_char, - ) -> *mut DBTablePropertiesCollection; - - pub fn crocksdb_flushjobinfo_cf_name( - info: *const DBFlushJobInfo, - size: *mut size_t, - ) -> *const c_char; - pub fn crocksdb_flushjobinfo_file_path( - info: *const DBFlushJobInfo, - size: *mut size_t, - ) -> *const c_char; - pub fn crocksdb_flushjobinfo_table_properties( - info: *const DBFlushJobInfo, - ) -> *const DBTableProperties; - pub fn crocksdb_flushjobinfo_triggered_writes_slowdown(info: *const DBFlushJobInfo) -> bool; - pub fn crocksdb_flushjobinfo_triggered_writes_stop(info: *const DBFlushJobInfo) -> bool; - - pub fn crocksdb_compactionjobinfo_status( - info: *const DBCompactionJobInfo, - errptr: *mut *mut c_char, - ); - pub fn crocksdb_compactionjobinfo_cf_name( - info: *const DBCompactionJobInfo, - size: *mut size_t, - ) -> *const c_char; - pub fn crocksdb_compactionjobinfo_input_files_count(info: *const DBCompactionJobInfo) - -> size_t; - pub fn crocksdb_compactionjobinfo_input_file_at( - info: *const DBCompactionJobInfo, - pos: size_t, - len: *mut size_t, - ) -> *const c_char; - pub fn crocksdb_compactionjobinfo_output_files_count( - info: *const DBCompactionJobInfo, - ) -> size_t; - pub fn crocksdb_compactionjobinfo_output_file_at( - info: *const DBCompactionJobInfo, - pos: size_t, - len: *mut size_t, - ) -> *const c_char; - pub fn crocksdb_compactionjobinfo_table_properties( - info: *const DBCompactionJobInfo, - ) -> *const DBTablePropertiesCollection; - pub fn crocksdb_compactionjobinfo_elapsed_micros(info: *const DBCompactionJobInfo) -> u64; - pub fn crocksdb_compactionjobinfo_num_corrupt_keys(info: *const DBCompactionJobInfo) -> u64; - pub fn crocksdb_compactionjobinfo_output_level(info: *const DBCompactionJobInfo) -> c_int; - pub fn crocksdb_compactionjobinfo_input_records(info: *const DBCompactionJobInfo) -> u64; - pub fn crocksdb_compactionjobinfo_output_records(info: *const DBCompactionJobInfo) -> u64; - pub fn crocksdb_compactionjobinfo_total_input_bytes(info: *const DBCompactionJobInfo) -> u64; - pub fn crocksdb_compactionjobinfo_total_output_bytes(info: *const DBCompactionJobInfo) -> u64; - pub fn crocksdb_compactionjobinfo_compaction_reason( - info: *const DBCompactionJobInfo, - ) -> CompactionReason; - - pub fn crocksdb_externalfileingestioninfo_cf_name( - info: *const DBIngestionInfo, - size: *mut size_t, - ) -> *const c_char; - pub fn crocksdb_externalfileingestioninfo_internal_file_path( - info: *const DBIngestionInfo, - size: *mut size_t, - ) -> *const c_char; - pub fn crocksdb_externalfileingestioninfo_table_properties( - info: *const DBIngestionInfo, - ) -> *const DBTableProperties; - - pub fn crocksdb_writestallinfo_cf_name( - info: *const DBWriteStallInfo, - size: *mut size_t, - ) -> *const c_char; - pub fn crocksdb_writestallinfo_prev( - info: *const DBWriteStallInfo, - ) -> *const WriteStallCondition; - pub fn crocksdb_writestallinfo_cur(info: *const DBWriteStallInfo) - -> *const WriteStallCondition; - - pub fn crocksdb_eventlistener_create( - state: *mut c_void, - destructor: extern "C" fn(*mut c_void), - flush: extern "C" fn(*mut c_void, *mut DBInstance, *const DBFlushJobInfo), - compact: extern "C" fn(*mut c_void, *mut DBInstance, *const DBCompactionJobInfo), - ingest: extern "C" fn(*mut c_void, *mut DBInstance, *const DBIngestionInfo), - bg_error: extern "C" fn(*mut c_void, DBBackgroundErrorReason, *mut DBStatusPtr), - stall_conditions: extern "C" fn(*mut c_void, *const DBWriteStallInfo), - ) -> *mut DBEventListener; - pub fn crocksdb_eventlistener_destroy(et: *mut DBEventListener); - pub fn crocksdb_options_add_eventlistener(opt: *mut Options, et: *mut DBEventListener); - // Get All Key Versions - pub fn crocksdb_keyversions_destroy(kvs: *mut DBKeyVersions); - - pub fn crocksdb_get_all_key_versions( - db: *mut DBInstance, - begin_key: *const u8, - begin_keylen: size_t, - end_key: *const u8, - end_keylen: size_t, - errptr: *mut *mut c_char, - ) -> *mut DBKeyVersions; - - pub fn crocksdb_keyversions_count(kvs: *mut DBKeyVersions) -> size_t; - - pub fn crocksdb_keyversions_key(kvs: *mut DBKeyVersions, index: usize) -> *const c_char; - - pub fn crocksdb_keyversions_value(kvs: *mut DBKeyVersions, index: usize) -> *const c_char; - - pub fn crocksdb_keyversions_seq(kvs: *mut DBKeyVersions, index: usize) -> u64; - - pub fn crocksdb_keyversions_type(kvs: *mut DBKeyVersions, index: usize) -> c_int; - - pub fn crocksdb_set_external_sst_file_global_seq_no( - db: *mut DBInstance, - handle: *mut DBCFHandle, - file: *const c_char, - seq_no: u64, - err: *mut *mut c_char, - ) -> u64; - - pub fn crocksdb_get_column_family_meta_data( - db: *mut DBInstance, - cf: *mut DBCFHandle, - meta: *mut DBColumnFamilyMetaData, - ); - - pub fn crocksdb_column_family_meta_data_create() -> *mut DBColumnFamilyMetaData; - pub fn crocksdb_column_family_meta_data_destroy(meta: *mut DBColumnFamilyMetaData); - pub fn crocksdb_column_family_meta_data_level_count( - meta: *const DBColumnFamilyMetaData, - ) -> size_t; - pub fn crocksdb_column_family_meta_data_level_data( - meta: *const DBColumnFamilyMetaData, - n: size_t, - ) -> *const DBLevelMetaData; - - pub fn crocksdb_level_meta_data_file_count(meta: *const DBLevelMetaData) -> size_t; - pub fn crocksdb_level_meta_data_file_data( - meta: *const DBLevelMetaData, - n: size_t, - ) -> *const DBSstFileMetaData; - - pub fn crocksdb_sst_file_meta_data_size(meta: *const DBSstFileMetaData) -> size_t; - pub fn crocksdb_sst_file_meta_data_name(meta: *const DBSstFileMetaData) -> *const c_char; - pub fn crocksdb_sst_file_meta_data_smallestkey( - meta: *const DBSstFileMetaData, - len: *mut size_t, - ) -> *const c_char; - pub fn crocksdb_sst_file_meta_data_largestkey( - meta: *const DBSstFileMetaData, - len: *mut size_t, - ) -> *const c_char; - - pub fn crocksdb_compaction_options_create() -> *mut DBCompactionOptions; - pub fn crocksdb_compaction_options_destroy(opts: *mut DBCompactionOptions); - pub fn crocksdb_compaction_options_set_compression( - opts: *mut DBCompactionOptions, - compression: DBCompressionType, - ); - pub fn crocksdb_compaction_options_set_output_file_size_limit( - opts: *mut DBCompactionOptions, - size: size_t, - ); - pub fn crocksdb_compaction_options_set_max_subcompactions( - opts: *mut DBCompactionOptions, - v: i32, - ); - - pub fn crocksdb_compact_files_cf( - db: *mut DBInstance, - cf: *mut DBCFHandle, - opts: *const DBCompactionOptions, - input_file_names: *const *const c_char, - input_file_count: size_t, - output_level: c_int, - errptr: *mut *mut c_char, - ); - - pub fn crocksdb_get_perf_level() -> c_int; - pub fn crocksdb_set_perf_level(level: c_int); - pub fn crocksdb_get_perf_context() -> *mut DBPerfContext; - pub fn crocksdb_perf_context_reset(ctx: *mut DBPerfContext); - pub fn crocksdb_perf_context_user_key_comparison_count(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_block_cache_hit_count(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_block_read_count(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_block_read_byte(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_block_read_time(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_block_checksum_time(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_block_decompress_time(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_get_read_bytes(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_multiget_read_bytes(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_iter_read_bytes(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_internal_key_skipped_count(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_internal_delete_skipped_count(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_internal_recent_skipped_count(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_internal_merge_count(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_get_snapshot_time(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_get_from_memtable_time(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_get_from_memtable_count(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_get_post_process_time(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_get_from_output_files_time(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_seek_on_memtable_time(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_seek_on_memtable_count(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_next_on_memtable_count(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_prev_on_memtable_count(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_seek_child_seek_time(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_seek_child_seek_count(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_seek_min_heap_time(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_seek_max_heap_time(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_seek_internal_seek_time(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_find_next_user_entry_time(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_write_wal_time(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_write_memtable_time(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_write_delay_time(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_write_pre_and_post_process_time(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_db_mutex_lock_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_db_condition_wait_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_merge_operator_time_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_read_index_block_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_read_filter_block_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_new_table_block_iter_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_new_table_iterator_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_block_seek_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_find_table_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_bloom_memtable_hit_count(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_bloom_memtable_miss_count(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_bloom_sst_hit_count(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_bloom_sst_miss_count(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_env_new_sequential_file_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_env_new_random_access_file_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_env_new_writable_file_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_env_reuse_writable_file_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_env_new_random_rw_file_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_env_new_directory_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_env_file_exists_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_env_get_children_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_env_get_children_file_attributes_nanos( - ctx: *mut DBPerfContext, - ) -> u64; - pub fn crocksdb_perf_context_env_delete_file_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_env_create_dir_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_env_create_dir_if_missing_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_env_delete_dir_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_env_get_file_size_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_env_get_file_modification_time_nanos( - ctx: *mut DBPerfContext, - ) -> u64; - pub fn crocksdb_perf_context_env_rename_file_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_env_link_file_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_env_lock_file_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_env_unlock_file_nanos(ctx: *mut DBPerfContext) -> u64; - pub fn crocksdb_perf_context_env_new_logger_nanos(ctx: *mut DBPerfContext) -> u64; - - pub fn crocksdb_get_iostats_context() -> *mut DBIOStatsContext; - pub fn crocksdb_iostats_context_reset(ctx: *mut DBIOStatsContext); - pub fn crocksdb_iostats_context_bytes_written(ctx: *mut DBIOStatsContext) -> u64; - pub fn crocksdb_iostats_context_bytes_read(ctx: *mut DBIOStatsContext) -> u64; - pub fn crocksdb_iostats_context_open_nanos(ctx: *mut DBIOStatsContext) -> u64; - pub fn crocksdb_iostats_context_allocate_nanos(ctx: *mut DBIOStatsContext) -> u64; - pub fn crocksdb_iostats_context_write_nanos(ctx: *mut DBIOStatsContext) -> u64; - pub fn crocksdb_iostats_context_read_nanos(ctx: *mut DBIOStatsContext) -> u64; - pub fn crocksdb_iostats_context_range_sync_nanos(ctx: *mut DBIOStatsContext) -> u64; - pub fn crocksdb_iostats_context_fsync_nanos(ctx: *mut DBIOStatsContext) -> u64; - pub fn crocksdb_iostats_context_prepare_write_nanos(ctx: *mut DBIOStatsContext) -> u64; - pub fn crocksdb_iostats_context_logger_nanos(ctx: *mut DBIOStatsContext) -> u64; - - pub fn crocksdb_run_ldb_tool(argc: c_int, argv: *const *const c_char, opts: *const Options); -} - -// Titan -extern "C" { - pub fn ctitandb_open_column_families( - path: *const c_char, - options: *const Options, - titan_options: *const DBTitanDBOptions, - num_column_families: c_int, - column_family_names: *const *const c_char, - column_family_options: *const *const Options, - titan_column_family_options: *const *const DBTitanDBOptions, - column_family_handles: *const *mut DBCFHandle, - err: *mut *mut c_char, - ) -> *mut DBInstance; - - pub fn ctitandb_create_column_family( - db: *mut DBInstance, - column_family_options: *const Options, - titan_column_family_options: *const DBTitanDBOptions, - column_family_name: *const c_char, - err: *mut *mut c_char, - ) -> *mut DBCFHandle; - - pub fn ctitandb_options_create() -> *mut DBTitanDBOptions; - pub fn ctitandb_options_destroy(opts: *mut DBTitanDBOptions); - pub fn ctitandb_options_copy(opts: *mut DBTitanDBOptions) -> *mut DBTitanDBOptions; - pub fn ctitandb_get_titan_options_cf( - db: *mut DBInstance, - cf: *mut DBCFHandle, - ) -> *mut DBTitanDBOptions; - pub fn ctitandb_options_dirname(opts: *mut DBTitanDBOptions) -> *const c_char; - pub fn ctitandb_options_set_dirname(opts: *mut DBTitanDBOptions, name: *const c_char); - pub fn ctitandb_options_min_blob_size(opts: *mut DBTitanDBOptions) -> u64; - pub fn ctitandb_options_set_min_blob_size(opts: *mut DBTitanDBOptions, size: u64); - pub fn ctitandb_options_blob_file_compression(opts: *mut DBTitanDBOptions) - -> DBCompressionType; - pub fn ctitandb_options_set_blob_file_compression( - opts: *mut DBTitanDBOptions, - t: DBCompressionType, - ); - - pub fn ctitandb_decode_blob_index( - value: *const u8, - value_size: u64, - index: *mut DBTitanBlobIndex, - errptr: *mut *mut c_char, - ); - pub fn ctitandb_encode_blob_index( - index: &DBTitanBlobIndex, - value: *mut *mut u8, - value_size: *mut u64, - ); - - pub fn ctitandb_options_set_disable_background_gc(opts: *mut DBTitanDBOptions, disable: bool); - pub fn ctitandb_options_set_level_merge(opts: *mut DBTitanDBOptions, enable: bool); - pub fn ctitandb_options_set_range_merge(opts: *mut DBTitanDBOptions, enable: bool); - pub fn ctitandb_options_set_max_sorted_runs(opts: *mut DBTitanDBOptions, size: i32); - pub fn ctitandb_options_set_max_background_gc(opts: *mut DBTitanDBOptions, size: i32); - pub fn ctitandb_options_set_purge_obsolete_files_period_sec( - opts: *mut DBTitanDBOptions, - period: usize, - ); - pub fn ctitandb_options_set_min_gc_batch_size(opts: *mut DBTitanDBOptions, size: u64); - pub fn ctitandb_options_set_max_gc_batch_size(opts: *mut DBTitanDBOptions, size: u64); - pub fn ctitandb_options_set_blob_cache(opts: *mut DBTitanDBOptions, cache: *mut DBCache); - pub fn ctitandb_options_get_blob_cache_usage(options: *const DBTitanDBOptions) -> usize; - pub fn ctitandb_options_set_blob_cache_capacity( - options: *const DBTitanDBOptions, - capacity: usize, - err: *mut *mut c_char, - ); - pub fn ctitandb_options_get_blob_cache_capacity(options: *const DBTitanDBOptions) -> usize; - - pub fn ctitandb_options_set_discardable_ratio(opts: *mut DBTitanDBOptions, ratio: f64); - pub fn ctitandb_options_set_sample_ratio(opts: *mut DBTitanDBOptions, ratio: f64); - pub fn ctitandb_options_set_merge_small_file_threshold(opts: *mut DBTitanDBOptions, size: u64); - pub fn ctitandb_options_set_blob_run_mode(opts: *mut DBTitanDBOptions, t: DBTitanDBBlobRunMode); - - pub fn ctitandb_readoptions_set_key_only(opts: *mut DBTitanReadOptions, v: bool); - - pub fn ctitandb_readoptions_create() -> *mut DBTitanReadOptions; - pub fn ctitandb_readoptions_destroy(readopts: *mut DBTitanReadOptions); - - pub fn ctitandb_create_iterator( - db: *mut DBInstance, - readopts: *const DBReadOptions, - titan_readopts: *const DBTitanReadOptions, - ) -> *mut DBIterator; - pub fn ctitandb_create_iterator_cf( - db: *mut DBInstance, - readopts: *const DBReadOptions, - titan_readopts: *const DBTitanReadOptions, - cf_handle: *mut DBCFHandle, - ) -> *mut DBIterator; - pub fn ctitandb_delete_files_in_range( - db: *mut DBInstance, - range_start_key: *const u8, - range_start_key_len: size_t, - range_limit_key: *const u8, - range_limit_key_len: size_t, - include_end: bool, - err: *mut *mut c_char, - ); - pub fn ctitandb_delete_files_in_range_cf( - db: *mut DBInstance, - cf: *mut DBCFHandle, - range_start_key: *const u8, - range_start_key_len: size_t, - range_limit_key: *const u8, - range_limit_key_len: size_t, - include_end: bool, - err: *mut *mut c_char, - ); - pub fn ctitandb_delete_files_in_ranges_cf( - db: *mut DBInstance, - cf: *mut DBCFHandle, - start_keys: *const *const u8, - start_keys_lens: *const size_t, - limit_keys: *const *const u8, - limit_keys_lens: *const size_t, - num_ranges: size_t, - include_end: bool, - errptr: *mut *mut c_char, - ); -} - -#[cfg(test)] -mod test { - use super::*; - use libc::{self, c_void}; - use std::ffi::{CStr, CString}; - use std::{fs, ptr, slice}; - - fn tempdir_with_prefix(prefix: &str) -> tempfile::TempDir { - tempfile::Builder::new().prefix(prefix).tempdir().expect() - } - - #[test] - fn internal() { - unsafe { - let opts = crocksdb_options_create(); - assert!(!opts.is_null()); - - crocksdb_options_increase_parallelism(opts, 0); - crocksdb_options_optimize_level_style_compaction(opts, 0); - crocksdb_options_set_create_if_missing(opts, true); - let rustpath = tempdir_with_prefix("_rust_rocksdb_internaltest"); - let cpath = CString::new(rustpath.path().to_str().unwrap()).unwrap(); - let cpath_ptr = cpath.as_ptr(); - - let mut err = ptr::null_mut(); - let db = crocksdb_open(opts, cpath_ptr, &mut err); - assert!(err.is_null(), error_message(err)); - - let writeopts = crocksdb_writeoptions_create(); - assert!(!writeopts.is_null()); - - let key = b"name\x00"; - let val = b"spacejam\x00"; - crocksdb_put(db, writeopts, key.as_ptr(), 4, val.as_ptr(), 8, &mut err); - crocksdb_writeoptions_destroy(writeopts); - assert!(err.is_null(), error_message(err)); - - let readopts = crocksdb_readoptions_create(); - assert!(!readopts.is_null()); - - let mut val_len = 0; - crocksdb_get(db, readopts, key.as_ptr(), 4, &mut val_len, &mut err); - crocksdb_readoptions_destroy(readopts); - assert!(err.is_null(), error_message(err)); - - // flush first to get approximate size later. - let flush_opt = crocksdb_flushoptions_create(); - crocksdb_flushoptions_set_wait(flush_opt, true); - crocksdb_flush(db, flush_opt, &mut err); - crocksdb_flushoptions_destroy(flush_opt); - assert!(err.is_null(), error_message(err)); - - let mut sizes = vec![0; 1]; - crocksdb_approximate_sizes( - db, - 1, - vec![b"\x00\x00".as_ptr()].as_ptr(), - vec![1].as_ptr(), - vec![b"\xff\x00".as_ptr()].as_ptr(), - vec![1].as_ptr(), - sizes.as_mut_ptr(), - ); - assert_eq!(sizes.len(), 1); - assert!(sizes[0] > 0); - - crocksdb_delete_files_in_range( - db, - b"\x00\x00".as_ptr(), - 2, - b"\xff\x00".as_ptr(), - 2, - true, - &mut err, - ); - assert!(err.is_null(), error_message(err)); - - let propname = CString::new("rocksdb.total-sst-files-size").unwrap(); - let value = crocksdb_property_value(db, propname.as_ptr()); - assert!(!value.is_null()); - - let sst_size = CStr::from_ptr(value) - .to_str() - .unwrap() - .parse::() - .unwrap(); - assert!(sst_size > 0); - libc::free(value as *mut c_void); - - let propname = CString::new("fake_key").unwrap(); - let value = crocksdb_property_value(db, propname.as_ptr()); - assert!(value.is_null()); - libc::free(value as *mut c_void); - - crocksdb_close(db); - crocksdb_destroy_db(opts, cpath_ptr, &mut err); - assert!(err.is_null()); - } - } - - unsafe fn check_get( - db: *mut DBInstance, - opt: *const DBReadOptions, - key: &[u8], - val: Option<&[u8]>, - ) { - let mut val_len = 0; - let mut err = ptr::null_mut(); - let res_ptr = crocksdb_get(db, opt, key.as_ptr(), key.len(), &mut val_len, &mut err); - assert!(err.is_null()); - let res = if res_ptr.is_null() { - None - } else { - Some(slice::from_raw_parts(res_ptr, val_len)) - }; - assert_eq!(res, val); - if !res_ptr.is_null() { - libc::free(res_ptr as *mut libc::c_void); - } - } - - #[test] - fn test_ingest_external_file() { - unsafe { - let opts = crocksdb_options_create(); - crocksdb_options_set_create_if_missing(opts, true); - - let rustpath = tempdir_with_prefix("_rust_rocksdb_internaltest"); - let cpath = CString::new(rustpath.path().to_str().unwrap()).unwrap(); - let cpath_ptr = cpath.as_ptr(); - - let mut err = ptr::null_mut(); - let db = crocksdb_open(opts, cpath_ptr, &mut err); - assert!(err.is_null(), error_message(err)); - - let env_opt = crocksdb_envoptions_create(); - let io_options = crocksdb_options_create(); - let writer = crocksdb_sstfilewriter_create(env_opt, io_options); - - let sst_dir = tempdir_with_prefix("_rust_rocksdb_internaltest"); - let sst_path = sst_dir.path().join("sstfilename"); - let c_sst_path = CString::new(sst_path.to_str().unwrap()).unwrap(); - let c_sst_path_ptr = c_sst_path.as_ptr(); - - crocksdb_sstfilewriter_open(writer, c_sst_path_ptr, &mut err); - assert!(err.is_null(), error_message(err)); - crocksdb_sstfilewriter_put(writer, b"sstk1".as_ptr(), 5, b"v1".as_ptr(), 2, &mut err); - assert!(err.is_null(), error_message(err)); - crocksdb_sstfilewriter_put(writer, b"sstk2".as_ptr(), 5, b"v2".as_ptr(), 2, &mut err); - assert!(err.is_null(), error_message(err)); - crocksdb_sstfilewriter_put(writer, b"sstk3".as_ptr(), 5, b"v3".as_ptr(), 2, &mut err); - assert!(err.is_null(), error_message(err)); - crocksdb_sstfilewriter_finish(writer, ptr::null_mut(), &mut err); - assert!(err.is_null(), error_message(err)); - assert!(crocksdb_sstfilewriter_file_size(writer) > 0); - - let ing_opt = crocksdb_ingestexternalfileoptions_create(); - let file_list = &[c_sst_path_ptr]; - crocksdb_ingest_external_file(db, file_list.as_ptr(), 1, ing_opt, &mut err); - assert!(err.is_null(), error_message(err)); - let roptions = crocksdb_readoptions_create(); - check_get(db, roptions, b"sstk1", Some(b"v1")); - check_get(db, roptions, b"sstk2", Some(b"v2")); - check_get(db, roptions, b"sstk3", Some(b"v3")); - - let snap = crocksdb_create_snapshot(db); - - fs::remove_file(sst_path).unwrap(); - crocksdb_sstfilewriter_open(writer, c_sst_path_ptr, &mut err); - assert!(err.is_null(), error_message(err)); - crocksdb_sstfilewriter_put(writer, "sstk2".as_ptr(), 5, "v4".as_ptr(), 2, &mut err); - assert!(err.is_null(), error_message(err)); - crocksdb_sstfilewriter_put(writer, "sstk22".as_ptr(), 6, "v5".as_ptr(), 2, &mut err); - assert!(err.is_null(), error_message(err)); - crocksdb_sstfilewriter_put(writer, "sstk3".as_ptr(), 5, "v6".as_ptr(), 2, &mut err); - assert!(err.is_null(), error_message(err)); - crocksdb_sstfilewriter_finish(writer, ptr::null_mut(), &mut err); - assert!(err.is_null(), error_message(err)); - assert!(crocksdb_sstfilewriter_file_size(writer) > 0); - - crocksdb_ingest_external_file(db, file_list.as_ptr(), 1, ing_opt, &mut err); - assert!(err.is_null(), error_message(err)); - check_get(db, roptions, b"sstk1", Some(b"v1")); - check_get(db, roptions, b"sstk2", Some(b"v4")); - check_get(db, roptions, b"sstk22", Some(b"v5")); - check_get(db, roptions, b"sstk3", Some(b"v6")); - - let roptions2 = crocksdb_readoptions_create(); - crocksdb_readoptions_set_snapshot(roptions2, snap); - check_get(db, roptions2, b"sstk1", Some(b"v1")); - check_get(db, roptions2, b"sstk2", Some(b"v2")); - check_get(db, roptions2, b"sstk22", None); - check_get(db, roptions2, b"sstk3", Some(b"v3")); - crocksdb_readoptions_destroy(roptions2); - - crocksdb_readoptions_destroy(roptions); - crocksdb_release_snapshot(db, snap); - crocksdb_ingestexternalfileoptions_destroy(ing_opt); - crocksdb_sstfilewriter_destroy(writer); - crocksdb_options_destroy(io_options); - crocksdb_envoptions_destroy(env_opt); - } - } -} diff --git a/src/compaction_filter.rs b/src/compaction_filter.rs index de8234e47..5b66e727a 100644 --- a/src/compaction_filter.rs +++ b/src/compaction_filter.rs @@ -1,4 +1,4 @@ -use crocksdb_ffi::{self, DBCompactionFilter}; +use crocksdb_ffi::{self, crocksdb_compactionfilter_t}; use libc::{c_char, c_int, c_void, size_t}; use std::ffi::CString; use std::slice; @@ -37,23 +37,25 @@ extern "C" fn destructor(filter: *mut c_void) { extern "C" fn filter( filter: *mut c_void, level: c_int, - key: *const u8, + key: *const libc::c_char, key_len: size_t, - value: *const u8, + value: *const libc::c_char, value_len: size_t, - _: *mut *mut u8, + _: *mut *mut libc::c_char, _: *mut size_t, - value_changed: *mut bool, -) -> bool { + value_changed: *mut u8, +) -> u8 { unsafe { let filter = &mut *(filter as *mut CompactionFilterProxy); - let key = slice::from_raw_parts(key, key_len); - let value = slice::from_raw_parts(value, value_len); - *value_changed = false; - filter.filter.filter(level as usize, key, value) + let key = slice::from_raw_parts(key as *const u8, key_len); + let value = slice::from_raw_parts(value as *const u8, value_len); + *value_changed = false as u8; + filter.filter.filter(level as usize, key, value) as u8 } } +pub type DBCompactionFilter = crocksdb_compactionfilter_t; + pub struct CompactionFilterHandle { pub inner: *mut DBCompactionFilter, } @@ -77,10 +79,10 @@ pub unsafe fn new_compaction_filter( })); let filter = crocksdb_ffi::crocksdb_compactionfilter_create( proxy as *mut c_void, - destructor, - filter, - name, + Some(destructor), + Some(filter), + Some(name), ); - crocksdb_ffi::crocksdb_compactionfilter_set_ignore_snapshots(filter, ignore_snapshots); + crocksdb_ffi::crocksdb_compactionfilter_set_ignore_snapshots(filter, ignore_snapshots as u8); Ok(CompactionFilterHandle { inner: filter }) } diff --git a/src/event_listener.rs b/src/event_listener.rs index 0e336c9ca..ad40a712a 100644 --- a/src/event_listener.rs +++ b/src/event_listener.rs @@ -12,14 +12,18 @@ // limitations under the License. use crocksdb_ffi::{ - self, CompactionReason, DBBackgroundErrorReason, DBCompactionJobInfo, DBEventListener, - DBFlushJobInfo, DBIngestionInfo, DBInstance, DBStatusPtr, DBWriteStallInfo, - WriteStallCondition, + self, crocksdb_backgrounderrorreason_t, crocksdb_compactionjobinfo_t, crocksdb_eventlistener_t, + crocksdb_externalfileingestioninfo_t, crocksdb_flushjobinfo_t, crocksdb_status_ptr_t, + crocksdb_t, crocksdb_writestallinfo_t, }; + use libc::c_void; use std::path::Path; use std::{slice, str}; -use {TableProperties, TablePropertiesCollectionView}; +use { + CompactionReason, DBBackgroundErrorReason, TableProperties, TablePropertiesCollectionView, + WriteStallCondition, +}; macro_rules! fetch_str { ($func:ident($($arg:expr),*)) => ({ @@ -30,8 +34,7 @@ macro_rules! fetch_str { }) } -#[repr(transparent)] -pub struct FlushJobInfo(DBFlushJobInfo); +pub struct FlushJobInfo(crocksdb_flushjobinfo_t); impl FlushJobInfo { pub fn cf_name(&self) -> &str { @@ -51,16 +54,15 @@ impl FlushJobInfo { } pub fn triggered_writes_slowdown(&self) -> bool { - unsafe { crocksdb_ffi::crocksdb_flushjobinfo_triggered_writes_slowdown(&self.0) } + unsafe { crocksdb_ffi::crocksdb_flushjobinfo_triggered_writes_slowdown(&self.0) != 0 } } pub fn triggered_writes_stop(&self) -> bool { - unsafe { crocksdb_ffi::crocksdb_flushjobinfo_triggered_writes_stop(&self.0) } + unsafe { crocksdb_ffi::crocksdb_flushjobinfo_triggered_writes_stop(&self.0) != 0 } } } -#[repr(transparent)] -pub struct CompactionJobInfo(DBCompactionJobInfo); +pub struct CompactionJobInfo(crocksdb_compactionjobinfo_t); impl CompactionJobInfo { pub fn status(&self) -> Result<(), String> { @@ -126,12 +128,16 @@ impl CompactionJobInfo { } pub fn compaction_reason(&self) -> CompactionReason { - unsafe { crocksdb_ffi::crocksdb_compactionjobinfo_compaction_reason(&self.0) } + unsafe { + num::FromPrimitive::from_u32( + *crocksdb_ffi::crocksdb_compactionjobinfo_compaction_reason(&self.0), + ) + .unwrap() + } } } -#[repr(transparent)] -pub struct IngestionInfo(DBIngestionInfo); +pub struct IngestionInfo(crocksdb_externalfileingestioninfo_t); impl IngestionInfo { pub fn cf_name(&self) -> &str { @@ -155,18 +161,23 @@ impl IngestionInfo { } } -#[repr(transparent)] -pub struct WriteStallInfo(DBWriteStallInfo); +pub struct WriteStallInfo(crocksdb_writestallinfo_t); impl WriteStallInfo { pub fn cf_name(&self) -> &str { unsafe { fetch_str!(crocksdb_writestallinfo_cf_name(&self.0)) } } pub fn cur(&self) -> WriteStallCondition { - unsafe { *crocksdb_ffi::crocksdb_writestallinfo_cur(&self.0) } + unsafe { + num::FromPrimitive::from_u32(*crocksdb_ffi::crocksdb_writestallinfo_cur(&self.0) as u32) + .unwrap() + } } pub fn prev(&self) -> WriteStallCondition { - unsafe { *crocksdb_ffi::crocksdb_writestallinfo_prev(&self.0) } + unsafe { + num::FromPrimitive::from_u32(*crocksdb_ffi::crocksdb_writestallinfo_prev(&self.0)) + .unwrap() + } } } @@ -197,8 +208,8 @@ extern "C" fn destructor(ctx: *mut c_void) { // TODO: refactor DB implement so that we can convert DBInstance to DB. extern "C" fn on_flush_completed( ctx: *mut c_void, - _: *mut DBInstance, - info: *const DBFlushJobInfo, + _: *mut crocksdb_t, + info: *const crocksdb_flushjobinfo_t, ) { let (ctx, info) = unsafe { ( @@ -211,8 +222,8 @@ extern "C" fn on_flush_completed( extern "C" fn on_compaction_completed( ctx: *mut c_void, - _: *mut DBInstance, - info: *const DBCompactionJobInfo, + _: *mut crocksdb_t, + info: *const crocksdb_compactionjobinfo_t, ) { let (ctx, info) = unsafe { ( @@ -225,8 +236,8 @@ extern "C" fn on_compaction_completed( extern "C" fn on_external_file_ingested( ctx: *mut c_void, - _: *mut DBInstance, - info: *const DBIngestionInfo, + _: *mut crocksdb_t, + info: *const crocksdb_externalfileingestioninfo_t, ) { let (ctx, info) = unsafe { ( @@ -239,8 +250,8 @@ extern "C" fn on_external_file_ingested( extern "C" fn on_background_error( ctx: *mut c_void, - reason: DBBackgroundErrorReason, - status: *mut DBStatusPtr, + reason: crocksdb_backgrounderrorreason_t, + status: *mut crocksdb_status_ptr_t, ) { let (ctx, result) = unsafe { ( @@ -251,10 +262,14 @@ extern "C" fn on_background_error( }(), ) }; - ctx.on_background_error(reason, result); + + ctx.on_background_error(num::FromPrimitive::from_u32(reason).unwrap(), result); } -extern "C" fn on_stall_conditions_changed(ctx: *mut c_void, info: *const DBWriteStallInfo) { +extern "C" fn on_stall_conditions_changed( + ctx: *mut c_void, + info: *const crocksdb_writestallinfo_t, +) { let (ctx, info) = unsafe { ( &*(ctx as *mut Box), @@ -264,17 +279,18 @@ extern "C" fn on_stall_conditions_changed(ctx: *mut c_void, info: *const DBWrite ctx.on_stall_conditions_changed(info); } +pub type DBEventListener = crocksdb_eventlistener_t; pub fn new_event_listener(l: L) -> *mut DBEventListener { let p: Box = Box::new(l); unsafe { crocksdb_ffi::crocksdb_eventlistener_create( Box::into_raw(Box::new(p)) as *mut c_void, - destructor, - on_flush_completed, - on_compaction_completed, - on_external_file_ingested, - on_background_error, - on_stall_conditions_changed, + Some(destructor), + Some(on_flush_completed), + Some(on_compaction_completed), + Some(on_external_file_ingested), + Some(on_background_error), + Some(on_stall_conditions_changed), ) } } diff --git a/src/lib.rs b/src/lib.rs index 5aafa9ba5..eec37090c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -15,6 +15,7 @@ extern crate core; extern crate libc; +extern crate num; #[macro_use] pub extern crate librocksdb_sys; #[cfg(test)] @@ -25,10 +26,8 @@ pub use event_listener::{ CompactionJobInfo, EventListener, FlushJobInfo, IngestionInfo, WriteStallInfo, }; pub use librocksdb_sys::{ - self as crocksdb_ffi, new_bloom_filter, CompactionPriority, CompactionReason, - DBBackgroundErrorReason, DBBottommostLevelCompaction, DBCompactionStyle, DBCompressionType, - DBEntryType, DBInfoLogLevel, DBRateLimiterMode, DBRecoveryMode, DBStatisticsHistogramType, - DBStatisticsTickerType, DBStatusPtr, DBTitanDBBlobRunMode, IndexType, WriteStallCondition, + self as crocksdb_ffi, crocksdb_status_ptr_t as DBStatusPtr, new_bloom_filter, + DBStatisticsHistogramType, DBStatisticsTickerType, }; pub use merge_operator::MergeOperands; pub use metadata::{ColumnFamilyMetaData, LevelMetaData, SstFileMetaData}; @@ -71,6 +70,222 @@ mod table_properties; mod table_properties_collector; mod table_properties_collector_factory; mod titan; +mod util; + +use std::fmt; +#[macro_use] +extern crate num_derive; + +#[derive(Copy, Clone, Debug, Eq, PartialEq, FromPrimitive)] +#[repr(C)] +pub enum WriteStallCondition { + Normal = 0, + Delayed = 1, + Stopped = 2, +} + +#[derive(Clone, Debug, Default)] +#[repr(C)] +pub struct DBTitanBlobIndex { + pub file_number: u64, + pub blob_offset: u64, + pub blob_size: u64, +} + +#[derive(Copy, Clone, Debug, Eq, PartialEq, FromPrimitive)] +#[repr(C)] +pub enum DBEntryType { + Put = 0, + Delete = 1, + SingleDelete = 2, + Merge = 3, + RangeDeletion = 4, + BlobIndex = 5, + Other = 6, +} + +#[derive(Copy, Clone, Debug, Eq, PartialEq, FromPrimitive)] +#[repr(C)] +pub enum DBCompressionType { + No = 0, + Snappy = 1, + Zlib = 2, + Bz2 = 3, + Lz4 = 4, + Lz4hc = 5, + // DBXpress = 6, not support currently. + Zstd = 7, + ZstdNotFinal = 0x40, + Disable = 0xff, +} + +#[derive(Copy, Clone, Debug, Eq, PartialEq, FromPrimitive)] +#[repr(C)] +pub enum DBCompactionStyle { + Level = 0, + Universal = 1, + Fifo = 2, + None = 3, +} + +#[derive(Copy, Clone, Debug, Eq, PartialEq, FromPrimitive)] +#[repr(C)] +pub enum DBUniversalCompactionStyle { + SimilarSize = 0, + TotalSize = 1, +} + +#[derive(Copy, Clone, Debug, Eq, PartialEq, FromPrimitive)] +#[repr(C)] +pub enum DBRecoveryMode { + TolerateCorruptedTailRecords = 0, + AbsoluteConsistency = 1, + PointInTime = 2, + SkipAnyCorruptedRecords = 3, +} + +#[derive(Copy, Clone, Debug, Eq, PartialEq, FromPrimitive)] +#[repr(C)] +pub enum CompactionPriority { + // In Level-based compaction, it Determines which file from a level to be + // picked to merge to the next level. We suggest people try + // kMinOverlappingRatio first when you tune your database. + ByCompensatedSize = 0, + // First compact files whose data's latest update time is oldest. + // Try this if you only update some hot keys in small ranges. + OldestLargestSeqFirst = 1, + // First compact files whose range hasn't been compacted to the next level + // for the longest. If your updates are random across the key space, + // write amplification is slightly better with this option. + OldestSmallestSeqFirst = 2, + // First compact files whose ratio between overlapping size in next level + // and its size is the smallest. It in many cases can optimize write + // amplification. + MinOverlappingRatio = 3, +} + +#[derive(Copy, Clone, Debug, Eq, PartialEq, FromPrimitive)] +#[repr(C)] +pub enum CompactionReason { + Unknown = 0, + // [Level] number of L0 files > level0_file_num_compaction_trigger + LevelL0FilesNum = 1, + // [Level] total size of level > MaxBytesForLevel() + LevelMaxLevelSize = 2, + // [Universal] Compacting for size amplification + UniversalSizeAmplification = 3, + // [Universal] Compacting for size ratio + UniversalSizeRatio = 4, + // [Universal] number of sorted runs > level0_file_num_compaction_trigger + UniversalSortedRunNum = 5, + // [FIFO] total size > max_table_files_size + FIFOMaxSize = 6, + // [FIFO] reduce number of files. + FIFOReduceNumFiles = 7, + // [FIFO] files with creation time < (current_time - interval) + FIFOTtl = 8, + // Manual compaction + ManualCompaction = 9, + // DB::SuggestCompactRange() marked files for compaction + FilesMarkedForCompaction = 10, + // [Level] Automatic compaction within bottommost level to cleanup duplicate + // versions of same user key, usually due to a released snapshot. + BottommostFiles = 11, + // Compaction based on TTL + Ttl = 12, + // According to the comments in flush_job.cc, RocksDB treats flush as + // a level 0 compaction in internal stats. + Flush = 13, + // Compaction caused by external sst file ingestion + ExternalSstIngestion = 14, + // total number of compaction reasons, new reasons must be added above this. + NumOfReasons = 15, +} + +impl fmt::Display for CompactionReason { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{:?}", self) + } +} + +#[derive(Copy, Clone, Debug, Eq, PartialEq, FromPrimitive)] +#[repr(C)] +pub enum DBInfoLogLevel { + Debug = 0, + Info = 1, + Warn = 2, + Error = 3, + Fatal = 4, + Header = 5, + NumInfoLog = 6, +} + +#[derive(Copy, Clone, Debug, Eq, PartialEq, FromPrimitive)] +#[repr(C)] +pub enum DBTableProperty { + DataSize = 1, + IndexSize = 2, + FilterSize = 3, + RawKeySize = 4, + RawValueSize = 5, + NumDataBlocks = 6, + NumEntries = 7, + FormatVersion = 8, + FixedKeyLen = 9, + ColumnFamilyId = 10, + ColumnFamilyName = 11, + FilterPolicyName = 12, + ComparatorName = 13, + MergeOperatorName = 14, + PrefixExtractorName = 15, + PropertyCollectorsNames = 16, + CompressionName = 17, +} + +#[derive(Copy, Clone, Debug, Eq, PartialEq, FromPrimitive)] +#[repr(C)] +pub enum DBBottommostLevelCompaction { + // Skip bottommost level compaction + Skip = 0, + // Compact bottommost level if there is a compaction filter + // This is the default option + IfHaveCompactionFilter = 1, + // Force bottommost level compaction + Force = 2, +} + +#[derive(Copy, Clone, Debug, Eq, PartialEq, FromPrimitive)] +#[repr(C)] +pub enum DBRateLimiterMode { + ReadOnly = 1, + WriteOnly = 2, + AllIo = 3, +} + +#[derive(Copy, Clone, Debug, Eq, PartialEq, FromPrimitive)] +#[repr(C)] +pub enum DBTitanDBBlobRunMode { + Normal = 0, + ReadOnly = 1, + Fallback = 2, +} + +#[derive(Copy, Clone, Debug, Eq, PartialEq, FromPrimitive)] +#[repr(C)] +pub enum IndexType { + BinarySearch = 0, + HashSearch = 1, + TwoLevelIndexSearch = 2, +} + +#[derive(Copy, Clone, Debug, Eq, PartialEq, FromPrimitive)] +#[repr(C)] +pub enum DBBackgroundErrorReason { + Flush = 1, + Compaction = 2, + WriteCallback = 3, + MemTable = 4, +} #[cfg(test)] fn tempdir_with_prefix(prefix: &str) -> tempfile::TempDir { diff --git a/src/merge_operator.rs b/src/merge_operator.rs index ccfbc6467..f944a520d 100644 --- a/src/merge_operator.rs +++ b/src/merge_operator.rs @@ -48,7 +48,7 @@ pub unsafe extern "C" fn full_merge_callback( num_operands: c_int, success: *mut u8, new_value_length: *mut size_t, -) -> *const c_char { +) -> *mut c_char { let cb: &mut MergeOperatorCallback = &mut *(raw_cb as *mut MergeOperatorCallback); let operands = &mut MergeOperands::new(operands_list, operands_list_len, num_operands); let key: &[u8] = slice::from_raw_parts(raw_key as *const u8, key_len as usize); @@ -58,12 +58,11 @@ pub unsafe extern "C" fn full_merge_callback( result.shrink_to_fit(); // TODO(tan) investigate zero-copy techniques to improve performance let buf = libc::malloc(result.len() as size_t); - let buf = buf as *mut u8; assert!(!buf.is_null()); *new_value_length = result.len() as size_t; *success = 1 as u8; - ptr::copy(result.as_ptr(), &mut *buf, result.len()); - buf as *const c_char + ptr::copy(result.as_ptr() as *mut c_void, &mut *buf, result.len()); + buf as *mut c_char } pub unsafe extern "C" fn partial_merge_callback( @@ -75,7 +74,7 @@ pub unsafe extern "C" fn partial_merge_callback( num_operands: c_int, success: *mut u8, new_value_length: *mut size_t, -) -> *const c_char { +) -> *mut c_char { let cb: &mut MergeOperatorCallback = &mut *(raw_cb as *mut MergeOperatorCallback); let operands = &mut MergeOperands::new(operands_list, operands_list_len, num_operands); let key: &[u8] = slice::from_raw_parts(raw_key as *const u8, key_len as usize); @@ -83,12 +82,11 @@ pub unsafe extern "C" fn partial_merge_callback( result.shrink_to_fit(); // TODO(tan) investigate zero-copy techniques to improve performance let buf = libc::malloc(result.len() as size_t); - let buf = buf as *mut u8; assert!(!buf.is_null()); *new_value_length = result.len() as size_t; *success = 1 as u8; - ptr::copy(result.as_ptr(), &mut *buf, result.len()); - buf as *const c_char + ptr::copy(result.as_ptr() as *mut c_void, &mut *buf, result.len()); + buf as *mut c_char } pub struct MergeOperands { diff --git a/src/metadata.rs b/src/metadata.rs index 02d71f489..11f4482b0 100644 --- a/src/metadata.rs +++ b/src/metadata.rs @@ -11,12 +11,16 @@ // See the License for the specific language governing permissions and // limitations under the License. -use crocksdb_ffi::{self, DBColumnFamilyMetaData, DBLevelMetaData, DBSstFileMetaData}; +use crocksdb_ffi::{ + self, crocksdb_column_family_meta_data_t, crocksdb_level_meta_data_t, + crocksdb_sst_file_meta_data_t, +}; use std::ffi::CStr; use std::slice; use libc::size_t; +pub type DBColumnFamilyMetaData = crocksdb_column_family_meta_data_t; pub struct ColumnFamilyMetaData { inner: *mut DBColumnFamilyMetaData, } @@ -47,6 +51,7 @@ impl Drop for ColumnFamilyMetaData { } } +pub type DBLevelMetaData = crocksdb_level_meta_data_t; pub struct LevelMetaData<'a> { inner: *const DBLevelMetaData, _mark: &'a ColumnFamilyMetaData, @@ -73,6 +78,7 @@ impl<'a> LevelMetaData<'a> { } } +pub type DBSstFileMetaData = crocksdb_sst_file_meta_data_t; pub struct SstFileMetaData<'a> { inner: *const DBSstFileMetaData, _mark: &'a ColumnFamilyMetaData, diff --git a/src/perf_context.rs b/src/perf_context.rs index df08243f2..b19a95c7b 100644 --- a/src/perf_context.rs +++ b/src/perf_context.rs @@ -11,7 +11,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -use crocksdb_ffi::{self, DBIOStatsContext, DBPerfContext}; +use crocksdb_ffi::{self, crocksdb_iostats_context_t, crocksdb_perf_context_t}; #[derive(Copy, Clone, Debug, PartialEq)] pub enum PerfLevel { @@ -51,7 +51,7 @@ pub fn set_perf_level(level: PerfLevel) { } pub struct PerfContext { - inner: *mut DBPerfContext, + inner: *mut crocksdb_perf_context_t, } impl PerfContext { @@ -337,7 +337,7 @@ impl PerfContext { } pub struct IOStatsContext { - inner: *mut DBIOStatsContext, + inner: *mut crocksdb_iostats_context_t, } impl IOStatsContext { diff --git a/src/rocksdb.rs b/src/rocksdb.rs index 54bdca872..2c9b0bf3d 100644 --- a/src/rocksdb.rs +++ b/src/rocksdb.rs @@ -13,12 +13,12 @@ // limitations under the License. use crocksdb_ffi::{ - self, DBBackupEngine, DBCFHandle, DBCache, DBCompressionType, DBEnv, DBInstance, DBMapProperty, - DBPinnableSlice, DBSequentialFile, DBStatisticsHistogramType, DBStatisticsTickerType, - DBTitanDBOptions, DBWriteBatch, + self, crocksdb_backup_engine_t, crocksdb_cache_t, crocksdb_column_family_handle_t, + crocksdb_env_t, crocksdb_map_property_t, crocksdb_memory_allocator_t, crocksdb_pinnableslice_t, + crocksdb_sequential_file_t, crocksdb_t, crocksdb_writebatch_t, ctitandb_options_t, + DBStatisticsHistogramType, DBStatisticsTickerType, }; use libc::{self, c_char, c_int, c_void, size_t}; -use librocksdb_sys::DBMemoryAllocator; use metadata::ColumnFamilyMetaData; use rocksdb_options::{ CColumnFamilyDescriptor, ColumnFamilyDescriptor, ColumnFamilyOptions, CompactOptions, @@ -41,9 +41,11 @@ use std::{fs, ptr, slice}; use table_properties::{TableProperties, TablePropertiesCollection}; use titan::TitanDBOptions; +use util::opt_bytes_to_ptr; +use DBCompressionType; pub struct CFHandle { - inner: *mut DBCFHandle, + inner: *mut crocksdb_column_family_handle_t, } impl CFHandle { @@ -98,7 +100,7 @@ fn build_cstring_list(str_list: &[&str]) -> Vec { } pub struct MapProperty { - inner: *mut DBMapProperty, + inner: *mut crocksdb_map_property_t, } impl Drop for MapProperty { @@ -137,7 +139,7 @@ impl MapProperty { } pub struct DB { - inner: *mut DBInstance, + inner: *mut crocksdb_t, cfs: BTreeMap, path: String, opts: DBOptions, @@ -161,7 +163,7 @@ impl DB { } pub struct WriteBatch { - inner: *mut DBWriteBatch, + inner: *mut crocksdb_writebatch_t, } unsafe impl Send for WriteBatch {} @@ -174,7 +176,7 @@ pub struct Snapshot> { pub struct DBIterator { _db: D, _readopts: ReadOptions, - inner: *mut crocksdb_ffi::DBIterator, + inner: *mut crocksdb_ffi::crocksdb_iterator_t, } pub enum SeekKey<'a> { @@ -241,9 +243,11 @@ impl DBIterator { match key { SeekKey::Start => crocksdb_ffi::crocksdb_iter_seek_to_first(self.inner), SeekKey::End => crocksdb_ffi::crocksdb_iter_seek_to_last(self.inner), - SeekKey::Key(key) => { - crocksdb_ffi::crocksdb_iter_seek(self.inner, key.as_ptr(), key.len() as size_t) - } + SeekKey::Key(key) => crocksdb_ffi::crocksdb_iter_seek( + self.inner, + key.as_ptr() as *const i8, + key.len() as size_t, + ), } } self.valid() @@ -256,7 +260,7 @@ impl DBIterator { SeekKey::End => crocksdb_ffi::crocksdb_iter_seek_to_last(self.inner), SeekKey::Key(key) => crocksdb_ffi::crocksdb_iter_seek_for_prev( self.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len() as size_t, ), } @@ -286,7 +290,7 @@ impl DBIterator { let key_len_ptr: *mut size_t = &mut key_len; unsafe { let key_ptr = crocksdb_ffi::crocksdb_iter_key(self.inner, key_len_ptr); - slice::from_raw_parts(key_ptr, key_len as usize) + slice::from_raw_parts(key_ptr as *const u8, key_len as usize) } } @@ -297,7 +301,7 @@ impl DBIterator { let val_len_ptr: *mut size_t = &mut val_len; unsafe { let val_ptr = crocksdb_ffi::crocksdb_iter_value(self.inner, val_len_ptr); - slice::from_raw_parts(val_ptr, val_len as usize) + slice::from_raw_parts(val_ptr as *const u8, val_len as usize) } } @@ -311,7 +315,7 @@ impl DBIterator { } pub fn valid(&self) -> Result { - let valid = unsafe { crocksdb_ffi::crocksdb_iter_valid(self.inner) }; + let valid = unsafe { crocksdb_ffi::crocksdb_iter_valid(self.inner) != 0 }; if !valid { self.status()?; } @@ -537,6 +541,7 @@ impl DB { DB::open_cf_internal(opts, path, cfds, &[], Some(error_if_log_file_exist)) } + #[allow(tyvar_behind_raw_pointer)] fn open_cf_internal<'a, T>( opts: DBOptions, path: &str, @@ -574,7 +579,7 @@ impl DB { let cf_handles: Vec<_> = vec![ptr::null_mut(); cf_names.len()]; let cf_options: Vec<_> = options .iter() - .map(|x| x.inner as *const crocksdb_ffi::Options) + .map(|x| x.inner as *const crocksdb_ffi::crocksdb_options_t) .collect(); let titan_cf_options: Vec<_> = options .iter() @@ -597,10 +602,12 @@ impl DB { let db_options = opts.inner; let db_path = cpath.as_ptr(); let db_cfs_count = cf_names.len() as c_int; - let db_cf_ptrs = cf_names.as_ptr(); - let db_cf_opts = cf_options.as_ptr(); - let titan_cf_opts = titan_cf_options.as_ptr(); - let db_cf_handles = cf_handles.as_ptr(); + let db_cf_ptrs = cf_names.as_ptr() as *mut *const i8; + let db_cf_opts = cf_options.as_ptr() as *mut *const librocksdb_sys::crocksdb_options_t; + let titan_cf_opts = + titan_cf_options.as_ptr() as *mut *const librocksdb_sys::ctitandb_options_t; + let db_cf_handles = + cf_handles.as_ptr() as *mut *mut librocksdb_sys::crocksdb_column_family_handle_t; let titan_options = opts.titan_inner; if !titan_options.is_null() { @@ -621,7 +628,7 @@ impl DB { db_cf_ptrs, db_cf_opts, db_cf_handles, - flag + flag as u8 )) } } else if titan_options.is_null() { @@ -660,7 +667,7 @@ impl DB { db_cf_ptrs, db_cf_opts, ttl_array, - readonly, + readonly as u8, db_cf_handles )) } @@ -780,7 +787,7 @@ impl DB { let val = ffi_try!(crocksdb_get_pinned( self.inner, readopts.get_inner(), - key.as_ptr(), + key.as_ptr() as *const i8, key.len() as size_t )); if val.is_null() { @@ -806,7 +813,7 @@ impl DB { self.inner, readopts.get_inner(), cf.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len() as size_t )); if val.is_null() { @@ -922,9 +929,9 @@ impl DB { ffi_try!(crocksdb_put( self.inner, writeopts.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len() as size_t, - value.as_ptr(), + value.as_ptr() as *const i8, value.len() as size_t )); Ok(()) @@ -943,9 +950,9 @@ impl DB { self.inner, writeopts.inner, cf.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len() as size_t, - value.as_ptr(), + value.as_ptr() as *const i8, value.len() as size_t )); Ok(()) @@ -961,9 +968,9 @@ impl DB { ffi_try!(crocksdb_merge( self.inner, writeopts.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len() as size_t, - value.as_ptr(), + value.as_ptr() as *const i8, value.len() as size_t )); Ok(()) @@ -981,9 +988,9 @@ impl DB { self.inner, writeopts.inner, cf.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len() as size_t, - value.as_ptr(), + value.as_ptr() as *const i8, value.len() as size_t )); Ok(()) @@ -994,7 +1001,7 @@ impl DB { ffi_try!(crocksdb_delete( self.inner, writeopts.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len() as size_t )); Ok(()) @@ -1012,7 +1019,7 @@ impl DB { self.inner, writeopts.inner, cf.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len() as size_t )); Ok(()) @@ -1024,7 +1031,7 @@ impl DB { ffi_try!(crocksdb_single_delete( self.inner, writeopts.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len() as size_t )); Ok(()) @@ -1042,7 +1049,7 @@ impl DB { self.inner, writeopts.inner, cf.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len() as size_t )); Ok(()) @@ -1061,9 +1068,9 @@ impl DB { self.inner, writeopts.inner, cf.inner, - begin_key.as_ptr(), + begin_key.as_ptr() as *const i8, begin_key.len() as size_t, - end_key.as_ptr(), + end_key.as_ptr() as *const i8, end_key.len() as size_t )); Ok(()) @@ -1096,7 +1103,7 @@ impl DB { /// afterwards. pub fn flush_wal(&self, sync: bool) -> Result<(), String> { unsafe { - ffi_try!(crocksdb_flush_wal(self.inner, sync)); + ffi_try!(crocksdb_flush_wal(self.inner, sync as u8)); Ok(()) } } @@ -1151,9 +1158,9 @@ impl DB { crocksdb_ffi::crocksdb_approximate_sizes( self.inner, n, - start_key_ptr, + start_key_ptr as *const *const i8, start_key_len_ptr, - end_key_ptr, + end_key_ptr as *const *const i8, end_key_len_ptr, size_ptr, ) @@ -1163,9 +1170,9 @@ impl DB { self.inner, cf.inner, n, - start_key_ptr, + start_key_ptr as *const *const i8, start_key_len_ptr, - end_key_ptr, + end_key_ptr as *const *const i8, end_key_len_ptr, size_ptr, ) @@ -1180,9 +1187,9 @@ impl DB { unsafe { crocksdb_ffi::crocksdb_approximate_memtable_stats( self.inner, - range.start_key.as_ptr(), + range.start_key.as_ptr() as *const i8, range.start_key.len(), - range.end_key.as_ptr(), + range.end_key.as_ptr() as *const i8, range.end_key.len(), &mut count, &mut size, @@ -1198,9 +1205,9 @@ impl DB { crocksdb_ffi::crocksdb_approximate_memtable_stats_cf( self.inner, cf.inner, - range.start_key.as_ptr(), + range.start_key.as_ptr() as *const i8, range.start_key.len(), - range.end_key.as_ptr(), + range.end_key.as_ptr() as *const i8, range.end_key.len(), &mut count, &mut size, @@ -1211,9 +1218,15 @@ impl DB { pub fn compact_range(&self, start_key: Option<&[u8]>, end_key: Option<&[u8]>) { unsafe { - let (start, s_len) = start_key.map_or((ptr::null(), 0), |k| (k.as_ptr(), k.len())); - let (end, e_len) = end_key.map_or((ptr::null(), 0), |k| (k.as_ptr(), k.len())); - crocksdb_ffi::crocksdb_compact_range(self.inner, start, s_len, end, e_len); + let (_, s_len) = start_key.map_or((ptr::null(), 0), |k| (k.as_ptr(), k.len())); + let (_, e_len) = end_key.map_or((ptr::null(), 0), |k| (k.as_ptr(), k.len())); + crocksdb_ffi::crocksdb_compact_range( + self.inner, + opt_bytes_to_ptr(start_key), + s_len, + opt_bytes_to_ptr(end_key), + e_len, + ); } } @@ -1224,9 +1237,16 @@ impl DB { end_key: Option<&[u8]>, ) { unsafe { - let (start, s_len) = start_key.map_or((ptr::null(), 0), |k| (k.as_ptr(), k.len())); - let (end, e_len) = end_key.map_or((ptr::null(), 0), |k| (k.as_ptr(), k.len())); - crocksdb_ffi::crocksdb_compact_range_cf(self.inner, cf.inner, start, s_len, end, e_len); + let (_, s_len) = start_key.map_or((ptr::null(), 0), |k| (k.as_ptr(), k.len())); + let (_, e_len) = end_key.map_or((ptr::null(), 0), |k| (k.as_ptr(), k.len())); + crocksdb_ffi::crocksdb_compact_range_cf( + self.inner, + cf.inner, + opt_bytes_to_ptr(start_key), + s_len, + opt_bytes_to_ptr(end_key), + e_len, + ); } } @@ -1244,9 +1264,9 @@ impl DB { self.inner, cf.inner, compact_options.inner, - start, + start as *const i8, s_len, - end, + end as *const i8, e_len, ); } @@ -1262,20 +1282,20 @@ impl DB { if self.is_titan() { ffi_try!(ctitandb_delete_files_in_range( self.inner, - start_key.as_ptr(), + start_key.as_ptr() as *const i8, start_key.len() as size_t, - end_key.as_ptr(), + end_key.as_ptr() as *const i8, end_key.len() as size_t, - include_end + include_end as u8 )); } else { ffi_try!(crocksdb_delete_files_in_range( self.inner, - start_key.as_ptr(), + start_key.as_ptr() as *const i8, start_key.len() as size_t, - end_key.as_ptr(), + end_key.as_ptr() as *const i8, end_key.len() as size_t, - include_end + include_end as u8 )); } Ok(()) @@ -1294,21 +1314,21 @@ impl DB { ffi_try!(ctitandb_delete_files_in_range_cf( self.inner, cf.inner, - start_key.as_ptr(), + start_key.as_ptr() as *const i8, start_key.len() as size_t, - end_key.as_ptr(), + end_key.as_ptr() as *const i8, end_key.len() as size_t, - include_end + include_end as u8 )); } else { ffi_try!(crocksdb_delete_files_in_range_cf( self.inner, cf.inner, - start_key.as_ptr(), + start_key.as_ptr() as *const i8, start_key.len() as size_t, - end_key.as_ptr(), + end_key.as_ptr() as *const i8, end_key.len() as size_t, - include_end + include_end as u8 )); } Ok(()) @@ -1330,23 +1350,23 @@ impl DB { ffi_try!(ctitandb_delete_files_in_ranges_cf( self.inner, cf.inner, - start_keys.as_ptr(), + start_keys.as_ptr() as *const *const i8, start_keys_lens.as_ptr(), - limit_keys.as_ptr(), + limit_keys.as_ptr() as *const *const i8, limit_keys_lens.as_ptr(), ranges.len(), - include_end + include_end as u8 )); } else { ffi_try!(crocksdb_delete_files_in_ranges_cf( self.inner, cf.inner, - start_keys.as_ptr(), + start_keys.as_ptr() as *const *const i8, start_keys_lens.as_ptr(), - limit_keys.as_ptr(), + limit_keys.as_ptr() as *const *const i8, limit_keys_lens.as_ptr(), ranges.len(), - include_end + include_end as u8 )); } } @@ -1451,12 +1471,13 @@ impl DB { unsafe { let info = MapProperty::new(); let cname = CString::new(name.as_bytes()).unwrap(); - if !crocksdb_ffi::crocksdb_get_map_property_cf( + if crocksdb_ffi::crocksdb_get_map_property_cf( self.inner, cf.inner, cname.as_ptr(), info.inner, - ) { + ) == 0 + { return None; } Some(info) @@ -1477,8 +1498,8 @@ impl DB { let value_ptrs: Vec<_> = value_strs.iter().map(|s| s.as_ptr()).collect(); ffi_try!(crocksdb_set_db_options( self.inner, - name_ptrs.as_ptr() as *const *const c_char, - value_ptrs.as_ptr() as *const *const c_char, + name_ptrs.as_ptr() as *mut *const i8, + value_ptrs.as_ptr() as *mut *const i8, options.len() as size_t )); Ok(()) @@ -1492,7 +1513,7 @@ impl DB { let titan_inner = if self.is_titan() { crocksdb_ffi::ctitandb_get_titan_options_cf(self.inner, cf.inner) } else { - ptr::null_mut::() + ptr::null_mut::() }; ColumnFamilyOptions::from_raw(inner, titan_inner) } @@ -1504,7 +1525,7 @@ impl DB { let titan_inner = if self.is_titan() { crocksdb_ffi::ctitandb_get_titan_options_cf(self.inner, cf.inner) } else { - ptr::null_mut::() + ptr::null_mut::() }; ColumnFamilyOptions::from_raw(inner, titan_inner) } @@ -1525,8 +1546,8 @@ impl DB { ffi_try!(crocksdb_set_options_cf( self.inner, cf.inner, - name_ptrs.as_ptr() as *const *const c_char, - value_ptrs.as_ptr() as *const *const c_char, + name_ptrs.as_ptr() as *mut *const i8, + value_ptrs.as_ptr() as *mut *const i8, options.len() as size_t )); Ok(()) @@ -1592,7 +1613,7 @@ impl DB { opt.inner )) }; - Ok(has_flush) + Ok(has_flush != 0) } pub fn backup_at(&self, path: &str) -> Result { @@ -1693,9 +1714,9 @@ impl DB { self.inner, cf.inner, ranges.len() as i32, - start_keys.as_ptr(), + start_keys.as_ptr() as *const *const i8, start_keys_lens.as_ptr(), - limit_keys.as_ptr(), + limit_keys.as_ptr() as *const *const i8, limit_keys_lens.as_ptr() )); Ok(TablePropertiesCollection::from_raw(props)) @@ -1710,23 +1731,23 @@ impl DB { unsafe { let kvs = ffi_try!(crocksdb_get_all_key_versions( self.inner, - start_key.as_ptr(), + start_key.as_ptr() as *const i8, start_key.len() as size_t, - end_key.as_ptr(), + end_key.as_ptr() as *const i8, end_key.len() as size_t )); let size = crocksdb_ffi::crocksdb_keyversions_count(kvs) as usize; let mut key_versions = Vec::with_capacity(size); for i in 0..size { key_versions.push(KeyVersion { - key: CStr::from_ptr(crocksdb_ffi::crocksdb_keyversions_key(kvs, i)) + key: CStr::from_ptr(crocksdb_ffi::crocksdb_keyversions_key(kvs, i as i32)) .to_string_lossy() .into_owned(), - value: CStr::from_ptr(crocksdb_ffi::crocksdb_keyversions_value(kvs, i)) + value: CStr::from_ptr(crocksdb_ffi::crocksdb_keyversions_value(kvs, i as i32)) .to_string_lossy() .into_owned(), - seq: crocksdb_ffi::crocksdb_keyversions_seq(kvs, i), - value_type: crocksdb_ffi::crocksdb_keyversions_type(kvs, i), + seq: crocksdb_ffi::crocksdb_keyversions_seq(kvs, i as i32), + value_type: crocksdb_ffi::crocksdb_keyversions_type(kvs, i as i32), }) } crocksdb_ffi::crocksdb_keyversions_destroy(kvs); @@ -1759,7 +1780,7 @@ impl DB { self.inner, cf.inner, opts.inner, - input_file_names.as_ptr() as *const *const c_char, + input_file_names.as_ptr() as *mut *const i8, input_file_names.len(), output_level )); @@ -1905,9 +1926,9 @@ impl Writable for WriteBatch { unsafe { crocksdb_ffi::crocksdb_writebatch_put( self.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len() as size_t, - value.as_ptr(), + value.as_ptr() as *const i8, value.len() as size_t, ); Ok(()) @@ -1919,9 +1940,9 @@ impl Writable for WriteBatch { crocksdb_ffi::crocksdb_writebatch_put_cf( self.inner, cf.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len() as size_t, - value.as_ptr(), + value.as_ptr() as *const i8, value.len() as size_t, ); Ok(()) @@ -1932,9 +1953,9 @@ impl Writable for WriteBatch { unsafe { crocksdb_ffi::crocksdb_writebatch_merge( self.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len() as size_t, - value.as_ptr(), + value.as_ptr() as *const i8, value.len() as size_t, ); Ok(()) @@ -1946,9 +1967,9 @@ impl Writable for WriteBatch { crocksdb_ffi::crocksdb_writebatch_merge_cf( self.inner, cf.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len() as size_t, - value.as_ptr(), + value.as_ptr() as *const i8, value.len() as size_t, ); Ok(()) @@ -1957,7 +1978,11 @@ impl Writable for WriteBatch { fn delete(&self, key: &[u8]) -> Result<(), String> { unsafe { - crocksdb_ffi::crocksdb_writebatch_delete(self.inner, key.as_ptr(), key.len() as size_t); + crocksdb_ffi::crocksdb_writebatch_delete( + self.inner, + key.as_ptr() as *const i8, + key.len() as size_t, + ); Ok(()) } } @@ -1967,7 +1992,7 @@ impl Writable for WriteBatch { crocksdb_ffi::crocksdb_writebatch_delete_cf( self.inner, cf.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len() as size_t, ); Ok(()) @@ -1978,7 +2003,7 @@ impl Writable for WriteBatch { unsafe { crocksdb_ffi::crocksdb_writebatch_single_delete( self.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len() as size_t, ); Ok(()) @@ -1990,7 +2015,7 @@ impl Writable for WriteBatch { crocksdb_ffi::crocksdb_writebatch_single_delete_cf( self.inner, cf.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len() as size_t, ); Ok(()) @@ -2001,9 +2026,9 @@ impl Writable for WriteBatch { unsafe { crocksdb_ffi::crocksdb_writebatch_delete_range( self.inner, - begin_key.as_ptr(), + begin_key.as_ptr() as *const i8, begin_key.len(), - end_key.as_ptr(), + end_key.as_ptr() as *const i8, end_key.len(), ); Ok(()) @@ -2020,9 +2045,9 @@ impl Writable for WriteBatch { crocksdb_ffi::crocksdb_writebatch_delete_range_cf( self.inner, cf.inner, - begin_key.as_ptr(), + begin_key.as_ptr() as *const i8, begin_key.len(), - end_key.as_ptr(), + end_key.as_ptr() as *const i8, end_key.len(), ); Ok(()) @@ -2030,6 +2055,7 @@ impl Writable for WriteBatch { } } +pub type DBPinnableSlice = crocksdb_pinnableslice_t; pub struct DBVector { pinned_slice: *mut DBPinnableSlice, } @@ -2053,7 +2079,7 @@ impl Deref for DBVector { let val_len_ptr = &mut val_len as *mut size_t; unsafe { let val = crocksdb_ffi::crocksdb_pinnableslice_value(self.pinned_slice, val_len_ptr); - slice::from_raw_parts(val, val_len) + slice::from_raw_parts(val as *const u8, val_len) } } } @@ -2077,7 +2103,7 @@ impl DBVector { } pub struct BackupEngine { - inner: *mut DBBackupEngine, + inner: *mut crocksdb_backup_engine_t, } impl BackupEngine { @@ -2119,7 +2145,7 @@ impl Drop for BackupEngine { // SstFileReader is used to read sst files that are generated by DB or // SstFileWriter. pub struct SstFileReader { - inner: *mut crocksdb_ffi::SstFileReader, + inner: *mut crocksdb_ffi::crocksdb_sstfilereader_t, _opt: ColumnFamilyOptions, } @@ -2187,7 +2213,7 @@ impl SstFileReader { pub fn read_table_properties(&self, mut action: F) { extern "C" fn callback( ctx: *mut c_void, - ptr: *const crocksdb_ffi::DBTableProperties, + ptr: *const crocksdb_ffi::crocksdb_table_properties_t, ) { unsafe { let caller = ptr::read(ctx as *mut F); @@ -2199,7 +2225,7 @@ impl SstFileReader { crocksdb_ffi::crocksdb_sstfilereader_read_table_properties( self.inner, &mut action as *mut F as *mut c_void, - callback::, + Some(callback::), ); mem::forget(action); } @@ -2220,7 +2246,7 @@ impl Drop for SstFileReader { /// SstFileWriter is used to create sst files that can be added to database later /// All keys in files generated by SstFileWriter will have sequence number = 0 pub struct SstFileWriter { - inner: *mut crocksdb_ffi::SstFileWriter, + inner: *mut crocksdb_ffi::crocksdb_sstfilewriter_t, _env_opt: EnvOptions, _opt: ColumnFamilyOptions, } @@ -2270,9 +2296,9 @@ impl SstFileWriter { unsafe { ffi_try!(crocksdb_sstfilewriter_put( self.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len(), - val.as_ptr(), + val.as_ptr() as *const i8, val.len() )); Ok(()) @@ -2283,9 +2309,9 @@ impl SstFileWriter { unsafe { ffi_try!(crocksdb_sstfilewriter_merge( self.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len(), - val.as_ptr(), + val.as_ptr() as *const i8, val.len() )); Ok(()) @@ -2296,7 +2322,7 @@ impl SstFileWriter { unsafe { ffi_try!(crocksdb_sstfilewriter_delete( self.inner, - key.as_ptr(), + key.as_ptr() as *const i8, key.len() )); Ok(()) @@ -2307,9 +2333,9 @@ impl SstFileWriter { unsafe { ffi_try!(crocksdb_sstfilewriter_delete_range( self.inner, - begin_key.as_ptr(), + begin_key.as_ptr() as *const i8, begin_key.len(), - end_key.as_ptr(), + end_key.as_ptr() as *const i8, end_key.len() )); Ok(()) @@ -2337,7 +2363,7 @@ impl Drop for SstFileWriter { } pub struct ExternalSstFileInfo { - inner: *mut crocksdb_ffi::ExternalSstFileInfo, + inner: *mut crocksdb_ffi::crocksdb_externalsstfileinfo_t, } impl ExternalSstFileInfo { @@ -2353,7 +2379,7 @@ impl ExternalSstFileInfo { let mut len: size_t = 0; unsafe { let ptr = crocksdb_ffi::crocksdb_externalsstfileinfo_file_path(self.inner, &mut len); - let bytes = slice::from_raw_parts(ptr, len as usize); + let bytes = slice::from_raw_parts(ptr as *const u8, len as usize); PathBuf::from(String::from_utf8(bytes.to_owned()).unwrap()) } } @@ -2362,7 +2388,7 @@ impl ExternalSstFileInfo { let mut len: size_t = 0; unsafe { let ptr = crocksdb_ffi::crocksdb_externalsstfileinfo_smallest_key(self.inner, &mut len); - slice::from_raw_parts(ptr, len as usize) + slice::from_raw_parts(ptr as *const u8, len as usize) } } @@ -2370,7 +2396,7 @@ impl ExternalSstFileInfo { let mut len: size_t = 0; unsafe { let ptr = crocksdb_ffi::crocksdb_externalsstfileinfo_largest_key(self.inner, &mut len); - slice::from_raw_parts(ptr, len as usize) + slice::from_raw_parts(ptr as *const u8, len as usize) } } @@ -2400,14 +2426,14 @@ pub fn supported_compression() -> Vec { let size = crocksdb_ffi::crocksdb_get_supported_compression_number() as usize; let mut v: Vec = Vec::with_capacity(size); let pv = v.as_mut_ptr(); - crocksdb_ffi::crocksdb_get_supported_compression(pv, size as size_t); + crocksdb_ffi::crocksdb_get_supported_compression(pv as *mut i32, size as size_t); v.set_len(size); v } } pub struct Env { - pub inner: *mut DBEnv, + pub inner: *mut crocksdb_env_t, #[allow(dead_code)] base: Option>, } @@ -2507,6 +2533,7 @@ impl Drop for Env { } } +pub type DBSequentialFile = crocksdb_sequential_file_t; pub struct SequentialFile { inner: *mut DBSequentialFile, } @@ -2531,7 +2558,7 @@ impl io::Read for SequentialFile { let size = crocksdb_ffi::crocksdb_sequential_file_read( self.inner, buf.len() as size_t, - buf.as_mut_ptr(), + buf.as_mut_ptr() as *mut i8, &mut err, ); if !err.is_null() { @@ -2554,7 +2581,7 @@ impl Drop for SequentialFile { } pub struct Cache { - pub inner: *mut DBCache, + pub inner: *mut crocksdb_cache_t, } impl Cache { @@ -2577,7 +2604,7 @@ impl Drop for Cache { } pub struct MemoryAllocator { - pub inner: *mut DBMemoryAllocator, + pub inner: *mut crocksdb_memory_allocator_t, } impl MemoryAllocator { @@ -2628,18 +2655,19 @@ pub fn load_latest_options( let dbpath = CString::new(dbpath.as_bytes()).map_err(|_| ERR_CONVERT_PATH.to_owned())?; let db_options = DBOptions::new(); unsafe { - let raw_cf_descs: *mut *mut crocksdb_ffi::ColumnFamilyDescriptor = ptr::null_mut(); + let mut raw_cf_descs: *mut *mut crocksdb_ffi::crocksdb_column_family_descriptor = + ptr::null_mut(); let mut cf_descs_len: size_t = 0; let ok = ffi_try!(crocksdb_load_latest_options( dbpath.as_ptr(), env.inner, db_options.inner, - &raw_cf_descs, + &mut raw_cf_descs, &mut cf_descs_len, - ignore_unknown_options + ignore_unknown_options as u8 )); - if !ok { + if ok == 0 { return Ok(None); } let cf_descs_list = slice::from_raw_parts(raw_cf_descs, cf_descs_len); @@ -2663,7 +2691,7 @@ pub fn run_ldb_tool(ldb_args: &[String], opts: &DBOptions) { let args: Vec<_> = ldb_args_cstrs.iter().map(|s| s.as_ptr()).collect(); crocksdb_ffi::crocksdb_run_ldb_tool( args.len() as i32, - args.as_ptr() as *const *const c_char, + args.as_ptr() as *mut *mut i8, opts.inner, ); } diff --git a/src/rocksdb_options.rs b/src/rocksdb_options.rs index c883fe886..87eae8550 100644 --- a/src/rocksdb_options.rs +++ b/src/rocksdb_options.rs @@ -16,12 +16,11 @@ use compaction_filter::{new_compaction_filter, CompactionFilter, CompactionFilterHandle}; use comparator::{self, compare_callback, ComparatorCallback}; use crocksdb_ffi::{ - self, DBBlockBasedTableOptions, DBBottommostLevelCompaction, DBCompactOptions, - DBCompactionOptions, DBCompressionType, DBFifoCompactionOptions, DBFlushOptions, - DBInfoLogLevel, DBInstance, DBLRUCacheOptions, DBRateLimiter, DBRateLimiterMode, DBReadOptions, - DBRecoveryMode, DBRestoreOptions, DBSnapshot, DBStatisticsHistogramType, - DBStatisticsTickerType, DBTitanDBOptions, DBTitanReadOptions, DBWriteOptions, IndexType, - Options, + self, crocksdb_block_based_table_options_t, crocksdb_compaction_options_t, + crocksdb_compactoptions_t, crocksdb_fifo_compaction_options_t, crocksdb_flushoptions_t, + crocksdb_options_t, crocksdb_ratelimiter_t, crocksdb_readoptions_t, crocksdb_restore_options_t, + crocksdb_snapshot_t, crocksdb_t, crocksdb_writeoptions_t, ctitandb_options_t, + ctitandb_readoptions_t, DBStatisticsHistogramType, DBStatisticsTickerType, }; use event_listener::{new_event_listener, EventListener}; use libc::{self, c_double, c_int, c_uchar, c_void, size_t}; @@ -39,6 +38,10 @@ use table_properties_collector_factory::{ new_table_properties_collector_factory, TablePropertiesCollectorFactory, }; use titan::TitanDBOptions; +use { + CompactionPriority, DBBottommostLevelCompaction, DBCompactionStyle, DBCompressionType, + DBInfoLogLevel, DBRateLimiterMode, DBRecoveryMode, IndexType, +}; #[derive(Default, Debug)] pub struct HistogramData { @@ -51,7 +54,7 @@ pub struct HistogramData { } pub struct BlockBasedOptions { - inner: *mut DBBlockBasedTableOptions, + inner: *mut crocksdb_block_based_table_options_t, } impl Drop for BlockBasedOptions { @@ -94,7 +97,10 @@ impl BlockBasedOptions { pub fn set_index_type(&mut self, index_type: IndexType) { unsafe { - crocksdb_ffi::crocksdb_block_based_options_set_index_type(self.inner, index_type); + crocksdb_ffi::crocksdb_block_based_options_set_index_type( + self.inner, + index_type as i32, + ); } } @@ -106,7 +112,7 @@ impl BlockBasedOptions { pub fn set_no_block_cache(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_block_based_options_set_no_block_cache(self.inner, v); + crocksdb_ffi::crocksdb_block_based_options_set_no_block_cache(self.inner, v as u8); } } @@ -164,7 +170,7 @@ impl BlockBasedOptions { pub fn set_whole_key_filtering(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_block_based_options_set_whole_key_filtering(self.inner, v); + crocksdb_ffi::crocksdb_block_based_options_set_whole_key_filtering(self.inner, v as u8); } } @@ -186,7 +192,7 @@ impl BlockBasedOptions { } pub struct RateLimiter { - inner: *mut DBRateLimiter, + inner: *mut crocksdb_ratelimiter_t, } unsafe impl Send for RateLimiter {} @@ -216,8 +222,8 @@ impl RateLimiter { rate_bytes_per_sec, refill_period_us, fairness, - mode, - auto_tuned, + mode as u32, + auto_tuned as u8, ) }; RateLimiter { inner: limiter } @@ -267,9 +273,12 @@ const DEFAULT_FAIRNESS: i32 = 10; // should be good by leaving it at default 10 /// This object is convenient for wrapping snapshot by yourself. In most /// cases, using `Snapshot` is enough. pub struct UnsafeSnap { - inner: *const DBSnapshot, + inner: *const crocksdb_snapshot_t, } +pub type DBInstance = crocksdb_t; +pub type DBSnapshot = crocksdb_snapshot_t; + impl UnsafeSnap { pub unsafe fn new(db: *mut DBInstance) -> UnsafeSnap { UnsafeSnap { @@ -282,6 +291,9 @@ impl UnsafeSnap { } } +pub type DBReadOptions = crocksdb_readoptions_t; +pub type DBTitanReadOptions = ctitandb_readoptions_t; + pub struct ReadOptions { inner: *mut DBReadOptions, lower_bound: Vec, @@ -327,13 +339,13 @@ impl ReadOptions { pub fn set_verify_checksums(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_readoptions_set_verify_checksums(self.inner, v); + crocksdb_ffi::crocksdb_readoptions_set_verify_checksums(self.inner, v as u8); } } pub fn fill_cache(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_readoptions_set_fill_cache(self.inner, v); + crocksdb_ffi::crocksdb_readoptions_set_fill_cache(self.inner, v as u8); } } @@ -346,7 +358,7 @@ impl ReadOptions { unsafe { crocksdb_ffi::crocksdb_readoptions_set_iterate_lower_bound( self.inner, - self.lower_bound.as_ptr(), + self.lower_bound.as_ptr() as *const i8, self.lower_bound.len(), ); } @@ -361,7 +373,7 @@ impl ReadOptions { unsafe { crocksdb_ffi::crocksdb_readoptions_set_iterate_upper_bound( self.inner, - self.upper_bound.as_ptr(), + self.upper_bound.as_ptr() as *const i8, self.upper_bound.len(), ); } @@ -379,13 +391,13 @@ impl ReadOptions { pub fn set_tailing(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_readoptions_set_tailing(self.inner, v); + crocksdb_ffi::crocksdb_readoptions_set_tailing(self.inner, v as u8); } } pub fn set_managed(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_readoptions_set_managed(self.inner, v); + crocksdb_ffi::crocksdb_readoptions_set_managed(self.inner, v as u8); } } @@ -403,33 +415,33 @@ impl ReadOptions { pub fn set_total_order_seek(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_readoptions_set_total_order_seek(self.inner, v); + crocksdb_ffi::crocksdb_readoptions_set_total_order_seek(self.inner, v as u8); } } pub fn set_prefix_same_as_start(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_readoptions_set_prefix_same_as_start(self.inner, v); + crocksdb_ffi::crocksdb_readoptions_set_prefix_same_as_start(self.inner, v as u8); } } pub fn set_pin_data(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_readoptions_set_pin_data(self.inner, v); + crocksdb_ffi::crocksdb_readoptions_set_pin_data(self.inner, v as u8); } } pub fn set_background_purge_on_iterator_cleanup(&mut self, v: bool) { unsafe { crocksdb_ffi::crocksdb_readoptions_set_background_purge_on_iterator_cleanup( - self.inner, v, + self.inner, v as u8, ); } } pub fn set_ignore_range_deletions(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_readoptions_set_ignore_range_deletions(self.inner, v); + crocksdb_ffi::crocksdb_readoptions_set_ignore_range_deletions(self.inner, v as u8); } } @@ -446,7 +458,7 @@ impl ReadOptions { if self.titan_inner.is_null() { self.titan_inner = crocksdb_ffi::ctitandb_readoptions_create(); } - crocksdb_ffi::ctitandb_readoptions_set_key_only(self.titan_inner, v); + crocksdb_ffi::ctitandb_readoptions_set_key_only(self.titan_inner, v as u8); } } @@ -457,13 +469,15 @@ impl ReadOptions { crocksdb_ffi::crocksdb_readoptions_set_table_filter( self.inner, f, - table_filter, - destroy_table_filter, + Some(table_filter), + Some(destroy_table_filter), ); } } } +pub type DBWriteOptions = crocksdb_writeoptions_t; + pub struct WriteOptions { pub inner: *mut DBWriteOptions, } @@ -494,7 +508,7 @@ impl WriteOptions { pub fn set_sync(&mut self, sync: bool) { unsafe { - crocksdb_ffi::crocksdb_writeoptions_set_sync(self.inner, sync); + crocksdb_ffi::crocksdb_writeoptions_set_sync(self.inner, sync as u8); } } @@ -510,23 +524,27 @@ impl WriteOptions { pub fn set_ignore_missing_column_families(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_writeoptions_set_ignore_missing_column_families(self.inner, v); + crocksdb_ffi::crocksdb_writeoptions_set_ignore_missing_column_families( + self.inner, v as u8, + ); } } pub fn set_no_slowdown(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_writeoptions_set_no_slowdown(self.inner, v); + crocksdb_ffi::crocksdb_writeoptions_set_no_slowdown(self.inner, v as u8); } } pub fn set_low_pri(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_writeoptions_set_low_pri(self.inner, v); + crocksdb_ffi::crocksdb_writeoptions_set_low_pri(self.inner, v as u8); } } } +pub type DBCompactOptions = crocksdb_compactoptions_t; + pub struct CompactOptions { pub inner: *mut DBCompactOptions, } @@ -542,13 +560,15 @@ impl CompactOptions { pub fn set_exclusive_manual_compaction(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_compactoptions_set_exclusive_manual_compaction(self.inner, v); + crocksdb_ffi::crocksdb_compactoptions_set_exclusive_manual_compaction( + self.inner, v as u8, + ); } } pub fn set_change_level(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_compactoptions_set_change_level(self.inner, v); + crocksdb_ffi::crocksdb_compactoptions_set_change_level(self.inner, v as u8); } } @@ -566,7 +586,9 @@ impl CompactOptions { pub fn set_bottommost_level_compaction(&mut self, v: DBBottommostLevelCompaction) { unsafe { - crocksdb_ffi::crocksdb_compactoptions_set_bottommost_level_compaction(self.inner, v); + crocksdb_ffi::crocksdb_compactoptions_set_bottommost_level_compaction( + self.inner, v as i32, + ); } } } @@ -579,6 +601,8 @@ impl Drop for CompactOptions { } } +pub type DBCompactionOptions = crocksdb_compaction_options_t; + pub struct CompactionOptions { pub inner: *mut DBCompactionOptions, } @@ -594,7 +618,10 @@ impl CompactionOptions { pub fn set_compression(&mut self, compression: DBCompressionType) { unsafe { - crocksdb_ffi::crocksdb_compaction_options_set_compression(self.inner, compression); + crocksdb_ffi::crocksdb_compaction_options_set_compression( + self.inner, + compression as i32, + ); } } @@ -619,6 +646,9 @@ impl Drop for CompactionOptions { } } +pub type Options = crocksdb_options_t; +pub type DBTitanDBOptions = ctitandb_options_t; + pub struct DBOptions { pub inner: *mut Options, env: Option>, @@ -702,7 +732,10 @@ impl DBOptions { pub fn create_if_missing(&mut self, create_if_missing: bool) { unsafe { - crocksdb_ffi::crocksdb_options_set_create_if_missing(self.inner, create_if_missing); + crocksdb_ffi::crocksdb_options_set_create_if_missing( + self.inner, + create_if_missing as u8, + ); } } @@ -755,21 +788,21 @@ impl DBOptions { pub fn set_use_direct_reads(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_options_set_use_direct_reads(self.inner, v); + crocksdb_ffi::crocksdb_options_set_use_direct_reads(self.inner, v as u8); } } pub fn set_use_direct_io_for_flush_and_compaction(&mut self, v: bool) { unsafe { crocksdb_ffi::crocksdb_options_set_use_direct_io_for_flush_and_compaction( - self.inner, v, + self.inner, v as u8, ); } } pub fn set_max_manifest_file_size(&mut self, size: u64) { unsafe { - crocksdb_ffi::crocksdb_options_set_max_manifest_file_size(self.inner, size); + crocksdb_ffi::crocksdb_options_set_max_manifest_file_size(self.inner, size as usize); } } @@ -797,7 +830,7 @@ impl DBOptions { pub fn set_wal_recovery_mode(&mut self, mode: DBRecoveryMode) { unsafe { - crocksdb_ffi::crocksdb_options_set_wal_recovery_mode(self.inner, mode); + crocksdb_ffi::crocksdb_options_set_wal_recovery_mode(self.inner, mode as i32); } } @@ -809,13 +842,16 @@ impl DBOptions { pub fn enable_statistics(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_options_enable_statistics(self.inner, v); + crocksdb_ffi::crocksdb_options_enable_statistics(self.inner, v as u8); } } pub fn get_statistics_ticker_count(&self, ticker_type: DBStatisticsTickerType) -> u64 { unsafe { - crocksdb_ffi::crocksdb_options_statistics_get_ticker_count(self.inner, ticker_type) + crocksdb_ffi::crocksdb_options_statistics_get_ticker_count( + self.inner, + ticker_type as u32, + ) } } @@ -826,7 +862,7 @@ impl DBOptions { unsafe { crocksdb_ffi::crocksdb_options_statistics_get_and_reset_ticker_count( self.inner, - ticker_type, + ticker_type as u32, ) } } @@ -839,7 +875,7 @@ impl DBOptions { let mut data = HistogramData::default(); let ret = crocksdb_ffi::crocksdb_options_statistics_get_histogram( self.inner, - hist_type, + hist_type as u32, &mut data.median, &mut data.percentile95, &mut data.percentile99, @@ -847,7 +883,7 @@ impl DBOptions { &mut data.standard_deviation, &mut data.max, ); - if !ret { + if ret == 0 { return None; } Some(data) @@ -860,7 +896,8 @@ impl DBOptions { ) -> Option { unsafe { let value = crocksdb_ffi::crocksdb_options_statistics_get_histogram_string( - self.inner, hist_type, + self.inner, + hist_type as u32, ); if value.is_null() { @@ -896,7 +933,7 @@ impl DBOptions { pub fn set_stats_dump_period_sec(&mut self, period: usize) { unsafe { - crocksdb_ffi::crocksdb_options_set_stats_dump_period_sec(self.inner, period); + crocksdb_ffi::crocksdb_options_set_stats_dump_period_sec(self.inner, period as u32); } } @@ -940,7 +977,7 @@ impl DBOptions { pub fn set_info_log_level(&mut self, level: DBInfoLogLevel) { unsafe { - crocksdb_ffi::crocksdb_options_set_info_log_level(self.inner, level); + crocksdb_ffi::crocksdb_options_set_info_log_level(self.inner, level as i32); } } @@ -1018,25 +1055,25 @@ impl DBOptions { pub fn enable_pipelined_write(&self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_options_set_enable_pipelined_write(self.inner, v); + crocksdb_ffi::crocksdb_options_set_enable_pipelined_write(self.inner, v as u8); } } pub fn enable_unordered_write(&self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_options_set_unordered_write(self.inner, v); + crocksdb_ffi::crocksdb_options_set_unordered_write(self.inner, v as u8); } } pub fn allow_concurrent_memtable_write(&self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_options_set_allow_concurrent_memtable_write(self.inner, v); + crocksdb_ffi::crocksdb_options_set_allow_concurrent_memtable_write(self.inner, v as u8); } } pub fn manual_wal_flush(&self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_options_set_manual_wal_flush(self.inner, v); + crocksdb_ffi::crocksdb_options_set_manual_wal_flush(self.inner, v as u8); } } @@ -1177,7 +1214,7 @@ impl ColumnFamilyOptions { unsafe { crocksdb_ffi::crocksdb_options_optimize_level_style_compaction( self.inner, - memtable_memory_budget, + memtable_memory_budget as u64, ); } } @@ -1237,19 +1274,22 @@ impl ColumnFamilyOptions { pub fn compression(&mut self, t: DBCompressionType) { unsafe { - crocksdb_ffi::crocksdb_options_set_compression(self.inner, t); + crocksdb_ffi::crocksdb_options_set_compression(self.inner, t as i32); } } pub fn get_compression(&self) -> DBCompressionType { - unsafe { crocksdb_ffi::crocksdb_options_get_compression(self.inner) } + unsafe { + num::FromPrimitive::from_i32(crocksdb_ffi::crocksdb_options_get_compression(self.inner)) + .unwrap() + } } pub fn compression_per_level(&mut self, level_types: &[DBCompressionType]) { unsafe { crocksdb_ffi::crocksdb_options_set_compression_per_level( self.inner, - level_types.as_ptr(), + level_types.as_ptr() as *mut i32, level_types.len() as size_t, ) } @@ -1263,12 +1303,14 @@ impl ColumnFamilyOptions { let pret = ret.as_mut_ptr(); crocksdb_ffi::crocksdb_options_get_compression_per_level(self.inner, pret); ret.set_len(size); - ret + ret.iter() + .map(|&x| num::FromPrimitive::from_i32(x).unwrap()) + .collect() } } pub fn bottommost_compression(&self, c: DBCompressionType) { - unsafe { crocksdb_ffi::crocksdb_set_bottommost_compression(self.inner, c) } + unsafe { crocksdb_ffi::crocksdb_set_bottommost_compression(self.inner, c as i32) } } pub fn add_merge_operator(&mut self, name: &str, merge_fn: MergeFn) { @@ -1281,11 +1323,11 @@ impl ColumnFamilyOptions { unsafe { let mo = crocksdb_ffi::crocksdb_mergeoperator_create( cb, - merge_operator::destructor_callback, - full_merge_callback, - partial_merge_callback, + Some(merge_operator::destructor_callback), + Some(full_merge_callback), + Some(partial_merge_callback), None, - merge_operator::name_callback, + Some(merge_operator::name_callback), ); crocksdb_ffi::crocksdb_options_set_merge_operator(self.inner, mo); } @@ -1301,9 +1343,9 @@ impl ColumnFamilyOptions { unsafe { let cmp = crocksdb_ffi::crocksdb_comparator_create( cb, - comparator::destructor_callback, - compare_callback, - comparator::name_callback, + Some(comparator::destructor_callback), + Some(compare_callback), + Some(comparator::name_callback), ); crocksdb_ffi::crocksdb_options_set_comparator(self.inner, cmp); } @@ -1329,7 +1371,7 @@ impl ColumnFamilyOptions { pub fn set_write_buffer_size(&mut self, size: u64) { unsafe { - crocksdb_ffi::crocksdb_options_set_write_buffer_size(self.inner, size); + crocksdb_ffi::crocksdb_options_set_write_buffer_size(self.inner, size as usize); } } @@ -1362,20 +1404,23 @@ impl ColumnFamilyOptions { pub fn set_level_compaction_dynamic_level_bytes(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_options_set_level_compaction_dynamic_level_bytes(self.inner, v); + crocksdb_ffi::crocksdb_options_set_level_compaction_dynamic_level_bytes( + self.inner, v as u8, + ); } } pub fn get_level_compaction_dynamic_level_bytes(&self) -> bool { unsafe { - crocksdb_ffi::crocksdb_options_get_level_compaction_dynamic_level_bytes(self.inner) + crocksdb_ffi::crocksdb_options_get_level_compaction_dynamic_level_bytes(self.inner) != 0 } } pub fn set_soft_pending_compaction_bytes_limit(&mut self, size: u64) { unsafe { crocksdb_ffi::crocksdb_options_set_soft_pending_compaction_bytes_limit( - self.inner, size, + self.inner, + size as usize, ); } } @@ -1383,13 +1428,15 @@ impl ColumnFamilyOptions { pub fn get_soft_pending_compaction_bytes_limit(&self) -> u64 { unsafe { crocksdb_ffi::crocksdb_options_get_soft_pending_compaction_bytes_limit(self.inner) + as u64 } } pub fn set_hard_pending_compaction_bytes_limit(&mut self, size: u64) { unsafe { crocksdb_ffi::crocksdb_options_set_hard_pending_compaction_bytes_limit( - self.inner, size, + self.inner, + size as usize, ); } } @@ -1397,6 +1444,7 @@ impl ColumnFamilyOptions { pub fn get_hard_pending_compaction_bytes_limit(&self) -> u64 { unsafe { crocksdb_ffi::crocksdb_options_get_hard_pending_compaction_bytes_limit(self.inner) + as u64 } } @@ -1446,15 +1494,15 @@ impl ColumnFamilyOptions { unsafe { crocksdb_ffi::crocksdb_options_get_level0_stop_writes_trigger(self.inner) as u32 } } - pub fn set_compaction_style(&mut self, style: crocksdb_ffi::DBCompactionStyle) { + pub fn set_compaction_style(&mut self, style: DBCompactionStyle) { unsafe { - crocksdb_ffi::crocksdb_options_set_compaction_style(self.inner, style); + crocksdb_ffi::crocksdb_options_set_compaction_style(self.inner, style as i32); } } - pub fn compaction_priority(&mut self, priority: crocksdb_ffi::CompactionPriority) { + pub fn compaction_priority(&mut self, priority: CompactionPriority) { unsafe { - crocksdb_ffi::crocksdb_options_set_compaction_priority(self.inner, priority); + crocksdb_ffi::crocksdb_options_set_compaction_priority(self.inner, priority as u8); } } @@ -1519,7 +1567,7 @@ impl ColumnFamilyOptions { pub fn set_optimize_filters_for_hits(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_options_set_optimize_filters_for_hits(self.inner, v); + crocksdb_ffi::crocksdb_options_set_optimize_filters_for_hits(self.inner, v as u8); } } @@ -1552,7 +1600,7 @@ impl ColumnFamilyOptions { pub fn set_force_consistency_checks(&mut self, v: bool) { unsafe { - crocksdb_ffi::crocksdb_options_set_force_consistency_checks(self.inner, v); + crocksdb_ffi::crocksdb_options_set_force_consistency_checks(self.inner, v as u8); } } @@ -1663,12 +1711,12 @@ impl<'a> From<(&'a str, ColumnFamilyOptions)> for ColumnFamilyDescriptor<'a> { } pub struct CColumnFamilyDescriptor { - inner: *mut crocksdb_ffi::ColumnFamilyDescriptor, + inner: *mut crocksdb_ffi::crocksdb_column_family_descriptor, } impl CColumnFamilyDescriptor { pub unsafe fn from_raw( - inner: *mut crocksdb_ffi::ColumnFamilyDescriptor, + inner: *mut crocksdb_ffi::crocksdb_column_family_descriptor, ) -> CColumnFamilyDescriptor { assert!( !inner.is_null(), @@ -1701,6 +1749,8 @@ impl Drop for CColumnFamilyDescriptor { } } +pub type DBFlushOptions = crocksdb_flushoptions_t; + pub struct FlushOptions { pub inner: *mut DBFlushOptions, } @@ -1716,13 +1766,13 @@ impl FlushOptions { pub fn set_wait(&mut self, wait: bool) { unsafe { - crocksdb_ffi::crocksdb_flushoptions_set_wait(self.inner, wait); + crocksdb_ffi::crocksdb_flushoptions_set_wait(self.inner, wait as u8); } } pub fn set_allow_write_stall(&mut self, allow: bool) { unsafe { - crocksdb_ffi::crocksdb_flushoptions_set_allow_write_stall(self.inner, allow); + crocksdb_ffi::crocksdb_flushoptions_set_allow_write_stall(self.inner, allow as u8); } } } @@ -1737,7 +1787,7 @@ impl Drop for FlushOptions { /// IngestExternalFileOptions is used by DB::ingest_external_file pub struct IngestExternalFileOptions { - pub inner: *mut crocksdb_ffi::IngestExternalFileOptions, + pub inner: *mut crocksdb_ffi::crocksdb_ingestexternalfileoptions_t, } impl IngestExternalFileOptions { @@ -1755,7 +1805,7 @@ impl IngestExternalFileOptions { unsafe { crocksdb_ffi::crocksdb_ingestexternalfileoptions_set_snapshot_consistency( self.inner, - whether_consistent, + whether_consistent as u8, ); } } @@ -1766,7 +1816,7 @@ impl IngestExternalFileOptions { unsafe { crocksdb_ffi::crocksdb_ingestexternalfileoptions_set_allow_global_seqno( self.inner, - whether_allow, + whether_allow as u8, ); } } @@ -1777,7 +1827,7 @@ impl IngestExternalFileOptions { unsafe { crocksdb_ffi::crocksdb_ingestexternalfileoptions_set_allow_blocking_flush( self.inner, - whether_allow, + whether_allow as u8, ); } } @@ -1787,7 +1837,7 @@ impl IngestExternalFileOptions { unsafe { crocksdb_ffi::crocksdb_ingestexternalfileoptions_set_move_files( self.inner, - whether_move, + whether_move as u8, ); } } @@ -1803,7 +1853,7 @@ impl Drop for IngestExternalFileOptions { /// Options while opening a file to read/write pub struct EnvOptions { - pub inner: *mut crocksdb_ffi::EnvOptions, + pub inner: *mut crocksdb_ffi::crocksdb_envoptions_t, } impl EnvOptions { @@ -1825,7 +1875,7 @@ impl Drop for EnvOptions { } pub struct RestoreOptions { - pub inner: *mut DBRestoreOptions, + pub inner: *mut crocksdb_restore_options_t, } impl RestoreOptions { @@ -1856,7 +1906,7 @@ impl Drop for RestoreOptions { } pub struct FifoCompactionOptions { - pub inner: *mut DBFifoCompactionOptions, + pub inner: *mut crocksdb_fifo_compaction_options_t, } impl FifoCompactionOptions { @@ -1881,7 +1931,7 @@ impl FifoCompactionOptions { unsafe { crocksdb_ffi::crocksdb_fifo_compaction_options_set_allow_compaction( self.inner, - allow_compaction, + allow_compaction as u8, ); } } @@ -1896,7 +1946,7 @@ impl Drop for FifoCompactionOptions { } pub struct LRUCacheOptions { - pub inner: *mut DBLRUCacheOptions, + pub inner: *mut crocksdb_ffi::crocksdb_lru_cache_options_t, } impl LRUCacheOptions { @@ -1928,7 +1978,7 @@ impl LRUCacheOptions { unsafe { crocksdb_ffi::crocksdb_lru_cache_options_set_strict_capacity_limit( self.inner, - strict_capacity_limit, + strict_capacity_limit as u8, ); } } diff --git a/src/slice_transform.rs b/src/slice_transform.rs index 7718fa191..f9f061de9 100644 --- a/src/slice_transform.rs +++ b/src/slice_transform.rs @@ -11,7 +11,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -use crocksdb_ffi::{self, DBSliceTransform}; +use crocksdb_ffi::{self, crocksdb_slicetransform_t}; use libc::{c_char, c_void, size_t}; use std::ffi::CString; use std::slice; @@ -55,31 +55,31 @@ extern "C" fn destructor(transform: *mut c_void) { extern "C" fn transform( transform: *mut c_void, - key: *const u8, + key: *const c_char, key_len: size_t, dest_len: *mut size_t, -) -> *const u8 { +) -> *mut i8 { unsafe { let transform = &mut *(transform as *mut SliceTransformProxy); - let key = slice::from_raw_parts(key, key_len); + let key = slice::from_raw_parts(key as *const u8, key_len); let prefix = transform.transform.transform(key); *dest_len = prefix.len() as size_t; - prefix.as_ptr() as *const u8 + prefix.as_ptr() as *mut i8 } } -extern "C" fn in_domain(transform: *mut c_void, key: *const u8, key_len: size_t) -> u8 { +extern "C" fn in_domain(transform: *mut c_void, key: *const c_char, key_len: size_t) -> u8 { unsafe { let transform = &mut *(transform as *mut SliceTransformProxy); - let key = slice::from_raw_parts(key, key_len); + let key = slice::from_raw_parts(key as *const u8, key_len); transform.transform.in_domain(key) as u8 } } -extern "C" fn in_range(transform: *mut c_void, key: *const u8, key_len: size_t) -> u8 { +extern "C" fn in_range(transform: *mut c_void, key: *const c_char, key_len: size_t) -> u8 { unsafe { let transform = &mut *(transform as *mut SliceTransformProxy); - let key = slice::from_raw_parts(key, key_len); + let key = slice::from_raw_parts(key as *const u8, key_len); transform.transform.in_range(key) as u8 } } @@ -87,18 +87,18 @@ extern "C" fn in_range(transform: *mut c_void, key: *const u8, key_len: size_t) pub unsafe fn new_slice_transform( c_name: CString, f: Box, -) -> Result<*mut DBSliceTransform, String> { +) -> Result<*mut crocksdb_slicetransform_t, String> { let proxy = Box::into_raw(Box::new(SliceTransformProxy { name: c_name, transform: f, })); let transform = crocksdb_ffi::crocksdb_slicetransform_create( proxy as *mut c_void, - destructor, - transform, - in_domain, - in_range, - name, + Some(destructor), + Some(transform), + Some(in_domain), + Some(in_range), + Some(name), ); Ok(transform) } diff --git a/src/table_filter.rs b/src/table_filter.rs index 5e0a34349..bf76d2a8b 100644 --- a/src/table_filter.rs +++ b/src/table_filter.rs @@ -11,7 +11,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -use crocksdb_ffi::DBTableProperties; +use crocksdb_ffi::crocksdb_table_properties_t; use libc::{c_int, c_void}; use table_properties::TableProperties; @@ -24,7 +24,10 @@ pub trait TableFilter { fn table_filter(&self, props: &TableProperties) -> bool; } -pub extern "C" fn table_filter(ctx: *mut c_void, props: *const DBTableProperties) -> c_int { +pub extern "C" fn table_filter( + ctx: *mut c_void, + props: *const crocksdb_table_properties_t, +) -> c_int { unsafe { let filter = &*(ctx as *mut Box); let props = &*(props as *const TableProperties); diff --git a/src/table_properties.rs b/src/table_properties.rs index d5fccee7a..1f8f26e92 100644 --- a/src/table_properties.rs +++ b/src/table_properties.rs @@ -12,15 +12,17 @@ // limitations under the License. use crocksdb_ffi::{ - self, DBTableProperties, DBTablePropertiesCollection, DBTablePropertiesCollectionIterator, - DBTableProperty, DBUserCollectedProperties, DBUserCollectedPropertiesIterator, + self, crocksdb_table_properties_collection_iterator_t, crocksdb_table_properties_collection_t, + crocksdb_table_properties_t, crocksdb_user_collected_properties_iterator_t, + crocksdb_user_collected_properties_t, }; use libc::size_t; use std::marker::PhantomData; use std::ops::{Deref, Index}; use std::{slice, str}; +use DBTableProperty; -#[repr(transparent)] +pub type DBTablePropertiesCollection = crocksdb_table_properties_collection_t; pub struct TablePropertiesCollectionView(DBTablePropertiesCollection); impl TablePropertiesCollectionView { @@ -54,7 +56,7 @@ impl<'a> IntoIterator for &'a TablePropertiesCollectionView { pub struct TablePropertiesCollectionIter<'a> { props: PhantomData<&'a TablePropertiesCollection>, - inner: *mut DBTablePropertiesCollectionIterator, + inner: *mut crocksdb_table_properties_collection_iterator_t, } impl<'a> Drop for TablePropertiesCollectionIter<'a> { @@ -82,7 +84,7 @@ impl<'a> Iterator for TablePropertiesCollectionIter<'a> { fn next(&mut self) -> Option<(&'a str, &'a TableProperties)> { unsafe { loop { - if !crocksdb_ffi::crocksdb_table_properties_collection_iter_valid(self.inner) { + if crocksdb_ffi::crocksdb_table_properties_collection_iter_valid(self.inner) == 0 { return None; } @@ -90,7 +92,7 @@ impl<'a> Iterator for TablePropertiesCollectionIter<'a> { let k = crocksdb_ffi::crocksdb_table_properties_collection_iter_key( self.inner, &mut klen, ); - let bytes = slice::from_raw_parts(k, klen); + let bytes = slice::from_raw_parts(k as *const u8, klen); let key = str::from_utf8(bytes).unwrap(); let props = crocksdb_ffi::crocksdb_table_properties_collection_iter_value(self.inner); @@ -130,7 +132,7 @@ impl Deref for TablePropertiesCollection { } } -#[repr(transparent)] +pub type DBTableProperties = crocksdb_table_properties_t; pub struct TableProperties { inner: DBTableProperties, } @@ -138,17 +140,23 @@ pub struct TableProperties { impl TableProperties { pub unsafe fn from_ptr<'a>(ptr: *const DBTableProperties) -> &'a TableProperties { &*(ptr as *const TableProperties) + //let res = &*ptr; + //mem::transmute(res) } fn get_u64(&self, prop: DBTableProperty) -> u64 { - unsafe { crocksdb_ffi::crocksdb_table_properties_get_u64(&self.inner, prop) } + unsafe { crocksdb_ffi::crocksdb_table_properties_get_u64(&self.inner, prop as u32) } } fn get_str(&self, prop: DBTableProperty) -> &str { unsafe { let mut slen: size_t = 0; - let s = crocksdb_ffi::crocksdb_table_properties_get_str(&self.inner, prop, &mut slen); - let bytes = slice::from_raw_parts(s, slen); + let s = crocksdb_ffi::crocksdb_table_properties_get_str( + &self.inner, + prop as u32, + &mut slen, + ); + let bytes = slice::from_raw_parts(s as *const u8, slen); str::from_utf8(bytes).unwrap() } } @@ -229,7 +237,7 @@ impl TableProperties { } } -#[repr(transparent)] +pub type DBUserCollectedProperties = crocksdb_user_collected_properties_t; pub struct UserCollectedProperties { inner: DBUserCollectedProperties, } @@ -245,14 +253,14 @@ impl UserCollectedProperties { unsafe { let ptr = crocksdb_ffi::crocksdb_user_collected_properties_get( &self.inner, - bytes.as_ptr(), + bytes.as_ptr() as *const i8, bytes.len(), &mut size, ); if ptr.is_null() { return None; } - Some(slice::from_raw_parts(ptr, size)) + Some(slice::from_raw_parts(ptr as *const u8, size)) } } @@ -286,7 +294,7 @@ impl<'a> IntoIterator for &'a UserCollectedProperties { pub struct UserCollectedPropertiesIter<'a> { props: PhantomData<&'a UserCollectedProperties>, - inner: *mut DBUserCollectedPropertiesIterator, + inner: *mut crocksdb_user_collected_properties_iterator_t, } impl<'a> Drop for UserCollectedPropertiesIter<'a> { @@ -313,18 +321,18 @@ impl<'a> Iterator for UserCollectedPropertiesIter<'a> { fn next(&mut self) -> Option<(&'a [u8], &'a [u8])> { unsafe { - if !crocksdb_ffi::crocksdb_user_collected_properties_iter_valid(self.inner) { + if crocksdb_ffi::crocksdb_user_collected_properties_iter_valid(self.inner) == 0 { return None; } let mut klen: size_t = 0; let k = crocksdb_ffi::crocksdb_user_collected_properties_iter_key(self.inner, &mut klen); - let key = slice::from_raw_parts(k, klen); + let key = slice::from_raw_parts(k as *const u8, klen); let mut vlen: size_t = 0; let v = crocksdb_ffi::crocksdb_user_collected_properties_iter_value(self.inner, &mut vlen); - let val = slice::from_raw_parts(v, vlen); + let val = slice::from_raw_parts(v as *const u8, vlen); crocksdb_ffi::crocksdb_user_collected_properties_iter_next(self.inner); diff --git a/src/table_properties_collector.rs b/src/table_properties_collector.rs index 72d3511c6..e0489262a 100644 --- a/src/table_properties_collector.rs +++ b/src/table_properties_collector.rs @@ -11,12 +11,15 @@ // See the License for the specific language governing permissions and // limitations under the License. -use crocksdb_ffi::{self, DBEntryType, DBTablePropertiesCollector, DBUserCollectedProperties}; +use crocksdb_ffi::{ + self, crocksdb_table_properties_collector_t, crocksdb_user_collected_properties_t, +}; use libc::{c_char, c_int, c_void, size_t}; use std::collections::HashMap; use std::ffi::CString; use std::mem; use std::slice; +use DBEntryType; /// `TablePropertiesCollector` provides the mechanism for users to collect /// their own properties that they are interested in. This class is essentially @@ -62,9 +65,9 @@ extern "C" fn destruct(handle: *mut c_void) { pub extern "C" fn add( handle: *mut c_void, - key: *const u8, + key: *const c_char, key_len: size_t, - value: *const u8, + value: *const c_char, value_len: size_t, entry_type: c_int, seq: u64, @@ -72,29 +75,30 @@ pub extern "C" fn add( ) { unsafe { let handle = &mut *(handle as *mut TablePropertiesCollectorHandle); - let key = slice::from_raw_parts(key, key_len); - let value = slice::from_raw_parts(value, value_len); + let key = slice::from_raw_parts(key as *const u8, key_len); + let value = slice::from_raw_parts(value as *const u8, value_len); handle .rep .add(key, value, mem::transmute(entry_type), seq, file_size); } } -pub extern "C" fn finish(handle: *mut c_void, props: *mut DBUserCollectedProperties) { +pub extern "C" fn finish(handle: *mut c_void, props: *mut crocksdb_user_collected_properties_t) { unsafe { let handle = &mut *(handle as *mut TablePropertiesCollectorHandle); for (key, value) in handle.rep.finish() { crocksdb_ffi::crocksdb_user_collected_properties_add( props, - key.as_ptr(), + key.as_ptr() as *const i8, key.len(), - value.as_ptr(), + value.as_ptr() as *const i8, value.len(), ); } } } +pub type DBTablePropertiesCollector = crocksdb_table_properties_collector_t; pub unsafe fn new_table_properties_collector( cname: &str, collector: Box, @@ -102,9 +106,9 @@ pub unsafe fn new_table_properties_collector( let handle = TablePropertiesCollectorHandle::new(cname, collector); crocksdb_ffi::crocksdb_table_properties_collector_create( Box::into_raw(Box::new(handle)) as *mut c_void, - name, - destruct, - add, - finish, + Some(name), + Some(destruct), + Some(add), + Some(finish), ) } diff --git a/src/table_properties_collector_factory.rs b/src/table_properties_collector_factory.rs index b7f55a69b..bab480794 100644 --- a/src/table_properties_collector_factory.rs +++ b/src/table_properties_collector_factory.rs @@ -11,7 +11,9 @@ // See the License for the specific language governing permissions and // limitations under the License. -use crocksdb_ffi::{self, DBTablePropertiesCollector, DBTablePropertiesCollectorFactory}; +use crocksdb_ffi::{ + self, crocksdb_table_properties_collector_factory_t, crocksdb_table_properties_collector_t, +}; use libc::{c_char, c_void}; use std::ffi::CString; use table_properties_collector::{new_table_properties_collector, TablePropertiesCollector}; @@ -56,7 +58,7 @@ extern "C" fn destruct(handle: *mut c_void) { extern "C" fn create_table_properties_collector( handle: *mut c_void, cf: u32, -) -> *mut DBTablePropertiesCollector { +) -> *mut crocksdb_table_properties_collector_t { unsafe { let handle = &mut *(handle as *mut TablePropertiesCollectorFactoryHandle); let collector = handle.rep.create_table_properties_collector(cf); @@ -64,6 +66,8 @@ extern "C" fn create_table_properties_collector( } } +pub type DBTablePropertiesCollectorFactory = crocksdb_table_properties_collector_factory_t; + pub unsafe fn new_table_properties_collector_factory( fname: &str, factory: Box, @@ -71,8 +75,8 @@ pub unsafe fn new_table_properties_collector_factory( let handle = TablePropertiesCollectorFactoryHandle::new(fname, factory); crocksdb_ffi::crocksdb_table_properties_collector_factory_create( Box::into_raw(Box::new(handle)) as *mut c_void, - name, - destruct, - create_table_properties_collector, + Some(name), + Some(destruct), + Some(create_table_properties_collector), ) } diff --git a/src/titan.rs b/src/titan.rs index c83db3098..c7c6c7d91 100644 --- a/src/titan.rs +++ b/src/titan.rs @@ -1,8 +1,8 @@ use std::ffi::{CStr, CString}; use std::ops::Deref; -use crocksdb_ffi::{self, DBCompressionType, DBTitanBlobIndex, DBTitanDBOptions}; -use librocksdb_sys::{ctitandb_encode_blob_index, DBTitanDBBlobRunMode}; +use crocksdb_ffi::{self, ctitandb_blob_index_t, ctitandb_options_t}; +use librocksdb_sys::ctitandb_encode_blob_index; use rocksdb::Cache; use rocksdb_options::LRUCacheOptions; use std::ops::DerefMut; @@ -10,6 +10,9 @@ use std::os::raw::c_double; use std::os::raw::c_int; use std::ptr; use std::slice; +use {DBCompressionType, DBTitanDBBlobRunMode}; + +pub type DBTitanDBOptions = ctitandb_options_t; pub struct TitanDBOptions { pub inner: *mut DBTitanDBOptions, @@ -51,30 +54,35 @@ impl TitanDBOptions { } pub fn blob_file_compression(&self) -> DBCompressionType { - unsafe { crocksdb_ffi::ctitandb_options_blob_file_compression(self.inner) } + unsafe { + num::FromPrimitive::from_i32(crocksdb_ffi::ctitandb_options_blob_file_compression( + self.inner, + )) + .unwrap() + } } pub fn set_blob_file_compression(&mut self, t: DBCompressionType) { unsafe { - crocksdb_ffi::ctitandb_options_set_blob_file_compression(self.inner, t); + crocksdb_ffi::ctitandb_options_set_blob_file_compression(self.inner, t as i32); } } pub fn set_disable_background_gc(&mut self, disable: bool) { unsafe { - crocksdb_ffi::ctitandb_options_set_disable_background_gc(self.inner, disable); + crocksdb_ffi::ctitandb_options_set_disable_background_gc(self.inner, disable as u8); } } pub fn set_level_merge(&mut self, enable: bool) { unsafe { - crocksdb_ffi::ctitandb_options_set_level_merge(self.inner, enable); + crocksdb_ffi::ctitandb_options_set_level_merge(self.inner, enable as u8); } } pub fn set_range_merge(&mut self, enable: bool) { unsafe { - crocksdb_ffi::ctitandb_options_set_range_merge(self.inner, enable); + crocksdb_ffi::ctitandb_options_set_range_merge(self.inner, enable as u8); } } @@ -92,7 +100,10 @@ impl TitanDBOptions { pub fn set_purge_obsolete_files_period(&mut self, period: usize) { unsafe { - crocksdb_ffi::ctitandb_options_set_purge_obsolete_files_period_sec(self.inner, period); + crocksdb_ffi::ctitandb_options_set_purge_obsolete_files_period_sec( + self.inner, + period as u32, + ); } } @@ -146,7 +157,7 @@ impl TitanDBOptions { pub fn set_blob_run_mode(&mut self, t: DBTitanDBBlobRunMode) { unsafe { - crocksdb_ffi::ctitandb_options_set_blob_run_mode(self.inner, t); + crocksdb_ffi::ctitandb_options_set_blob_run_mode(self.inner, t as i32); } } } @@ -159,9 +170,20 @@ impl Drop for TitanDBOptions { } } -#[derive(Debug, Default)] +#[derive(Debug)] pub struct TitanBlobIndex { - inner: DBTitanBlobIndex, + inner: ctitandb_blob_index_t, +} + +impl Default for TitanBlobIndex { + fn default() -> TitanBlobIndex { + let blob_index = ctitandb_blob_index_t { + file_number: 0, + blob_offset: 0, + blob_size: 0, + }; + TitanBlobIndex { inner: blob_index } + } } impl TitanBlobIndex { @@ -169,9 +191,9 @@ impl TitanBlobIndex { let mut index = Self::default(); unsafe { ffi_try!(ctitandb_decode_blob_index( - value.as_ptr(), - value.len() as u64, - &mut index.inner as *mut DBTitanBlobIndex + value.as_ptr() as *const i8, + value.len() as usize, + &mut index.inner as *mut ctitandb_blob_index_t )); } Ok(index) @@ -179,10 +201,10 @@ impl TitanBlobIndex { pub fn encode(&self) -> Vec { let mut value = ptr::null_mut(); - let mut value_size: u64 = 0; + let mut value_size: usize = 0; unsafe { ctitandb_encode_blob_index(&self.inner, &mut value, &mut value_size); - let slice = slice::from_raw_parts(value, value_size as usize); + let slice = slice::from_raw_parts(value as *mut u8, value_size); let vec = slice.to_vec(); libc::free(value as *mut libc::c_void); vec @@ -191,7 +213,7 @@ impl TitanBlobIndex { } impl Deref for TitanBlobIndex { - type Target = DBTitanBlobIndex; + type Target = ctitandb_blob_index_t; fn deref(&self) -> &Self::Target { &self.inner } diff --git a/src/util.rs b/src/util.rs new file mode 100644 index 000000000..7864d7e1e --- /dev/null +++ b/src/util.rs @@ -0,0 +1,22 @@ +// Copyright 2018 PingCAP, Inc. +// +// 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, +// See the License for the specific language governing permissions and +// limitations under the License. + +use libc::c_char; +use std::ptr; + +pub fn opt_bytes_to_ptr>(opt: Option) -> *const c_char { + match opt { + Some(v) => v.as_ref().as_ptr() as *const c_char, + None => ptr::null(), + } +} diff --git a/tests/cases/test_rocksdb_options.rs b/tests/cases/test_rocksdb_options.rs index 1642ae34b..72c6e342f 100644 --- a/tests/cases/test_rocksdb_options.rs +++ b/tests/cases/test_rocksdb_options.rs @@ -17,11 +17,11 @@ use std::thread; use std::time::Duration; use rocksdb::crocksdb_ffi::{ - CompactionPriority, DBCompressionType, DBInfoLogLevel as InfoLogLevel, DBRateLimiterMode, DBStatisticsHistogramType as HistogramType, DBStatisticsTickerType as TickerType, }; use rocksdb::{ - BlockBasedOptions, Cache, ColumnFamilyOptions, CompactOptions, DBOptions, Env, + BlockBasedOptions, Cache, ColumnFamilyOptions, CompactOptions, CompactionPriority, + DBCompressionType, DBInfoLogLevel as InfoLogLevel, DBOptions, DBRateLimiterMode, Env, FifoCompactionOptions, IndexType, LRUCacheOptions, ReadOptions, SeekKey, SliceTransform, Writable, WriteOptions, DB, };