reifydb_core/

common.rs

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

use std::{
	fmt,
	fmt::{Display, Formatter},
	num::ParseIntError,
	str::FromStr,
};

use reifydb_value::value::duration::Duration;
use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Visitor};

#[repr(transparent)]
#[derive(Debug, Copy, Clone, PartialOrd, PartialEq, Ord, Eq, Hash)]
pub struct CommitVersion(pub u64);

impl FromStr for CommitVersion {
	type Err = ParseIntError;

	fn from_str(s: &str) -> Result<Self, Self::Err> {
		Ok(CommitVersion(u64::from_str(s)?))
	}
}

impl Display for CommitVersion {
	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
		Display::fmt(&self.0, f)
	}
}

impl PartialEq<i32> for CommitVersion {
	fn eq(&self, other: &i32) -> bool {
		self.0 == *other as u64
	}
}

impl PartialEq<CommitVersion> for i32 {
	fn eq(&self, other: &CommitVersion) -> bool {
		*self as u64 == other.0
	}
}

impl PartialEq<u64> for CommitVersion {
	fn eq(&self, other: &u64) -> bool {
		self.0.eq(other)
	}
}

impl From<CommitVersion> for u64 {
	fn from(value: CommitVersion) -> Self {
		value.0
	}
}

impl From<i32> for CommitVersion {
	fn from(value: i32) -> Self {
		Self(value as u64)
	}
}

impl From<u64> for CommitVersion {
	fn from(value: u64) -> Self {
		Self(value)
	}
}

impl Serialize for CommitVersion {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
		S: Serializer,
	{
		serializer.serialize_u64(self.0)
	}
}

impl<'de> Deserialize<'de> for CommitVersion {
	fn deserialize<D>(deserializer: D) -> Result<CommitVersion, D::Error>
	where
		D: Deserializer<'de>,
	{
		struct U64Visitor;

		impl Visitor<'_> for U64Visitor {
			type Value = CommitVersion;

			fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
				formatter.write_str("an unsigned 64-bit number")
			}

			fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E> {
				Ok(CommitVersion(value))
			}
		}

		deserializer.deserialize_u64(U64Visitor)
	}
}

#[repr(transparent)]
#[derive(Debug, Copy, Clone, PartialOrd, PartialEq, Ord, Eq, Hash, Serialize, Deserialize)]
#[serde(transparent)]
pub struct SourceVersion(pub u64);

impl From<CommitVersion> for SourceVersion {
	fn from(version: CommitVersion) -> Self {
		Self(version.0)
	}
}

#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct ChangeVersion {
	pub commit: CommitVersion,
	pub source: SourceVersion,
}

impl From<CommitVersion> for ChangeVersion {
	fn from(commit: CommitVersion) -> Self {
		Self {
			commit,
			source: SourceVersion::from(commit),
		}
	}
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, Default)]
pub enum JoinType {
	Inner,
	#[default]
	Left,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
pub enum IndexType {
	#[default]
	Index,
	Unique,
	Primary,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum WindowSize {
	Duration(Duration),
	Count(u64),
}

impl WindowSize {
	pub fn is_count(&self) -> bool {
		matches!(self, WindowSize::Count(_))
	}

	pub fn as_duration(&self) -> Option<Duration> {
		match self {
			WindowSize::Duration(d) => Some(*d),
			_ => None,
		}
	}

	pub fn as_count(&self) -> Option<u64> {
		match self {
			WindowSize::Count(c) => Some(*c),
			_ => None,
		}
	}
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum TimeDomain {
	None,
	Event,
	Processing,
}

impl TimeDomain {
	pub fn to_u8(self) -> u8 {
		match self {
			TimeDomain::None => 0,
			TimeDomain::Event => 1,
			TimeDomain::Processing => 2,
		}
	}

	pub fn from_u8(value: u8) -> Self {
		match value {
			1 => TimeDomain::Event,
			2 => TimeDomain::Processing,
			_ => TimeDomain::None,
		}
	}

	pub fn as_str(&self) -> &'static str {
		match self {
			TimeDomain::None => "none",
			TimeDomain::Event => "event",
			TimeDomain::Processing => "processing",
		}
	}
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum TimeSource {
	None,
	Event {
		ts: String,
	},
	Processing,
}

impl TimeSource {
	pub fn domain(&self) -> TimeDomain {
		match self {
			TimeSource::None => TimeDomain::None,
			TimeSource::Event {
				..
			} => TimeDomain::Event,
			TimeSource::Processing => TimeDomain::Processing,
		}
	}

	pub fn ts(&self) -> Option<&str> {
		match self {
			TimeSource::Event {
				ts,
			} => Some(ts.as_str()),
			TimeSource::None | TimeSource::Processing => None,
		}
	}
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum WindowKind {
	Tumbling {
		size: WindowSize,
	},

	Sliding {
		size: WindowSize,
		slide: WindowSize,
	},

	Rolling {
		size: WindowSize,
		#[serde(default)]
		lag: Option<Duration>,
	},

	Session {
		gap: Duration,
	},
}

impl WindowKind {
	pub fn size(&self) -> Option<&WindowSize> {
		match self {
			WindowKind::Tumbling {
				size,
				..
			} => Some(size),
			WindowKind::Sliding {
				size,
				..
			} => Some(size),
			WindowKind::Rolling {
				size,
				..
			} => Some(size),
			WindowKind::Session {
				..
			} => None,
		}
	}
}