reifydb_core/value/column/push/
value.rs

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

reifydb_core/value/column/push/
value.rs
