reifydb_core/value/encoded/
value.rs

1// Copyright (c) reifydb.com 2025
2// This file is licensed under the AGPL-3.0-or-later, see license.md file
3
4use reifydb_type::{IdentityId, OrderedF32, OrderedF64, Type, Uuid4, Uuid7, Value};
5
6use crate::value::encoded::{EncodedValues, EncodedValuesLayout};
7
8impl EncodedValuesLayout {
9	pub fn set_values(&self, row: &mut EncodedValues, values: &[Value]) {
10		debug_assert!(values.len() == self.fields.len());
11		for (idx, value) in values.iter().enumerate() {
12			self.set_value(row, idx, value)
13		}
14	}
15
16	pub fn set_value(&self, row: &mut EncodedValues, index: usize, val: &Value) {
17		let field = &self.fields[index];
18		debug_assert!(row.len() >= self.total_static_size());
19
20		match (field.r#type, val) {
21			(Type::Boolean, Value::Boolean(v)) => self.set_bool(row, index, *v),
22			(Type::Boolean, Value::Undefined) => self.set_undefined(row, index),
23
24			(Type::Float4, Value::Float4(v)) => self.set_f32(row, index, v.value()),
25			(Type::Float4, Value::Undefined) => self.set_undefined(row, index),
26
27			(Type::Float8, Value::Float8(v)) => self.set_f64(row, index, v.value()),
28			(Type::Float8, Value::Undefined) => self.set_undefined(row, index),
29
30			(Type::Int1, Value::Int1(v)) => self.set_i8(row, index, *v),
31			(Type::Int1, Value::Undefined) => self.set_undefined(row, index),
32
33			(Type::Int2, Value::Int2(v)) => self.set_i16(row, index, *v),
34			(Type::Int2, Value::Undefined) => self.set_undefined(row, index),
35
36			(Type::Int4, Value::Int4(v)) => self.set_i32(row, index, *v),
37			(Type::Int4, Value::Undefined) => self.set_undefined(row, index),
38
39			(Type::Int8, Value::Int8(v)) => self.set_i64(row, index, *v),
40			(Type::Int8, Value::Undefined) => self.set_undefined(row, index),
41
42			(Type::Int16, Value::Int16(v)) => self.set_i128(row, index, *v),
43			(Type::Int16, Value::Undefined) => self.set_undefined(row, index),
44
45			(Type::Utf8, Value::Utf8(v)) => self.set_utf8(row, index, v),
46			(Type::Utf8, Value::Undefined) => self.set_undefined(row, index),
47
48			(Type::Uint1, Value::Uint1(v)) => self.set_u8(row, index, *v),
49			(Type::Uint1, Value::Undefined) => self.set_undefined(row, index),
50
51			(Type::Uint2, Value::Uint2(v)) => self.set_u16(row, index, *v),
52			(Type::Uint2, Value::Undefined) => self.set_undefined(row, index),
53
54			(Type::Uint4, Value::Uint4(v)) => self.set_u32(row, index, *v),
55			(Type::Uint4, Value::Undefined) => self.set_undefined(row, index),
56
57			(Type::Uint8, Value::Uint8(v)) => self.set_u64(row, index, *v),
58			(Type::Uint8, Value::Undefined) => self.set_undefined(row, index),
59
60			(Type::Uint16, Value::Uint16(v)) => self.set_u128(row, index, *v),
61			(Type::Uint16, Value::Undefined) => self.set_undefined(row, index),
62
63			(Type::Date, Value::Date(v)) => self.set_date(row, index, v.clone()),
64			(Type::Date, Value::Undefined) => self.set_undefined(row, index),
65
66			(Type::DateTime, Value::DateTime(v)) => self.set_datetime(row, index, v.clone()),
67			(Type::DateTime, Value::Undefined) => self.set_undefined(row, index),
68
69			(Type::Time, Value::Time(v)) => self.set_time(row, index, v.clone()),
70			(Type::Time, Value::Undefined) => self.set_undefined(row, index),
71
72			(Type::Duration, Value::Duration(v)) => self.set_duration(row, index, v.clone()),
73			(Type::Duration, Value::Undefined) => self.set_undefined(row, index),
74
75			(Type::Uuid4, Value::Uuid4(v)) => self.set_uuid4(row, index, v.clone()),
76			(Type::Uuid4, Value::Undefined) => self.set_undefined(row, index),
77
78			(Type::Uuid7, Value::Uuid7(v)) => self.set_uuid7(row, index, v.clone()),
79			(Type::Uuid7, Value::Undefined) => self.set_undefined(row, index),
80
81			(Type::Blob, Value::Blob(v)) => self.set_blob(row, index, v),
82			(Type::Blob, Value::Undefined) => self.set_undefined(row, index),
83
84			(Type::Int, Value::Int(v)) => self.set_int(row, index, v),
85			(Type::Uint, Value::Uint(v)) => self.set_uint(row, index, v),
86			(Type::Int, Value::Undefined) => self.set_undefined(row, index),
87			(Type::Uint, Value::Undefined) => self.set_undefined(row, index),
88
89			(
90				Type::Decimal {
91					..
92				},
93				Value::Decimal(v),
94			) => self.set_decimal(row, index, v),
95			(
96				Type::Decimal {
97					..
98				},
99				Value::Undefined,
100			) => self.set_undefined(row, index),
101
102			(Type::Undefined, Value::Undefined) => {}
103			(Type::Any, Value::Any(_)) => unreachable!("Any type cannot be stored in database"),
104			(Type::Any, Value::Undefined) => self.set_undefined(row, index),
105			(ty, val) => unreachable!("{ty:?}, {val:?}"),
106		}
107	}
108
109	pub fn get_value(&self, row: &EncodedValues, index: usize) -> Value {
110		let field = &self.fields[index];
111		if !row.is_defined(index) {
112			return Value::Undefined;
113		}
114		match field.r#type {
115			Type::Boolean => Value::Boolean(self.get_bool(row, index)),
116			Type::Float4 => OrderedF32::try_from(self.get_f32(row, index))
117				.map(Value::Float4)
118				.unwrap_or(Value::Undefined),
119			Type::Float8 => OrderedF64::try_from(self.get_f64(row, index))
120				.map(Value::Float8)
121				.unwrap_or(Value::Undefined),
122			Type::Int1 => Value::Int1(self.get_i8(row, index)),
123			Type::Int2 => Value::Int2(self.get_i16(row, index)),
124			Type::Int4 => Value::Int4(self.get_i32(row, index)),
125			Type::Int8 => Value::Int8(self.get_i64(row, index)),
126			Type::Int16 => Value::Int16(self.get_i128(row, index)),
127			Type::Utf8 => Value::Utf8(self.get_utf8(row, index).to_string()),
128			Type::Uint1 => Value::Uint1(self.get_u8(row, index)),
129			Type::Uint2 => Value::Uint2(self.get_u16(row, index)),
130			Type::Uint4 => Value::Uint4(self.get_u32(row, index)),
131			Type::Uint8 => Value::Uint8(self.get_u64(row, index)),
132			Type::Uint16 => Value::Uint16(self.get_u128(row, index)),
133			Type::Date => Value::Date(self.get_date(row, index)),
134			Type::DateTime => Value::DateTime(self.get_datetime(row, index)),
135			Type::Time => Value::Time(self.get_time(row, index)),
136			Type::Duration => Value::Duration(self.get_duration(row, index)),
137			Type::IdentityId => {
138				Value::IdentityId(IdentityId::from(Uuid7::from(self.get_uuid7(row, index))))
139			}
140			Type::Uuid4 => Value::Uuid4(Uuid4::from(self.get_uuid4(row, index))),
141			Type::Uuid7 => Value::Uuid7(Uuid7::from(self.get_uuid7(row, index))),
142			Type::Blob => Value::Blob(self.get_blob(row, index)),
143			Type::Int => Value::Int(self.get_int(row, index)),
144			Type::Uint => Value::Uint(self.get_uint(row, index)),
145			Type::Decimal {
146				..
147			} => Value::Decimal(self.get_decimal(row, index)),
148			Type::Undefined => Value::Undefined,
149			Type::Any => unreachable!("Any type cannot be stored in database"),
150		}
151	}
152}
153
154#[cfg(test)]
155#[allow(clippy::approx_constant)]
156mod tests {
157	use reifydb_type::{Blob, Date, DateTime, Duration, OrderedF32, OrderedF64, Time, Type, Uuid4, Uuid7, Value};
158
159	use crate::value::encoded::EncodedValuesLayout;
160
161	#[test]
162	fn test_set_utf8_with_dynamic_content() {
163		let layout = EncodedValuesLayout::new(&[Type::Utf8, Type::Int4, Type::Utf8]);
164		let mut row = layout.allocate();
165
166		let value1 = Value::Utf8("hello".to_string());
167		let value2 = Value::Int4(42);
168		let value3 = Value::Utf8("world".to_string());
169
170		layout.set_value(&mut row, 0, &value1);
171		layout.set_value(&mut row, 1, &value2);
172		layout.set_value(&mut row, 2, &value3);
173
174		assert_eq!(layout.get_utf8(&row, 0), "hello");
175		assert_eq!(layout.get_i32(&row, 1), 42);
176		assert_eq!(layout.get_utf8(&row, 2), "world");
177	}
178
179	#[test]
180	fn test_set_values_with_mixed_dynamic_content() {
181		let layout =
182			EncodedValuesLayout::new(&[Type::Boolean, Type::Utf8, Type::Float4, Type::Utf8, Type::Int2]);
183		let mut row = layout.allocate();
184
185		let values = vec![
186			Value::Boolean(true),
187			Value::Utf8("first_string".to_string()),
188			Value::Float4(OrderedF32::try_from(3.14f32).unwrap()),
189			Value::Utf8("second_string".to_string()),
190			Value::Int2(-100),
191		];
192
193		layout.set_values(&mut row, &values);
194
195		assert_eq!(layout.get_bool(&row, 0), true);
196		assert_eq!(layout.get_utf8(&row, 1), "first_string");
197		assert_eq!(layout.get_f32(&row, 2), 3.14f32);
198		assert_eq!(layout.get_utf8(&row, 3), "second_string");
199		assert_eq!(layout.get_i16(&row, 4), -100);
200	}
201
202	#[test]
203	fn test_set_with_empty_and_large_utf8() {
204		let layout = EncodedValuesLayout::new(&[Type::Utf8, Type::Utf8, Type::Utf8]);
205		let mut row = layout.allocate();
206
207		let large_string = "X".repeat(2000);
208		let values = vec![
209			Value::Utf8("".to_string()),
210			Value::Utf8(large_string.clone()),
211			Value::Utf8("small".to_string()),
212		];
213
214		layout.set_values(&mut row, &values);
215
216		assert_eq!(layout.get_utf8(&row, 0), "");
217		assert_eq!(layout.get_utf8(&row, 1), large_string);
218		assert_eq!(layout.get_utf8(&row, 2), "small");
219		assert_eq!(layout.dynamic_section_size(&row), 2005); // 0 + 2000 + 5
220	}
221
222	#[test]
223	fn test_get_from_dynamic_content() {
224		let layout = EncodedValuesLayout::new(&[Type::Utf8, Type::Int8, Type::Utf8]);
225		let mut row = layout.allocate();
226
227		layout.set_utf8(&mut row, 0, "test_string");
228		layout.set_i64(&mut row, 1, 9876543210i64);
229		layout.set_utf8(&mut row, 2, "another_string");
230
231		let value0 = layout.get_value(&row, 0);
232		let value1 = layout.get_value(&row, 1);
233		let value2 = layout.get_value(&row, 2);
234
235		match value0 {
236			Value::Utf8(s) => assert_eq!(s, "test_string"),
237			_ => panic!("Expected UTF8 value"),
238		}
239
240		match value1 {
241			Value::Int8(i) => assert_eq!(i, 9876543210),
242			_ => panic!("Expected Int8 value"),
243		}
244
245		match value2 {
246			Value::Utf8(s) => assert_eq!(s, "another_string"),
247			_ => panic!("Expected UTF8 value"),
248		}
249	}
250
251	#[test]
252	fn test_set_undefined_with_utf8_fields() {
253		let layout = EncodedValuesLayout::new(&[Type::Utf8, Type::Boolean, Type::Utf8]);
254		let mut row = layout.allocate();
255
256		// Set some values
257		layout.set_value(&mut row, 0, &Value::Utf8("hello".to_string()));
258		layout.set_value(&mut row, 1, &Value::Boolean(true));
259		layout.set_value(&mut row, 2, &Value::Utf8("world".to_string()));
260
261		assert!(row.is_defined(0));
262		assert!(row.is_defined(1));
263		assert!(row.is_defined(2));
264
265		// Set some as undefined
266		layout.set_value(&mut row, 0, &Value::Undefined);
267		layout.set_value(&mut row, 2, &Value::Undefined);
268
269		assert!(!row.is_defined(0));
270		assert!(row.is_defined(1));
271		assert!(!row.is_defined(2));
272
273		assert_eq!(layout.get_bool(&row, 1), true);
274	}
275
276	#[test]
277	fn test_get_all_types_including_utf8() {
278		let layout = EncodedValuesLayout::new(&[
279			Type::Boolean,
280			Type::Int1,
281			Type::Int2,
282			Type::Int4,
283			Type::Int8,
284			Type::Uint1,
285			Type::Uint2,
286			Type::Uint4,
287			Type::Uint8,
288			Type::Float4,
289			Type::Float8,
290			Type::Utf8,
291		]);
292		let mut row = layout.allocate();
293
294		layout.set_bool(&mut row, 0, true);
295		layout.set_i8(&mut row, 1, -42);
296		layout.set_i16(&mut row, 2, -1000i16);
297		layout.set_i32(&mut row, 3, -50000i32);
298		layout.set_i64(&mut row, 4, -3000000000i64);
299		layout.set_u8(&mut row, 5, 200u8);
300		layout.set_u16(&mut row, 6, 50000u16);
301		layout.set_u32(&mut row, 7, 3000000000u32);
302		layout.set_u64(&mut row, 8, 15000000000000000000u64);
303		layout.set_f32(&mut row, 9, 2.5);
304		layout.set_f64(&mut row, 10, 123.456789);
305		layout.set_utf8(&mut row, 11, "dynamic_string");
306
307		let values: Vec<Value> = (0..12).map(|i| layout.get_value(&row, i)).collect();
308
309		assert_eq!(values[0], Value::Boolean(true));
310		assert_eq!(values[1], Value::Int1(-42));
311		assert_eq!(values[2], Value::Int2(-1000));
312		assert_eq!(values[3], Value::Int4(-50000));
313		assert_eq!(values[4], Value::Int8(-3000000000));
314		assert_eq!(values[5], Value::Uint1(200));
315		assert_eq!(values[6], Value::Uint2(50000));
316		assert_eq!(values[7], Value::Uint4(3000000000));
317		assert_eq!(values[8], Value::Uint8(15000000000000000000));
318		assert_eq!(values[9], Value::Float4(OrderedF32::try_from(2.5f32).unwrap()));
319		assert_eq!(values[10], Value::Float8(OrderedF64::try_from(123.456789f64).unwrap()));
320		assert_eq!(values[11], Value::Utf8("dynamic_string".to_string()));
321	}
322
323	#[test]
324	fn test_set_values_sparse_with_utf8() {
325		let layout = EncodedValuesLayout::new(&[Type::Utf8, Type::Utf8, Type::Utf8, Type::Utf8]);
326		let mut row = layout.allocate();
327
328		// Only set some values
329		let values = vec![
330			Value::Utf8("first".to_string()),
331			Value::Undefined,
332			Value::Utf8("third".to_string()),
333			Value::Undefined,
334		];
335
336		layout.set_values(&mut row, &values);
337
338		assert!(row.is_defined(0));
339		assert!(!row.is_defined(1));
340		assert!(row.is_defined(2));
341		assert!(!row.is_defined(3));
342
343		assert_eq!(layout.get_utf8(&row, 0), "first");
344		assert_eq!(layout.get_utf8(&row, 2), "third");
345	}
346
347	#[test]
348	fn test_set_values_unicode_strings() {
349		let layout = EncodedValuesLayout::new(&[Type::Utf8, Type::Int4, Type::Utf8]);
350		let mut row = layout.allocate();
351
352		let values = vec![
353			Value::Utf8("🎉🚀✨".to_string()),
354			Value::Int4(123),
355			Value::Utf8("Hello 世界".to_string()),
356		];
357
358		layout.set_values(&mut row, &values);
359
360		assert_eq!(layout.get_utf8(&row, 0), "🎉🚀✨");
361		assert_eq!(layout.get_i32(&row, 1), 123);
362		assert_eq!(layout.get_utf8(&row, 2), "Hello 世界");
363	}
364
365	#[test]
366	fn test_static_fields_only_no_dynamic_with_values() {
367		let layout = EncodedValuesLayout::new(&[Type::Boolean, Type::Int4, Type::Float8]);
368		let mut row = layout.allocate();
369
370		let values = vec![
371			Value::Boolean(false),
372			Value::Int4(999),
373			Value::Float8(OrderedF64::try_from(std::f64::consts::E).unwrap()),
374		];
375
376		layout.set_values(&mut row, &values);
377
378		// Verify no dynamic section
379		assert_eq!(layout.dynamic_section_size(&row), 0);
380		assert_eq!(row.len(), layout.total_static_size());
381
382		assert_eq!(layout.get_bool(&row, 0), false);
383		assert_eq!(layout.get_i32(&row, 1), 999);
384		assert_eq!(layout.get_f64(&row, 2), std::f64::consts::E);
385	}
386
387	#[test]
388	fn test_temporal_types_roundtrip() {
389		let layout = EncodedValuesLayout::new(&[Type::Date, Type::DateTime, Type::Time, Type::Duration]);
390		let mut row = layout.allocate();
391
392		let original_values = vec![
393			Value::Date(Date::new(2025, 7, 15).unwrap()),
394			Value::DateTime(DateTime::now()),
395			Value::Time(Time::new(14, 30, 45, 123456789).unwrap()),
396			Value::Duration(Duration::from_seconds(3600)),
397		];
398
399		layout.set_values(&mut row, &original_values);
400
401		let retrieved_values: Vec<Value> = (0..4).map(|i| layout.get_value(&row, i)).collect();
402
403		assert_eq!(retrieved_values, original_values);
404	}
405
406	#[test]
407	fn test_temporal_types_with_undefined() {
408		let layout = EncodedValuesLayout::new(&[Type::Date, Type::DateTime, Type::Time, Type::Duration]);
409		let mut row = layout.allocate();
410
411		let values = vec![
412			Value::Date(Date::new(2000, 1, 1).unwrap()),
413			Value::Undefined,
414			Value::Time(Time::default()),
415			Value::Undefined,
416		];
417
418		layout.set_values(&mut row, &values);
419
420		assert!(row.is_defined(0));
421		assert!(!row.is_defined(1));
422		assert!(row.is_defined(2));
423		assert!(!row.is_defined(3));
424
425		let retrieved_values: Vec<Value> = (0..4).map(|i| layout.get_value(&row, i)).collect();
426
427		assert_eq!(retrieved_values[0], values[0]);
428		assert_eq!(retrieved_values[1], Value::Undefined);
429		assert_eq!(retrieved_values[2], values[2]);
430		assert_eq!(retrieved_values[3], Value::Undefined);
431	}
432
433	#[test]
434	fn test_mixed_temporal_and_regular_types() {
435		let layout = EncodedValuesLayout::new(&[
436			Type::Boolean,
437			Type::Date,
438			Type::Utf8,
439			Type::DateTime,
440			Type::Int4,
441			Type::Time,
442			Type::Duration,
443		]);
444		let mut row = layout.allocate();
445
446		let values = vec![
447			Value::Boolean(true),
448			Value::Date(Date::new(1985, 10, 26).unwrap()),
449			Value::Utf8("time travel".to_string()),
450			Value::DateTime(DateTime::new(2015, 10, 21, 16, 29, 0, 0).unwrap()),
451			Value::Int4(88),
452			Value::Time(Time::new(12, 0, 0, 0).unwrap()),
453			Value::Duration(Duration::from_minutes(30)),
454		];
455
456		layout.set_values(&mut row, &values);
457
458		let retrieved_values: Vec<Value> = (0..7).map(|i| layout.get_value(&row, i)).collect();
459
460		assert_eq!(retrieved_values, values);
461	}
462
463	#[test]
464	fn test_roundtrip_with_dynamic_content() {
465		let layout = EncodedValuesLayout::new(&[Type::Utf8, Type::Int2, Type::Utf8, Type::Float4]);
466		let mut row = layout.allocate();
467
468		let original_values = vec![
469			Value::Utf8("roundtrip_test".to_string()),
470			Value::Int2(32000),
471			Value::Utf8("".to_string()),
472			Value::Float4(OrderedF32::try_from(1.5f32).unwrap()),
473		];
474
475		// Set values
476		layout.set_values(&mut row, &original_values);
477
478		// Get values back
479		let retrieved_values: Vec<Value> = (0..4).map(|i| layout.get_value(&row, i)).collect();
480
481		assert_eq!(retrieved_values, original_values);
482	}
483
484	#[test]
485	fn test_blob_roundtrip() {
486		let layout = EncodedValuesLayout::new(&[Type::Blob, Type::Int4, Type::Blob]);
487		let mut row = layout.allocate();
488
489		let blob1 = Blob::new(vec![0xDE, 0xAD, 0xBE, 0xEF]);
490		let blob2 = Blob::new(vec![]);
491		let values = vec![Value::Blob(blob1.clone()), Value::Int4(42), Value::Blob(blob2.clone())];
492
493		layout.set_values(&mut row, &values);
494
495		let retrieved_values: Vec<Value> = (0..3).map(|i| layout.get_value(&row, i)).collect();
496
497		assert_eq!(retrieved_values, values);
498
499		// Verify blob content directly
500		match &retrieved_values[0] {
501			Value::Blob(b) => assert_eq!(b.as_bytes(), &[0xDE, 0xAD, 0xBE, 0xEF]),
502			_ => panic!("Expected Blob value"),
503		}
504
505		match &retrieved_values[2] {
506			Value::Blob(b) => assert!(b.is_empty()),
507			_ => panic!("Expected Blob value"),
508		}
509	}
510
511	#[test]
512	fn test_blob_with_undefined() {
513		let layout = EncodedValuesLayout::new(&[Type::Blob, Type::Blob, Type::Blob]);
514		let mut row = layout.allocate();
515
516		let values = vec![
517			Value::Blob(Blob::new(vec![0x00, 0x01, 0x02])),
518			Value::Undefined,
519			Value::Blob(Blob::new(vec![0xFF, 0xFE])),
520		];
521
522		layout.set_values(&mut row, &values);
523
524		assert!(row.is_defined(0));
525		assert!(!row.is_defined(1));
526		assert!(row.is_defined(2));
527
528		let retrieved_values: Vec<Value> = (0..3).map(|i| layout.get_value(&row, i)).collect();
529
530		assert_eq!(retrieved_values[0], values[0]);
531		assert_eq!(retrieved_values[1], Value::Undefined);
532		assert_eq!(retrieved_values[2], values[2]);
533	}
534
535	#[test]
536	fn test_uuid_roundtrip() {
537		let layout = EncodedValuesLayout::new(&[Type::Uuid4, Type::Uuid7, Type::Int4]);
538		let mut row = layout.allocate();
539
540		let uuid4 = Uuid4::generate();
541		let uuid7 = Uuid7::generate();
542		let values = vec![Value::Uuid4(uuid4), Value::Uuid7(uuid7), Value::Int4(123)];
543
544		layout.set_values(&mut row, &values);
545
546		let retrieved_values: Vec<Value> = (0..3).map(|i| layout.get_value(&row, i)).collect();
547
548		assert_eq!(retrieved_values, values);
549	}
550
551	#[test]
552	fn test_uuid_with_undefined() {
553		let layout = EncodedValuesLayout::new(&[Type::Uuid4, Type::Uuid7]);
554		let mut row = layout.allocate();
555
556		let values = vec![Value::Undefined, Value::Uuid7(Uuid7::generate())];
557
558		layout.set_values(&mut row, &values);
559
560		assert!(!row.is_defined(0));
561		assert!(row.is_defined(1));
562
563		let retrieved_values: Vec<Value> = (0..2).map(|i| layout.get_value(&row, i)).collect();
564
565		assert_eq!(retrieved_values[0], Value::Undefined);
566		assert_eq!(retrieved_values[1], values[1]);
567	}
568
569	#[test]
570	fn test_mixed_blob_row_number_uuid_types() {
571		let layout = EncodedValuesLayout::new(&[
572			Type::Blob,
573			Type::Int16,
574			Type::Uuid4,
575			Type::Utf8,
576			Type::Uuid7,
577			Type::Int4,
578		]);
579		let mut row = layout.allocate();
580
581		let values = vec![
582			Value::Blob(Blob::new(vec![0xCA, 0xFE, 0xBA, 0xBE])),
583			Value::Int16(42424242i128),
584			Value::Uuid4(Uuid4::generate()),
585			Value::Utf8("mixed types test".to_string()),
586			Value::Uuid7(Uuid7::generate()),
587			Value::Int4(-999),
588		];
589
590		layout.set_values(&mut row, &values);
591
592		let retrieved_values: Vec<Value> = (0..6).map(|i| layout.get_value(&row, i)).collect();
593
594		assert_eq!(retrieved_values, values);
595
596		// Verify dynamic content exists (for blob and utf8)
597		assert!(layout.dynamic_section_size(&row) > 0);
598	}
599
600	#[test]
601	fn test_all_types_comprehensive() {
602		// except encoded id
603
604		let layout = EncodedValuesLayout::new(&[
605			Type::Boolean,
606			Type::Int1,
607			Type::Int2,
608			Type::Int4,
609			Type::Int8,
610			Type::Int16,
611			Type::Uint1,
612			Type::Uint2,
613			Type::Uint4,
614			Type::Uint8,
615			Type::Uint16,
616			Type::Float4,
617			Type::Float8,
618			Type::Utf8,
619			Type::Date,
620			Type::DateTime,
621			Type::Time,
622			Type::Duration,
623			Type::Uuid4,
624			Type::Uuid7,
625			Type::Blob,
626		]);
627		let mut row = layout.allocate();
628
629		let values = vec![
630			Value::Boolean(true),
631			Value::Int1(-128),
632			Value::Int2(-32768),
633			Value::Int4(-2147483648),
634			Value::Int8(-9223372036854775808),
635			Value::Int16(-170141183460469231731687303715884105728),
636			Value::Uint1(255),
637			Value::Uint2(65535),
638			Value::Uint4(4294967295),
639			Value::Uint8(18446744073709551615),
640			Value::Uint16(340282366920938463463374607431768211455),
641			Value::Float4(OrderedF32::try_from(3.14159f32).unwrap()),
642			Value::Float8(OrderedF64::try_from(2.718281828459045).unwrap()),
643			Value::Utf8("comprehensive test".to_string()),
644			Value::Date(Date::new(2025, 12, 31).unwrap()),
645			Value::DateTime(DateTime::new(2025, 1, 1, 0, 0, 0, 0).unwrap()),
646			Value::Time(Time::new(23, 59, 59, 999999999).unwrap()),
647			Value::Duration(Duration::from_hours(24)),
648			Value::Uuid4(Uuid4::generate()),
649			Value::Uuid7(Uuid7::generate()),
650			Value::Blob(Blob::new(vec![
651				0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD,
652				0xEE, 0xFF,
653			])),
654		];
655
656		layout.set_values(&mut row, &values);
657
658		let retrieved_values: Vec<Value> = (0..21).map(|i| layout.get_value(&row, i)).collect();
659
660		assert_eq!(retrieved_values, values);
661
662		// Verify all fields are defined
663		for i in 0..21 {
664			assert!(row.is_defined(i), "Field {} should be defined", i);
665		}
666	}
667}
reifydb_core/value/encoded/value.rs

reifydb_core/value/encoded/
value.rs
