reifydb_core/encoded/
datetime.rs

1// SPDX-License-Identifier: Apache-2.0
2// Copyright (c) 2025 ReifyDB
3
4use std::ptr;
5
6use reifydb_type::value::{datetime::DateTime, r#type::Type};
7
8use crate::encoded::{row::EncodedRow, schema::RowSchema};
9
10impl RowSchema {
11	pub fn set_datetime(&self, row: &mut EncodedRow, index: usize, value: DateTime) {
12		let field = &self.fields()[index];
13		debug_assert!(row.len() >= self.total_static_size());
14		debug_assert_eq!(*field.constraint.get_type().inner_type(), Type::DateTime);
15		row.set_valid(index, true);
16
17		let nanos = value.to_nanos();
18		unsafe {
19			ptr::write_unaligned(row.make_mut().as_mut_ptr().add(field.offset as usize) as *mut u64, nanos);
20		}
21	}
22
23	pub fn get_datetime(&self, row: &EncodedRow, index: usize) -> DateTime {
24		let field = &self.fields()[index];
25		debug_assert!(row.len() >= self.total_static_size());
26		debug_assert_eq!(*field.constraint.get_type().inner_type(), Type::DateTime);
27		unsafe {
28			let nanos = (row.as_ptr().add(field.offset as usize) as *const u64).read_unaligned();
29			DateTime::from_nanos(nanos)
30		}
31	}
32
33	pub fn try_get_datetime(&self, row: &EncodedRow, index: usize) -> Option<DateTime> {
34		if row.is_defined(index) && self.fields()[index].constraint.get_type() == Type::DateTime {
35			Some(self.get_datetime(row, index))
36		} else {
37			None
38		}
39	}
40}
41
42#[cfg(test)]
43pub mod tests {
44	use reifydb_type::value::{datetime::DateTime, r#type::Type};
45
46	use crate::encoded::schema::RowSchema;
47
48	#[test]
49	fn test_set_get_datetime() {
50		let schema = RowSchema::testing(&[Type::DateTime]);
51		let mut row = schema.allocate();
52
53		let value = DateTime::new(2024, 9, 9, 08, 17, 0, 1234).unwrap();
54		schema.set_datetime(&mut row, 0, value.clone());
55		assert_eq!(schema.get_datetime(&row, 0), value);
56	}
57
58	#[test]
59	fn test_try_get_datetime() {
60		let schema = RowSchema::testing(&[Type::DateTime]);
61		let mut row = schema.allocate();
62
63		assert_eq!(schema.try_get_datetime(&row, 0), None);
64
65		let test_datetime = DateTime::from_timestamp(1642694400).unwrap();
66		schema.set_datetime(&mut row, 0, test_datetime.clone());
67		assert_eq!(schema.try_get_datetime(&row, 0), Some(test_datetime));
68	}
69
70	#[test]
71	fn test_epoch() {
72		let schema = RowSchema::testing(&[Type::DateTime]);
73		let mut row = schema.allocate();
74
75		let epoch = DateTime::default(); // Unix epoch
76		schema.set_datetime(&mut row, 0, epoch.clone());
77		assert_eq!(schema.get_datetime(&row, 0), epoch);
78	}
79
80	#[test]
81	fn test_with_nanoseconds() {
82		let schema = RowSchema::testing(&[Type::DateTime]);
83		let mut row = schema.allocate();
84
85		// Test with high precision nanoseconds
86		let precise_datetime = DateTime::new(2024, 12, 25, 15, 30, 45, 123456789).unwrap();
87		schema.set_datetime(&mut row, 0, precise_datetime.clone());
88		assert_eq!(schema.get_datetime(&row, 0), precise_datetime);
89	}
90
91	#[test]
92	fn test_various_timestamps() {
93		let schema = RowSchema::testing(&[Type::DateTime]);
94
95		let test_datetimes = [
96			DateTime::from_timestamp(0).unwrap(),          // Unix epoch
97			DateTime::from_timestamp(946684800).unwrap(),  // 2000-01-01
98			DateTime::from_timestamp(1640995200).unwrap(), // 2022-01-01
99			DateTime::from_timestamp(1735689600).unwrap(), // 2025-01-01
100		];
101
102		for datetime in test_datetimes {
103			let mut row = schema.allocate();
104			schema.set_datetime(&mut row, 0, datetime.clone());
105			assert_eq!(schema.get_datetime(&row, 0), datetime);
106		}
107	}
108
109	#[test]
110	fn test_mixed_with_other_types() {
111		let schema = RowSchema::testing(&[Type::DateTime, Type::Boolean, Type::DateTime, Type::Int8]);
112		let mut row = schema.allocate();
113
114		let datetime1 = DateTime::new(2025, 6, 15, 12, 0, 0, 0).unwrap();
115		let datetime2 = DateTime::new(1995, 3, 22, 18, 30, 45, 500000000).unwrap();
116
117		schema.set_datetime(&mut row, 0, datetime1.clone());
118		schema.set_bool(&mut row, 1, true);
119		schema.set_datetime(&mut row, 2, datetime2.clone());
120		schema.set_i64(&mut row, 3, 1234567890);
121
122		assert_eq!(schema.get_datetime(&row, 0), datetime1);
123		assert_eq!(schema.get_bool(&row, 1), true);
124		assert_eq!(schema.get_datetime(&row, 2), datetime2);
125		assert_eq!(schema.get_i64(&row, 3), 1234567890);
126	}
127
128	#[test]
129	fn test_undefined_handling() {
130		let schema = RowSchema::testing(&[Type::DateTime, Type::DateTime]);
131		let mut row = schema.allocate();
132
133		let datetime = DateTime::new(2025, 7, 4, 16, 20, 15, 750000000).unwrap();
134		schema.set_datetime(&mut row, 0, datetime.clone());
135
136		assert_eq!(schema.try_get_datetime(&row, 0), Some(datetime));
137		assert_eq!(schema.try_get_datetime(&row, 1), None);
138
139		schema.set_none(&mut row, 0);
140		assert_eq!(schema.try_get_datetime(&row, 0), None);
141	}
142
143	#[test]
144	fn test_precision_preservation() {
145		let schema = RowSchema::testing(&[Type::DateTime]);
146		let mut row = schema.allocate();
147
148		// Test that nanosecond precision is preserved
149		let high_precision = DateTime::new(2024, 1, 1, 0, 0, 0, 999999999).unwrap();
150		schema.set_datetime(&mut row, 0, high_precision.clone());
151
152		let retrieved = schema.get_datetime(&row, 0);
153		assert_eq!(retrieved, high_precision);
154
155		let orig_nanos = high_precision.to_nanos();
156		let ret_nanos = retrieved.to_nanos();
157		assert_eq!(orig_nanos, ret_nanos);
158	}
159
160	#[test]
161	fn test_year_2038_problem() {
162		let schema = RowSchema::testing(&[Type::DateTime]);
163		let mut row = schema.allocate();
164
165		// Test the Y2038 boundary (beyond 32-bit timestamp limits)
166		let post_2038 = DateTime::from_timestamp(2147483648).unwrap(); // 2038-01-19
167		schema.set_datetime(&mut row, 0, post_2038.clone());
168		assert_eq!(schema.get_datetime(&row, 0), post_2038);
169	}
170
171	#[test]
172	fn test_far_future() {
173		let schema = RowSchema::testing(&[Type::DateTime]);
174		let mut row = schema.allocate();
175
176		// Test a far future date
177		let far_future = DateTime::from_timestamp(4102444800).unwrap(); // 2100-01-01
178		schema.set_datetime(&mut row, 0, far_future.clone());
179		assert_eq!(schema.get_datetime(&row, 0), far_future);
180	}
181
182	#[test]
183	fn test_microsecond_precision() {
184		let schema = RowSchema::testing(&[Type::DateTime]);
185		let mut row = schema.allocate();
186
187		// Test microsecond precision (common in databases)
188		let microsecond_precision = DateTime::new(2024, 6, 15, 14, 30, 25, 123456000).unwrap();
189		schema.set_datetime(&mut row, 0, microsecond_precision.clone());
190		assert_eq!(schema.get_datetime(&row, 0), microsecond_precision);
191	}
192
193	#[test]
194	fn test_try_get_datetime_wrong_type() {
195		let schema = RowSchema::testing(&[Type::Boolean]);
196		let mut row = schema.allocate();
197
198		schema.set_bool(&mut row, 0, true);
199
200		assert_eq!(schema.try_get_datetime(&row, 0), None);
201	}
202}
reifydb_core/encoded/datetime.rs

reifydb_core/encoded/
datetime.rs
