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

reifydb_core/value/column/push/
value.rs
