Add block based metadata cache options

Author: zaidoon1

src/db_options.rs

@@ -777,6 +777,81 @@ impl BlockBasedOptions {
             );
         }
     }
+
+    /// The tier of block-based tables whose top-level index into metadata
+    /// partitions will be pinned. Currently indexes and filters may be
+    /// partitioned.
+    ///
+    /// Note `cache_index_and_filter_blocks` must be true for this option to have
+    /// any effect. Otherwise any top-level index into metadata partitions would be
+    /// held in table reader memory, outside the block cache.
+    ///
+    /// Default: `BlockBasedPinningTier:Fallback`
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use rust_rocksdb::{BlockBasedOptions, BlockBasedPinningTier, Options};
+    ///
+    /// let mut opts = Options::default();
+    /// let mut block_opts = BlockBasedOptions::default();
+    /// block_opts.set_top_level_index_pinning_tier(BlockBasedPinningTier::FlushAndSimilar);
+    /// ```
+    pub fn set_top_level_index_pinning_tier(&mut self, tier: BlockBasedPinningTier) {
+        unsafe {
+            ffi::rocksdb_block_based_options_set_top_level_index_pinning_tier(
+                self.inner,
+                tier as c_int,
+            );
+        }
+    }
+
+    /// The tier of block-based tables whose metadata partitions will be pinned.
+    /// Currently indexes and filters may be partitioned.
+    ///
+    /// Default: `BlockBasedPinningTier:Fallback`
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use rust_rocksdb::{BlockBasedOptions, BlockBasedPinningTier, Options};
+    ///
+    /// let mut opts = Options::default();
+    /// let mut block_opts = BlockBasedOptions::default();
+    /// block_opts.set_partition_pinning_tier(BlockBasedPinningTier::FlushAndSimilar);
+    /// ```
+    pub fn set_partition_pinning_tier(&mut self, tier: BlockBasedPinningTier) {
+        unsafe {
+            ffi::rocksdb_block_based_options_set_partition_pinning_tier(self.inner, tier as c_int);
+        }
+    }
+
+    /// The tier of block-based tables whose unpartitioned metadata blocks will be
+    /// pinned.
+    ///
+    /// Note `cache_index_and_filter_blocks` must be true for this option to have
+    /// any effect. Otherwise the unpartitioned meta-blocks would be held in table
+    /// reader memory, outside the block cache.
+    ///
+    /// Default: `BlockBasedPinningTier:Fallback`
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use rust_rocksdb::{BlockBasedOptions, BlockBasedPinningTier, Options};
+    ///
+    /// let mut opts = Options::default();
+    /// let mut block_opts = BlockBasedOptions::default();
+    /// block_opts.set_unpartitioned_pinning_tier(BlockBasedPinningTier::FlushAndSimilar);
+    /// ```
+    pub fn set_unpartitioned_pinning_tier(&mut self, tier: BlockBasedPinningTier) {
+        unsafe {
+            ffi::rocksdb_block_based_options_set_unpartitioned_pinning_tier(
+                self.inner,
+                tier as c_int,
+            );
+        }
+    }
 }
 
 impl Default for BlockBasedOptions {
@@ -4198,6 +4273,15 @@ pub enum DBCompactionPri {
     RoundRobin = ffi::rocksdb_k_round_robin_compaction_pri as isize,
 }
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
+pub enum BlockBasedPinningTier {
+    Fallback = ffi::rocksdb_block_based_k_fallback_pinning_tier as isize,
+    None = ffi::rocksdb_block_based_k_none_pinning_tier as isize,
+    FlushAndSimilar = ffi::rocksdb_block_based_k_flush_and_similar_pinning_tier as isize,
+    All = ffi::rocksdb_block_based_k_all_pinning_tier as isize,
+}
+
 pub struct FifoCompactOptions {
     pub(crate) inner: *mut ffi::rocksdb_fifo_compaction_options_t,
 }

src/lib.rs

@@ -114,12 +114,13 @@ pub use crate::{
         DBWALIterator, Direction, IteratorMode,
     },
     db_options::{
-        BlockBasedIndexType, BlockBasedOptions, BottommostLevelCompaction, Cache, ChecksumType,
-        CompactOptions, CuckooTableOptions, DBCompactionPri, DBCompactionStyle, DBCompressionType,
-        DBPath, DBRecoveryMode, DataBlockIndexType, FifoCompactOptions, FlushOptions,
-        IngestExternalFileOptions, KeyEncodingType, LogLevel, MemtableFactory, Options,
-        PlainTableFactoryOptions, RateLimiterMode, ReadOptions, ReadTier, UniversalCompactOptions,
-        UniversalCompactionStopStyle, WaitForCompactOptions, WriteBufferManager, WriteOptions,
+        BlockBasedIndexType, BlockBasedOptions, BlockBasedPinningTier, BottommostLevelCompaction,
+        Cache, ChecksumType, CompactOptions, CuckooTableOptions, DBCompactionPri,
+        DBCompactionStyle, DBCompressionType, DBPath, DBRecoveryMode, DataBlockIndexType,
+        FifoCompactOptions, FlushOptions, IngestExternalFileOptions, KeyEncodingType, LogLevel,
+        MemtableFactory, Options, PlainTableFactoryOptions, RateLimiterMode, ReadOptions, ReadTier,
+        UniversalCompactOptions, UniversalCompactionStopStyle, WaitForCompactOptions,
+        WriteBufferManager, WriteOptions,
     },
     db_pinnable_slice::DBPinnableSlice,
     env::Env,

tests/test_rocksdb_options.rs

@@ -17,8 +17,8 @@ mod util;
 use std::{fs, io::Read as _};
 
 use rust_rocksdb::{
-    BlockBasedOptions, Cache, DBCompactionPri, DBCompressionType, DataBlockIndexType, Env, Options,
-    ReadOptions, DB,
+    BlockBasedOptions, BlockBasedPinningTier, Cache, DBCompactionPri, DBCompressionType,
+    DataBlockIndexType, Env, Options, ReadOptions, DB,
 };
 use util::DBPath;
 
@@ -89,6 +89,9 @@ fn test_block_based_options() {
         block_opts.set_pin_l0_filter_and_index_blocks_in_cache(true);
         block_opts.set_format_version(4);
         block_opts.set_index_block_restart_interval(16);
+        block_opts.set_top_level_index_pinning_tier(BlockBasedPinningTier::All);
+        block_opts.set_partition_pinning_tier(BlockBasedPinningTier::All);
+        block_opts.set_unpartitioned_pinning_tier(BlockBasedPinningTier::All);
 
         opts.set_block_based_table_factory(&block_opts);
         let _db = DB::open(&opts, &n).unwrap();
@@ -105,6 +108,20 @@ fn test_block_based_options() {
         assert!(settings.contains("format_version: 4"));
         assert!(settings.contains("index_block_restart_interval: 16"));
     }
+
+    {
+        let mut opts = Options::default();
+        opts.create_if_missing(true);
+
+        let mut block_opts = BlockBasedOptions::default();
+        block_opts.set_cache_index_and_filter_blocks(true);
+        block_opts.set_top_level_index_pinning_tier(BlockBasedPinningTier::FlushAndSimilar);
+        block_opts.set_partition_pinning_tier(BlockBasedPinningTier::All);
+        block_opts.set_unpartitioned_pinning_tier(BlockBasedPinningTier::None);
+
+        opts.set_block_based_table_factory(&block_opts);
+        let _db = DB::open(&opts, &n).unwrap();
+    }
 }
 
 #[test]