reifydb-store-multi 0.9.1

Multi-version storage for OLTP operations with MVCC support
Documentation 
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
112
113
114
115
116
117
118
119
120

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 ReifyDB

use reifydb_core::event::EventBus;
use reifydb_runtime::{actor::system::ActorSpawner, context::clock::Clock};
#[cfg(all(feature = "sqlite", not(target_arch = "wasm32")))]
use reifydb_sqlite::{SqliteConfig, SqliteTempPathGuard};
use reifydb_store_commit::store::CommitStore;
use reifydb_value::value::duration::Duration;

use crate::tier::{persistent::MultiPersistentTier, point::MultiPointConfig, range::MultiRangeConfig};

#[derive(Clone)]
pub struct MultiStoreConfig {
	pub commit: CommitStoreConfig,
	pub persistent: Option<PersistentConfig>,
	pub point: Option<MultiPointConfig>,
	pub range: Option<MultiRangeConfig>,
	pub retention: RetentionConfig,
	pub merge_config: MergeConfig,
	pub event_bus: EventBus,
	pub spawner: ActorSpawner,
	pub clock: Clock,
}

impl MultiStoreConfig {
	pub fn memory(spawner: ActorSpawner, clock: Clock, event_bus: EventBus) -> Self {
		Self {
			commit: CommitStoreConfig {
				storage: CommitStore::new(),
			},
			persistent: None,
			point: None,
			range: None,
			retention: Default::default(),
			merge_config: Default::default(),
			event_bus,
			spawner,
			clock,
		}
	}

	#[cfg(all(feature = "sqlite", not(target_arch = "wasm32")))]
	pub fn sqlite(persistent: PersistentConfig, spawner: ActorSpawner, clock: Clock, event_bus: EventBus) -> Self {
		Self {
			commit: CommitStoreConfig {
				storage: CommitStore::new(),
			},
			persistent: Some(persistent),
			point: None,
			range: None,
			retention: Default::default(),
			merge_config: Default::default(),
			event_bus,
			spawner,
			clock,
		}
	}
}

#[derive(Clone)]
pub struct CommitStoreConfig {
	pub storage: CommitStore,
}

#[derive(Clone)]
pub struct PersistentConfig {
	pub storage: MultiPersistentTier,
}

impl PersistentConfig {
	pub fn opened(storage: MultiPersistentTier) -> Self {
		Self {
			storage,
		}
	}

	#[cfg(all(feature = "sqlite", not(target_arch = "wasm32")))]
	pub fn sqlite(sqlite_config: SqliteConfig) -> Self {
		Self::opened(MultiPersistentTier::sqlite(sqlite_config))
	}

	#[cfg(all(feature = "sqlite", not(target_arch = "wasm32")))]
	pub fn sqlite_in_memory() -> (Self, SqliteTempPathGuard) {
		let (storage, guard) = MultiPersistentTier::sqlite_in_memory();
		(Self::opened(storage), guard)
	}
}

#[derive(Clone, Debug)]
pub struct RetentionConfig {
	pub buffer: Duration,
	pub persistent: Duration,
}

#[derive(Clone, Debug)]
pub struct MergeConfig {
	pub merge_threshold_rows: usize,
	pub merge_batch_size: usize,
	pub enable_auto_eviction: bool,
}

impl Default for RetentionConfig {
	fn default() -> Self {
		Self {
			buffer: Duration::from_seconds(300).unwrap(),
			persistent: Duration::from_seconds(3600).unwrap(),
		}
	}
}

impl Default for MergeConfig {
	fn default() -> Self {
		Self {
			merge_threshold_rows: 100_000,
			merge_batch_size: 10_000,
			enable_auto_eviction: true,
		}
	}
}