rocks 0.1.10

RocksDB bindings for Rust.
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

//! 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 rocks_sys as ll;

use crate::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) -> &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;
// }
//