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

reifydb_core/value/encoded/
value.rs
