reifydb-core 0.8.1

Core database interfaces and data structures for ReifyDB
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
121
122
123
124
125
126
127
128

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

use crate::window::span::Slot;

pub const DEFAULT_STATE_CACHE_CAPACITY: usize = 1024;

pub const DEFAULT_INTERNAL_STATE_CACHE_CAPACITY: usize = 1024;

pub const DEFAULT_EXPIRE_BATCH: usize = 256;

#[derive(Clone, Copy, Debug)]
pub struct WindowEngineConfig {
	state_cache_capacity: usize,
	internal_state_cache_capacity: usize,
	expire_batch: usize,
}

impl WindowEngineConfig {
	pub fn builder() -> WindowEngineConfigBuilder {
		WindowEngineConfigBuilder::default()
	}

	pub fn state_cache_capacity(&self) -> usize {
		self.state_cache_capacity
	}

	pub fn internal_state_cache_capacity(&self) -> usize {
		self.internal_state_cache_capacity
	}

	pub fn expire_batch(&self) -> usize {
		self.expire_batch
	}
}

#[derive(Clone, Copy, Debug)]
pub struct WindowEngineConfigBuilder {
	state_cache_capacity: usize,
	internal_state_cache_capacity: usize,
	expire_batch: usize,
}

impl Default for WindowEngineConfigBuilder {
	fn default() -> Self {
		Self {
			state_cache_capacity: DEFAULT_STATE_CACHE_CAPACITY,
			internal_state_cache_capacity: DEFAULT_INTERNAL_STATE_CACHE_CAPACITY,
			expire_batch: DEFAULT_EXPIRE_BATCH,
		}
	}
}

impl WindowEngineConfigBuilder {
	pub fn state_cache_capacity(mut self, capacity: usize) -> Self {
		self.state_cache_capacity = capacity;
		self
	}

	pub fn internal_state_cache_capacity(mut self, capacity: usize) -> Self {
		self.internal_state_cache_capacity = capacity;
		self
	}

	pub fn expire_batch(mut self, batch: usize) -> Self {
		self.expire_batch = batch;
		self
	}

	pub fn build(self) -> WindowEngineConfig {
		WindowEngineConfig {
			state_cache_capacity: self.state_cache_capacity,
			internal_state_cache_capacity: self.internal_state_cache_capacity,
			expire_batch: self.expire_batch,
		}
	}
}

#[derive(Clone, Copy, Debug)]
pub struct TumblingCarryConfig<C: Slot> {
	base: WindowEngineConfig,
	retention: Option<C::Duration>,
}

impl<C: Slot> TumblingCarryConfig<C> {
	pub fn builder() -> TumblingCarryConfigBuilder<C> {
		TumblingCarryConfigBuilder::new()
	}

	pub fn base(&self) -> WindowEngineConfig {
		self.base
	}

	pub fn retention(&self) -> Option<C::Duration> {
		self.retention
	}
}

pub struct TumblingCarryConfigBuilder<C: Slot> {
	base: WindowEngineConfig,
	retention: Option<C::Duration>,
}

impl<C: Slot> TumblingCarryConfigBuilder<C> {
	fn new() -> Self {
		Self {
			base: WindowEngineConfig::builder().build(),
			retention: None,
		}
	}

	pub fn base(mut self, base: WindowEngineConfig) -> Self {
		self.base = base;
		self
	}

	pub fn retention(mut self, retention: Option<C::Duration>) -> Self {
		self.retention = retention;
		self
	}

	pub fn build(self) -> TumblingCarryConfig<C> {
		TumblingCarryConfig {
			base: self.base,
			retention: self.retention,
		}
	}
}