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

reifydb_core/value/column/transform/
append.rs
