reifydb_core/value/column/push/
value.rs

1// SPDX-License-Identifier: Apache-2.0
2// Copyright (c) 2026 ReifyDB
3
4use reifydb_value::{
5	util::bitvec::BitVec,
6	value::{
7		Value,
8		blob::Blob,
9		date::Date,
10		datetime::DateTime,
11		decimal::Decimal,
12		dictionary::DictionaryEntryId,
13		duration::Duration,
14		identity::IdentityId,
15		int::Int,
16		time::Time,
17		uint::Uint,
18		uuid::{Uuid4, Uuid7},
19	},
20};
21
22use crate::value::column::buffer::{ColumnBuffer, with_container};
23
24macro_rules! push_or_promote {
25	(@wrap_option $self:expr, $new_col:expr, $len:expr) => {
26		if $len > 0 {
27			let mut bitvec = BitVec::repeat($len, false);
28			bitvec.push(true);
29			*$self = ColumnBuffer::Option {
30				inner: Box::new($new_col),
31				bitvec,
32			};
33		} else {
34			*$self = $new_col;
35		}
36	};
37
38	($self:expr, $val:expr, $col_variant:ident, $factory_expr:expr) => {
39		match $self {
40			ColumnBuffer::$col_variant(_) => $self.push($val),
41			_ => unimplemented!(),
42		}
43	};
44
45	(struct $self:expr, $val:expr, $col_variant:ident, $factory_expr:expr) => {
46		match $self {
47			ColumnBuffer::$col_variant {
48				..
49			} => $self.push($val),
50			_ => unimplemented!(),
51		}
52	};
53
54	(direct $self:expr, $val:expr, $col_variant:ident, $factory_expr:expr) => {
55		match $self {
56			ColumnBuffer::$col_variant(container) => container.push($val),
57			_ => unimplemented!(),
58		}
59	};
60
61	(struct_direct $self:expr, $val:expr, $col_variant:ident, $factory_expr:expr) => {
62		match $self {
63			ColumnBuffer::$col_variant {
64				container,
65				..
66			} => container.push($val),
67			_ => unimplemented!(),
68		}
69	};
70}
71
72impl ColumnBuffer {
73	pub fn push_value(&mut self, value: Value) {
74		if let ColumnBuffer::Option {
75			inner,
76			bitvec,
77		} = self
78		{
79			if matches!(value, Value::None { .. }) {
80				with_container!(inner.as_mut(), |c| c.push_default());
81				bitvec.push(false);
82			} else if bitvec.count_ones() == 0 {
83				let len = inner.len();
84
85				let mut new_inner = match &value {
86					Value::Boolean(_) => ColumnBuffer::bool(vec![false; len]),
87					Value::Float4(_) => ColumnBuffer::float4(vec![0.0f32; len]),
88					Value::Float8(_) => ColumnBuffer::float8(vec![0.0f64; len]),
89					Value::Int1(_) => ColumnBuffer::int1(vec![0i8; len]),
90					Value::Int2(_) => ColumnBuffer::int2(vec![0i16; len]),
91					Value::Int4(_) => ColumnBuffer::int4(vec![0i32; len]),
92					Value::Int8(_) => ColumnBuffer::int8(vec![0i64; len]),
93					Value::Int16(_) => ColumnBuffer::int16(vec![0i128; len]),
94					Value::Uint1(_) => ColumnBuffer::uint1(vec![0u8; len]),
95					Value::Uint2(_) => ColumnBuffer::uint2(vec![0u16; len]),
96					Value::Uint4(_) => ColumnBuffer::uint4(vec![0u32; len]),
97					Value::Uint8(_) => ColumnBuffer::uint8(vec![0u64; len]),
98					Value::Uint16(_) => ColumnBuffer::uint16(vec![0u128; len]),
99					Value::Utf8(_) => ColumnBuffer::utf8(vec![String::new(); len]),
100					Value::Date(_) => ColumnBuffer::date(vec![Date::default(); len]),
101					Value::DateTime(_) => ColumnBuffer::datetime(vec![DateTime::default(); len]),
102					Value::Time(_) => ColumnBuffer::time(vec![Time::default(); len]),
103					Value::Duration(_) => ColumnBuffer::duration(vec![Duration::default(); len]),
104					Value::Uuid4(_) => ColumnBuffer::uuid4(vec![Uuid4::default(); len]),
105					Value::Uuid7(_) => ColumnBuffer::uuid7(vec![Uuid7::default(); len]),
106					Value::IdentityId(_) => {
107						ColumnBuffer::identity_id(vec![IdentityId::default(); len])
108					}
109					Value::DictionaryId(_) => {
110						ColumnBuffer::dictionary_id(vec![DictionaryEntryId::default(); len])
111					}
112					Value::Blob(_) => ColumnBuffer::blob(vec![Blob::default(); len]),
113					Value::Int(_) => ColumnBuffer::int(vec![Int::default(); len]),
114					Value::Uint(_) => ColumnBuffer::uint(vec![Uint::default(); len]),
115					Value::Decimal(_) => ColumnBuffer::decimal(vec![Decimal::default(); len]),
116					Value::Any(_) => ColumnBuffer::any(vec![Value::none(); len]),
117					Value::Record(_) => ColumnBuffer::any(vec![Value::none(); len]),
118					Value::Tuple(_) => ColumnBuffer::any(vec![Value::none(); len]),
119					_ => unreachable!(),
120				};
121				new_inner.push_value(value);
122				if len > 0 {
123					let mut new_bitvec = BitVec::repeat(len, false);
124					new_bitvec.push(true);
125					*self = ColumnBuffer::Option {
126						inner: Box::new(new_inner),
127						bitvec: new_bitvec,
128					};
129				} else {
130					*self = new_inner;
131				}
132			} else {
133				inner.push_value(value);
134				bitvec.push(true);
135			}
136			return;
137		}
138		match value {
139			Value::Boolean(v) => push_or_promote!(self, v, Bool, ColumnBuffer::bool(vec![])),
140			Value::Float4(v) => push_or_promote!(self, v.value(), Float4, ColumnBuffer::float4(vec![])),
141			Value::Float8(v) => push_or_promote!(self, v.value(), Float8, ColumnBuffer::float8(vec![])),
142			Value::Int1(v) => push_or_promote!(self, v, Int1, ColumnBuffer::int1(vec![])),
143			Value::Int2(v) => push_or_promote!(self, v, Int2, ColumnBuffer::int2(vec![])),
144			Value::Int4(v) => push_or_promote!(self, v, Int4, ColumnBuffer::int4(vec![])),
145			Value::Int8(v) => push_or_promote!(self, v, Int8, ColumnBuffer::int8(vec![])),
146			Value::Int16(v) => push_or_promote!(self, v, Int16, ColumnBuffer::int16(vec![])),
147			Value::Uint1(v) => push_or_promote!(self, v, Uint1, ColumnBuffer::uint1(vec![])),
148			Value::Uint2(v) => push_or_promote!(self, v, Uint2, ColumnBuffer::uint2(vec![])),
149			Value::Uint4(v) => push_or_promote!(self, v, Uint4, ColumnBuffer::uint4(vec![])),
150			Value::Uint8(v) => push_or_promote!(self, v, Uint8, ColumnBuffer::uint8(vec![])),
151			Value::Uint16(v) => push_or_promote!(self, v, Uint16, ColumnBuffer::uint16(vec![])),
152			Value::Utf8(v) => {
153				push_or_promote!(struct self, v, Utf8, ColumnBuffer::utf8(Vec::<String>::new()))
154			}
155			Value::Date(v) => push_or_promote!(self, v, Date, ColumnBuffer::date(vec![])),
156			Value::DateTime(v) => push_or_promote!(self, v, DateTime, ColumnBuffer::datetime(vec![])),
157			Value::Time(v) => push_or_promote!(self, v, Time, ColumnBuffer::time(vec![])),
158			Value::Duration(v) => push_or_promote!(self, v, Duration, ColumnBuffer::duration(vec![])),
159			Value::Uuid4(v) => push_or_promote!(self, v, Uuid4, ColumnBuffer::uuid4(vec![])),
160			Value::Uuid7(v) => push_or_promote!(self, v, Uuid7, ColumnBuffer::uuid7(vec![])),
161			Value::IdentityId(v) => {
162				push_or_promote!(direct self, v, IdentityId, ColumnBuffer::identity_id(vec![]))
163			}
164			Value::DictionaryId(v) => {
165				push_or_promote!(direct self, v, DictionaryId, ColumnBuffer::dictionary_id(vec![]))
166			}
167			Value::Blob(v) => push_or_promote!(struct_direct self, v, Blob, ColumnBuffer::blob(vec![])),
168			Value::Int(v) => push_or_promote!(struct_direct self, v, Int, ColumnBuffer::int(vec![])),
169			Value::Uint(v) => push_or_promote!(struct_direct self, v, Uint, ColumnBuffer::uint(vec![])),
170			Value::Decimal(v) => {
171				push_or_promote!(struct_direct self, v, Decimal, ColumnBuffer::decimal(vec![]))
172			}
173			Value::None {
174				..
175			} => self.push_none(),
176			Value::Type(t) => self.push_value(Value::Any(Box::new(Value::Type(t)))),
177			Value::List(v) => self.push_value(Value::Any(Box::new(Value::List(v)))),
178			Value::Record(v) => self.push_value(Value::Any(Box::new(Value::Record(v)))),
179			Value::Tuple(v) => self.push_value(Value::Any(Box::new(Value::Tuple(v)))),
180			Value::Any(v) => match self {
181				ColumnBuffer::Any(container) => container.push(*v),
182				_ => unreachable!("Cannot push Any value to non-Any column"),
183			},
184		}
185	}
186}
187
188#[cfg(test)]
189#[allow(clippy::approx_constant)]
190pub mod tests {
191	use reifydb_runtime::context::{
192		clock::{Clock, MockClock},
193		rng::Rng,
194	};
195	use reifydb_value::value::{
196		Value,
197		date::Date,
198		datetime::DateTime,
199		dictionary::DictionaryEntryId,
200		duration::Duration,
201		identity::IdentityId,
202		ordered_f32::OrderedF32,
203		ordered_f64::OrderedF64,
204		time::Time,
205		uuid::{Uuid4, Uuid7},
206		value_type::ValueType,
207	};
208
209	use crate::value::column::ColumnBuffer;
210
211	fn test_clock_and_rng() -> (MockClock, Clock, Rng) {
212		let mock = MockClock::from_millis(1000);
213		let clock = Clock::Mock(mock.clone());
214		let rng = Rng::seeded(42);
215		(mock, clock, rng)
216	}
217
218	#[test]
219	fn test_bool() {
220		let mut col = ColumnBuffer::bool(vec![true]);
221		col.push_value(Value::Boolean(false));
222		let ColumnBuffer::Bool(container) = col else {
223			panic!("Expected Bool");
224		};
225		assert_eq!(container.data().to_vec(), vec![true, false]);
226	}
227
228	#[test]
229	fn test_undefined_bool() {
230		let mut col = ColumnBuffer::bool(vec![true]);
231		col.push_value(Value::none());
232		// Pushing none promotes the bare column to Option-wrapped.
233		assert_eq!(col.len(), 2);
234		assert!(col.is_defined(0));
235		assert!(!col.is_defined(1));
236	}
237
238	#[test]
239	fn test_push_value_to_none_bool() {
240		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 2);
241		col.push_value(Value::Boolean(true));
242		assert_eq!(col.len(), 3);
243		assert!(!col.is_defined(0));
244		assert!(!col.is_defined(1));
245		assert!(col.is_defined(2));
246		assert_eq!(col.get_value(2), Value::Boolean(true));
247	}
248
249	#[test]
250	fn test_float4() {
251		let mut col = ColumnBuffer::float4(vec![1.0]);
252		col.push_value(Value::Float4(OrderedF32::try_from(2.0).unwrap()));
253		let ColumnBuffer::Float4(container) = col else {
254			panic!("Expected Float4");
255		};
256		assert_eq!(container.data().as_slice(), &[1.0, 2.0]);
257	}
258
259	#[test]
260	fn test_undefined_float4() {
261		let mut col = ColumnBuffer::float4(vec![1.0]);
262		col.push_value(Value::none());
263		assert_eq!(col.len(), 2);
264		assert!(col.is_defined(0));
265		assert!(!col.is_defined(1));
266	}
267
268	#[test]
269	fn test_push_value_to_none_float4() {
270		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
271		col.push_value(Value::Float4(OrderedF32::try_from(3.14).unwrap()));
272		assert_eq!(col.len(), 2);
273		assert!(!col.is_defined(0));
274		assert!(col.is_defined(1));
275	}
276
277	#[test]
278	fn test_float8() {
279		let mut col = ColumnBuffer::float8(vec![1.0]);
280		col.push_value(Value::Float8(OrderedF64::try_from(2.0).unwrap()));
281		let ColumnBuffer::Float8(container) = col else {
282			panic!("Expected Float8");
283		};
284		assert_eq!(container.data().as_slice(), &[1.0, 2.0]);
285	}
286
287	#[test]
288	fn test_undefined_float8() {
289		let mut col = ColumnBuffer::float8(vec![1.0]);
290		col.push_value(Value::none());
291		assert_eq!(col.len(), 2);
292		assert!(col.is_defined(0));
293		assert!(!col.is_defined(1));
294	}
295
296	#[test]
297	fn test_push_value_to_none_float8() {
298		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
299		col.push_value(Value::Float8(OrderedF64::try_from(2.718).unwrap()));
300		assert_eq!(col.len(), 2);
301		assert!(!col.is_defined(0));
302		assert!(col.is_defined(1));
303	}
304
305	#[test]
306	fn test_int1() {
307		let mut col = ColumnBuffer::int1(vec![1]);
308		col.push_value(Value::Int1(2));
309		let ColumnBuffer::Int1(container) = col else {
310			panic!("Expected Int1");
311		};
312		assert_eq!(container.data().as_slice(), &[1, 2]);
313	}
314
315	#[test]
316	fn test_undefined_int1() {
317		let mut col = ColumnBuffer::int1(vec![1]);
318		col.push_value(Value::none());
319		assert_eq!(col.len(), 2);
320		assert!(col.is_defined(0));
321		assert!(!col.is_defined(1));
322	}
323
324	#[test]
325	fn test_push_value_to_none_int1() {
326		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
327		col.push_value(Value::Int1(5));
328		assert_eq!(col.len(), 2);
329		assert!(!col.is_defined(0));
330		assert!(col.is_defined(1));
331		assert_eq!(col.get_value(1), Value::Int1(5));
332	}
333
334	#[test]
335	fn test_int2() {
336		let mut col = ColumnBuffer::int2(vec![1]);
337		col.push_value(Value::Int2(3));
338		let ColumnBuffer::Int2(container) = col else {
339			panic!("Expected Int2");
340		};
341		assert_eq!(container.data().as_slice(), &[1, 3]);
342	}
343
344	#[test]
345	fn test_undefined_int2() {
346		let mut col = ColumnBuffer::int2(vec![1]);
347		col.push_value(Value::none());
348		assert_eq!(col.len(), 2);
349		assert!(col.is_defined(0));
350		assert!(!col.is_defined(1));
351	}
352
353	#[test]
354	fn test_push_value_to_none_int2() {
355		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
356		col.push_value(Value::Int2(10));
357		assert_eq!(col.len(), 2);
358		assert!(!col.is_defined(0));
359		assert!(col.is_defined(1));
360		assert_eq!(col.get_value(1), Value::Int2(10));
361	}
362
363	#[test]
364	fn test_int4() {
365		let mut col = ColumnBuffer::int4(vec![10]);
366		col.push_value(Value::Int4(20));
367		let ColumnBuffer::Int4(container) = col else {
368			panic!("Expected Int4");
369		};
370		assert_eq!(container.data().as_slice(), &[10, 20]);
371	}
372
373	#[test]
374	fn test_undefined_int4() {
375		let mut col = ColumnBuffer::int4(vec![10]);
376		col.push_value(Value::none());
377		assert_eq!(col.len(), 2);
378		assert!(col.is_defined(0));
379		assert!(!col.is_defined(1));
380	}
381
382	#[test]
383	fn test_push_value_to_none_int4() {
384		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
385		col.push_value(Value::Int4(20));
386		assert_eq!(col.len(), 2);
387		assert!(!col.is_defined(0));
388		assert!(col.is_defined(1));
389		assert_eq!(col.get_value(1), Value::Int4(20));
390	}
391
392	#[test]
393	fn test_int8() {
394		let mut col = ColumnBuffer::int8(vec![100]);
395		col.push_value(Value::Int8(200));
396		let ColumnBuffer::Int8(container) = col else {
397			panic!("Expected Int8");
398		};
399		assert_eq!(container.data().as_slice(), &[100, 200]);
400	}
401
402	#[test]
403	fn test_undefined_int8() {
404		let mut col = ColumnBuffer::int8(vec![100]);
405		col.push_value(Value::none());
406		assert_eq!(col.len(), 2);
407		assert!(col.is_defined(0));
408		assert!(!col.is_defined(1));
409	}
410
411	#[test]
412	fn test_push_value_to_none_int8() {
413		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
414		col.push_value(Value::Int8(30));
415		assert_eq!(col.len(), 2);
416		assert!(!col.is_defined(0));
417		assert!(col.is_defined(1));
418		assert_eq!(col.get_value(1), Value::Int8(30));
419	}
420
421	#[test]
422	fn test_int16() {
423		let mut col = ColumnBuffer::int16(vec![1000]);
424		col.push_value(Value::Int16(2000));
425		let ColumnBuffer::Int16(container) = col else {
426			panic!("Expected Int16");
427		};
428		assert_eq!(container.data().as_slice(), &[1000, 2000]);
429	}
430
431	#[test]
432	fn test_undefined_int16() {
433		let mut col = ColumnBuffer::int16(vec![1000]);
434		col.push_value(Value::none());
435		assert_eq!(col.len(), 2);
436		assert!(col.is_defined(0));
437		assert!(!col.is_defined(1));
438	}
439
440	#[test]
441	fn test_push_value_to_none_int16() {
442		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
443		col.push_value(Value::Int16(40));
444		assert_eq!(col.len(), 2);
445		assert!(!col.is_defined(0));
446		assert!(col.is_defined(1));
447		assert_eq!(col.get_value(1), Value::Int16(40));
448	}
449
450	#[test]
451	fn test_uint1() {
452		let mut col = ColumnBuffer::uint1(vec![1]);
453		col.push_value(Value::Uint1(2));
454		let ColumnBuffer::Uint1(container) = col else {
455			panic!("Expected Uint1");
456		};
457		assert_eq!(container.data().as_slice(), &[1, 2]);
458	}
459
460	#[test]
461	fn test_undefined_uint1() {
462		let mut col = ColumnBuffer::uint1(vec![1]);
463		col.push_value(Value::none());
464		assert_eq!(col.len(), 2);
465		assert!(col.is_defined(0));
466		assert!(!col.is_defined(1));
467	}
468
469	#[test]
470	fn test_push_value_to_none_uint1() {
471		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
472		col.push_value(Value::Uint1(1));
473		assert_eq!(col.len(), 2);
474		assert!(!col.is_defined(0));
475		assert!(col.is_defined(1));
476		assert_eq!(col.get_value(1), Value::Uint1(1));
477	}
478
479	#[test]
480	fn test_uint2() {
481		let mut col = ColumnBuffer::uint2(vec![10]);
482		col.push_value(Value::Uint2(20));
483		let ColumnBuffer::Uint2(container) = col else {
484			panic!("Expected Uint2");
485		};
486		assert_eq!(container.data().as_slice(), &[10, 20]);
487	}
488
489	#[test]
490	fn test_undefined_uint2() {
491		let mut col = ColumnBuffer::uint2(vec![10]);
492		col.push_value(Value::none());
493		assert_eq!(col.len(), 2);
494		assert!(col.is_defined(0));
495		assert!(!col.is_defined(1));
496	}
497
498	#[test]
499	fn test_push_value_to_none_uint2() {
500		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
501		col.push_value(Value::Uint2(2));
502		assert_eq!(col.len(), 2);
503		assert!(!col.is_defined(0));
504		assert!(col.is_defined(1));
505		assert_eq!(col.get_value(1), Value::Uint2(2));
506	}
507
508	#[test]
509	fn test_uint4() {
510		let mut col = ColumnBuffer::uint4(vec![100]);
511		col.push_value(Value::Uint4(200));
512		let ColumnBuffer::Uint4(container) = col else {
513			panic!("Expected Uint4");
514		};
515		assert_eq!(container.data().as_slice(), &[100, 200]);
516	}
517
518	#[test]
519	fn test_undefined_uint4() {
520		let mut col = ColumnBuffer::uint4(vec![100]);
521		col.push_value(Value::none());
522		assert_eq!(col.len(), 2);
523		assert!(col.is_defined(0));
524		assert!(!col.is_defined(1));
525	}
526
527	#[test]
528	fn test_push_value_to_none_uint4() {
529		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
530		col.push_value(Value::Uint4(3));
531		assert_eq!(col.len(), 2);
532		assert!(!col.is_defined(0));
533		assert!(col.is_defined(1));
534		assert_eq!(col.get_value(1), Value::Uint4(3));
535	}
536
537	#[test]
538	fn test_uint8() {
539		let mut col = ColumnBuffer::uint8(vec![1000]);
540		col.push_value(Value::Uint8(2000));
541		let ColumnBuffer::Uint8(container) = col else {
542			panic!("Expected Uint8");
543		};
544		assert_eq!(container.data().as_slice(), &[1000, 2000]);
545	}
546
547	#[test]
548	fn test_undefined_uint8() {
549		let mut col = ColumnBuffer::uint8(vec![1000]);
550		col.push_value(Value::none());
551		assert_eq!(col.len(), 2);
552		assert!(col.is_defined(0));
553		assert!(!col.is_defined(1));
554	}
555
556	#[test]
557	fn test_push_value_to_none_uint8() {
558		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
559		col.push_value(Value::Uint8(4));
560		assert_eq!(col.len(), 2);
561		assert!(!col.is_defined(0));
562		assert!(col.is_defined(1));
563		assert_eq!(col.get_value(1), Value::Uint8(4));
564	}
565
566	#[test]
567	fn test_uint16() {
568		let mut col = ColumnBuffer::uint16(vec![10000]);
569		col.push_value(Value::Uint16(20000));
570		let ColumnBuffer::Uint16(container) = col else {
571			panic!("Expected Uint16");
572		};
573		assert_eq!(container.data().as_slice(), &[10000, 20000]);
574	}
575
576	#[test]
577	fn test_undefined_uint16() {
578		let mut col = ColumnBuffer::uint16(vec![10000]);
579		col.push_value(Value::none());
580		assert_eq!(col.len(), 2);
581		assert!(col.is_defined(0));
582		assert!(!col.is_defined(1));
583	}
584
585	#[test]
586	fn test_push_value_to_none_uint16() {
587		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
588		col.push_value(Value::Uint16(5));
589		assert_eq!(col.len(), 2);
590		assert!(!col.is_defined(0));
591		assert!(col.is_defined(1));
592		assert_eq!(col.get_value(1), Value::Uint16(5));
593	}
594
595	#[test]
596	fn test_utf8() {
597		let mut col = ColumnBuffer::utf8(vec!["hello".to_string()]);
598		col.push_value(Value::Utf8("world".to_string()));
599		let ColumnBuffer::Utf8 {
600			container,
601			..
602		} = col
603		else {
604			panic!("Expected Utf8");
605		};
606		let collected: Vec<&str> = container.iter_str().collect();
607		assert_eq!(collected, vec!["hello", "world"]);
608	}
609
610	#[test]
611	fn test_undefined_utf8() {
612		let mut col = ColumnBuffer::utf8(vec!["hello".to_string()]);
613		col.push_value(Value::none());
614		assert_eq!(col.len(), 2);
615		assert!(col.is_defined(0));
616		assert!(!col.is_defined(1));
617	}
618
619	#[test]
620	fn test_push_value_to_none_utf8() {
621		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
622		col.push_value(Value::Utf8("ok".to_string()));
623		assert_eq!(col.len(), 2);
624		assert!(!col.is_defined(0));
625		assert!(col.is_defined(1));
626		assert_eq!(col.get_value(1), Value::Utf8("ok".to_string()));
627	}
628
629	#[test]
630	fn test_undefined() {
631		let mut col = ColumnBuffer::int2(vec![1]);
632		col.push_value(Value::none());
633		assert_eq!(col.len(), 2);
634		assert!(col.is_defined(0));
635		assert!(!col.is_defined(1));
636	}
637
638	#[test]
639	fn test_date() {
640		let date1 = Date::from_ymd(2023, 1, 1).unwrap();
641		let date2 = Date::from_ymd(2023, 12, 31).unwrap();
642		let mut col = ColumnBuffer::date(vec![date1]);
643		col.push_value(Value::Date(date2));
644		let ColumnBuffer::Date(container) = col else {
645			panic!("Expected Date");
646		};
647		assert_eq!(container.data().as_slice(), &[date1, date2]);
648	}
649
650	#[test]
651	fn test_undefined_date() {
652		let date1 = Date::from_ymd(2023, 1, 1).unwrap();
653		let mut col = ColumnBuffer::date(vec![date1]);
654		col.push_value(Value::none());
655		assert_eq!(col.len(), 2);
656		assert!(col.is_defined(0));
657		assert!(!col.is_defined(1));
658	}
659
660	#[test]
661	fn test_push_value_to_none_date() {
662		let date = Date::from_ymd(2023, 6, 15).unwrap();
663		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
664		col.push_value(Value::Date(date));
665		assert_eq!(col.len(), 2);
666		assert!(!col.is_defined(0));
667		assert!(col.is_defined(1));
668		assert_eq!(col.get_value(1), Value::Date(date));
669	}
670
671	#[test]
672	fn test_datetime() {
673		let dt1 = DateTime::from_epoch_secs(1672531200).unwrap(); // 2023-01-01 00:00:00 SVTC
674		let dt2 = DateTime::from_epoch_secs(1704067200).unwrap(); // 2024-01-01 00:00:00 SVTC
675		let mut col = ColumnBuffer::datetime(vec![dt1]);
676		col.push_value(Value::DateTime(dt2));
677		let ColumnBuffer::DateTime(container) = col else {
678			panic!("Expected DateTime");
679		};
680		assert_eq!(container.data().as_slice(), &[dt1, dt2]);
681	}
682
683	#[test]
684	fn test_undefined_datetime() {
685		let dt1 = DateTime::from_epoch_secs(1672531200).unwrap();
686		let mut col = ColumnBuffer::datetime(vec![dt1]);
687		col.push_value(Value::none());
688		assert_eq!(col.len(), 2);
689		assert!(col.is_defined(0));
690		assert!(!col.is_defined(1));
691	}
692
693	#[test]
694	fn test_push_value_to_none_datetime() {
695		let dt = DateTime::from_epoch_secs(1672531200).unwrap();
696		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
697		col.push_value(Value::DateTime(dt));
698		assert_eq!(col.len(), 2);
699		assert!(!col.is_defined(0));
700		assert!(col.is_defined(1));
701		assert_eq!(col.get_value(1), Value::DateTime(dt));
702	}
703
704	#[test]
705	fn test_time() {
706		let time1 = Time::from_hms(12, 30, 0).unwrap();
707		let time2 = Time::from_hms(18, 45, 30).unwrap();
708		let mut col = ColumnBuffer::time(vec![time1]);
709		col.push_value(Value::Time(time2));
710		let ColumnBuffer::Time(container) = col else {
711			panic!("Expected Time");
712		};
713		assert_eq!(container.data().as_slice(), &[time1, time2]);
714	}
715
716	#[test]
717	fn test_undefined_time() {
718		let time1 = Time::from_hms(12, 30, 0).unwrap();
719		let mut col = ColumnBuffer::time(vec![time1]);
720		col.push_value(Value::none());
721		assert_eq!(col.len(), 2);
722		assert!(col.is_defined(0));
723		assert!(!col.is_defined(1));
724	}
725
726	#[test]
727	fn test_push_value_to_none_time() {
728		let time = Time::from_hms(15, 20, 10).unwrap();
729		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
730		col.push_value(Value::Time(time));
731		assert_eq!(col.len(), 2);
732		assert!(!col.is_defined(0));
733		assert!(col.is_defined(1));
734		assert_eq!(col.get_value(1), Value::Time(time));
735	}
736
737	#[test]
738	fn test_duration() {
739		let duration1 = Duration::from_days(30).unwrap();
740		let duration2 = Duration::from_hours(24).unwrap();
741		let mut col = ColumnBuffer::duration(vec![duration1]);
742		col.push_value(Value::Duration(duration2));
743		let ColumnBuffer::Duration(container) = col else {
744			panic!("Expected Duration");
745		};
746		assert_eq!(container.data().as_slice(), &[duration1, duration2]);
747	}
748
749	#[test]
750	fn test_undefined_duration() {
751		let duration1 = Duration::from_days(30).unwrap();
752		let mut col = ColumnBuffer::duration(vec![duration1]);
753		col.push_value(Value::none());
754		assert_eq!(col.len(), 2);
755		assert!(col.is_defined(0));
756		assert!(!col.is_defined(1));
757	}
758
759	#[test]
760	fn test_push_value_to_none_duration() {
761		let duration = Duration::from_minutes(90).unwrap();
762		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
763		col.push_value(Value::Duration(duration));
764		assert_eq!(col.len(), 2);
765		assert!(!col.is_defined(0));
766		assert!(col.is_defined(1));
767		assert_eq!(col.get_value(1), Value::Duration(duration));
768	}
769
770	#[test]
771	fn test_identity_id() {
772		let (mock, clock, rng) = test_clock_and_rng();
773		let id1 = IdentityId::generate(&clock, &rng);
774		mock.advance_millis(1);
775		let id2 = IdentityId::generate(&clock, &rng);
776		let mut col = ColumnBuffer::identity_id(vec![id1]);
777		col.push_value(Value::IdentityId(id2));
778		let ColumnBuffer::IdentityId(container) = col else {
779			panic!("Expected IdentityId");
780		};
781		assert_eq!(container.data().as_slice(), &[id1, id2]);
782	}
783
784	#[test]
785	fn test_undefined_identity_id() {
786		let (_, clock, rng) = test_clock_and_rng();
787		let id1 = IdentityId::generate(&clock, &rng);
788		let mut col = ColumnBuffer::identity_id(vec![id1]);
789		col.push_value(Value::none());
790		assert_eq!(col.len(), 2);
791		assert!(col.is_defined(0));
792		assert!(!col.is_defined(1));
793	}
794
795	#[test]
796	fn test_push_value_to_none_identity_id() {
797		let (_, clock, rng) = test_clock_and_rng();
798		let id = IdentityId::generate(&clock, &rng);
799		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
800		col.push_value(Value::IdentityId(id));
801		assert_eq!(col.len(), 2);
802		assert!(!col.is_defined(0));
803		assert!(col.is_defined(1));
804		assert_eq!(col.get_value(1), Value::IdentityId(id));
805	}
806
807	#[test]
808	fn test_uuid4() {
809		let uuid1 = Uuid4::generate();
810		let uuid2 = Uuid4::generate();
811		let mut col = ColumnBuffer::uuid4(vec![uuid1]);
812		col.push_value(Value::Uuid4(uuid2));
813		let ColumnBuffer::Uuid4(container) = col else {
814			panic!("Expected Uuid4");
815		};
816		assert_eq!(container.data().as_slice(), &[uuid1, uuid2]);
817	}
818
819	#[test]
820	fn test_undefined_uuid4() {
821		let uuid1 = Uuid4::generate();
822		let mut col = ColumnBuffer::uuid4(vec![uuid1]);
823		col.push_value(Value::none());
824		assert_eq!(col.len(), 2);
825		assert!(col.is_defined(0));
826		assert!(!col.is_defined(1));
827	}
828
829	#[test]
830	fn test_push_value_to_none_uuid4() {
831		let uuid = Uuid4::generate();
832		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
833		col.push_value(Value::Uuid4(uuid));
834		assert_eq!(col.len(), 2);
835		assert!(!col.is_defined(0));
836		assert!(col.is_defined(1));
837		assert_eq!(col.get_value(1), Value::Uuid4(uuid));
838	}
839
840	#[test]
841	fn test_uuid7() {
842		let (mock, clock, rng) = test_clock_and_rng();
843		let uuid1 = Uuid7::generate(&clock, &rng);
844		mock.advance_millis(1);
845		let uuid2 = Uuid7::generate(&clock, &rng);
846		let mut col = ColumnBuffer::uuid7(vec![uuid1]);
847		col.push_value(Value::Uuid7(uuid2));
848		let ColumnBuffer::Uuid7(container) = col else {
849			panic!("Expected Uuid7");
850		};
851		assert_eq!(container.data().as_slice(), &[uuid1, uuid2]);
852	}
853
854	#[test]
855	fn test_undefined_uuid7() {
856		let (_, clock, rng) = test_clock_and_rng();
857		let uuid1 = Uuid7::generate(&clock, &rng);
858		let mut col = ColumnBuffer::uuid7(vec![uuid1]);
859		col.push_value(Value::none());
860		assert_eq!(col.len(), 2);
861		assert!(col.is_defined(0));
862		assert!(!col.is_defined(1));
863	}
864
865	#[test]
866	fn test_push_value_to_none_uuid7() {
867		let (_, clock, rng) = test_clock_and_rng();
868		let uuid = Uuid7::generate(&clock, &rng);
869		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
870		col.push_value(Value::Uuid7(uuid));
871		assert_eq!(col.len(), 2);
872		assert!(!col.is_defined(0));
873		assert!(col.is_defined(1));
874		assert_eq!(col.get_value(1), Value::Uuid7(uuid));
875	}
876
877	#[test]
878	fn test_dictionary_id() {
879		let e1 = DictionaryEntryId::U4(10);
880		let e2 = DictionaryEntryId::U4(20);
881		let mut col = ColumnBuffer::dictionary_id(vec![e1]);
882		col.push_value(Value::DictionaryId(e2));
883		let ColumnBuffer::DictionaryId(container) = col else {
884			panic!("Expected DictionaryId");
885		};
886		assert_eq!(container.data().as_slice(), &[e1, e2]);
887	}
888
889	#[test]
890	fn test_undefined_dictionary_id() {
891		let e1 = DictionaryEntryId::U4(10);
892		let mut col = ColumnBuffer::dictionary_id(vec![e1]);
893		col.push_value(Value::none());
894		assert_eq!(col.len(), 2);
895		assert!(col.is_defined(0));
896		assert!(!col.is_defined(1));
897	}
898
899	#[test]
900	fn test_push_value_to_none_dictionary_id() {
901		let e = DictionaryEntryId::U4(42);
902		let mut col = ColumnBuffer::none_typed(ValueType::Boolean, 1);
903		col.push_value(Value::DictionaryId(e));
904		assert_eq!(col.len(), 2);
905		assert!(!col.is_defined(0));
906		assert!(col.is_defined(1));
907		assert_eq!(col.get_value(1), Value::DictionaryId(e));
908	}
909}
reifydb_core/value/column/push/value.rs

reifydb_core/value/column/push/
value.rs
