Struct bonsaidb_local::config::KeyValuePersistence

pub struct KeyValuePersistence(_);

Rules for persisting key-value changes. Default persistence is to immediately persist all changes. While this ensures data integrity, the overhead of the key-value store can be significantly reduced by utilizing lazy persistence strategies that delay writing changes until certain thresholds have been met.

Immediate persistence

The default persistence mode will trigger commits always:

assert!(!KeyValuePersistence::default().should_commit(0, Duration::ZERO));
assert!(KeyValuePersistence::default().should_commit(1, Duration::ZERO));

Lazy persistence

Lazy persistence allows setting multiple thresholds, allowing for customized behavior that can help tune performance, especially under write-heavy loads.

It is good practice to include one PersistenceThreshold that has no duration, as it will ensure that the in-memory cache cannot exceed a certain size. This number is counted for each database indepenently.

let persistence = KeyValuePersistence::lazy([
    PersistenceThreshold::after_changes(1).and_duration(Duration::from_secs(120)),
    PersistenceThreshold::after_changes(10).and_duration(Duration::from_secs(10)),
    PersistenceThreshold::after_changes(100),
]);

// After 1 change and 60 seconds, no changes would be committed:
assert!(!persistence.should_commit(1, Duration::from_secs(60)));
// But on or after 120 seconds, that change will be committed:
assert!(persistence.should_commit(1, Duration::from_secs(120)));

// After 10 changes and 10 seconds, changes will be committed:
assert!(persistence.should_commit(10, Duration::from_secs(10)));

// Once 100 changes have been accumulated, this ruleset will always commit
// regardless of duration.
assert!(persistence.should_commit(100, Duration::ZERO));

Implementations

impl KeyValuePersistence

pub const fn immediate() -> Self

Returns a ruleset that commits all changes immediately.

pub fn lazy<II>(rules: II) -> Selfwhere II: IntoIterator<Item = PersistenceThreshold>,

Returns a ruleset that lazily commits data based on a list of thresholds.

pub fn should_commit( &self, number_of_changes: usize, elapsed_since_last_commit: Duration ) -> bool

Returns true if these rules determine that the outstanding changes should be persisted.

Trait Implementations

impl Clone for KeyValuePersistence

fn clone(&self) -> KeyValuePersistence

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for KeyValuePersistence

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for KeyValuePersistence

fn default() -> Self

Returns KeyValuePersistence::immediate().