reifydb_core/value/column/push/
value.rs

1use reifydb_type::Value;
2
3// Copyright (c) reifydb.com 2025
4// This file is licensed under the AGPL-3.0-or-later, see license.md file
5use crate::value::column::data::ColumnData;
6
7impl ColumnData {
8	pub fn push_value(&mut self, value: Value) {
9		match value {
10			Value::Boolean(v) => match self {
11				ColumnData::Bool(_) => self.push(v),
12				ColumnData::Undefined(container) => {
13					let mut new_container = ColumnData::bool(vec![]);
14					if let ColumnData::Bool(new_container) = &mut new_container {
15						for _ in 0..container.len() {
16							new_container.push_undefined();
17						}
18						new_container.push(v);
19					}
20					*self = new_container;
21				}
22				_ => unimplemented!(),
23			},
24
25			Value::Float4(v) => match self {
26				ColumnData::Float4(_) => self.push(v.value()),
27				ColumnData::Undefined(container) => {
28					let mut new_container = ColumnData::float4(vec![]);
29					if let ColumnData::Float4(new_container) = &mut new_container {
30						for _ in 0..container.len() {
31							new_container.push_undefined();
32						}
33						new_container.push(v.value());
34					}
35					*self = new_container;
36				}
37				_ => unimplemented!(),
38			},
39
40			Value::Float8(v) => match self {
41				ColumnData::Float8(_) => self.push(v.value()),
42				ColumnData::Undefined(container) => {
43					let mut new_container = ColumnData::float8(vec![]);
44					if let ColumnData::Float8(new_container) = &mut new_container {
45						for _ in 0..container.len() {
46							new_container.push_undefined();
47						}
48						new_container.push(v.value());
49					}
50					*self = new_container;
51				}
52				_ => unimplemented!(),
53			},
54
55			Value::Int1(v) => match self {
56				ColumnData::Int1(_) => self.push(v),
57				ColumnData::Undefined(container) => {
58					let mut new_container = ColumnData::int1(vec![]);
59					if let ColumnData::Int1(new_container) = &mut new_container {
60						for _ in 0..container.len() {
61							new_container.push_undefined();
62						}
63						new_container.push(v);
64					}
65					*self = new_container;
66				}
67				_ => unimplemented!(),
68			},
69
70			Value::Int2(v) => match self {
71				ColumnData::Int2(_) => self.push(v),
72				ColumnData::Undefined(container) => {
73					let mut new_container = ColumnData::int2(vec![]);
74					if let ColumnData::Int2(new_container) = &mut new_container {
75						for _ in 0..container.len() {
76							new_container.push_undefined();
77						}
78						new_container.push(v);
79					}
80					*self = new_container;
81				}
82				_ => unimplemented!(),
83			},
84
85			Value::Int4(v) => match self {
86				ColumnData::Int4(_) => self.push(v),
87				ColumnData::Undefined(container) => {
88					let mut new_container = ColumnData::int4(vec![]);
89					if let ColumnData::Int4(new_container) = &mut new_container {
90						for _ in 0..container.len() {
91							new_container.push_undefined();
92						}
93						new_container.push(v);
94					}
95					*self = new_container;
96				}
97				_ => unimplemented!(),
98			},
99
100			Value::Int8(v) => match self {
101				ColumnData::Int8(_) => self.push(v),
102				ColumnData::Undefined(container) => {
103					let mut new_container = ColumnData::int8(vec![]);
104					if let ColumnData::Int8(new_container) = &mut new_container {
105						for _ in 0..container.len() {
106							new_container.push_undefined();
107						}
108						new_container.push(v);
109					}
110					*self = new_container;
111				}
112				_ => unimplemented!(),
113			},
114
115			Value::Int16(v) => match self {
116				ColumnData::Int16(_) => self.push(v),
117				ColumnData::Undefined(container) => {
118					let mut new_container = ColumnData::int16(vec![]);
119					if let ColumnData::Int16(new_container) = &mut new_container {
120						for _ in 0..container.len() {
121							new_container.push_undefined();
122						}
123						new_container.push(v);
124					}
125					*self = new_container;
126				}
127				_ => unimplemented!(),
128			},
129
130			Value::Utf8(v) => match self {
131				ColumnData::Utf8 {
132					..
133				} => self.push(v),
134				ColumnData::Undefined(container) => {
135					let mut new_container = ColumnData::utf8(Vec::<String>::new());
136					if let ColumnData::Utf8 {
137						container: new_container,
138						..
139					} = &mut new_container
140					{
141						for _ in 0..container.len() {
142							new_container.push_undefined();
143						}
144						new_container.push(v);
145					}
146					*self = new_container;
147				}
148				_ => unimplemented!(),
149			},
150
151			Value::Uint1(v) => match self {
152				ColumnData::Uint1(_) => self.push(v),
153				ColumnData::Undefined(container) => {
154					let mut new_container = ColumnData::uint1(vec![]);
155					if let ColumnData::Uint1(new_container) = &mut new_container {
156						for _ in 0..container.len() {
157							new_container.push_undefined();
158						}
159						new_container.push(v);
160					}
161					*self = new_container;
162				}
163				_ => unimplemented!(),
164			},
165
166			Value::Uint2(v) => match self {
167				ColumnData::Uint2(_) => self.push(v),
168				ColumnData::Undefined(container) => {
169					let mut new_container = ColumnData::uint2(vec![]);
170					if let ColumnData::Uint2(new_container) = &mut new_container {
171						for _ in 0..container.len() {
172							new_container.push_undefined();
173						}
174						new_container.push(v);
175					}
176					*self = new_container;
177				}
178				_ => unimplemented!(),
179			},
180
181			Value::Uint4(v) => match self {
182				ColumnData::Uint4(_) => self.push(v),
183				ColumnData::Undefined(container) => {
184					let mut new_container = ColumnData::uint4(vec![]);
185					if let ColumnData::Uint4(new_container) = &mut new_container {
186						for _ in 0..container.len() {
187							new_container.push_undefined();
188						}
189						new_container.push(v);
190					}
191					*self = new_container;
192				}
193				_ => unimplemented!(),
194			},
195
196			Value::Uint8(v) => match self {
197				ColumnData::Uint8(_) => self.push(v),
198				ColumnData::Undefined(container) => {
199					let mut new_container = ColumnData::uint8(vec![]);
200					if let ColumnData::Uint8(new_container) = &mut new_container {
201						for _ in 0..container.len() {
202							new_container.push_undefined();
203						}
204						new_container.push(v);
205					}
206					*self = new_container;
207				}
208				_ => unimplemented!(),
209			},
210
211			Value::Uint16(v) => match self {
212				ColumnData::Uint16(_) => self.push(v),
213				ColumnData::Undefined(container) => {
214					let mut new_container = ColumnData::uint16(vec![]);
215					if let ColumnData::Uint16(new_container) = &mut new_container {
216						for _ in 0..container.len() {
217							new_container.push_undefined();
218						}
219						new_container.push(v);
220					}
221					*self = new_container;
222				}
223				_ => unimplemented!(),
224			},
225
226			Value::Date(v) => match self {
227				ColumnData::Date(_) => self.push(v),
228				ColumnData::Undefined(container) => {
229					let mut new_container = ColumnData::date(vec![]);
230					if let ColumnData::Date(new_container) = &mut new_container {
231						for _ in 0..container.len() {
232							new_container.push_undefined();
233						}
234						new_container.push(v);
235					}
236					*self = new_container;
237				}
238				_ => unimplemented!(),
239			},
240
241			Value::DateTime(v) => match self {
242				ColumnData::DateTime(_) => self.push(v),
243				ColumnData::Undefined(container) => {
244					let mut new_container = ColumnData::datetime(vec![]);
245					if let ColumnData::DateTime(new_container) = &mut new_container {
246						for _ in 0..container.len() {
247							new_container.push_undefined();
248						}
249						new_container.push(v);
250					}
251					*self = new_container;
252				}
253				_ => unimplemented!(),
254			},
255
256			Value::Time(v) => match self {
257				ColumnData::Time(_) => self.push(v),
258				ColumnData::Undefined(container) => {
259					let mut new_container = ColumnData::time(vec![]);
260					if let ColumnData::Time(new_container) = &mut new_container {
261						for _ in 0..container.len() {
262							new_container.push_undefined();
263						}
264						new_container.push(v);
265					}
266					*self = new_container;
267				}
268				_ => unimplemented!(),
269			},
270
271			Value::Duration(v) => match self {
272				ColumnData::Duration(_) => self.push(v),
273				ColumnData::Undefined(container) => {
274					let mut new_container = ColumnData::duration(vec![]);
275					if let ColumnData::Duration(new_container) = &mut new_container {
276						for _ in 0..container.len() {
277							new_container.push_undefined();
278						}
279						new_container.push(v);
280					}
281					*self = new_container;
282				}
283				_ => unimplemented!(),
284			},
285
286			Value::Uuid4(v) => match self {
287				ColumnData::Uuid4(_) => self.push(v),
288				ColumnData::Undefined(container) => {
289					let mut new_container = ColumnData::uuid4(vec![]);
290					if let ColumnData::Uuid4(new_container) = &mut new_container {
291						for _ in 0..container.len() {
292							new_container.push_undefined();
293						}
294						new_container.push(v);
295					}
296					*self = new_container;
297				}
298				_ => unimplemented!(),
299			},
300
301			Value::Uuid7(v) => match self {
302				ColumnData::Uuid7(_) => self.push(v),
303				ColumnData::Undefined(container) => {
304					let mut new_container = ColumnData::uuid7(vec![]);
305					if let ColumnData::Uuid7(new_container) = &mut new_container {
306						for _ in 0..container.len() {
307							new_container.push_undefined();
308						}
309						new_container.push(v);
310					}
311					*self = new_container;
312				}
313				_ => unimplemented!(),
314			},
315
316			Value::Undefined => self.push_undefined(),
317			Value::RowNumber(row_number) => match self {
318				ColumnData::RowNumber(container) => container.push(row_number),
319				ColumnData::Undefined(container) => {
320					let mut new_container = ColumnData::row_number(vec![]);
321					if let ColumnData::RowNumber(new_container) = &mut new_container {
322						for _ in 0..container.len() {
323							new_container.push_undefined();
324						}
325						new_container.push(row_number);
326					}
327					*self = new_container;
328				}
329				_ => unimplemented!(),
330			},
331			Value::IdentityId(id) => match self {
332				ColumnData::IdentityId(container) => container.push(id),
333				ColumnData::Undefined(container) => {
334					let mut new_container = ColumnData::identity_id(vec![]);
335					if let ColumnData::IdentityId(new_container) = &mut new_container {
336						for _ in 0..container.len() {
337							new_container.push_undefined();
338						}
339						new_container.push(id);
340					}
341					*self = new_container;
342				}
343				_ => unimplemented!(),
344			},
345			Value::Blob(v) => match self {
346				ColumnData::Blob {
347					container,
348					..
349				} => container.push(v),
350				ColumnData::Undefined(container) => {
351					let mut new_container = ColumnData::blob(vec![]);
352					if let ColumnData::Blob {
353						container: new_container,
354						..
355					} = &mut new_container
356					{
357						for _ in 0..container.len() {
358							new_container.push_undefined();
359						}
360						new_container.push(v);
361					}
362					*self = new_container;
363				}
364				_ => unimplemented!(),
365			},
366
367			Value::Int(v) => match self {
368				ColumnData::Int {
369					container,
370					..
371				} => container.push(v),
372				ColumnData::Undefined(container) => {
373					let mut new_container = ColumnData::int(vec![]);
374					if let ColumnData::Int {
375						container: new_container,
376						..
377					} = &mut new_container
378					{
379						for _ in 0..container.len() {
380							new_container.push_undefined();
381						}
382						new_container.push(v);
383					}
384					*self = new_container;
385				}
386				_ => unimplemented!(),
387			},
388			Value::Uint(v) => match self {
389				ColumnData::Uint {
390					container,
391					..
392				} => container.push(v),
393				ColumnData::Undefined(container) => {
394					let mut new_container = ColumnData::uint(vec![]);
395					if let ColumnData::Uint {
396						container: new_container,
397						..
398					} = &mut new_container
399					{
400						for _ in 0..container.len() {
401							new_container.push_undefined();
402						}
403						new_container.push(v);
404					}
405					*self = new_container;
406				}
407				_ => unimplemented!(),
408			},
409
410			Value::Decimal(v) => match self {
411				ColumnData::Decimal {
412					container,
413					..
414				} => container.push(v),
415				ColumnData::Undefined(container) => {
416					let mut new_container = ColumnData::decimal(vec![]);
417					if let ColumnData::Decimal {
418						container: new_container,
419						..
420					} = &mut new_container
421					{
422						for _ in 0..container.len() {
423							new_container.push_undefined();
424						}
425						new_container.push(v);
426					}
427					*self = new_container;
428				}
429				_ => unimplemented!(),
430			},
431
432			Value::Any(v) => match self {
433				ColumnData::Any(container) => container.push(v),
434				ColumnData::Undefined(container) => {
435					let mut new_container = ColumnData::any(vec![]);
436					if let ColumnData::Any(new_container) = &mut new_container {
437						for _ in 0..container.len() {
438							new_container.push_undefined();
439						}
440						new_container.push(v);
441					}
442					*self = new_container;
443				}
444				_ => unreachable!("Cannot push Any value to non-Any column"),
445			},
446		}
447	}
448}
449
450#[cfg(test)]
451#[allow(clippy::approx_constant)]
452mod tests {
453	use reifydb_type::{
454		Date, DateTime, Duration, IdentityId, OrderedF32, OrderedF64, RowNumber, Time, Uuid4, Uuid7, Value,
455	};
456	use uuid::Uuid;
457
458	use crate::value::column::ColumnData;
459
460	#[test]
461	fn test_bool() {
462		let mut col = ColumnData::bool(vec![true]);
463		col.push_value(Value::Boolean(false));
464		let ColumnData::Bool(container) = col else {
465			panic!("Expected Bool");
466		};
467		assert_eq!(container.data().to_vec(), vec![true, false]);
468		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
469	}
470
471	#[test]
472	fn test_undefined_bool() {
473		let mut col = ColumnData::bool(vec![true]);
474		col.push_value(Value::Undefined);
475		let ColumnData::Bool(container) = col else {
476			panic!("Expected Bool");
477		};
478		assert_eq!(container.data().to_vec(), vec![true, false]);
479		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
480	}
481
482	#[test]
483	fn test_push_value_to_undefined_bool() {
484		let mut col = ColumnData::undefined(2);
485		col.push_value(Value::Boolean(true));
486		let ColumnData::Bool(container) = col else {
487			panic!("Expected Bool");
488		};
489		assert_eq!(container.data().to_vec(), vec![false, false, true]);
490		assert_eq!(container.bitvec().to_vec(), vec![false, false, true]);
491	}
492
493	#[test]
494	fn test_float4() {
495		let mut col = ColumnData::float4(vec![1.0]);
496		col.push_value(Value::Float4(OrderedF32::try_from(2.0).unwrap()));
497		let ColumnData::Float4(container) = col else {
498			panic!("Expected Float4");
499		};
500		assert_eq!(container.data().as_slice(), &[1.0, 2.0]);
501		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
502	}
503
504	#[test]
505	fn test_undefined_float4() {
506		let mut col = ColumnData::float4(vec![1.0]);
507		col.push_value(Value::Undefined);
508		let ColumnData::Float4(container) = col else {
509			panic!("Expected Float4");
510		};
511		assert_eq!(container.data().as_slice(), &[1.0, 0.0]);
512		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
513	}
514
515	#[test]
516	fn test_push_value_to_undefined_float4() {
517		let mut col = ColumnData::undefined(1);
518		col.push_value(Value::Float4(OrderedF32::try_from(3.14).unwrap()));
519		let ColumnData::Float4(container) = col else {
520			panic!("Expected Float4");
521		};
522		assert_eq!(container.data().as_slice(), &[0.0, 3.14]);
523		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
524	}
525
526	#[test]
527	fn test_float8() {
528		let mut col = ColumnData::float8(vec![1.0]);
529		col.push_value(Value::Float8(OrderedF64::try_from(2.0).unwrap()));
530		let ColumnData::Float8(container) = col else {
531			panic!("Expected Float8");
532		};
533		assert_eq!(container.data().as_slice(), &[1.0, 2.0]);
534		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
535	}
536
537	#[test]
538	fn test_undefined_float8() {
539		let mut col = ColumnData::float8(vec![1.0]);
540		col.push_value(Value::Undefined);
541		let ColumnData::Float8(container) = col else {
542			panic!("Expected Float8");
543		};
544		assert_eq!(container.data().as_slice(), &[1.0, 0.0]);
545		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
546	}
547
548	#[test]
549	fn test_push_value_to_undefined_float8() {
550		let mut col = ColumnData::undefined(1);
551		col.push_value(Value::Float8(OrderedF64::try_from(2.718).unwrap()));
552		let ColumnData::Float8(container) = col else {
553			panic!("Expected Float8");
554		};
555		assert_eq!(container.data().as_slice(), &[0.0, 2.718]);
556		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
557	}
558
559	#[test]
560	fn test_int1() {
561		let mut col = ColumnData::int1(vec![1]);
562		col.push_value(Value::Int1(2));
563		let ColumnData::Int1(container) = col else {
564			panic!("Expected Int1");
565		};
566		assert_eq!(container.data().as_slice(), &[1, 2]);
567		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
568	}
569
570	#[test]
571	fn test_undefined_int1() {
572		let mut col = ColumnData::int1(vec![1]);
573		col.push_value(Value::Undefined);
574		let ColumnData::Int1(container) = col else {
575			panic!("Expected Int1");
576		};
577		assert_eq!(container.data().as_slice(), &[1, 0]);
578		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
579	}
580
581	#[test]
582	fn test_push_value_to_undefined_int1() {
583		let mut col = ColumnData::undefined(1);
584		col.push_value(Value::Int1(5));
585		let ColumnData::Int1(container) = col else {
586			panic!("Expected Int1");
587		};
588		assert_eq!(container.data().as_slice(), &[0, 5]);
589		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
590	}
591
592	#[test]
593	fn test_int2() {
594		let mut col = ColumnData::int2(vec![1]);
595		col.push_value(Value::Int2(3));
596		let ColumnData::Int2(container) = col else {
597			panic!("Expected Int2");
598		};
599		assert_eq!(container.data().as_slice(), &[1, 3]);
600		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
601	}
602
603	#[test]
604	fn test_undefined_int2() {
605		let mut col = ColumnData::int2(vec![1]);
606		col.push_value(Value::Undefined);
607		let ColumnData::Int2(container) = col else {
608			panic!("Expected Int2");
609		};
610		assert_eq!(container.data().as_slice(), &[1, 0]);
611		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
612	}
613
614	#[test]
615	fn test_push_value_to_undefined_int2() {
616		let mut col = ColumnData::undefined(1);
617		col.push_value(Value::Int2(10));
618		let ColumnData::Int2(container) = col else {
619			panic!("Expected Int2");
620		};
621		assert_eq!(container.data().as_slice(), &[0, 10]);
622		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
623	}
624
625	#[test]
626	fn test_int4() {
627		let mut col = ColumnData::int4(vec![10]);
628		col.push_value(Value::Int4(20));
629		let ColumnData::Int4(container) = col else {
630			panic!("Expected Int4");
631		};
632		assert_eq!(container.data().as_slice(), &[10, 20]);
633		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
634	}
635
636	#[test]
637	fn test_undefined_int4() {
638		let mut col = ColumnData::int4(vec![10]);
639		col.push_value(Value::Undefined);
640		let ColumnData::Int4(container) = col else {
641			panic!("Expected Int4");
642		};
643		assert_eq!(container.data().as_slice(), &[10, 0]);
644		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
645	}
646
647	#[test]
648	fn test_push_value_to_undefined_int4() {
649		let mut col = ColumnData::undefined(1);
650		col.push_value(Value::Int4(20));
651		let ColumnData::Int4(container) = col else {
652			panic!("Expected Int4");
653		};
654		assert_eq!(container.data().as_slice(), &[0, 20]);
655		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
656	}
657
658	#[test]
659	fn test_int8() {
660		let mut col = ColumnData::int8(vec![100]);
661		col.push_value(Value::Int8(200));
662		let ColumnData::Int8(container) = col else {
663			panic!("Expected Int8");
664		};
665		assert_eq!(container.data().as_slice(), &[100, 200]);
666		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
667	}
668
669	#[test]
670	fn test_undefined_int8() {
671		let mut col = ColumnData::int8(vec![100]);
672		col.push_value(Value::Undefined);
673		let ColumnData::Int8(container) = col else {
674			panic!("Expected Int8");
675		};
676		assert_eq!(container.data().as_slice(), &[100, 0]);
677		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
678	}
679
680	#[test]
681	fn test_push_value_to_undefined_int8() {
682		let mut col = ColumnData::undefined(1);
683		col.push_value(Value::Int8(30));
684		let ColumnData::Int8(container) = col else {
685			panic!("Expected Int8");
686		};
687		assert_eq!(container.data().as_slice(), &[0, 30]);
688		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
689	}
690
691	#[test]
692	fn test_int16() {
693		let mut col = ColumnData::int16(vec![1000]);
694		col.push_value(Value::Int16(2000));
695		let ColumnData::Int16(container) = col else {
696			panic!("Expected Int16");
697		};
698		assert_eq!(container.data().as_slice(), &[1000, 2000]);
699		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
700	}
701
702	#[test]
703	fn test_undefined_int16() {
704		let mut col = ColumnData::int16(vec![1000]);
705		col.push_value(Value::Undefined);
706		let ColumnData::Int16(container) = col else {
707			panic!("Expected Int16");
708		};
709		assert_eq!(container.data().as_slice(), &[1000, 0]);
710		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
711	}
712
713	#[test]
714	fn test_push_value_to_undefined_int16() {
715		let mut col = ColumnData::undefined(1);
716		col.push_value(Value::Int16(40));
717		let ColumnData::Int16(container) = col else {
718			panic!("Expected Int16");
719		};
720		assert_eq!(container.data().as_slice(), &[0, 40]);
721		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
722	}
723
724	#[test]
725	fn test_uint1() {
726		let mut col = ColumnData::uint1(vec![1]);
727		col.push_value(Value::Uint1(2));
728		let ColumnData::Uint1(container) = col else {
729			panic!("Expected Uint1");
730		};
731		assert_eq!(container.data().as_slice(), &[1, 2]);
732		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
733	}
734
735	#[test]
736	fn test_undefined_uint1() {
737		let mut col = ColumnData::uint1(vec![1]);
738		col.push_value(Value::Undefined);
739		let ColumnData::Uint1(container) = col else {
740			panic!("Expected Uint1");
741		};
742		assert_eq!(container.data().as_slice(), &[1, 0]);
743		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
744	}
745
746	#[test]
747	fn test_push_value_to_undefined_uint1() {
748		let mut col = ColumnData::undefined(1);
749		col.push_value(Value::Uint1(1));
750		let ColumnData::Uint1(container) = col else {
751			panic!("Expected Uint1");
752		};
753		assert_eq!(container.data().as_slice(), &[0, 1]);
754		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
755	}
756
757	#[test]
758	fn test_uint2() {
759		let mut col = ColumnData::uint2(vec![10]);
760		col.push_value(Value::Uint2(20));
761		let ColumnData::Uint2(container) = col else {
762			panic!("Expected Uint2");
763		};
764		assert_eq!(container.data().as_slice(), &[10, 20]);
765		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
766	}
767
768	#[test]
769	fn test_undefined_uint2() {
770		let mut col = ColumnData::uint2(vec![10]);
771		col.push_value(Value::Undefined);
772		let ColumnData::Uint2(container) = col else {
773			panic!("Expected Uint2");
774		};
775		assert_eq!(container.data().as_slice(), &[10, 0]);
776		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
777	}
778
779	#[test]
780	fn test_push_value_to_undefined_uint2() {
781		let mut col = ColumnData::undefined(1);
782		col.push_value(Value::Uint2(2));
783		let ColumnData::Uint2(container) = col else {
784			panic!("Expected Uint2");
785		};
786		assert_eq!(container.data().as_slice(), &[0, 2]);
787		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
788	}
789
790	#[test]
791	fn test_uint4() {
792		let mut col = ColumnData::uint4(vec![100]);
793		col.push_value(Value::Uint4(200));
794		let ColumnData::Uint4(container) = col else {
795			panic!("Expected Uint4");
796		};
797		assert_eq!(container.data().as_slice(), &[100, 200]);
798		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
799	}
800
801	#[test]
802	fn test_undefined_uint4() {
803		let mut col = ColumnData::uint4(vec![100]);
804		col.push_value(Value::Undefined);
805		let ColumnData::Uint4(container) = col else {
806			panic!("Expected Uint4");
807		};
808		assert_eq!(container.data().as_slice(), &[100, 0]);
809		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
810	}
811
812	#[test]
813	fn test_push_value_to_undefined_uint4() {
814		let mut col = ColumnData::undefined(1);
815		col.push_value(Value::Uint4(3));
816		let ColumnData::Uint4(container) = col else {
817			panic!("Expected Uint4");
818		};
819		assert_eq!(container.data().as_slice(), &[0, 3]);
820		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
821	}
822
823	#[test]
824	fn test_uint8() {
825		let mut col = ColumnData::uint8(vec![1000]);
826		col.push_value(Value::Uint8(2000));
827		let ColumnData::Uint8(container) = col else {
828			panic!("Expected Uint8");
829		};
830		assert_eq!(container.data().as_slice(), &[1000, 2000]);
831		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
832	}
833
834	#[test]
835	fn test_undefined_uint8() {
836		let mut col = ColumnData::uint8(vec![1000]);
837		col.push_value(Value::Undefined);
838		let ColumnData::Uint8(container) = col else {
839			panic!("Expected Uint8");
840		};
841		assert_eq!(container.data().as_slice(), &[1000, 0]);
842		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
843	}
844
845	#[test]
846	fn test_push_value_to_undefined_uint8() {
847		let mut col = ColumnData::undefined(1);
848		col.push_value(Value::Uint8(4));
849		let ColumnData::Uint8(container) = col else {
850			panic!("Expected Uint8");
851		};
852		assert_eq!(container.data().as_slice(), &[0, 4]);
853		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
854	}
855
856	#[test]
857	fn test_uint16() {
858		let mut col = ColumnData::uint16(vec![10000]);
859		col.push_value(Value::Uint16(20000));
860		let ColumnData::Uint16(container) = col else {
861			panic!("Expected Uint16");
862		};
863		assert_eq!(container.data().as_slice(), &[10000, 20000]);
864		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
865	}
866
867	#[test]
868	fn test_undefined_uint16() {
869		let mut col = ColumnData::uint16(vec![10000]);
870		col.push_value(Value::Undefined);
871		let ColumnData::Uint16(container) = col else {
872			panic!("Expected Uint16");
873		};
874		assert_eq!(container.data().as_slice(), &[10000, 0]);
875		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
876	}
877
878	#[test]
879	fn test_push_value_to_undefined_uint16() {
880		let mut col = ColumnData::undefined(1);
881		col.push_value(Value::Uint16(5));
882		let ColumnData::Uint16(container) = col else {
883			panic!("Expected Uint16");
884		};
885		assert_eq!(container.data().as_slice(), &[0, 5]);
886		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
887	}
888
889	#[test]
890	fn test_utf8() {
891		let mut col = ColumnData::utf8(vec!["hello".to_string()]);
892		col.push_value(Value::Utf8("world".to_string()));
893		let ColumnData::Utf8 {
894			container,
895			..
896		} = col
897		else {
898			panic!("Expected Utf8");
899		};
900		assert_eq!(container.data().as_slice(), &["hello".to_string(), "world".to_string()]);
901		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
902	}
903
904	#[test]
905	fn test_undefined_utf8() {
906		let mut col = ColumnData::utf8(vec!["hello".to_string()]);
907		col.push_value(Value::Undefined);
908		let ColumnData::Utf8 {
909			container,
910			..
911		} = col
912		else {
913			panic!("Expected Utf8");
914		};
915		assert_eq!(container.data().as_slice(), &["hello".to_string(), "".to_string()]);
916		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
917	}
918
919	#[test]
920	fn test_push_value_to_undefined_utf8() {
921		let mut col = ColumnData::undefined(1);
922		col.push_value(Value::Utf8("ok".to_string()));
923		let ColumnData::Utf8 {
924			container,
925			..
926		} = col
927		else {
928			panic!("Expected Utf8");
929		};
930		assert_eq!(container.data().as_slice(), &["".to_string(), "ok".to_string()]);
931		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
932	}
933
934	#[test]
935	fn test_undefined() {
936		let mut col = ColumnData::int2(vec![1]);
937		col.push_value(Value::Undefined);
938		let ColumnData::Int2(container) = col else {
939			panic!("Expected Int2");
940		};
941		assert_eq!(container.data().as_slice(), &[1, 0]);
942		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
943	}
944
945	#[test]
946	fn test_date() {
947		let date1 = Date::from_ymd(2023, 1, 1).unwrap();
948		let date2 = Date::from_ymd(2023, 12, 31).unwrap();
949		let mut col = ColumnData::date(vec![date1]);
950		col.push_value(Value::Date(date2));
951		let ColumnData::Date(container) = col else {
952			panic!("Expected Date");
953		};
954		assert_eq!(container.data().as_slice(), &[date1, date2]);
955		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
956	}
957
958	#[test]
959	fn test_undefined_date() {
960		let date1 = Date::from_ymd(2023, 1, 1).unwrap();
961		let mut col = ColumnData::date(vec![date1]);
962		col.push_value(Value::Undefined);
963		let ColumnData::Date(container) = col else {
964			panic!("Expected Date");
965		};
966		assert_eq!(container.data().as_slice(), &[date1, Date::default()]);
967		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
968	}
969
970	#[test]
971	fn test_push_value_to_undefined_date() {
972		let date = Date::from_ymd(2023, 6, 15).unwrap();
973		let mut col = ColumnData::undefined(1);
974		col.push_value(Value::Date(date));
975		let ColumnData::Date(container) = col else {
976			panic!("Expected Date");
977		};
978		assert_eq!(container.data().as_slice(), &[Date::default(), date]);
979		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
980	}
981
982	#[test]
983	fn test_datetime() {
984		let dt1 = DateTime::from_timestamp(1672531200).unwrap(); // 2023-01-01 00:00:00 SVTC
985		let dt2 = DateTime::from_timestamp(1704067200).unwrap(); // 2024-01-01 00:00:00 SVTC
986		let mut col = ColumnData::datetime(vec![dt1]);
987		col.push_value(Value::DateTime(dt2));
988		let ColumnData::DateTime(container) = col else {
989			panic!("Expected DateTime");
990		};
991		assert_eq!(container.data().as_slice(), &[dt1, dt2]);
992		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
993	}
994
995	#[test]
996	fn test_undefined_datetime() {
997		use DateTime;
998		let dt1 = DateTime::from_timestamp(1672531200).unwrap();
999		let mut col = ColumnData::datetime(vec![dt1]);
1000		col.push_value(Value::Undefined);
1001		let ColumnData::DateTime(container) = col else {
1002			panic!("Expected DateTime");
1003		};
1004		assert_eq!(container.data().as_slice(), &[dt1, DateTime::default()]);
1005		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
1006	}
1007
1008	#[test]
1009	fn test_push_value_to_undefined_datetime() {
1010		let dt = DateTime::from_timestamp(1672531200).unwrap();
1011		let mut col = ColumnData::undefined(1);
1012		col.push_value(Value::DateTime(dt));
1013		let ColumnData::DateTime(container) = col else {
1014			panic!("Expected DateTime");
1015		};
1016		assert_eq!(container.data().as_slice(), &[DateTime::default(), dt]);
1017		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
1018	}
1019
1020	#[test]
1021	fn test_time() {
1022		let time1 = Time::from_hms(12, 30, 0).unwrap();
1023		let time2 = Time::from_hms(18, 45, 30).unwrap();
1024		let mut col = ColumnData::time(vec![time1]);
1025		col.push_value(Value::Time(time2));
1026		let ColumnData::Time(container) = col else {
1027			panic!("Expected Time");
1028		};
1029		assert_eq!(container.data().as_slice(), &[time1, time2]);
1030		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
1031	}
1032
1033	#[test]
1034	fn test_undefined_time() {
1035		let time1 = Time::from_hms(12, 30, 0).unwrap();
1036		let mut col = ColumnData::time(vec![time1]);
1037		col.push_value(Value::Undefined);
1038		let ColumnData::Time(container) = col else {
1039			panic!("Expected Time");
1040		};
1041		assert_eq!(container.data().as_slice(), &[time1, Time::default()]);
1042		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
1043	}
1044
1045	#[test]
1046	fn test_push_value_to_undefined_time() {
1047		let time = Time::from_hms(15, 20, 10).unwrap();
1048		let mut col = ColumnData::undefined(1);
1049		col.push_value(Value::Time(time));
1050		let ColumnData::Time(container) = col else {
1051			panic!("Expected Time");
1052		};
1053		assert_eq!(container.data().as_slice(), &[Time::default(), time]);
1054		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
1055	}
1056
1057	#[test]
1058	fn test_duration() {
1059		let duration1 = Duration::from_days(30);
1060		let duration2 = Duration::from_hours(24);
1061		let mut col = ColumnData::duration(vec![duration1]);
1062		col.push_value(Value::Duration(duration2));
1063		let ColumnData::Duration(container) = col else {
1064			panic!("Expected Duration");
1065		};
1066		assert_eq!(container.data().as_slice(), &[duration1, duration2]);
1067		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
1068	}
1069
1070	#[test]
1071	fn test_undefined_duration() {
1072		let duration1 = Duration::from_days(30);
1073		let mut col = ColumnData::duration(vec![duration1]);
1074		col.push_value(Value::Undefined);
1075		let ColumnData::Duration(container) = col else {
1076			panic!("Expected Duration");
1077		};
1078		assert_eq!(container.data().as_slice(), &[duration1, Duration::default()]);
1079		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
1080	}
1081
1082	#[test]
1083	fn test_push_value_to_undefined_duration() {
1084		let duration = Duration::from_minutes(90);
1085		let mut col = ColumnData::undefined(1);
1086		col.push_value(Value::Duration(duration));
1087		let ColumnData::Duration(container) = col else {
1088			panic!("Expected Duration");
1089		};
1090		assert_eq!(container.data().as_slice(), &[Duration::default(), duration]);
1091		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
1092	}
1093
1094	#[test]
1095	fn test_row_number() {
1096		let row_number1 = RowNumber::new(1);
1097		let row_number2 = RowNumber::new(2);
1098		let mut col = ColumnData::row_number(vec![row_number1]);
1099		col.push_value(Value::RowNumber(row_number2));
1100		let ColumnData::RowNumber(container) = col else {
1101			panic!("Expected RowNumber");
1102		};
1103		assert_eq!(container.data().as_slice(), &[row_number1, row_number2]);
1104		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
1105	}
1106
1107	#[test]
1108	fn test_undefined_row_number() {
1109		let row_number1 = RowNumber::new(1);
1110		let mut col = ColumnData::row_number(vec![row_number1]);
1111		col.push_value(Value::Undefined);
1112		let ColumnData::RowNumber(container) = col else {
1113			panic!("Expected RowNumber");
1114		};
1115		assert_eq!(container.data().as_slice(), &[row_number1, RowNumber::default()]);
1116		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
1117	}
1118
1119	#[test]
1120	fn test_push_value_to_undefined_row_number() {
1121		let row_number = RowNumber::new(42);
1122		let mut col = ColumnData::undefined(1);
1123		col.push_value(Value::RowNumber(row_number));
1124		let ColumnData::RowNumber(container) = col else {
1125			panic!("Expected RowNumber");
1126		};
1127		assert_eq!(container.data().as_slice(), &[RowNumber::default(), row_number]);
1128		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
1129	}
1130
1131	#[test]
1132	fn test_identity_id() {
1133		let id1 = IdentityId::generate();
1134		let id2 = IdentityId::generate();
1135		let mut col = ColumnData::identity_id(vec![id1]);
1136		col.push_value(Value::IdentityId(id2));
1137		let ColumnData::IdentityId(container) = col else {
1138			panic!("Expected IdentityId");
1139		};
1140		assert_eq!(container.data().as_slice(), &[id1, id2]);
1141		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
1142	}
1143
1144	#[test]
1145	fn test_undefined_identity_id() {
1146		let id1 = IdentityId::generate();
1147		let mut col = ColumnData::identity_id(vec![id1]);
1148		col.push_value(Value::Undefined);
1149		let ColumnData::IdentityId(container) = col else {
1150			panic!("Expected IdentityId");
1151		};
1152		assert_eq!(container.data().as_slice(), &[id1, IdentityId::default()]);
1153		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
1154	}
1155
1156	#[test]
1157	fn test_push_value_to_undefined_identity_id() {
1158		let id = IdentityId::generate();
1159		let mut col = ColumnData::undefined(1);
1160		col.push_value(Value::IdentityId(id));
1161		let ColumnData::IdentityId(container) = col else {
1162			panic!("Expected IdentityId");
1163		};
1164		assert_eq!(container.data().as_slice(), &[IdentityId::default(), id]);
1165		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
1166	}
1167
1168	#[test]
1169	fn test_uuid4() {
1170		let uuid1 = Uuid4::generate();
1171		let uuid2 = Uuid4::generate();
1172		let mut col = ColumnData::uuid4(vec![uuid1]);
1173		col.push_value(Value::Uuid4(uuid2));
1174		let ColumnData::Uuid4(container) = col else {
1175			panic!("Expected Uuid4");
1176		};
1177		assert_eq!(container.data().as_slice(), &[uuid1, uuid2]);
1178		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
1179	}
1180
1181	#[test]
1182	fn test_undefined_uuid4() {
1183		let uuid1 = Uuid4::generate();
1184		let mut col = ColumnData::uuid4(vec![uuid1]);
1185		col.push_value(Value::Undefined);
1186		let ColumnData::Uuid4(container) = col else {
1187			panic!("Expected Uuid4");
1188		};
1189		assert_eq!(container.data().as_slice(), &[uuid1, Uuid4::from(Uuid::nil())]);
1190		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
1191	}
1192
1193	#[test]
1194	fn test_push_value_to_undefined_uuid4() {
1195		let uuid = Uuid4::generate();
1196		let mut col = ColumnData::undefined(1);
1197		col.push_value(Value::Uuid4(uuid));
1198		let ColumnData::Uuid4(container) = col else {
1199			panic!("Expected Uuid4");
1200		};
1201		assert_eq!(container.data().as_slice(), &[Uuid4::from(Uuid::nil()), uuid]);
1202		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
1203	}
1204
1205	#[test]
1206	fn test_uuid7() {
1207		let uuid1 = Uuid7::generate();
1208		let uuid2 = Uuid7::generate();
1209		let mut col = ColumnData::uuid7(vec![uuid1]);
1210		col.push_value(Value::Uuid7(uuid2));
1211		let ColumnData::Uuid7(container) = col else {
1212			panic!("Expected Uuid7");
1213		};
1214		assert_eq!(container.data().as_slice(), &[uuid1, uuid2]);
1215		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
1216	}
1217
1218	#[test]
1219	fn test_undefined_uuid7() {
1220		let uuid1 = Uuid7::generate();
1221		let mut col = ColumnData::uuid7(vec![uuid1]);
1222		col.push_value(Value::Undefined);
1223		let ColumnData::Uuid7(container) = col else {
1224			panic!("Expected Uuid7");
1225		};
1226		assert_eq!(container.data().as_slice(), &[uuid1, Uuid7::from(Uuid::nil())]);
1227		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
1228	}
1229
1230	#[test]
1231	fn test_push_value_to_undefined_uuid7() {
1232		let uuid = Uuid7::generate();
1233		let mut col = ColumnData::undefined(1);
1234		col.push_value(Value::Uuid7(uuid));
1235		let ColumnData::Uuid7(container) = col else {
1236			panic!("Expected Uuid7");
1237		};
1238		assert_eq!(container.data().as_slice(), &[Uuid7::from(Uuid::nil()), uuid]);
1239		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
1240	}
1241}
reifydb_core/value/column/push/value.rs

reifydb_core/value/column/push/
value.rs
