reifydb_core/encoded/
datetime.rs

1// SPDX-License-Identifier: AGPL-3.0-or-later
2// Copyright (c) 2026 ReifyDB
3
4use std::ptr;
5
6use reifydb_value::value::{datetime::DateTime, value_type::ValueType};
7
8use crate::encoded::{row::EncodedRow, shape::RowShape};
9
10impl RowShape {
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(), ValueType::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(), ValueType::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() == ValueType::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_value::value::{datetime::DateTime, value_type::ValueType};
45
46	use crate::encoded::shape::RowShape;
47
48	#[test]
49	fn test_set_get_datetime() {
50		let shape = RowShape::testing(&[ValueType::DateTime]);
51		let mut row = shape.allocate();
52
53		let value = DateTime::new(2024, 9, 9, 08, 17, 0, 1234).unwrap();
54		shape.set_datetime(&mut row, 0, value.clone());
55		assert_eq!(shape.get_datetime(&row, 0), value);
56	}
57
58	#[test]
59	fn test_try_get_datetime() {
60		let shape = RowShape::testing(&[ValueType::DateTime]);
61		let mut row = shape.allocate();
62
63		assert_eq!(shape.try_get_datetime(&row, 0), None);
64
65		let test_datetime = DateTime::from_timestamp(1642694400).unwrap();
66		shape.set_datetime(&mut row, 0, test_datetime.clone());
67		assert_eq!(shape.try_get_datetime(&row, 0), Some(test_datetime));
68	}
69
70	#[test]
71	fn test_epoch() {
72		let shape = RowShape::testing(&[ValueType::DateTime]);
73		let mut row = shape.allocate();
74
75		let epoch = DateTime::default(); // Unix epoch
76		shape.set_datetime(&mut row, 0, epoch.clone());
77		assert_eq!(shape.get_datetime(&row, 0), epoch);
78	}
79
80	#[test]
81	fn test_with_nanoseconds() {
82		let shape = RowShape::testing(&[ValueType::DateTime]);
83		let mut row = shape.allocate();
84
85		// Test with high precision nanoseconds
86		let precise_datetime = DateTime::new(2024, 12, 25, 15, 30, 45, 123456789).unwrap();
87		shape.set_datetime(&mut row, 0, precise_datetime.clone());
88		assert_eq!(shape.get_datetime(&row, 0), precise_datetime);
89	}
90
91	#[test]
92	fn test_various_timestamps() {
93		let shape = RowShape::testing(&[ValueType::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 = shape.allocate();
104			shape.set_datetime(&mut row, 0, datetime.clone());
105			assert_eq!(shape.get_datetime(&row, 0), datetime);
106		}
107	}
108
109	#[test]
110	fn test_mixed_with_other_types() {
111		let shape = RowShape::testing(&[
112			ValueType::DateTime,
113			ValueType::Boolean,
114			ValueType::DateTime,
115			ValueType::Int8,
116		]);
117		let mut row = shape.allocate();
118
119		let datetime1 = DateTime::new(2025, 6, 15, 12, 0, 0, 0).unwrap();
120		let datetime2 = DateTime::new(1995, 3, 22, 18, 30, 45, 500000000).unwrap();
121
122		shape.set_datetime(&mut row, 0, datetime1.clone());
123		shape.set_bool(&mut row, 1, true);
124		shape.set_datetime(&mut row, 2, datetime2.clone());
125		shape.set_i64(&mut row, 3, 1234567890);
126
127		assert_eq!(shape.get_datetime(&row, 0), datetime1);
128		assert_eq!(shape.get_bool(&row, 1), true);
129		assert_eq!(shape.get_datetime(&row, 2), datetime2);
130		assert_eq!(shape.get_i64(&row, 3), 1234567890);
131	}
132
133	#[test]
134	fn test_undefined_handling() {
135		let shape = RowShape::testing(&[ValueType::DateTime, ValueType::DateTime]);
136		let mut row = shape.allocate();
137
138		let datetime = DateTime::new(2025, 7, 4, 16, 20, 15, 750000000).unwrap();
139		shape.set_datetime(&mut row, 0, datetime.clone());
140
141		assert_eq!(shape.try_get_datetime(&row, 0), Some(datetime));
142		assert_eq!(shape.try_get_datetime(&row, 1), None);
143
144		shape.set_none(&mut row, 0);
145		assert_eq!(shape.try_get_datetime(&row, 0), None);
146	}
147
148	#[test]
149	fn test_precision_preservation() {
150		let shape = RowShape::testing(&[ValueType::DateTime]);
151		let mut row = shape.allocate();
152
153		// Test that nanosecond precision is preserved
154		let high_precision = DateTime::new(2024, 1, 1, 0, 0, 0, 999999999).unwrap();
155		shape.set_datetime(&mut row, 0, high_precision.clone());
156
157		let retrieved = shape.get_datetime(&row, 0);
158		assert_eq!(retrieved, high_precision);
159
160		let orig_nanos = high_precision.to_nanos();
161		let ret_nanos = retrieved.to_nanos();
162		assert_eq!(orig_nanos, ret_nanos);
163	}
164
165	#[test]
166	fn test_year_2038_problem() {
167		let shape = RowShape::testing(&[ValueType::DateTime]);
168		let mut row = shape.allocate();
169
170		// Test the Y2038 boundary (beyond 32-bit timestamp limits)
171		let post_2038 = DateTime::from_timestamp(2147483648).unwrap(); // 2038-01-19
172		shape.set_datetime(&mut row, 0, post_2038.clone());
173		assert_eq!(shape.get_datetime(&row, 0), post_2038);
174	}
175
176	#[test]
177	fn test_far_future() {
178		let shape = RowShape::testing(&[ValueType::DateTime]);
179		let mut row = shape.allocate();
180
181		// Test a far future date
182		let far_future = DateTime::from_timestamp(4102444800).unwrap(); // 2100-01-01
183		shape.set_datetime(&mut row, 0, far_future.clone());
184		assert_eq!(shape.get_datetime(&row, 0), far_future);
185	}
186
187	#[test]
188	fn test_microsecond_precision() {
189		let shape = RowShape::testing(&[ValueType::DateTime]);
190		let mut row = shape.allocate();
191
192		// Test microsecond precision (common in databases)
193		let microsecond_precision = DateTime::new(2024, 6, 15, 14, 30, 25, 123456000).unwrap();
194		shape.set_datetime(&mut row, 0, microsecond_precision.clone());
195		assert_eq!(shape.get_datetime(&row, 0), microsecond_precision);
196	}
197
198	#[test]
199	fn test_try_get_datetime_wrong_type() {
200		let shape = RowShape::testing(&[ValueType::Boolean]);
201		let mut row = shape.allocate();
202
203		shape.set_bool(&mut row, 0, true);
204
205		assert_eq!(shape.try_get_datetime(&row, 0), None);
206	}
207}
reifydb_core/encoded/datetime.rs

reifydb_core/encoded/
datetime.rs
