reifydb_core/value/column/transform/
append.rs

1// Copyright (c) reifydb.com 2025
2// This file is licensed under the AGPL-3.0-or-later, see license.md file
3
4use reifydb_type::{
5	Blob, Date, DateTime, Decimal, Duration, Int, Time, Type, Uint, Uuid4, Uuid7, diagnostic::engine, return_error,
6};
7
8use crate::{
9	BitVec,
10	value::{
11		column::{ColumnData, Columns},
12		encoded::{EncodedValues, EncodedValuesLayout},
13	},
14};
15
16impl<'a> Columns<'a> {
17	pub fn append_columns(&mut self, other: Columns<'a>) -> crate::Result<()> {
18		if self.len() != other.len() {
19			return_error!(engine::frame_error("mismatched column count".to_string()));
20		}
21
22		// Append encoded numbers from the other columns
23		if !other.row_numbers.is_empty() {
24			self.row_numbers.make_mut().extend(other.row_numbers.iter().copied());
25		}
26
27		let columns = self.columns.make_mut();
28		for (i, (l, r)) in columns.iter_mut().zip(other.columns.into_iter()).enumerate() {
29			if l.name() != r.name() {
30				return_error!(engine::frame_error(format!(
31					"column name mismatch at index {}: '{}' vs '{}'",
32					i,
33					l.name().text(),
34					r.name().text(),
35				)));
36			}
37			l.extend(r)?;
38		}
39		Ok(())
40	}
41}
42
43impl<'a> Columns<'a> {
44	pub fn append_rows(
45		&mut self,
46		layout: &EncodedValuesLayout,
47		rows: impl IntoIterator<Item = EncodedValues>,
48		row_numbers: Vec<reifydb_type::RowNumber>,
49	) -> crate::Result<()> {
50		if self.len() != layout.fields.len() {
51			return_error!(engine::frame_error(format!(
52				"mismatched column count: expected {}, got {}",
53				self.len(),
54				layout.fields.len()
55			)));
56		}
57
58		let rows: Vec<EncodedValues> = rows.into_iter().collect();
59
60		// Verify row_numbers length if provided
61		if !row_numbers.is_empty() && row_numbers.len() != rows.len() {
62			return_error!(engine::frame_error(format!(
63				"row_numbers length {} does not match rows length {}",
64				row_numbers.len(),
65				rows.len()
66			)));
67		}
68
69		// Append encoded numbers if provided
70		if !row_numbers.is_empty() {
71			self.row_numbers.make_mut().extend(row_numbers);
72		}
73
74		let values = layout.fields.iter().map(|f| f.r#type.clone()).collect::<Vec<_>>();
75		let layout = EncodedValuesLayout::new(&values);
76
77		// if there is an undefined column and the new data contains
78		// defined data convert this column into the new type and fill
79		// the undefined part
80		let columns = self.columns.make_mut();
81		for (index, column) in columns.iter_mut().enumerate() {
82			if let ColumnData::Undefined(container) = column.data() {
83				let size = container.len();
84				let new_data = match layout.value(index) {
85					Type::Boolean => ColumnData::bool_with_bitvec(
86						vec![false; size],
87						BitVec::repeat(size, false),
88					),
89					Type::Float4 => ColumnData::float4_with_bitvec(
90						vec![0.0f32; size],
91						BitVec::repeat(size, false),
92					),
93					Type::Float8 => ColumnData::float8_with_bitvec(
94						vec![0.0f64; size],
95						BitVec::repeat(size, false),
96					),
97					Type::Int1 => ColumnData::int1_with_bitvec(
98						vec![0i8; size],
99						BitVec::repeat(size, false),
100					),
101					Type::Int2 => ColumnData::int2_with_bitvec(
102						vec![0i16; size],
103						BitVec::repeat(size, false),
104					),
105					Type::Int4 => ColumnData::int4_with_bitvec(
106						vec![0i32; size],
107						BitVec::repeat(size, false),
108					),
109					Type::Int8 => ColumnData::int8_with_bitvec(
110						vec![0i64; size],
111						BitVec::repeat(size, false),
112					),
113					Type::Int16 => ColumnData::int16_with_bitvec(
114						vec![0i128; size],
115						BitVec::repeat(size, false),
116					),
117					Type::Utf8 => ColumnData::utf8_with_bitvec(
118						vec![String::new(); size],
119						BitVec::repeat(size, false),
120					),
121					Type::Uint1 => ColumnData::uint1_with_bitvec(
122						vec![0u8; size],
123						BitVec::repeat(size, false),
124					),
125					Type::Uint2 => ColumnData::uint2_with_bitvec(
126						vec![0u16; size],
127						BitVec::repeat(size, false),
128					),
129					Type::Uint4 => ColumnData::uint4_with_bitvec(
130						vec![0u32; size],
131						BitVec::repeat(size, false),
132					),
133					Type::Uint8 => ColumnData::uint8_with_bitvec(
134						vec![0u64; size],
135						BitVec::repeat(size, false),
136					),
137					Type::Uint16 => ColumnData::uint16_with_bitvec(
138						vec![0u128; size],
139						BitVec::repeat(size, false),
140					),
141					Type::Date => ColumnData::date_with_bitvec(
142						vec![Date::default(); size],
143						BitVec::repeat(size, false),
144					),
145					Type::DateTime => ColumnData::datetime_with_bitvec(
146						vec![DateTime::default(); size],
147						BitVec::repeat(size, false),
148					),
149					Type::Time => ColumnData::time_with_bitvec(
150						vec![Time::default(); size],
151						BitVec::repeat(size, false),
152					),
153					Type::Duration => ColumnData::duration_with_bitvec(
154						vec![Duration::default(); size],
155						BitVec::repeat(size, false),
156					),
157					Type::Undefined => column.data().clone(),
158					Type::RowNumber => ColumnData::row_number_with_bitvec(
159						vec![Default::default(); size],
160						BitVec::repeat(size, false),
161					),
162					Type::IdentityId => ColumnData::identity_id_with_bitvec(
163						vec![Default::default(); size],
164						BitVec::repeat(size, false),
165					),
166					Type::Uuid4 => ColumnData::uuid4_with_bitvec(
167						vec![Uuid4::from(uuid::Uuid::nil()); size],
168						BitVec::repeat(size, false),
169					),
170					Type::Uuid7 => ColumnData::uuid7_with_bitvec(
171						vec![Uuid7::from(uuid::Uuid::nil()); size],
172						BitVec::repeat(size, false),
173					),
174					Type::Blob => ColumnData::blob_with_bitvec(
175						vec![Blob::new(vec![]); size],
176						BitVec::repeat(size, false),
177					),
178					Type::Int => ColumnData::int_with_bitvec(
179						vec![Int::default(); size],
180						BitVec::repeat(size, false),
181					),
182					Type::Uint => ColumnData::uint_with_bitvec(
183						vec![Uint::default(); size],
184						BitVec::repeat(size, false),
185					),
186					Type::Decimal {
187						..
188					} => ColumnData::decimal_with_bitvec(
189						vec![Decimal::from(0); size],
190						BitVec::repeat(size, false),
191					),
192					Type::Any => ColumnData::any_with_bitvec(
193						vec![Box::new(reifydb_type::Value::Undefined); size],
194						BitVec::repeat(size, false),
195					),
196				};
197
198				*column = column.with_new_data(new_data);
199			}
200		}
201
202		for row in &rows {
203			if layout.all_defined(&row) {
204				// if all columns in the encoded are defined, then
205				// we can take a simpler implementation
206				self.append_all_defined(&layout, &row)?;
207			} else {
208				// at least one column is undefined
209				self.append_fallback(&layout, &row)?;
210			}
211		}
212
213		Ok(())
214	}
215
216	fn append_all_defined(&mut self, layout: &EncodedValuesLayout, row: &EncodedValues) -> crate::Result<()> {
217		let columns = self.columns.make_mut();
218		for (index, column) in columns.iter_mut().enumerate() {
219			match (column.data_mut(), layout.value(index)) {
220				(ColumnData::Bool(container), Type::Boolean) => {
221					container.push(layout.get_bool(&row, index));
222				}
223				(ColumnData::Float4(container), Type::Float4) => {
224					container.push(layout.get_f32(&row, index));
225				}
226				(ColumnData::Float8(container), Type::Float8) => {
227					container.push(layout.get_f64(&row, index));
228				}
229				(ColumnData::Int1(container), Type::Int1) => {
230					container.push(layout.get_i8(&row, index));
231				}
232				(ColumnData::Int2(container), Type::Int2) => {
233					container.push(layout.get_i16(&row, index));
234				}
235				(ColumnData::Int4(container), Type::Int4) => {
236					container.push(layout.get_i32(&row, index));
237				}
238				(ColumnData::Int8(container), Type::Int8) => {
239					container.push(layout.get_i64(&row, index));
240				}
241				(ColumnData::Int16(container), Type::Int16) => {
242					container.push(layout.get_i128(&row, index));
243				}
244				(
245					ColumnData::Utf8 {
246						container,
247						..
248					},
249					Type::Utf8,
250				) => {
251					container.push(layout.get_utf8(&row, index).to_string());
252				}
253				(ColumnData::Uint1(container), Type::Uint1) => {
254					container.push(layout.get_u8(&row, index));
255				}
256				(ColumnData::Uint2(container), Type::Uint2) => {
257					container.push(layout.get_u16(&row, index));
258				}
259				(ColumnData::Uint4(container), Type::Uint4) => {
260					container.push(layout.get_u32(&row, index));
261				}
262				(ColumnData::Uint8(container), Type::Uint8) => {
263					container.push(layout.get_u64(&row, index));
264				}
265				(ColumnData::Uint16(container), Type::Uint16) => {
266					container.push(layout.get_u128(&row, index));
267				}
268				(ColumnData::Date(container), Type::Date) => {
269					container.push(layout.get_date(&row, index));
270				}
271				(ColumnData::DateTime(container), Type::DateTime) => {
272					container.push(layout.get_datetime(&row, index));
273				}
274				(ColumnData::Time(container), Type::Time) => {
275					container.push(layout.get_time(&row, index));
276				}
277				(ColumnData::Duration(container), Type::Duration) => {
278					container.push(layout.get_duration(&row, index));
279				}
280				(ColumnData::Uuid4(container), Type::Uuid4) => {
281					container.push(layout.get_uuid4(&row, index));
282				}
283				(ColumnData::Uuid7(container), Type::Uuid7) => {
284					container.push(layout.get_uuid7(&row, index));
285				}
286				(
287					ColumnData::Blob {
288						container,
289						..
290					},
291					Type::Blob,
292				) => {
293					container.push(layout.get_blob(&row, index));
294				}
295				(
296					ColumnData::Int {
297						container,
298						..
299					},
300					Type::Int,
301				) => {
302					container.push(layout.get_int(&row, index));
303				}
304				(
305					ColumnData::Uint {
306						container,
307						..
308					},
309					Type::Uint,
310				) => {
311					container.push(layout.get_uint(&row, index));
312				}
313				(
314					ColumnData::Decimal {
315						container,
316						..
317					},
318					Type::Decimal {
319						..
320					},
321				) => {
322					container.push(layout.get_decimal(&row, index));
323				}
324				(_, v) => {
325					return_error!(engine::frame_error(format!(
326						"type mismatch for column '{}'({}): incompatible with value {}",
327						column.name().text(),
328						column.data().get_type(),
329						v
330					)));
331				}
332			}
333		}
334		Ok(())
335	}
336
337	fn append_fallback(&mut self, layout: &EncodedValuesLayout, row: &EncodedValues) -> crate::Result<()> {
338		let columns = self.columns.make_mut();
339		for (index, column) in columns.iter_mut().enumerate() {
340			match (column.data_mut(), layout.value(index)) {
341				(ColumnData::Bool(container), Type::Boolean) => match layout.try_get_bool(row, index) {
342					Some(v) => container.push(v),
343					None => container.push_undefined(),
344				},
345				(ColumnData::Float4(container), Type::Float4) => match layout.try_get_f32(row, index) {
346					Some(v) => container.push(v),
347					None => container.push_undefined(),
348				},
349				(ColumnData::Float8(container), Type::Float8) => match layout.try_get_f64(row, index) {
350					Some(v) => container.push(v),
351					None => container.push_undefined(),
352				},
353				(ColumnData::Int1(container), Type::Int1) => match layout.try_get_i8(row, index) {
354					Some(v) => container.push(v),
355					None => container.push_undefined(),
356				},
357				(ColumnData::Int2(container), Type::Int2) => match layout.try_get_i16(row, index) {
358					Some(v) => container.push(v),
359					None => container.push_undefined(),
360				},
361				(ColumnData::Int4(container), Type::Int4) => match layout.try_get_i32(row, index) {
362					Some(v) => container.push(v),
363					None => container.push_undefined(),
364				},
365				(ColumnData::Int8(container), Type::Int8) => match layout.try_get_i64(row, index) {
366					Some(v) => container.push(v),
367					None => container.push_undefined(),
368				},
369				(ColumnData::Int16(container), Type::Int16) => match layout.try_get_i128(row, index) {
370					Some(v) => container.push(v),
371					None => container.push_undefined(),
372				},
373				(
374					ColumnData::Utf8 {
375						container,
376						..
377					},
378					Type::Utf8,
379				) => match layout.try_get_utf8(row, index) {
380					Some(v) => container.push(v.to_string()),
381					None => container.push_undefined(),
382				},
383				(ColumnData::Uint1(container), Type::Uint1) => match layout.try_get_u8(row, index) {
384					Some(v) => container.push(v),
385					None => container.push_undefined(),
386				},
387				(ColumnData::Uint2(container), Type::Uint2) => match layout.try_get_u16(row, index) {
388					Some(v) => container.push(v),
389					None => container.push_undefined(),
390				},
391				(ColumnData::Uint4(container), Type::Uint4) => match layout.try_get_u32(row, index) {
392					Some(v) => container.push(v),
393					None => container.push_undefined(),
394				},
395				(ColumnData::Uint8(container), Type::Uint8) => match layout.try_get_u64(row, index) {
396					Some(v) => container.push(v),
397					None => container.push_undefined(),
398				},
399				(ColumnData::Uint16(container), Type::Uint16) => {
400					match layout.try_get_u128(row, index) {
401						Some(v) => container.push(v),
402						None => container.push_undefined(),
403					}
404				}
405				(ColumnData::Date(container), Type::Date) => match layout.try_get_date(row, index) {
406					Some(v) => container.push(v),
407					None => container.push_undefined(),
408				},
409				(ColumnData::DateTime(container), Type::DateTime) => {
410					match layout.try_get_datetime(row, index) {
411						Some(v) => container.push(v),
412						None => container.push_undefined(),
413					}
414				}
415				(ColumnData::Time(container), Type::Time) => match layout.try_get_time(row, index) {
416					Some(v) => container.push(v),
417					None => container.push_undefined(),
418				},
419				(ColumnData::Duration(container), Type::Duration) => {
420					match layout.try_get_duration(row, index) {
421						Some(v) => container.push(v),
422						None => container.push_undefined(),
423					}
424				}
425				(ColumnData::Uuid4(container), Type::Uuid4) => match layout.try_get_uuid4(row, index) {
426					Some(v) => container.push(v),
427					None => container.push_undefined(),
428				},
429				(ColumnData::Uuid7(container), Type::Uuid7) => match layout.try_get_uuid7(row, index) {
430					Some(v) => container.push(v),
431					None => container.push_undefined(),
432				},
433				(
434					ColumnData::Int {
435						container,
436						..
437					},
438					Type::Int,
439				) => match layout.try_get_int(row, index) {
440					Some(v) => container.push(v),
441					None => container.push_undefined(),
442				},
443				(
444					ColumnData::Uint {
445						container,
446						..
447					},
448					Type::Uint,
449				) => match layout.try_get_uint(row, index) {
450					Some(v) => container.push(v),
451					None => container.push_undefined(),
452				},
453				(
454					ColumnData::Decimal {
455						container,
456						..
457					},
458					Type::Decimal {
459						..
460					},
461				) => match layout.try_get_decimal(row, index) {
462					Some(v) => container.push(v),
463					None => container.push_undefined(),
464				},
465				(ColumnData::Undefined(container), Type::Undefined) => {
466					container.push_undefined();
467				}
468				(l, r) => unreachable!("{:#?} {:#?}", l, r),
469			}
470		}
471		Ok(())
472	}
473}
474
475#[cfg(test)]
476mod tests {
477	mod columns {
478		use reifydb_type::{RowNumber, Uuid4, Uuid7};
479		use uuid::{Timestamp, Uuid};
480
481		use crate::value::column::{Column, ColumnData, Columns};
482
483		#[test]
484		fn test_boolean() {
485			let mut test_instance1 = Columns::new(vec![Column::bool_with_bitvec("id", [true], [false])]);
486
487			let test_instance2 = Columns::new(vec![Column::bool_with_bitvec("id", [false], [true])]);
488
489			test_instance1.append_columns(test_instance2).unwrap();
490
491			assert_eq!(
492				test_instance1[0].data(),
493				&ColumnData::bool_with_bitvec([true, false], [false, true])
494			);
495		}
496
497		#[test]
498		fn test_float4() {
499			let mut test_instance1 = Columns::new(vec![Column::float4("id", [1.0f32, 2.0])]);
500
501			let test_instance2 =
502				Columns::new(vec![Column::float4_with_bitvec("id", [3.0f32, 4.0], [true, false])]);
503
504			test_instance1.append_columns(test_instance2).unwrap();
505
506			assert_eq!(
507				test_instance1[0].data(),
508				&ColumnData::float4_with_bitvec([1.0f32, 2.0, 3.0, 4.0], [true, true, true, false])
509			);
510		}
511
512		#[test]
513		fn test_float8() {
514			let mut test_instance1 = Columns::new(vec![Column::float8("id", [1.0f64, 2.0])]);
515
516			let test_instance2 =
517				Columns::new(vec![Column::float8_with_bitvec("id", [3.0f64, 4.0], [true, false])]);
518
519			test_instance1.append_columns(test_instance2).unwrap();
520
521			assert_eq!(
522				test_instance1[0].data(),
523				&ColumnData::float8_with_bitvec([1.0f64, 2.0, 3.0, 4.0], [true, true, true, false])
524			);
525		}
526
527		#[test]
528		fn test_int1() {
529			let mut test_instance1 = Columns::new(vec![Column::int1("id", [1, 2])]);
530
531			let test_instance2 = Columns::new(vec![Column::int1_with_bitvec("id", [3, 4], [true, false])]);
532
533			test_instance1.append_columns(test_instance2).unwrap();
534
535			assert_eq!(
536				test_instance1[0].data(),
537				&ColumnData::int1_with_bitvec([1, 2, 3, 4], [true, true, true, false])
538			);
539		}
540
541		#[test]
542		fn test_int2() {
543			let mut test_instance1 = Columns::new(vec![Column::int2("id", [1, 2])]);
544
545			let test_instance2 = Columns::new(vec![Column::int2_with_bitvec("id", [3, 4], [true, false])]);
546
547			test_instance1.append_columns(test_instance2).unwrap();
548
549			assert_eq!(
550				test_instance1[0].data(),
551				&ColumnData::int2_with_bitvec([1, 2, 3, 4], [true, true, true, false])
552			);
553		}
554
555		#[test]
556		fn test_int4() {
557			let mut test_instance1 = Columns::new(vec![Column::int4("id", [1, 2])]);
558
559			let test_instance2 = Columns::new(vec![Column::int4_with_bitvec("id", [3, 4], [true, false])]);
560
561			test_instance1.append_columns(test_instance2).unwrap();
562
563			assert_eq!(
564				test_instance1[0].data(),
565				&ColumnData::int4_with_bitvec([1, 2, 3, 4], [true, true, true, false])
566			);
567		}
568
569		#[test]
570		fn test_int8() {
571			let mut test_instance1 = Columns::new(vec![Column::int8("id", [1, 2])]);
572
573			let test_instance2 = Columns::new(vec![Column::int8_with_bitvec("id", [3, 4], [true, false])]);
574
575			test_instance1.append_columns(test_instance2).unwrap();
576
577			assert_eq!(
578				test_instance1[0].data(),
579				&ColumnData::int8_with_bitvec([1, 2, 3, 4], [true, true, true, false])
580			);
581		}
582
583		#[test]
584		fn test_int16() {
585			let mut test_instance1 = Columns::new(vec![Column::int16("id", [1, 2])]);
586
587			let test_instance2 = Columns::new(vec![Column::int16_with_bitvec("id", [3, 4], [true, false])]);
588
589			test_instance1.append_columns(test_instance2).unwrap();
590
591			assert_eq!(
592				test_instance1[0].data(),
593				&ColumnData::int16_with_bitvec([1, 2, 3, 4], [true, true, true, false])
594			);
595		}
596
597		#[test]
598		fn test_string() {
599			let mut test_instance1 = Columns::new(vec![Column::utf8_with_bitvec(
600				"id",
601				vec!["a".to_string(), "b".to_string()],
602				[true, true],
603			)]);
604
605			let test_instance2 = Columns::new(vec![Column::utf8_with_bitvec(
606				"id",
607				vec!["c".to_string(), "d".to_string()],
608				[true, false],
609			)]);
610
611			test_instance1.append_columns(test_instance2).unwrap();
612
613			assert_eq!(
614				test_instance1[0].data(),
615				&ColumnData::utf8_with_bitvec(
616					vec!["a".to_string(), "b".to_string(), "c".to_string(), "d".to_string()],
617					vec![true, true, true, false]
618				)
619			);
620		}
621
622		#[test]
623		fn test_uint1() {
624			let mut test_instance1 = Columns::new(vec![Column::uint1("id", [1, 2])]);
625
626			let test_instance2 = Columns::new(vec![Column::uint1_with_bitvec("id", [3, 4], [true, false])]);
627
628			test_instance1.append_columns(test_instance2).unwrap();
629
630			assert_eq!(
631				test_instance1[0].data(),
632				&ColumnData::uint1_with_bitvec([1, 2, 3, 4], [true, true, true, false])
633			);
634		}
635
636		#[test]
637		fn test_uint2() {
638			let mut test_instance1 = Columns::new(vec![Column::uint2("id", [1, 2])]);
639
640			let test_instance2 = Columns::new(vec![Column::uint2_with_bitvec("id", [3, 4], [true, false])]);
641
642			test_instance1.append_columns(test_instance2).unwrap();
643
644			assert_eq!(
645				test_instance1[0].data(),
646				&ColumnData::uint2_with_bitvec([1, 2, 3, 4], [true, true, true, false])
647			);
648		}
649
650		#[test]
651		fn test_uint4() {
652			let mut test_instance1 = Columns::new(vec![Column::uint4("id", [1, 2])]);
653
654			let test_instance2 = Columns::new(vec![Column::uint4_with_bitvec("id", [3, 4], [true, false])]);
655
656			test_instance1.append_columns(test_instance2).unwrap();
657
658			assert_eq!(
659				test_instance1[0].data(),
660				&ColumnData::uint4_with_bitvec([1, 2, 3, 4], [true, true, true, false])
661			);
662		}
663
664		#[test]
665		fn test_uint8() {
666			let mut test_instance1 = Columns::new(vec![Column::uint8("id", [1, 2])]);
667
668			let test_instance2 = Columns::new(vec![Column::uint8_with_bitvec("id", [3, 4], [true, false])]);
669
670			test_instance1.append_columns(test_instance2).unwrap();
671
672			assert_eq!(
673				test_instance1[0].data(),
674				&ColumnData::uint8_with_bitvec([1, 2, 3, 4], [true, true, true, false])
675			);
676		}
677
678		#[test]
679		fn test_uint16() {
680			let mut test_instance1 = Columns::new(vec![Column::uint16("id", [1, 2])]);
681
682			let test_instance2 =
683				Columns::new(vec![Column::uint16_with_bitvec("id", [3, 4], [true, false])]);
684
685			test_instance1.append_columns(test_instance2).unwrap();
686
687			assert_eq!(
688				test_instance1[0].data(),
689				&ColumnData::uint16_with_bitvec([1, 2, 3, 4], [true, true, true, false])
690			);
691		}
692
693		#[test]
694		fn test_uuid4() {
695			use uuid::Uuid;
696
697			let uuid1 = Uuid4::from(Uuid::new_v4());
698			let uuid2 = Uuid4::from(Uuid::new_v4());
699			let uuid3 = Uuid4::from(Uuid::new_v4());
700			let uuid4 = Uuid4::from(Uuid::new_v4());
701
702			let mut test_instance1 = Columns::new(vec![Column::uuid4("id", [uuid1, uuid2])]);
703
704			let test_instance2 =
705				Columns::new(vec![Column::uuid4_with_bitvec("id", [uuid3, uuid4], [true, false])]);
706
707			test_instance1.append_columns(test_instance2).unwrap();
708
709			assert_eq!(
710				test_instance1[0].data(),
711				&ColumnData::uuid4_with_bitvec([uuid1, uuid2, uuid3, uuid4], [true, true, true, false])
712			);
713		}
714
715		#[test]
716		fn test_uuid7() {
717			let uuid1 = Uuid7::from(Uuid::new_v7(Timestamp::from_gregorian(1, 1)));
718			let uuid2 = Uuid7::from(Uuid::new_v7(Timestamp::from_gregorian(1, 2)));
719			let uuid3 = Uuid7::from(Uuid::new_v7(Timestamp::from_gregorian(2, 1)));
720			let uuid4 = Uuid7::from(Uuid::new_v7(Timestamp::from_gregorian(2, 2)));
721
722			let mut test_instance1 = Columns::new(vec![Column::uuid7("id", [uuid1, uuid2])]);
723
724			let test_instance2 =
725				Columns::new(vec![Column::uuid7_with_bitvec("id", [uuid3, uuid4], [true, false])]);
726
727			test_instance1.append_columns(test_instance2).unwrap();
728
729			assert_eq!(
730				test_instance1[0].data(),
731				&ColumnData::uuid7_with_bitvec([uuid1, uuid2, uuid3, uuid4], [true, true, true, false])
732			);
733		}
734
735		#[test]
736		fn test_row_number() {
737			let mut test_instance1 = Columns::new(vec![Column::row_number([RowNumber(1), RowNumber(2)])]);
738
739			let test_instance2 = Columns::new(vec![Column::row_number_with_bitvec(
740				[RowNumber(3), RowNumber(4)],
741				[true, false],
742			)]);
743
744			test_instance1.append_columns(test_instance2).unwrap();
745
746			assert_eq!(
747				test_instance1[0].data(),
748				&ColumnData::row_number_with_bitvec(
749					[RowNumber(1), RowNumber(2), RowNumber(3), RowNumber(4)],
750					[true, true, true, false]
751				)
752			);
753		}
754
755		#[test]
756		fn test_with_undefined_lr_promotes_correctly() {
757			let mut test_instance1 =
758				Columns::new(vec![Column::int2_with_bitvec("id", [1, 2], [true, false])]);
759
760			let test_instance2 = Columns::new(vec![Column::undefined("id", 2)]);
761
762			test_instance1.append_columns(test_instance2).unwrap();
763
764			assert_eq!(
765				test_instance1[0].data(),
766				&ColumnData::int2_with_bitvec([1, 2, 0, 0], [true, false, false, false])
767			);
768		}
769
770		#[test]
771		fn test_with_undefined_l_promotes_correctly() {
772			let mut test_instance1 = Columns::new(vec![Column::undefined("score", 2)]);
773
774			let test_instance2 =
775				Columns::new(vec![Column::int2_with_bitvec("score", [10, 20], [true, false])]);
776
777			test_instance1.append_columns(test_instance2).unwrap();
778
779			assert_eq!(
780				test_instance1[0].data(),
781				&ColumnData::int2_with_bitvec([0, 0, 10, 20], [false, false, true, false])
782			);
783		}
784
785		#[test]
786		fn test_fails_on_column_count_mismatch() {
787			let mut test_instance1 = Columns::new(vec![Column::int2("id", [1])]);
788
789			let test_instance2 = Columns::new(vec![
790				Column::int2("id", [2]),
791				Column::utf8("name", vec!["Bob".to_string()]),
792			]);
793
794			let result = test_instance1.append_columns(test_instance2);
795			assert!(result.is_err());
796		}
797
798		#[test]
799		fn test_fails_on_column_name_mismatch() {
800			let mut test_instance1 = Columns::new(vec![Column::int2("id", [1])]);
801
802			let test_instance2 = Columns::new(vec![Column::int2("wrong", [2])]);
803
804			let result = test_instance1.append_columns(test_instance2);
805			assert!(result.is_err());
806		}
807
808		#[test]
809		fn test_fails_on_type_mismatch() {
810			let mut test_instance1 = Columns::new(vec![Column::int2("id", [1])]);
811
812			let test_instance2 = Columns::new(vec![Column::utf8("id", vec!["A".to_string()])]);
813
814			let result = test_instance1.append_columns(test_instance2);
815			assert!(result.is_err());
816		}
817	}
818
819	mod row {
820		use reifydb_type::{Fragment, OrderedF32, OrderedF64, Type, Value};
821
822		use crate::{
823			BitVec,
824			value::{
825				column::{Column, ColumnData, Columns},
826				encoded::EncodedValuesLayout,
827			},
828		};
829
830		#[test]
831		fn test_before_undefined_bool() {
832			let mut test_instance = Columns::new(vec![Column::undefined("test_col", 2)]);
833
834			let layout = EncodedValuesLayout::new(&[Type::Boolean]);
835			let mut row = layout.allocate();
836			layout.set_values(&mut row, &[Value::Boolean(true)]);
837
838			test_instance.append_rows(&layout, [row], vec![]).unwrap();
839
840			assert_eq!(
841				*test_instance[0].data(),
842				ColumnData::bool_with_bitvec(
843					[false, false, true],
844					BitVec::from_slice(&[false, false, true])
845				)
846			);
847		}
848
849		#[test]
850		fn test_before_undefined_float4() {
851			let mut test_instance = Columns::new(vec![Column::undefined("test_col", 2)]);
852			let layout = EncodedValuesLayout::new(&[Type::Float4]);
853			let mut row = layout.allocate();
854			layout.set_values(&mut row, &[Value::Float4(OrderedF32::try_from(1.5).unwrap())]);
855			test_instance.append_rows(&layout, [row], vec![]).unwrap();
856
857			assert_eq!(
858				*test_instance[0].data(),
859				ColumnData::float4_with_bitvec(
860					[0.0, 0.0, 1.5],
861					BitVec::from_slice(&[false, false, true])
862				)
863			);
864		}
865
866		#[test]
867		fn test_before_undefined_float8() {
868			let mut test_instance = Columns::new(vec![Column::undefined("test_col", 2)]);
869			let layout = EncodedValuesLayout::new(&[Type::Float8]);
870			let mut row = layout.allocate();
871			layout.set_values(&mut row, &[Value::Float8(OrderedF64::try_from(2.25).unwrap())]);
872			test_instance.append_rows(&layout, [row], vec![]).unwrap();
873
874			assert_eq!(
875				*test_instance[0].data(),
876				ColumnData::float8_with_bitvec(
877					[0.0, 0.0, 2.25],
878					BitVec::from_slice(&[false, false, true])
879				)
880			);
881		}
882
883		#[test]
884		fn test_before_undefined_int1() {
885			let mut test_instance = Columns::new(vec![Column::undefined("test_col", 2)]);
886			let layout = EncodedValuesLayout::new(&[Type::Int1]);
887			let mut row = layout.allocate();
888			layout.set_values(&mut row, &[Value::Int1(42)]);
889			test_instance.append_rows(&layout, [row], vec![]).unwrap();
890
891			assert_eq!(
892				*test_instance[0].data(),
893				ColumnData::int1_with_bitvec([0, 0, 42], BitVec::from_slice(&[false, false, true]))
894			);
895		}
896
897		#[test]
898		fn test_before_undefined_int2() {
899			let mut test_instance = Columns::new(vec![Column::undefined("test_col", 2)]);
900			let layout = EncodedValuesLayout::new(&[Type::Int2]);
901			let mut row = layout.allocate();
902			layout.set_values(&mut row, &[Value::Int2(-1234)]);
903			test_instance.append_rows(&layout, [row], vec![]).unwrap();
904
905			assert_eq!(
906				*test_instance[0].data(),
907				ColumnData::int2_with_bitvec([0, 0, -1234], BitVec::from_slice(&[false, false, true]))
908			);
909		}
910
911		#[test]
912		fn test_before_undefined_int4() {
913			let mut test_instance = Columns::new(vec![Column::undefined("test_col", 2)]);
914			let layout = EncodedValuesLayout::new(&[Type::Int4]);
915			let mut row = layout.allocate();
916			layout.set_values(&mut row, &[Value::Int4(56789)]);
917			test_instance.append_rows(&layout, [row], vec![]).unwrap();
918
919			assert_eq!(
920				*test_instance[0].data(),
921				ColumnData::int4_with_bitvec([0, 0, 56789], BitVec::from_slice(&[false, false, true]))
922			);
923		}
924
925		#[test]
926		fn test_before_undefined_int8() {
927			let mut test_instance = Columns::new(vec![Column::undefined("test_col", 2)]);
928			let layout = EncodedValuesLayout::new(&[Type::Int8]);
929			let mut row = layout.allocate();
930			layout.set_values(&mut row, &[Value::Int8(-987654321)]);
931			test_instance.append_rows(&layout, [row], vec![]).unwrap();
932
933			assert_eq!(
934				*test_instance[0].data(),
935				ColumnData::int8_with_bitvec(
936					[0, 0, -987654321],
937					BitVec::from_slice(&[false, false, true])
938				)
939			);
940		}
941
942		#[test]
943		fn test_before_undefined_int16() {
944			let mut test_instance = Columns::new(vec![Column::undefined("test_col", 2)]);
945			let layout = EncodedValuesLayout::new(&[Type::Int16]);
946			let mut row = layout.allocate();
947			layout.set_values(&mut row, &[Value::Int16(123456789012345678901234567890i128)]);
948			test_instance.append_rows(&layout, [row], vec![]).unwrap();
949
950			assert_eq!(
951				*test_instance[0].data(),
952				ColumnData::int16_with_bitvec(
953					[0, 0, 123456789012345678901234567890i128],
954					BitVec::from_slice(&[false, false, true])
955				)
956			);
957		}
958
959		#[test]
960		fn test_before_undefined_string() {
961			let mut test_instance = Columns::new(vec![Column::undefined("test_col", 2)]);
962			let layout = EncodedValuesLayout::new(&[Type::Utf8]);
963			let mut row = layout.allocate();
964			layout.set_values(&mut row, &[Value::Utf8("reifydb".into())]);
965			test_instance.append_rows(&layout, [row], vec![]).unwrap();
966
967			assert_eq!(
968				*test_instance[0].data(),
969				ColumnData::utf8_with_bitvec(
970					["".to_string(), "".to_string(), "reifydb".to_string()],
971					BitVec::from_slice(&[false, false, true])
972				)
973			);
974		}
975
976		#[test]
977		fn test_before_undefined_uint1() {
978			let mut test_instance = Columns::new(vec![Column::undefined("test_col", 2)]);
979			let layout = EncodedValuesLayout::new(&[Type::Uint1]);
980			let mut row = layout.allocate();
981			layout.set_values(&mut row, &[Value::Uint1(255)]);
982			test_instance.append_rows(&layout, [row], vec![]).unwrap();
983
984			assert_eq!(
985				*test_instance[0].data(),
986				ColumnData::uint1_with_bitvec([0, 0, 255], BitVec::from_slice(&[false, false, true]))
987			);
988		}
989
990		#[test]
991		fn test_before_undefined_uint2() {
992			let mut test_instance = Columns::new(vec![Column::undefined("test_col", 2)]);
993			let layout = EncodedValuesLayout::new(&[Type::Uint2]);
994			let mut row = layout.allocate();
995			layout.set_values(&mut row, &[Value::Uint2(65535)]);
996			test_instance.append_rows(&layout, [row], vec![]).unwrap();
997
998			assert_eq!(
999				*test_instance[0].data(),
1000				ColumnData::uint2_with_bitvec([0, 0, 65535], BitVec::from_slice(&[false, false, true]))
1001			);
1002		}
1003
1004		#[test]
1005		fn test_before_undefined_uint4() {
1006			let mut test_instance = Columns::new(vec![Column::undefined("test_col", 2)]);
1007			let layout = EncodedValuesLayout::new(&[Type::Uint4]);
1008			let mut row = layout.allocate();
1009			layout.set_values(&mut row, &[Value::Uint4(4294967295)]);
1010			test_instance.append_rows(&layout, [row], vec![]).unwrap();
1011
1012			assert_eq!(
1013				*test_instance[0].data(),
1014				ColumnData::uint4_with_bitvec(
1015					[0, 0, 4294967295],
1016					BitVec::from_slice(&[false, false, true])
1017				)
1018			);
1019		}
1020
1021		#[test]
1022		fn test_before_undefined_uint8() {
1023			let mut test_instance = Columns::new(vec![Column::undefined("test_col", 2)]);
1024			let layout = EncodedValuesLayout::new(&[Type::Uint8]);
1025			let mut row = layout.allocate();
1026			layout.set_values(&mut row, &[Value::Uint8(18446744073709551615)]);
1027			test_instance.append_rows(&layout, [row], vec![]).unwrap();
1028
1029			assert_eq!(
1030				*test_instance[0].data(),
1031				ColumnData::uint8_with_bitvec(
1032					[0, 0, 18446744073709551615],
1033					BitVec::from_slice(&[false, false, true])
1034				)
1035			);
1036		}
1037
1038		#[test]
1039		fn test_before_undefined_uint16() {
1040			let mut test_instance = Columns::new(vec![Column::undefined("test_col", 2)]);
1041			let layout = EncodedValuesLayout::new(&[Type::Uint16]);
1042			let mut row = layout.allocate();
1043			layout.set_values(&mut row, &[Value::Uint16(340282366920938463463374607431768211455u128)]);
1044			test_instance.append_rows(&layout, [row], vec![]).unwrap();
1045
1046			assert_eq!(
1047				*test_instance[0].data(),
1048				ColumnData::uint16_with_bitvec(
1049					[0, 0, 340282366920938463463374607431768211455u128],
1050					BitVec::from_slice(&[false, false, true])
1051				)
1052			);
1053		}
1054
1055		#[test]
1056		fn test_mismatched_columns() {
1057			let mut test_instance = Columns::new(vec![]);
1058
1059			let layout = EncodedValuesLayout::new(&[Type::Int2]);
1060			let mut row = layout.allocate();
1061			layout.set_values(&mut row, &[Value::Int2(2)]);
1062
1063			let err = test_instance.append_rows(&layout, [row], vec![]).err().unwrap();
1064			assert!(err.to_string().contains("mismatched column count: expected 0, got 1"));
1065		}
1066
1067		#[test]
1068		fn test_ok() {
1069			let mut test_instance = test_instance_with_columns();
1070
1071			let layout = EncodedValuesLayout::new(&[Type::Int2, Type::Boolean]);
1072			let mut row_one = layout.allocate();
1073			layout.set_values(&mut row_one, &[Value::Int2(2), Value::Boolean(true)]);
1074			let mut row_two = layout.allocate();
1075			layout.set_values(&mut row_two, &[Value::Int2(3), Value::Boolean(false)]);
1076
1077			test_instance.append_rows(&layout, [row_one, row_two], vec![]).unwrap();
1078
1079			assert_eq!(*test_instance[0].data(), ColumnData::int2([1, 2, 3]));
1080			assert_eq!(*test_instance[1].data(), ColumnData::bool([true, true, false]));
1081		}
1082
1083		#[test]
1084		fn test_all_defined_bool() {
1085			let mut test_instance = Columns::new(vec![Column::bool("test_col", Vec::<bool>::new())]);
1086
1087			let layout = EncodedValuesLayout::new(&[Type::Boolean]);
1088			let mut row_one = layout.allocate();
1089			layout.set_bool(&mut row_one, 0, true);
1090			let mut row_two = layout.allocate();
1091			layout.set_bool(&mut row_two, 0, false);
1092
1093			test_instance.append_rows(&layout, [row_one, row_two], vec![]).unwrap();
1094
1095			assert_eq!(*test_instance[0].data(), ColumnData::bool([true, false]));
1096		}
1097
1098		#[test]
1099		fn test_all_defined_float4() {
1100			let mut test_instance = Columns::new(vec![Column::float4("test_col", Vec::<f32>::new())]);
1101
1102			let layout = EncodedValuesLayout::new(&[Type::Float4]);
1103			let mut row_one = layout.allocate();
1104			layout.set_values(&mut row_one, &[Value::Float4(OrderedF32::try_from(1.0).unwrap())]);
1105			let mut row_two = layout.allocate();
1106			layout.set_values(&mut row_two, &[Value::Float4(OrderedF32::try_from(2.0).unwrap())]);
1107
1108			test_instance.append_rows(&layout, [row_one, row_two], vec![]).unwrap();
1109
1110			assert_eq!(*test_instance[0].data(), ColumnData::float4([1.0, 2.0]));
1111		}
1112
1113		#[test]
1114		fn test_all_defined_float8() {
1115			let mut test_instance = Columns::new(vec![Column::float8("test_col", Vec::<f64>::new())]);
1116
1117			let layout = EncodedValuesLayout::new(&[Type::Float8]);
1118			let mut row_one = layout.allocate();
1119			layout.set_values(&mut row_one, &[Value::Float8(OrderedF64::try_from(1.0).unwrap())]);
1120			let mut row_two = layout.allocate();
1121			layout.set_values(&mut row_two, &[Value::Float8(OrderedF64::try_from(2.0).unwrap())]);
1122
1123			test_instance.append_rows(&layout, [row_one, row_two], vec![]).unwrap();
1124
1125			assert_eq!(*test_instance[0].data(), ColumnData::float8([1.0, 2.0]));
1126		}
1127
1128		#[test]
1129		fn test_all_defined_int1() {
1130			let mut test_instance = Columns::new(vec![Column::int1("test_col", Vec::<i8>::new())]);
1131
1132			let layout = EncodedValuesLayout::new(&[Type::Int1]);
1133			let mut row_one = layout.allocate();
1134			layout.set_values(&mut row_one, &[Value::Int1(1)]);
1135			let mut row_two = layout.allocate();
1136			layout.set_values(&mut row_two, &[Value::Int1(2)]);
1137
1138			test_instance.append_rows(&layout, [row_one, row_two], vec![]).unwrap();
1139
1140			assert_eq!(*test_instance[0].data(), ColumnData::int1([1, 2]));
1141		}
1142
1143		#[test]
1144		fn test_all_defined_int2() {
1145			let mut test_instance = Columns::new(vec![Column::int2("test_col", Vec::<i16>::new())]);
1146
1147			let layout = EncodedValuesLayout::new(&[Type::Int2]);
1148			let mut row_one = layout.allocate();
1149			layout.set_values(&mut row_one, &[Value::Int2(100)]);
1150			let mut row_two = layout.allocate();
1151			layout.set_values(&mut row_two, &[Value::Int2(200)]);
1152
1153			test_instance.append_rows(&layout, [row_one, row_two], vec![]).unwrap();
1154
1155			assert_eq!(*test_instance[0].data(), ColumnData::int2([100, 200]));
1156		}
1157
1158		#[test]
1159		fn test_all_defined_int4() {
1160			let mut test_instance = Columns::new(vec![Column::int4("test_col", Vec::<i32>::new())]);
1161
1162			let layout = EncodedValuesLayout::new(&[Type::Int4]);
1163			let mut row_one = layout.allocate();
1164			layout.set_values(&mut row_one, &[Value::Int4(1000)]);
1165			let mut row_two = layout.allocate();
1166			layout.set_values(&mut row_two, &[Value::Int4(2000)]);
1167
1168			test_instance.append_rows(&layout, [row_one, row_two], vec![]).unwrap();
1169
1170			assert_eq!(*test_instance[0].data(), ColumnData::int4([1000, 2000]));
1171		}
1172
1173		#[test]
1174		fn test_all_defined_int8() {
1175			let mut test_instance = Columns::new(vec![Column::int8("test_col", Vec::<i64>::new())]);
1176
1177			let layout = EncodedValuesLayout::new(&[Type::Int8]);
1178			let mut row_one = layout.allocate();
1179			layout.set_values(&mut row_one, &[Value::Int8(10000)]);
1180			let mut row_two = layout.allocate();
1181			layout.set_values(&mut row_two, &[Value::Int8(20000)]);
1182
1183			test_instance.append_rows(&layout, [row_one, row_two], vec![]).unwrap();
1184
1185			assert_eq!(*test_instance[0].data(), ColumnData::int8([10000, 20000]));
1186		}
1187
1188		#[test]
1189		fn test_all_defined_int16() {
1190			let mut test_instance = Columns::new(vec![Column::int16("test_col", Vec::<i128>::new())]);
1191
1192			let layout = EncodedValuesLayout::new(&[Type::Int16]);
1193			let mut row_one = layout.allocate();
1194			layout.set_values(&mut row_one, &[Value::Int16(1000)]);
1195			let mut row_two = layout.allocate();
1196			layout.set_values(&mut row_two, &[Value::Int16(2000)]);
1197
1198			test_instance.append_rows(&layout, [row_one, row_two], vec![]).unwrap();
1199
1200			assert_eq!(*test_instance[0].data(), ColumnData::int16([1000, 2000]));
1201		}
1202
1203		#[test]
1204		fn test_all_defined_string() {
1205			let mut test_instance = Columns::new(vec![Column::utf8("test_col", Vec::<String>::new())]);
1206
1207			let layout = EncodedValuesLayout::new(&[Type::Utf8]);
1208			let mut row_one = layout.allocate();
1209			layout.set_values(&mut row_one, &[Value::Utf8("a".into())]);
1210			let mut row_two = layout.allocate();
1211			layout.set_values(&mut row_two, &[Value::Utf8("b".into())]);
1212
1213			test_instance.append_rows(&layout, [row_one, row_two], vec![]).unwrap();
1214
1215			assert_eq!(*test_instance[0].data(), ColumnData::utf8(["a".to_string(), "b".to_string()]));
1216		}
1217
1218		#[test]
1219		fn test_all_defined_uint1() {
1220			let mut test_instance = Columns::new(vec![Column::uint1("test_col", Vec::<u8>::new())]);
1221
1222			let layout = EncodedValuesLayout::new(&[Type::Uint1]);
1223			let mut row_one = layout.allocate();
1224			layout.set_values(&mut row_one, &[Value::Uint1(1)]);
1225			let mut row_two = layout.allocate();
1226			layout.set_values(&mut row_two, &[Value::Uint1(2)]);
1227
1228			test_instance.append_rows(&layout, [row_one, row_two], vec![]).unwrap();
1229
1230			assert_eq!(*test_instance[0].data(), ColumnData::uint1([1, 2]));
1231		}
1232
1233		#[test]
1234		fn test_all_defined_uint2() {
1235			let mut test_instance = Columns::new(vec![Column::uint2("test_col", Vec::<u16>::new())]);
1236
1237			let layout = EncodedValuesLayout::new(&[Type::Uint2]);
1238			let mut row_one = layout.allocate();
1239			layout.set_values(&mut row_one, &[Value::Uint2(100)]);
1240			let mut row_two = layout.allocate();
1241			layout.set_values(&mut row_two, &[Value::Uint2(200)]);
1242
1243			test_instance.append_rows(&layout, [row_one, row_two], vec![]).unwrap();
1244
1245			assert_eq!(*test_instance[0].data(), ColumnData::uint2([100, 200]));
1246		}
1247
1248		#[test]
1249		fn test_all_defined_uint4() {
1250			let mut test_instance = Columns::new(vec![Column::uint4("test_col", Vec::<u32>::new())]);
1251
1252			let layout = EncodedValuesLayout::new(&[Type::Uint4]);
1253			let mut row_one = layout.allocate();
1254			layout.set_values(&mut row_one, &[Value::Uint4(1000)]);
1255			let mut row_two = layout.allocate();
1256			layout.set_values(&mut row_two, &[Value::Uint4(2000)]);
1257
1258			test_instance.append_rows(&layout, [row_one, row_two], vec![]).unwrap();
1259
1260			assert_eq!(*test_instance[0].data(), ColumnData::uint4([1000, 2000]));
1261		}
1262
1263		#[test]
1264		fn test_all_defined_uint8() {
1265			let mut test_instance = Columns::new(vec![Column::uint8("test_col", Vec::<u64>::new())]);
1266
1267			let layout = EncodedValuesLayout::new(&[Type::Uint8]);
1268			let mut row_one = layout.allocate();
1269			layout.set_values(&mut row_one, &[Value::Uint8(10000)]);
1270			let mut row_two = layout.allocate();
1271			layout.set_values(&mut row_two, &[Value::Uint8(20000)]);
1272
1273			test_instance.append_rows(&layout, [row_one, row_two], vec![]).unwrap();
1274
1275			assert_eq!(*test_instance[0].data(), ColumnData::uint8([10000, 20000]));
1276		}
1277
1278		#[test]
1279		fn test_all_defined_uint16() {
1280			let mut test_instance = Columns::new(vec![Column::uint16("test_col", Vec::<u128>::new())]);
1281
1282			let layout = EncodedValuesLayout::new(&[Type::Uint16]);
1283			let mut row_one = layout.allocate();
1284			layout.set_values(&mut row_one, &[Value::Uint16(1000)]);
1285			let mut row_two = layout.allocate();
1286			layout.set_values(&mut row_two, &[Value::Uint16(2000)]);
1287
1288			test_instance.append_rows(&layout, [row_one, row_two], vec![]).unwrap();
1289
1290			assert_eq!(*test_instance[0].data(), ColumnData::uint16([1000, 2000]));
1291		}
1292
1293		#[test]
1294		fn test_row_with_undefined() {
1295			let mut test_instance = test_instance_with_columns();
1296
1297			let layout = EncodedValuesLayout::new(&[Type::Int2, Type::Boolean]);
1298			let mut row = layout.allocate();
1299			layout.set_values(&mut row, &[Value::Undefined, Value::Boolean(false)]);
1300
1301			test_instance.append_rows(&layout, [row], vec![]).unwrap();
1302
1303			assert_eq!(
1304				*test_instance[0].data(),
1305				ColumnData::int2_with_bitvec(vec![1, 0], vec![true, false])
1306			);
1307			assert_eq!(*test_instance[1].data(), ColumnData::bool_with_bitvec([true, false], [true, true]));
1308		}
1309
1310		#[test]
1311		fn test_row_with_type_mismatch_fails() {
1312			let mut test_instance = test_instance_with_columns();
1313
1314			let layout = EncodedValuesLayout::new(&[Type::Boolean, Type::Boolean]);
1315			let mut row = layout.allocate();
1316			layout.set_values(&mut row, &[Value::Boolean(true), Value::Boolean(true)]);
1317
1318			let result = test_instance.append_rows(&layout, [row], vec![]);
1319			assert!(result.is_err());
1320			assert!(result.unwrap_err().to_string().contains("type mismatch"));
1321		}
1322
1323		#[test]
1324		fn test_row_wrong_length_fails() {
1325			let mut test_instance = test_instance_with_columns();
1326
1327			let layout = EncodedValuesLayout::new(&[Type::Int2]);
1328			let mut row = layout.allocate();
1329			layout.set_values(&mut row, &[Value::Int2(2)]);
1330
1331			let result = test_instance.append_rows(&layout, [row], vec![]);
1332			assert!(result.is_err());
1333			assert!(result.unwrap_err().to_string().contains("mismatched column count"));
1334		}
1335
1336		#[test]
1337		fn test_fallback_bool() {
1338			let mut test_instance = Columns::new(vec![
1339				Column::bool("test_col", Vec::<bool>::new()),
1340				Column::bool("undefined", Vec::<bool>::new()),
1341			]);
1342
1343			let layout = EncodedValuesLayout::new(&[Type::Boolean, Type::Boolean]);
1344			let mut row_one = layout.allocate();
1345			layout.set_bool(&mut row_one, 0, true);
1346			layout.set_undefined(&mut row_one, 1);
1347
1348			test_instance.append_rows(&layout, [row_one], vec![]).unwrap();
1349
1350			assert_eq!(*test_instance[0].data(), ColumnData::bool_with_bitvec([true], [true]));
1351
1352			assert_eq!(*test_instance[1].data(), ColumnData::bool_with_bitvec([false], [false]));
1353		}
1354
1355		#[test]
1356		fn test_fallback_float4() {
1357			let mut test_instance = Columns::new(vec![
1358				Column::float4("test_col", Vec::<f32>::new()),
1359				Column::float4("undefined", Vec::<f32>::new()),
1360			]);
1361
1362			let layout = EncodedValuesLayout::new(&[Type::Float4, Type::Float4]);
1363			let mut row = layout.allocate();
1364			layout.set_f32(&mut row, 0, 1.5);
1365			layout.set_undefined(&mut row, 1);
1366
1367			test_instance.append_rows(&layout, [row], vec![]).unwrap();
1368
1369			assert_eq!(*test_instance[0].data(), ColumnData::float4_with_bitvec([1.5], [true]));
1370			assert_eq!(*test_instance[1].data(), ColumnData::float4_with_bitvec([0.0], [false]));
1371		}
1372
1373		#[test]
1374		fn test_fallback_float8() {
1375			let mut test_instance = Columns::new(vec![
1376				Column::float8("test_col", Vec::<f64>::new()),
1377				Column::float8("undefined", Vec::<f64>::new()),
1378			]);
1379
1380			let layout = EncodedValuesLayout::new(&[Type::Float8, Type::Float8]);
1381			let mut row = layout.allocate();
1382			layout.set_f64(&mut row, 0, 2.5);
1383			layout.set_undefined(&mut row, 1);
1384
1385			test_instance.append_rows(&layout, [row], vec![]).unwrap();
1386
1387			assert_eq!(*test_instance[0].data(), ColumnData::float8_with_bitvec([2.5], [true]));
1388			assert_eq!(*test_instance[1].data(), ColumnData::float8_with_bitvec([0.0], [false]));
1389		}
1390
1391		#[test]
1392		fn test_fallback_int1() {
1393			let mut test_instance = Columns::new(vec![
1394				Column::int1("test_col", Vec::<i8>::new()),
1395				Column::int1("undefined", Vec::<i8>::new()),
1396			]);
1397
1398			let layout = EncodedValuesLayout::new(&[Type::Int1, Type::Int1]);
1399			let mut row = layout.allocate();
1400			layout.set_i8(&mut row, 0, 42);
1401			layout.set_undefined(&mut row, 1);
1402
1403			test_instance.append_rows(&layout, [row], vec![]).unwrap();
1404
1405			assert_eq!(*test_instance[0].data(), ColumnData::int1_with_bitvec([42], [true]));
1406			assert_eq!(*test_instance[1].data(), ColumnData::int1_with_bitvec([0], [false]));
1407		}
1408
1409		#[test]
1410		fn test_fallback_int2() {
1411			let mut test_instance = Columns::new(vec![
1412				Column::int2("test_col", Vec::<i16>::new()),
1413				Column::int2("undefined", Vec::<i16>::new()),
1414			]);
1415
1416			let layout = EncodedValuesLayout::new(&[Type::Int2, Type::Int2]);
1417			let mut row = layout.allocate();
1418			layout.set_i16(&mut row, 0, -1234i16);
1419			layout.set_undefined(&mut row, 1);
1420
1421			test_instance.append_rows(&layout, [row], vec![]).unwrap();
1422
1423			assert_eq!(*test_instance[0].data(), ColumnData::int2_with_bitvec([-1234], [true]));
1424			assert_eq!(*test_instance[1].data(), ColumnData::int2_with_bitvec([0], [false]));
1425		}
1426
1427		#[test]
1428		fn test_fallback_int4() {
1429			let mut test_instance = Columns::new(vec![
1430				Column::int4("test_col", Vec::<i32>::new()),
1431				Column::int4("undefined", Vec::<i32>::new()),
1432			]);
1433
1434			let layout = EncodedValuesLayout::new(&[Type::Int4, Type::Int4]);
1435			let mut row = layout.allocate();
1436			layout.set_i32(&mut row, 0, 56789);
1437			layout.set_undefined(&mut row, 1);
1438
1439			test_instance.append_rows(&layout, [row], vec![]).unwrap();
1440
1441			assert_eq!(*test_instance[0].data(), ColumnData::int4_with_bitvec([56789], [true]));
1442			assert_eq!(*test_instance[1].data(), ColumnData::int4_with_bitvec([0], [false]));
1443		}
1444
1445		#[test]
1446		fn test_fallback_int8() {
1447			let mut test_instance = Columns::new(vec![
1448				Column::int8("test_col", Vec::<i64>::new()),
1449				Column::int8("undefined", Vec::<i64>::new()),
1450			]);
1451
1452			let layout = EncodedValuesLayout::new(&[Type::Int8, Type::Int8]);
1453			let mut row = layout.allocate();
1454			layout.set_i64(&mut row, 0, -987654321);
1455			layout.set_undefined(&mut row, 1);
1456
1457			test_instance.append_rows(&layout, [row], vec![]).unwrap();
1458
1459			assert_eq!(*test_instance[0].data(), ColumnData::int8_with_bitvec([-987654321], [true]));
1460			assert_eq!(*test_instance[1].data(), ColumnData::int8_with_bitvec([0], [false]));
1461		}
1462
1463		#[test]
1464		fn test_fallback_int16() {
1465			let mut test_instance = Columns::new(vec![
1466				Column::int16("test_col", Vec::<i128>::new()),
1467				Column::int16("undefined", Vec::<i128>::new()),
1468			]);
1469
1470			let layout = EncodedValuesLayout::new(&[Type::Int16, Type::Int16]);
1471			let mut row = layout.allocate();
1472			layout.set_i128(&mut row, 0, 123456789012345678901234567890i128);
1473			layout.set_undefined(&mut row, 1);
1474
1475			test_instance.append_rows(&layout, [row], vec![]).unwrap();
1476
1477			assert_eq!(
1478				*test_instance[0].data(),
1479				ColumnData::int16_with_bitvec([123456789012345678901234567890i128], [true])
1480			);
1481			assert_eq!(*test_instance[1].data(), ColumnData::int16_with_bitvec([0], [false]));
1482		}
1483
1484		#[test]
1485		fn test_fallback_string() {
1486			let mut test_instance = Columns::new(vec![
1487				Column::utf8("test_col", Vec::<String>::new()),
1488				Column::utf8("undefined", Vec::<String>::new()),
1489			]);
1490
1491			let layout = EncodedValuesLayout::new(&[Type::Utf8, Type::Utf8]);
1492			let mut row = layout.allocate();
1493			layout.set_utf8(&mut row, 0, "reifydb");
1494			layout.set_undefined(&mut row, 1);
1495
1496			test_instance.append_rows(&layout, [row], vec![]).unwrap();
1497
1498			assert_eq!(
1499				*test_instance[0].data(),
1500				ColumnData::utf8_with_bitvec(["reifydb".to_string()], [true])
1501			);
1502			assert_eq!(*test_instance[1].data(), ColumnData::utf8_with_bitvec(["".to_string()], [false]));
1503		}
1504
1505		#[test]
1506		fn test_fallback_uint1() {
1507			let mut test_instance = Columns::new(vec![
1508				Column::uint1("test_col", Vec::<u8>::new()),
1509				Column::uint1("undefined", Vec::<u8>::new()),
1510			]);
1511
1512			let layout = EncodedValuesLayout::new(&[Type::Uint1, Type::Uint1]);
1513			let mut row = layout.allocate();
1514			layout.set_u8(&mut row, 0, 255);
1515			layout.set_undefined(&mut row, 1);
1516
1517			test_instance.append_rows(&layout, [row], vec![]).unwrap();
1518
1519			assert_eq!(*test_instance[0].data(), ColumnData::uint1_with_bitvec([255], [true]));
1520			assert_eq!(*test_instance[1].data(), ColumnData::uint1_with_bitvec([0], [false]));
1521		}
1522
1523		#[test]
1524		fn test_fallback_uint2() {
1525			let mut test_instance = Columns::new(vec![
1526				Column::uint2("test_col", Vec::<u16>::new()),
1527				Column::uint2("undefined", Vec::<u16>::new()),
1528			]);
1529
1530			let layout = EncodedValuesLayout::new(&[Type::Uint2, Type::Uint2]);
1531			let mut row = layout.allocate();
1532			layout.set_u16(&mut row, 0, 65535u16);
1533			layout.set_undefined(&mut row, 1);
1534
1535			test_instance.append_rows(&layout, [row], vec![]).unwrap();
1536
1537			assert_eq!(*test_instance[0].data(), ColumnData::uint2_with_bitvec([65535], [true]));
1538			assert_eq!(*test_instance[1].data(), ColumnData::uint2_with_bitvec([0], [false]));
1539		}
1540
1541		#[test]
1542		fn test_fallback_uint4() {
1543			let mut test_instance = Columns::new(vec![
1544				Column::uint4("test_col", Vec::<u32>::new()),
1545				Column::uint4("undefined", Vec::<u32>::new()),
1546			]);
1547
1548			let layout = EncodedValuesLayout::new(&[Type::Uint4, Type::Uint4]);
1549			let mut row = layout.allocate();
1550			layout.set_u32(&mut row, 0, 4294967295u32);
1551			layout.set_undefined(&mut row, 1);
1552
1553			test_instance.append_rows(&layout, [row], vec![]).unwrap();
1554
1555			assert_eq!(*test_instance[0].data(), ColumnData::uint4_with_bitvec([4294967295], [true]));
1556			assert_eq!(*test_instance[1].data(), ColumnData::uint4_with_bitvec([0], [false]));
1557		}
1558
1559		#[test]
1560		fn test_fallback_uint8() {
1561			let mut test_instance = Columns::new(vec![
1562				Column::uint8("test_col", Vec::<u64>::new()),
1563				Column::uint8("undefined", Vec::<u64>::new()),
1564			]);
1565
1566			let layout = EncodedValuesLayout::new(&[Type::Uint8, Type::Uint8]);
1567			let mut row = layout.allocate();
1568			layout.set_u64(&mut row, 0, 18446744073709551615u64);
1569			layout.set_undefined(&mut row, 1);
1570
1571			test_instance.append_rows(&layout, [row], vec![]).unwrap();
1572
1573			assert_eq!(
1574				*test_instance[0].data(),
1575				ColumnData::uint8_with_bitvec([18446744073709551615], [true])
1576			);
1577			assert_eq!(*test_instance[1].data(), ColumnData::uint8_with_bitvec([0], [false]));
1578		}
1579
1580		#[test]
1581		fn test_fallback_uint16() {
1582			let mut test_instance = Columns::new(vec![
1583				Column::uint16("test_col", Vec::<u128>::new()),
1584				Column::uint16("undefined", Vec::<u128>::new()),
1585			]);
1586
1587			let layout = EncodedValuesLayout::new(&[Type::Uint16, Type::Uint16]);
1588			let mut row = layout.allocate();
1589			layout.set_u128(&mut row, 0, 340282366920938463463374607431768211455u128);
1590			layout.set_undefined(&mut row, 1);
1591
1592			test_instance.append_rows(&layout, [row], vec![]).unwrap();
1593
1594			assert_eq!(
1595				*test_instance[0].data(),
1596				ColumnData::uint16_with_bitvec([340282366920938463463374607431768211455u128], [true])
1597			);
1598			assert_eq!(*test_instance[1].data(), ColumnData::uint16_with_bitvec([0], [false]));
1599		}
1600
1601		fn test_instance_with_columns<'a>() -> Columns<'a> {
1602			Columns::new(vec![
1603				Column {
1604					name: Fragment::owned_internal("int2"),
1605					data: ColumnData::int2(vec![1]),
1606				},
1607				Column {
1608					name: Fragment::owned_internal("bool"),
1609					data: ColumnData::bool(vec![true]),
1610				},
1611			])
1612		}
1613	}
1614}
reifydb_core/value/column/transform/append.rs

reifydb_core/value/column/transform/
append.rs
