Add fifo compaction options (#143)

librocksdb_sys/crocksdb/c.cc

@@ -3052,6 +3052,16 @@ void crocksdb_fifo_compaction_options_set_max_table_files_size(
   fifo_opts->rep.max_table_files_size = size;
 }
 
+void crocksdb_fifo_compaction_options_set_ttl(
+    crocksdb_fifo_compaction_options_t* fifo_opts, uint64_t ttl) {
+  fifo_opts->rep.ttl = ttl;
+}
+
+void crocksdb_fifo_compaction_options_set_allow_compaction(
+    crocksdb_fifo_compaction_options_t* fifo_opts, bool allow_compaction) {
+  fifo_opts->rep.allow_compaction = allow_compaction;
+}
+
 void crocksdb_fifo_compaction_options_destroy(
     crocksdb_fifo_compaction_options_t* fifo_opts) {
   delete fifo_opts;

librocksdb_sys/crocksdb/crocksdb/c.h

@@ -1283,6 +1283,12 @@ crocksdb_fifo_compaction_options_create();
 extern C_ROCKSDB_LIBRARY_API void
 crocksdb_fifo_compaction_options_set_max_table_files_size(
     crocksdb_fifo_compaction_options_t* fifo_opts, uint64_t size);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_fifo_compaction_options_set_ttl(
+    crocksdb_fifo_compaction_options_t* fifo_opts, uint64_t ttl);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_fifo_compaction_options_set_allow_compaction(
+    crocksdb_fifo_compaction_options_t* fifo_opts, bool allow_compaction);
 extern C_ROCKSDB_LIBRARY_API void crocksdb_fifo_compaction_options_destroy(
     crocksdb_fifo_compaction_options_t* fifo_opts);
 

librocksdb_sys/src/lib.rs

@@ -44,6 +44,7 @@ pub enum DBSliceTransform {}
 pub enum DBRateLimiter {}
 pub enum DBLogger {}
 pub enum DBCompactOptions {}
+pub enum DBFifoCompactionOptions {}
 pub enum DBPinnableSlice {}
 pub enum DBUserCollectedProperties {}
 pub enum DBUserCollectedPropertiesIterator {}
@@ -421,6 +422,10 @@ extern "C" {
         a2: i32,
     );
     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,
@@ -942,6 +947,17 @@ extern "C" {
         opt: *mut DBCompactOptions,
         v: bool,
     );
+
+    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: uint64_t);
+    pub fn crocksdb_fifo_compaction_options_set_ttl(
+        fifo_opts: *mut DBFifoCompactionOptions, ttl: uint64_t);
+    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,

src/lib.rs

@@ -41,7 +41,7 @@ pub use rocksdb::{BackupEngine, CFHandle, DBIterator, DBVector, Kv, Range, SeekK
                   Writable, WriteBatch, DB};
 pub use rocksdb_options::{BlockBasedOptions, ColumnFamilyOptions, CompactOptions, DBOptions,
                           EnvOptions, HistogramData, IngestExternalFileOptions, ReadOptions,
-                          RestoreOptions, WriteOptions};
+                          RestoreOptions, WriteOptions, FifoCompactionOptions};
 pub use slice_transform::SliceTransform;
 pub use table_properties::{TableProperties, TablePropertiesCollection,
                            TablePropertiesCollectionView, UserCollectedProperties};

src/rocksdb_options.rs

@@ -18,7 +18,7 @@ use comparator::{self, compare_callback, ComparatorCallback};
 use crocksdb_ffi::{self, DBBlockBasedTableOptions, DBCompactOptions, DBCompressionType,
                    DBFlushOptions, DBInfoLogLevel, DBInstance, DBRateLimiter, DBReadOptions,
                    DBRecoveryMode, DBRestoreOptions, DBSnapshot, DBStatisticsHistogramType,
-                   DBStatisticsTickerType, DBWriteOptions, Options};
+                   DBStatisticsTickerType, DBWriteOptions, DBFifoCompactionOptions, Options};
 use event_listener::{new_event_listener, EventListener};
 use libc::{self, c_double, c_int, c_uchar, c_void, size_t};
 use merge_operator::{self, full_merge_callback, partial_merge_callback, MergeOperatorCallback};
@@ -1176,6 +1176,12 @@ impl ColumnFamilyOptions {
     pub fn get_block_cache_usage(&self) -> u64 {
         unsafe { crocksdb_ffi::crocksdb_options_get_block_cache_usage(self.inner) as u64 }
     }
+
+    pub fn set_fifo_compaction_options(&mut self, fifo_opts: FifoCompactionOptions) {
+        unsafe {
+            crocksdb_ffi::crocksdb_options_set_fifo_compaction_options(self.inner, fifo_opts.inner);
+        }
+    }
 }
 
 // ColumnFamilyDescriptor is a pair of column family's name and options.
@@ -1365,3 +1371,45 @@ impl Drop for RestoreOptions {
         }
     }
 }
+
+pub struct FifoCompactionOptions {
+    pub inner: *mut DBFifoCompactionOptions,
+}
+
+impl FifoCompactionOptions {
+    pub fn new() -> FifoCompactionOptions {
+        unsafe {
+            FifoCompactionOptions {
+                inner: crocksdb_ffi::crocksdb_fifo_compaction_options_create(),
+            }
+        }
+    }
+
+    pub fn set_ttl(&mut self, ttl: u64) {
+        unsafe {
+            crocksdb_ffi::crocksdb_fifo_compaction_options_set_ttl(self.inner, ttl);
+        }
+    }
+
+    pub fn set_max_table_files_size(&mut self, max_table_files_size: u64) {
+        unsafe {
+            crocksdb_ffi::crocksdb_fifo_compaction_options_set_max_table_files_size(
+                self.inner, max_table_files_size);
+        }
+    }
+
+    pub fn set_allow_compaction(&mut self, allow_compaction: bool) {
+        unsafe {
+            crocksdb_ffi::crocksdb_fifo_compaction_options_set_allow_compaction(
+                self.inner, allow_compaction);
+        }
+    }
+}
+
+impl Drop for FifoCompactionOptions {
+    fn drop(&mut self) {
+        unsafe {
+            crocksdb_ffi::crocksdb_fifo_compaction_options_destroy(self.inner);
+        }
+    }
+}

tests/test_rocksdb_options.rs

@@ -12,7 +12,7 @@
 // limitations under the License.
 
 use rocksdb::{BlockBasedOptions, ColumnFamilyOptions, CompactOptions, DBOptions, ReadOptions,
-              SeekKey, SliceTransform, Writable, WriteOptions, DB};
+              SeekKey, SliceTransform, Writable, WriteOptions, FifoCompactionOptions, DB};
 use rocksdb::crocksdb_ffi::{CompactionPriority, DBCompressionType, DBInfoLogLevel as InfoLogLevel,
                             DBStatisticsHistogramType as HistogramType,
                             DBStatisticsTickerType as TickerType};
@@ -613,3 +613,18 @@ fn test_block_based_options() {
         0
     );
 }
+
+#[test]
+fn test_fifo_compaction_options() {
+    let path = TempDir::new("_rust_rocksdb_fifo_compaction_options").expect("");
+    let path_str = path.path().to_str().unwrap();
+    let mut opts = DBOptions::new();
+    opts.create_if_missing(true);
+    let mut cf_opts = ColumnFamilyOptions::new();
+    let mut fifo_opts = FifoCompactionOptions::new();
+    fifo_opts.set_allow_compaction(true);
+    fifo_opts.set_ttl(100000);
+    fifo_opts.set_max_table_files_size(100000);
+    cf_opts.set_fifo_compaction_options(fifo_opts);
+    DB::open_cf(opts, path_str, vec![("default", cf_opts)]).unwrap();
+}