1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
//! A database can be configured with a custom `FilterPolicy` object. //! This object is responsible for creating a small filter from a set //! of keys. These filters are stored in rocksdb and are consulted //! automatically by rocksdb to decide whether or not to read some //! information from disk. In many cases, a filter can cut down the //! number of disk seeks form a handful to a single disk seek per //! `DB::Get()` call. //! //! Most people will want to use the builtin bloom filter support (see //! `NewBloomFilterPolicy()` below). use std::os::raw::c_void; use rocks_sys as ll; use to_raw::ToRaw; pub struct FilterPolicy { raw: *mut ll::rocks_raw_filterpolicy_t, } impl ToRaw<ll::rocks_raw_filterpolicy_t> for FilterPolicy { fn raw(&self) -> *mut ll::rocks_raw_filterpolicy_t { self.raw } } impl Drop for FilterPolicy { fn drop(&mut self) { unsafe { ll::rocks_raw_filterpolicy_destroy(self.raw); } } } impl FilterPolicy { // Return a new filter policy that uses a bloom filter with approximately // the specified number of bits per key. // // bits_per_key: bits per key in bloom filter. A good value for bits_per_key // is 10, which yields a filter with ~ 1% false positive rate. // // use_block_based_builder: use block based filter rather than full filter. // If you want to builder full filter, it needs to be set to false. // // Callers must delete the result after any database that is using the // result has been closed. // // Note: if you are using a custom comparator that ignores some parts // of the keys being compared, you must not use NewBloomFilterPolicy() // and must provide your own FilterPolicy that also ignores the // corresponding parts of the keys. For example, if the comparator // ignores trailing spaces, it would be incorrect to use a // FilterPolicy (like NewBloomFilterPolicy) that does not ignore // trailing spaces in keys. pub fn new_bloom_filter(bits_per_key: i32, use_block_based_builder: bool) -> FilterPolicy { FilterPolicy { raw: unsafe { ll::rocks_raw_filterpolicy_new_bloomfilter(bits_per_key, use_block_based_builder as u8) } } } } /* // We add a new format of filter block called full filter block // This new interface gives you more space of customization // // For the full filter block, you can plug in your version by implement // the FilterBitsBuilder and FilterBitsReader // // There are two sets of interface in FilterPolicy // // Set 1: CreateFilter, KeyMayMatch: used for blockbased filter // // Set 2: GetFilterBitsBuilder, GetFilterBitsReader, they are used for // full filter. // // Set 1 MUST be implemented correctly, Set 2 is optional // // RocksDB would first try using functions in Set 2. if they return nullptr, // it would use Set 1 instead. // // You can choose filter type in NewBloomFilterPolicy pub trait FilterPolicy { // Return the name of this policy. Note that if the filter encoding // changes in an incompatible way, the name returned by this method // must be changed. Otherwise, old incompatible filters may be // passed to methods of this type. fn name(&self) -> &'static str { "RustFilterPolicy\0" } // keys[0,n-1] contains a list of keys (potentially with duplicates) // that are ordered according to the user supplied comparator. // Append a filter that summarizes keys[0,n-1] to *dst. // // Warning: do not change the initial contents of *dst. Instead, // append the newly constructed filter to *dst. // // For Rust: must call dst.extend_from_slice() or dst.push() fn create_filter(&self, keys: &[&[u8]], dst: &mut Vec<u8>); // "filter" contains the data appended by a preceding call to // CreateFilter() on this class. This method must return true if // the key was in the list of keys passed to CreateFilter(). // This method may return true or false if the key was not on the // list, but it should aim to return false with a high probability. fn key_may_match(&self, key: &[u8], filter: &[u8]) -> bool; } */