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::IdentityId(id) => match self {
318				ColumnData::IdentityId(container) => container.push(id),
319				ColumnData::Undefined(container) => {
320					let mut new_container = ColumnData::identity_id(vec![]);
321					if let ColumnData::IdentityId(new_container) = &mut new_container {
322						for _ in 0..container.len() {
323							new_container.push_undefined();
324						}
325						new_container.push(id);
326					}
327					*self = new_container;
328				}
329				_ => unimplemented!(),
330			},
331			Value::Blob(v) => match self {
332				ColumnData::Blob {
333					container,
334					..
335				} => container.push(v),
336				ColumnData::Undefined(container) => {
337					let mut new_container = ColumnData::blob(vec![]);
338					if let ColumnData::Blob {
339						container: new_container,
340						..
341					} = &mut new_container
342					{
343						for _ in 0..container.len() {
344							new_container.push_undefined();
345						}
346						new_container.push(v);
347					}
348					*self = new_container;
349				}
350				_ => unimplemented!(),
351			},
352
353			Value::Int(v) => match self {
354				ColumnData::Int {
355					container,
356					..
357				} => container.push(v),
358				ColumnData::Undefined(container) => {
359					let mut new_container = ColumnData::int(vec![]);
360					if let ColumnData::Int {
361						container: new_container,
362						..
363					} = &mut new_container
364					{
365						for _ in 0..container.len() {
366							new_container.push_undefined();
367						}
368						new_container.push(v);
369					}
370					*self = new_container;
371				}
372				_ => unimplemented!(),
373			},
374			Value::Uint(v) => match self {
375				ColumnData::Uint {
376					container,
377					..
378				} => container.push(v),
379				ColumnData::Undefined(container) => {
380					let mut new_container = ColumnData::uint(vec![]);
381					if let ColumnData::Uint {
382						container: new_container,
383						..
384					} = &mut new_container
385					{
386						for _ in 0..container.len() {
387							new_container.push_undefined();
388						}
389						new_container.push(v);
390					}
391					*self = new_container;
392				}
393				_ => unimplemented!(),
394			},
395
396			Value::Decimal(v) => match self {
397				ColumnData::Decimal {
398					container,
399					..
400				} => container.push(v),
401				ColumnData::Undefined(container) => {
402					let mut new_container = ColumnData::decimal(vec![]);
403					if let ColumnData::Decimal {
404						container: new_container,
405						..
406					} = &mut new_container
407					{
408						for _ in 0..container.len() {
409							new_container.push_undefined();
410						}
411						new_container.push(v);
412					}
413					*self = new_container;
414				}
415				_ => unimplemented!(),
416			},
417
418			Value::Any(v) => match self {
419				ColumnData::Any(container) => container.push(v),
420				ColumnData::Undefined(container) => {
421					let mut new_container = ColumnData::any(vec![]);
422					if let ColumnData::Any(new_container) = &mut new_container {
423						for _ in 0..container.len() {
424							new_container.push_undefined();
425						}
426						new_container.push(v);
427					}
428					*self = new_container;
429				}
430				_ => unreachable!("Cannot push Any value to non-Any column"),
431			},
432		}
433	}
434}
435
436#[cfg(test)]
437#[allow(clippy::approx_constant)]
438mod tests {
439	use reifydb_type::{Date, DateTime, Duration, IdentityId, OrderedF32, OrderedF64, Time, Uuid4, Uuid7, Value};
440	use uuid::Uuid;
441
442	use crate::value::column::ColumnData;
443
444	#[test]
445	fn test_bool() {
446		let mut col = ColumnData::bool(vec![true]);
447		col.push_value(Value::Boolean(false));
448		let ColumnData::Bool(container) = col else {
449			panic!("Expected Bool");
450		};
451		assert_eq!(container.data().to_vec(), vec![true, false]);
452		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
453	}
454
455	#[test]
456	fn test_undefined_bool() {
457		let mut col = ColumnData::bool(vec![true]);
458		col.push_value(Value::Undefined);
459		let ColumnData::Bool(container) = col else {
460			panic!("Expected Bool");
461		};
462		assert_eq!(container.data().to_vec(), vec![true, false]);
463		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
464	}
465
466	#[test]
467	fn test_push_value_to_undefined_bool() {
468		let mut col = ColumnData::undefined(2);
469		col.push_value(Value::Boolean(true));
470		let ColumnData::Bool(container) = col else {
471			panic!("Expected Bool");
472		};
473		assert_eq!(container.data().to_vec(), vec![false, false, true]);
474		assert_eq!(container.bitvec().to_vec(), vec![false, false, true]);
475	}
476
477	#[test]
478	fn test_float4() {
479		let mut col = ColumnData::float4(vec![1.0]);
480		col.push_value(Value::Float4(OrderedF32::try_from(2.0).unwrap()));
481		let ColumnData::Float4(container) = col else {
482			panic!("Expected Float4");
483		};
484		assert_eq!(container.data().as_slice(), &[1.0, 2.0]);
485		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
486	}
487
488	#[test]
489	fn test_undefined_float4() {
490		let mut col = ColumnData::float4(vec![1.0]);
491		col.push_value(Value::Undefined);
492		let ColumnData::Float4(container) = col else {
493			panic!("Expected Float4");
494		};
495		assert_eq!(container.data().as_slice(), &[1.0, 0.0]);
496		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
497	}
498
499	#[test]
500	fn test_push_value_to_undefined_float4() {
501		let mut col = ColumnData::undefined(1);
502		col.push_value(Value::Float4(OrderedF32::try_from(3.14).unwrap()));
503		let ColumnData::Float4(container) = col else {
504			panic!("Expected Float4");
505		};
506		assert_eq!(container.data().as_slice(), &[0.0, 3.14]);
507		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
508	}
509
510	#[test]
511	fn test_float8() {
512		let mut col = ColumnData::float8(vec![1.0]);
513		col.push_value(Value::Float8(OrderedF64::try_from(2.0).unwrap()));
514		let ColumnData::Float8(container) = col else {
515			panic!("Expected Float8");
516		};
517		assert_eq!(container.data().as_slice(), &[1.0, 2.0]);
518		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
519	}
520
521	#[test]
522	fn test_undefined_float8() {
523		let mut col = ColumnData::float8(vec![1.0]);
524		col.push_value(Value::Undefined);
525		let ColumnData::Float8(container) = col else {
526			panic!("Expected Float8");
527		};
528		assert_eq!(container.data().as_slice(), &[1.0, 0.0]);
529		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
530	}
531
532	#[test]
533	fn test_push_value_to_undefined_float8() {
534		let mut col = ColumnData::undefined(1);
535		col.push_value(Value::Float8(OrderedF64::try_from(2.718).unwrap()));
536		let ColumnData::Float8(container) = col else {
537			panic!("Expected Float8");
538		};
539		assert_eq!(container.data().as_slice(), &[0.0, 2.718]);
540		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
541	}
542
543	#[test]
544	fn test_int1() {
545		let mut col = ColumnData::int1(vec![1]);
546		col.push_value(Value::Int1(2));
547		let ColumnData::Int1(container) = col else {
548			panic!("Expected Int1");
549		};
550		assert_eq!(container.data().as_slice(), &[1, 2]);
551		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
552	}
553
554	#[test]
555	fn test_undefined_int1() {
556		let mut col = ColumnData::int1(vec![1]);
557		col.push_value(Value::Undefined);
558		let ColumnData::Int1(container) = col else {
559			panic!("Expected Int1");
560		};
561		assert_eq!(container.data().as_slice(), &[1, 0]);
562		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
563	}
564
565	#[test]
566	fn test_push_value_to_undefined_int1() {
567		let mut col = ColumnData::undefined(1);
568		col.push_value(Value::Int1(5));
569		let ColumnData::Int1(container) = col else {
570			panic!("Expected Int1");
571		};
572		assert_eq!(container.data().as_slice(), &[0, 5]);
573		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
574	}
575
576	#[test]
577	fn test_int2() {
578		let mut col = ColumnData::int2(vec![1]);
579		col.push_value(Value::Int2(3));
580		let ColumnData::Int2(container) = col else {
581			panic!("Expected Int2");
582		};
583		assert_eq!(container.data().as_slice(), &[1, 3]);
584		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
585	}
586
587	#[test]
588	fn test_undefined_int2() {
589		let mut col = ColumnData::int2(vec![1]);
590		col.push_value(Value::Undefined);
591		let ColumnData::Int2(container) = col else {
592			panic!("Expected Int2");
593		};
594		assert_eq!(container.data().as_slice(), &[1, 0]);
595		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
596	}
597
598	#[test]
599	fn test_push_value_to_undefined_int2() {
600		let mut col = ColumnData::undefined(1);
601		col.push_value(Value::Int2(10));
602		let ColumnData::Int2(container) = col else {
603			panic!("Expected Int2");
604		};
605		assert_eq!(container.data().as_slice(), &[0, 10]);
606		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
607	}
608
609	#[test]
610	fn test_int4() {
611		let mut col = ColumnData::int4(vec![10]);
612		col.push_value(Value::Int4(20));
613		let ColumnData::Int4(container) = col else {
614			panic!("Expected Int4");
615		};
616		assert_eq!(container.data().as_slice(), &[10, 20]);
617		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
618	}
619
620	#[test]
621	fn test_undefined_int4() {
622		let mut col = ColumnData::int4(vec![10]);
623		col.push_value(Value::Undefined);
624		let ColumnData::Int4(container) = col else {
625			panic!("Expected Int4");
626		};
627		assert_eq!(container.data().as_slice(), &[10, 0]);
628		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
629	}
630
631	#[test]
632	fn test_push_value_to_undefined_int4() {
633		let mut col = ColumnData::undefined(1);
634		col.push_value(Value::Int4(20));
635		let ColumnData::Int4(container) = col else {
636			panic!("Expected Int4");
637		};
638		assert_eq!(container.data().as_slice(), &[0, 20]);
639		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
640	}
641
642	#[test]
643	fn test_int8() {
644		let mut col = ColumnData::int8(vec![100]);
645		col.push_value(Value::Int8(200));
646		let ColumnData::Int8(container) = col else {
647			panic!("Expected Int8");
648		};
649		assert_eq!(container.data().as_slice(), &[100, 200]);
650		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
651	}
652
653	#[test]
654	fn test_undefined_int8() {
655		let mut col = ColumnData::int8(vec![100]);
656		col.push_value(Value::Undefined);
657		let ColumnData::Int8(container) = col else {
658			panic!("Expected Int8");
659		};
660		assert_eq!(container.data().as_slice(), &[100, 0]);
661		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
662	}
663
664	#[test]
665	fn test_push_value_to_undefined_int8() {
666		let mut col = ColumnData::undefined(1);
667		col.push_value(Value::Int8(30));
668		let ColumnData::Int8(container) = col else {
669			panic!("Expected Int8");
670		};
671		assert_eq!(container.data().as_slice(), &[0, 30]);
672		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
673	}
674
675	#[test]
676	fn test_int16() {
677		let mut col = ColumnData::int16(vec![1000]);
678		col.push_value(Value::Int16(2000));
679		let ColumnData::Int16(container) = col else {
680			panic!("Expected Int16");
681		};
682		assert_eq!(container.data().as_slice(), &[1000, 2000]);
683		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
684	}
685
686	#[test]
687	fn test_undefined_int16() {
688		let mut col = ColumnData::int16(vec![1000]);
689		col.push_value(Value::Undefined);
690		let ColumnData::Int16(container) = col else {
691			panic!("Expected Int16");
692		};
693		assert_eq!(container.data().as_slice(), &[1000, 0]);
694		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
695	}
696
697	#[test]
698	fn test_push_value_to_undefined_int16() {
699		let mut col = ColumnData::undefined(1);
700		col.push_value(Value::Int16(40));
701		let ColumnData::Int16(container) = col else {
702			panic!("Expected Int16");
703		};
704		assert_eq!(container.data().as_slice(), &[0, 40]);
705		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
706	}
707
708	#[test]
709	fn test_uint1() {
710		let mut col = ColumnData::uint1(vec![1]);
711		col.push_value(Value::Uint1(2));
712		let ColumnData::Uint1(container) = col else {
713			panic!("Expected Uint1");
714		};
715		assert_eq!(container.data().as_slice(), &[1, 2]);
716		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
717	}
718
719	#[test]
720	fn test_undefined_uint1() {
721		let mut col = ColumnData::uint1(vec![1]);
722		col.push_value(Value::Undefined);
723		let ColumnData::Uint1(container) = col else {
724			panic!("Expected Uint1");
725		};
726		assert_eq!(container.data().as_slice(), &[1, 0]);
727		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
728	}
729
730	#[test]
731	fn test_push_value_to_undefined_uint1() {
732		let mut col = ColumnData::undefined(1);
733		col.push_value(Value::Uint1(1));
734		let ColumnData::Uint1(container) = col else {
735			panic!("Expected Uint1");
736		};
737		assert_eq!(container.data().as_slice(), &[0, 1]);
738		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
739	}
740
741	#[test]
742	fn test_uint2() {
743		let mut col = ColumnData::uint2(vec![10]);
744		col.push_value(Value::Uint2(20));
745		let ColumnData::Uint2(container) = col else {
746			panic!("Expected Uint2");
747		};
748		assert_eq!(container.data().as_slice(), &[10, 20]);
749		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
750	}
751
752	#[test]
753	fn test_undefined_uint2() {
754		let mut col = ColumnData::uint2(vec![10]);
755		col.push_value(Value::Undefined);
756		let ColumnData::Uint2(container) = col else {
757			panic!("Expected Uint2");
758		};
759		assert_eq!(container.data().as_slice(), &[10, 0]);
760		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
761	}
762
763	#[test]
764	fn test_push_value_to_undefined_uint2() {
765		let mut col = ColumnData::undefined(1);
766		col.push_value(Value::Uint2(2));
767		let ColumnData::Uint2(container) = col else {
768			panic!("Expected Uint2");
769		};
770		assert_eq!(container.data().as_slice(), &[0, 2]);
771		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
772	}
773
774	#[test]
775	fn test_uint4() {
776		let mut col = ColumnData::uint4(vec![100]);
777		col.push_value(Value::Uint4(200));
778		let ColumnData::Uint4(container) = col else {
779			panic!("Expected Uint4");
780		};
781		assert_eq!(container.data().as_slice(), &[100, 200]);
782		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
783	}
784
785	#[test]
786	fn test_undefined_uint4() {
787		let mut col = ColumnData::uint4(vec![100]);
788		col.push_value(Value::Undefined);
789		let ColumnData::Uint4(container) = col else {
790			panic!("Expected Uint4");
791		};
792		assert_eq!(container.data().as_slice(), &[100, 0]);
793		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
794	}
795
796	#[test]
797	fn test_push_value_to_undefined_uint4() {
798		let mut col = ColumnData::undefined(1);
799		col.push_value(Value::Uint4(3));
800		let ColumnData::Uint4(container) = col else {
801			panic!("Expected Uint4");
802		};
803		assert_eq!(container.data().as_slice(), &[0, 3]);
804		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
805	}
806
807	#[test]
808	fn test_uint8() {
809		let mut col = ColumnData::uint8(vec![1000]);
810		col.push_value(Value::Uint8(2000));
811		let ColumnData::Uint8(container) = col else {
812			panic!("Expected Uint8");
813		};
814		assert_eq!(container.data().as_slice(), &[1000, 2000]);
815		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
816	}
817
818	#[test]
819	fn test_undefined_uint8() {
820		let mut col = ColumnData::uint8(vec![1000]);
821		col.push_value(Value::Undefined);
822		let ColumnData::Uint8(container) = col else {
823			panic!("Expected Uint8");
824		};
825		assert_eq!(container.data().as_slice(), &[1000, 0]);
826		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
827	}
828
829	#[test]
830	fn test_push_value_to_undefined_uint8() {
831		let mut col = ColumnData::undefined(1);
832		col.push_value(Value::Uint8(4));
833		let ColumnData::Uint8(container) = col else {
834			panic!("Expected Uint8");
835		};
836		assert_eq!(container.data().as_slice(), &[0, 4]);
837		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
838	}
839
840	#[test]
841	fn test_uint16() {
842		let mut col = ColumnData::uint16(vec![10000]);
843		col.push_value(Value::Uint16(20000));
844		let ColumnData::Uint16(container) = col else {
845			panic!("Expected Uint16");
846		};
847		assert_eq!(container.data().as_slice(), &[10000, 20000]);
848		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
849	}
850
851	#[test]
852	fn test_undefined_uint16() {
853		let mut col = ColumnData::uint16(vec![10000]);
854		col.push_value(Value::Undefined);
855		let ColumnData::Uint16(container) = col else {
856			panic!("Expected Uint16");
857		};
858		assert_eq!(container.data().as_slice(), &[10000, 0]);
859		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
860	}
861
862	#[test]
863	fn test_push_value_to_undefined_uint16() {
864		let mut col = ColumnData::undefined(1);
865		col.push_value(Value::Uint16(5));
866		let ColumnData::Uint16(container) = col else {
867			panic!("Expected Uint16");
868		};
869		assert_eq!(container.data().as_slice(), &[0, 5]);
870		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
871	}
872
873	#[test]
874	fn test_utf8() {
875		let mut col = ColumnData::utf8(vec!["hello".to_string()]);
876		col.push_value(Value::Utf8("world".to_string()));
877		let ColumnData::Utf8 {
878			container,
879			..
880		} = col
881		else {
882			panic!("Expected Utf8");
883		};
884		assert_eq!(container.data().as_slice(), &["hello".to_string(), "world".to_string()]);
885		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
886	}
887
888	#[test]
889	fn test_undefined_utf8() {
890		let mut col = ColumnData::utf8(vec!["hello".to_string()]);
891		col.push_value(Value::Undefined);
892		let ColumnData::Utf8 {
893			container,
894			..
895		} = col
896		else {
897			panic!("Expected Utf8");
898		};
899		assert_eq!(container.data().as_slice(), &["hello".to_string(), "".to_string()]);
900		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
901	}
902
903	#[test]
904	fn test_push_value_to_undefined_utf8() {
905		let mut col = ColumnData::undefined(1);
906		col.push_value(Value::Utf8("ok".to_string()));
907		let ColumnData::Utf8 {
908			container,
909			..
910		} = col
911		else {
912			panic!("Expected Utf8");
913		};
914		assert_eq!(container.data().as_slice(), &["".to_string(), "ok".to_string()]);
915		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
916	}
917
918	#[test]
919	fn test_undefined() {
920		let mut col = ColumnData::int2(vec![1]);
921		col.push_value(Value::Undefined);
922		let ColumnData::Int2(container) = col else {
923			panic!("Expected Int2");
924		};
925		assert_eq!(container.data().as_slice(), &[1, 0]);
926		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
927	}
928
929	#[test]
930	fn test_date() {
931		let date1 = Date::from_ymd(2023, 1, 1).unwrap();
932		let date2 = Date::from_ymd(2023, 12, 31).unwrap();
933		let mut col = ColumnData::date(vec![date1]);
934		col.push_value(Value::Date(date2));
935		let ColumnData::Date(container) = col else {
936			panic!("Expected Date");
937		};
938		assert_eq!(container.data().as_slice(), &[date1, date2]);
939		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
940	}
941
942	#[test]
943	fn test_undefined_date() {
944		let date1 = Date::from_ymd(2023, 1, 1).unwrap();
945		let mut col = ColumnData::date(vec![date1]);
946		col.push_value(Value::Undefined);
947		let ColumnData::Date(container) = col else {
948			panic!("Expected Date");
949		};
950		assert_eq!(container.data().as_slice(), &[date1, Date::default()]);
951		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
952	}
953
954	#[test]
955	fn test_push_value_to_undefined_date() {
956		let date = Date::from_ymd(2023, 6, 15).unwrap();
957		let mut col = ColumnData::undefined(1);
958		col.push_value(Value::Date(date));
959		let ColumnData::Date(container) = col else {
960			panic!("Expected Date");
961		};
962		assert_eq!(container.data().as_slice(), &[Date::default(), date]);
963		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
964	}
965
966	#[test]
967	fn test_datetime() {
968		let dt1 = DateTime::from_timestamp(1672531200).unwrap(); // 2023-01-01 00:00:00 SVTC
969		let dt2 = DateTime::from_timestamp(1704067200).unwrap(); // 2024-01-01 00:00:00 SVTC
970		let mut col = ColumnData::datetime(vec![dt1]);
971		col.push_value(Value::DateTime(dt2));
972		let ColumnData::DateTime(container) = col else {
973			panic!("Expected DateTime");
974		};
975		assert_eq!(container.data().as_slice(), &[dt1, dt2]);
976		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
977	}
978
979	#[test]
980	fn test_undefined_datetime() {
981		use DateTime;
982		let dt1 = DateTime::from_timestamp(1672531200).unwrap();
983		let mut col = ColumnData::datetime(vec![dt1]);
984		col.push_value(Value::Undefined);
985		let ColumnData::DateTime(container) = col else {
986			panic!("Expected DateTime");
987		};
988		assert_eq!(container.data().as_slice(), &[dt1, DateTime::default()]);
989		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
990	}
991
992	#[test]
993	fn test_push_value_to_undefined_datetime() {
994		let dt = DateTime::from_timestamp(1672531200).unwrap();
995		let mut col = ColumnData::undefined(1);
996		col.push_value(Value::DateTime(dt));
997		let ColumnData::DateTime(container) = col else {
998			panic!("Expected DateTime");
999		};
1000		assert_eq!(container.data().as_slice(), &[DateTime::default(), dt]);
1001		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
1002	}
1003
1004	#[test]
1005	fn test_time() {
1006		let time1 = Time::from_hms(12, 30, 0).unwrap();
1007		let time2 = Time::from_hms(18, 45, 30).unwrap();
1008		let mut col = ColumnData::time(vec![time1]);
1009		col.push_value(Value::Time(time2));
1010		let ColumnData::Time(container) = col else {
1011			panic!("Expected Time");
1012		};
1013		assert_eq!(container.data().as_slice(), &[time1, time2]);
1014		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
1015	}
1016
1017	#[test]
1018	fn test_undefined_time() {
1019		let time1 = Time::from_hms(12, 30, 0).unwrap();
1020		let mut col = ColumnData::time(vec![time1]);
1021		col.push_value(Value::Undefined);
1022		let ColumnData::Time(container) = col else {
1023			panic!("Expected Time");
1024		};
1025		assert_eq!(container.data().as_slice(), &[time1, Time::default()]);
1026		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
1027	}
1028
1029	#[test]
1030	fn test_push_value_to_undefined_time() {
1031		let time = Time::from_hms(15, 20, 10).unwrap();
1032		let mut col = ColumnData::undefined(1);
1033		col.push_value(Value::Time(time));
1034		let ColumnData::Time(container) = col else {
1035			panic!("Expected Time");
1036		};
1037		assert_eq!(container.data().as_slice(), &[Time::default(), time]);
1038		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
1039	}
1040
1041	#[test]
1042	fn test_duration() {
1043		let duration1 = Duration::from_days(30);
1044		let duration2 = Duration::from_hours(24);
1045		let mut col = ColumnData::duration(vec![duration1]);
1046		col.push_value(Value::Duration(duration2));
1047		let ColumnData::Duration(container) = col else {
1048			panic!("Expected Duration");
1049		};
1050		assert_eq!(container.data().as_slice(), &[duration1, duration2]);
1051		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
1052	}
1053
1054	#[test]
1055	fn test_undefined_duration() {
1056		let duration1 = Duration::from_days(30);
1057		let mut col = ColumnData::duration(vec![duration1]);
1058		col.push_value(Value::Undefined);
1059		let ColumnData::Duration(container) = col else {
1060			panic!("Expected Duration");
1061		};
1062		assert_eq!(container.data().as_slice(), &[duration1, Duration::default()]);
1063		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
1064	}
1065
1066	#[test]
1067	fn test_push_value_to_undefined_duration() {
1068		let duration = Duration::from_minutes(90);
1069		let mut col = ColumnData::undefined(1);
1070		col.push_value(Value::Duration(duration));
1071		let ColumnData::Duration(container) = col else {
1072			panic!("Expected Duration");
1073		};
1074		assert_eq!(container.data().as_slice(), &[Duration::default(), duration]);
1075		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
1076	}
1077
1078	#[test]
1079	fn test_identity_id() {
1080		let id1 = IdentityId::generate();
1081		let id2 = IdentityId::generate();
1082		let mut col = ColumnData::identity_id(vec![id1]);
1083		col.push_value(Value::IdentityId(id2));
1084		let ColumnData::IdentityId(container) = col else {
1085			panic!("Expected IdentityId");
1086		};
1087		assert_eq!(container.data().as_slice(), &[id1, id2]);
1088		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
1089	}
1090
1091	#[test]
1092	fn test_undefined_identity_id() {
1093		let id1 = IdentityId::generate();
1094		let mut col = ColumnData::identity_id(vec![id1]);
1095		col.push_value(Value::Undefined);
1096		let ColumnData::IdentityId(container) = col else {
1097			panic!("Expected IdentityId");
1098		};
1099		assert_eq!(container.data().as_slice(), &[id1, IdentityId::default()]);
1100		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
1101	}
1102
1103	#[test]
1104	fn test_push_value_to_undefined_identity_id() {
1105		let id = IdentityId::generate();
1106		let mut col = ColumnData::undefined(1);
1107		col.push_value(Value::IdentityId(id));
1108		let ColumnData::IdentityId(container) = col else {
1109			panic!("Expected IdentityId");
1110		};
1111		assert_eq!(container.data().as_slice(), &[IdentityId::default(), id]);
1112		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
1113	}
1114
1115	#[test]
1116	fn test_uuid4() {
1117		let uuid1 = Uuid4::generate();
1118		let uuid2 = Uuid4::generate();
1119		let mut col = ColumnData::uuid4(vec![uuid1]);
1120		col.push_value(Value::Uuid4(uuid2));
1121		let ColumnData::Uuid4(container) = col else {
1122			panic!("Expected Uuid4");
1123		};
1124		assert_eq!(container.data().as_slice(), &[uuid1, uuid2]);
1125		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
1126	}
1127
1128	#[test]
1129	fn test_undefined_uuid4() {
1130		let uuid1 = Uuid4::generate();
1131		let mut col = ColumnData::uuid4(vec![uuid1]);
1132		col.push_value(Value::Undefined);
1133		let ColumnData::Uuid4(container) = col else {
1134			panic!("Expected Uuid4");
1135		};
1136		assert_eq!(container.data().as_slice(), &[uuid1, Uuid4::from(Uuid::nil())]);
1137		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
1138	}
1139
1140	#[test]
1141	fn test_push_value_to_undefined_uuid4() {
1142		let uuid = Uuid4::generate();
1143		let mut col = ColumnData::undefined(1);
1144		col.push_value(Value::Uuid4(uuid));
1145		let ColumnData::Uuid4(container) = col else {
1146			panic!("Expected Uuid4");
1147		};
1148		assert_eq!(container.data().as_slice(), &[Uuid4::from(Uuid::nil()), uuid]);
1149		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
1150	}
1151
1152	#[test]
1153	fn test_uuid7() {
1154		let uuid1 = Uuid7::generate();
1155		let uuid2 = Uuid7::generate();
1156		let mut col = ColumnData::uuid7(vec![uuid1]);
1157		col.push_value(Value::Uuid7(uuid2));
1158		let ColumnData::Uuid7(container) = col else {
1159			panic!("Expected Uuid7");
1160		};
1161		assert_eq!(container.data().as_slice(), &[uuid1, uuid2]);
1162		assert_eq!(container.bitvec().to_vec(), vec![true, true]);
1163	}
1164
1165	#[test]
1166	fn test_undefined_uuid7() {
1167		let uuid1 = Uuid7::generate();
1168		let mut col = ColumnData::uuid7(vec![uuid1]);
1169		col.push_value(Value::Undefined);
1170		let ColumnData::Uuid7(container) = col else {
1171			panic!("Expected Uuid7");
1172		};
1173		assert_eq!(container.data().as_slice(), &[uuid1, Uuid7::from(Uuid::nil())]);
1174		assert_eq!(container.bitvec().to_vec(), vec![true, false]);
1175	}
1176
1177	#[test]
1178	fn test_push_value_to_undefined_uuid7() {
1179		let uuid = Uuid7::generate();
1180		let mut col = ColumnData::undefined(1);
1181		col.push_value(Value::Uuid7(uuid));
1182		let ColumnData::Uuid7(container) = col else {
1183			panic!("Expected Uuid7");
1184		};
1185		assert_eq!(container.data().as_slice(), &[Uuid7::from(Uuid::nil()), uuid]);
1186		assert_eq!(container.bitvec().to_vec(), vec![false, true]);
1187	}
1188}
reifydb_core/value/column/push/value.rs

reifydb_core/value/column/push/
value.rs
