reifydb_core/
common.rs

1// SPDX-License-Identifier: Apache-2.0
2// Copyright (c) 2026 ReifyDB
3
4use std::{
5	fmt,
6	fmt::{Display, Formatter},
7	num::ParseIntError,
8	str::FromStr,
9};
10
11use reifydb_value::value::duration::Duration;
12use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Visitor};
13
14#[repr(transparent)]
15#[derive(Debug, Copy, Clone, PartialOrd, PartialEq, Ord, Eq, Hash)]
16pub struct CommitVersion(pub u64);
17
18impl FromStr for CommitVersion {
19	type Err = ParseIntError;
20
21	fn from_str(s: &str) -> Result<Self, Self::Err> {
22		Ok(CommitVersion(u64::from_str(s)?))
23	}
24}
25
26impl Display for CommitVersion {
27	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
28		Display::fmt(&self.0, f)
29	}
30}
31
32impl PartialEq<i32> for CommitVersion {
33	fn eq(&self, other: &i32) -> bool {
34		self.0 == *other as u64
35	}
36}
37
38impl PartialEq<CommitVersion> for i32 {
39	fn eq(&self, other: &CommitVersion) -> bool {
40		*self as u64 == other.0
41	}
42}
43
44impl PartialEq<u64> for CommitVersion {
45	fn eq(&self, other: &u64) -> bool {
46		self.0.eq(other)
47	}
48}
49
50impl From<CommitVersion> for u64 {
51	fn from(value: CommitVersion) -> Self {
52		value.0
53	}
54}
55
56impl From<i32> for CommitVersion {
57	fn from(value: i32) -> Self {
58		Self(value as u64)
59	}
60}
61
62impl From<u64> for CommitVersion {
63	fn from(value: u64) -> Self {
64		Self(value)
65	}
66}
67
68impl Serialize for CommitVersion {
69	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
70	where
71		S: Serializer,
72	{
73		serializer.serialize_u64(self.0)
74	}
75}
76
77impl<'de> Deserialize<'de> for CommitVersion {
78	fn deserialize<D>(deserializer: D) -> Result<CommitVersion, D::Error>
79	where
80		D: Deserializer<'de>,
81	{
82		struct U64Visitor;
83
84		impl Visitor<'_> for U64Visitor {
85			type Value = CommitVersion;
86
87			fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
88				formatter.write_str("an unsigned 64-bit number")
89			}
90
91			fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E> {
92				Ok(CommitVersion(value))
93			}
94		}
95
96		deserializer.deserialize_u64(U64Visitor)
97	}
98}
99
100#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, Default)]
101pub enum JoinType {
102	Inner,
103	#[default]
104	Left,
105}
106
107#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
108pub enum IndexType {
109	#[default]
110	Index,
111	Unique,
112	Primary,
113}
114
115#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
116pub enum WindowSize {
117	Duration(Duration),
118	Count(u64),
119}
120
121impl WindowSize {
122	pub fn is_count(&self) -> bool {
123		matches!(self, WindowSize::Count(_))
124	}
125
126	pub fn as_duration(&self) -> Option<Duration> {
127		match self {
128			WindowSize::Duration(d) => Some(*d),
129			_ => None,
130		}
131	}
132
133	pub fn as_count(&self) -> Option<u64> {
134		match self {
135			WindowSize::Count(c) => Some(*c),
136			_ => None,
137		}
138	}
139}
140
141#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
142pub enum TimeDomain {
143	None,
144	Event,
145	Processing,
146}
147
148impl TimeDomain {
149	pub fn to_u8(self) -> u8 {
150		match self {
151			TimeDomain::None => 0,
152			TimeDomain::Event => 1,
153			TimeDomain::Processing => 2,
154		}
155	}
156
157	pub fn from_u8(value: u8) -> Self {
158		match value {
159			1 => TimeDomain::Event,
160			2 => TimeDomain::Processing,
161			_ => TimeDomain::None,
162		}
163	}
164
165	pub fn as_str(&self) -> &'static str {
166		match self {
167			TimeDomain::None => "none",
168			TimeDomain::Event => "event",
169			TimeDomain::Processing => "processing",
170		}
171	}
172}
173
174#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
175pub enum TimeSource {
176	None,
177	Event {
178		ts: String,
179	},
180	Processing,
181}
182
183impl TimeSource {
184	pub fn domain(&self) -> TimeDomain {
185		match self {
186			TimeSource::None => TimeDomain::None,
187			TimeSource::Event {
188				..
189			} => TimeDomain::Event,
190			TimeSource::Processing => TimeDomain::Processing,
191		}
192	}
193
194	pub fn ts(&self) -> Option<&str> {
195		match self {
196			TimeSource::Event {
197				ts,
198			} => Some(ts.as_str()),
199			TimeSource::None | TimeSource::Processing => None,
200		}
201	}
202}
203
204#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
205pub enum WindowKind {
206	Tumbling {
207		size: WindowSize,
208	},
209
210	Sliding {
211		size: WindowSize,
212		slide: WindowSize,
213	},
214
215	Rolling {
216		size: WindowSize,
217		#[serde(default)]
218		lag: Option<Duration>,
219	},
220
221	Session {
222		gap: Duration,
223	},
224}
225
226impl WindowKind {
227	pub fn size(&self) -> Option<&WindowSize> {
228		match self {
229			WindowKind::Tumbling {
230				size,
231				..
232			} => Some(size),
233			WindowKind::Sliding {
234				size,
235				..
236			} => Some(size),
237			WindowKind::Rolling {
238				size,
239				..
240			} => Some(size),
241			WindowKind::Session {
242				..
243			} => None,
244		}
245	}
246}
reifydb_core/common.rs

reifydb_core/
common.rs
