1use std::marker::PhantomData;
8use std::sync::Arc;
9
10use arrow_array::builder::{FixedSizeBinaryBuilder, make_view};
11use arrow_array::types::{ByteArrayType, ByteViewType};
12use arrow_array::*;
13use arrow_buffer::{ArrowNativeType, Buffer, MutableBuffer, NullBuffer, ScalarBuffer};
14use arrow_data::{ArrayDataBuilder, MAX_INLINE_VIEW_LEN};
15use arrow_schema::{ArrowError, DataType};
16
17pub fn concat_elements_bytes<T: ByteArrayType>(
24 left: &GenericByteArray<T>,
25 right: &GenericByteArray<T>,
26) -> Result<GenericByteArray<T>, ArrowError> {
27 if left.len() != right.len() {
28 return Err(ArrowError::ComputeError(format!(
29 "Arrays must have the same length: {} != {}",
30 left.len(),
31 right.len()
32 )));
33 }
34
35 let nulls = NullBuffer::union(left.nulls(), right.nulls());
36
37 let left_offsets = left.offsets();
38 let right_offsets = right.offsets();
39
40 let left_values = left.value_data();
41 let right_values = right.value_data();
42
43 let mut output_values = Vec::with_capacity(
44 (left_offsets.last() - left_offsets.first()).as_usize()
45 + (right_offsets.last() - right_offsets.first()).as_usize(),
46 );
47
48 let mut output_offsets = Vec::with_capacity(left_offsets.len());
49 output_offsets.push(T::Offset::usize_as(0));
50 for (left_idx, right_idx) in left_offsets.windows(2).zip(right_offsets.windows(2)) {
51 output_values
52 .extend_from_slice(&left_values[left_idx[0].as_usize()..left_idx[1].as_usize()]);
53 output_values
54 .extend_from_slice(&right_values[right_idx[0].as_usize()..right_idx[1].as_usize()]);
55 let output_len = output_values.len();
56 let offset =
57 T::Offset::from_usize(output_len).ok_or(ArrowError::OffsetOverflowError(output_len))?;
58 output_offsets.push(offset);
59 }
60
61 let builder = ArrayDataBuilder::new(T::DATA_TYPE)
62 .len(left.len())
63 .add_buffer(output_offsets.into())
64 .add_buffer(output_values.into())
65 .nulls(nulls);
66
67 Ok(unsafe { builder.build_unchecked() }.into())
69}
70
71pub fn concat_elements_utf8<Offset: OffsetSizeTrait>(
86 left: &GenericStringArray<Offset>,
87 right: &GenericStringArray<Offset>,
88) -> Result<GenericStringArray<Offset>, ArrowError> {
89 concat_elements_bytes(left, right)
90}
91
92pub fn concat_element_binary<Offset: OffsetSizeTrait>(
94 left: &GenericBinaryArray<Offset>,
95 right: &GenericBinaryArray<Offset>,
96) -> Result<GenericBinaryArray<Offset>, ArrowError> {
97 concat_elements_bytes(left, right)
98}
99
100pub fn concat_elements_utf8_many<Offset: OffsetSizeTrait>(
113 arrays: &[&GenericStringArray<Offset>],
114) -> Result<GenericStringArray<Offset>, ArrowError> {
115 if arrays.is_empty() {
116 return Err(ArrowError::ComputeError(
117 "concat requires input of at least one array".to_string(),
118 ));
119 }
120
121 let size = arrays[0].len();
122 if !arrays.iter().all(|array| array.len() == size) {
123 return Err(ArrowError::ComputeError(format!(
124 "Arrays must have the same length of {size}",
125 )));
126 }
127
128 let nulls = arrays
129 .iter()
130 .fold(None, |acc, a| NullBuffer::union(acc.as_ref(), a.nulls()));
131
132 let data_values = arrays
133 .iter()
134 .map(|array| array.value_data())
135 .collect::<Vec<_>>();
136
137 let mut offsets = arrays
138 .iter()
139 .map(|a| a.value_offsets().iter().peekable())
140 .collect::<Vec<_>>();
141
142 let mut output_values = Vec::with_capacity(
143 arrays
144 .iter()
145 .map(|array| (array.offsets().last() - array.offsets().first()).as_usize())
146 .sum(),
147 );
148
149 let mut output_offsets = Vec::with_capacity(size + 1);
150 output_offsets.push(Offset::zero());
151 for _ in 0..size {
152 data_values
153 .iter()
154 .zip(offsets.iter_mut())
155 .for_each(|(values, offset)| {
156 let index_start = offset.next().unwrap().as_usize();
157 let index_end = offset.peek().unwrap().as_usize();
158 output_values.extend_from_slice(&values[index_start..index_end]);
159 });
160 let output_len = output_values.len();
161 let offset =
162 Offset::from_usize(output_len).ok_or(ArrowError::OffsetOverflowError(output_len))?;
163 output_offsets.push(offset);
164 }
165
166 let builder = ArrayDataBuilder::new(GenericStringArray::<Offset>::DATA_TYPE)
167 .len(size)
168 .add_buffer(output_offsets.into())
169 .add_buffer(output_values.into())
170 .nulls(nulls);
171
172 Ok(unsafe { builder.build_unchecked() }.into())
174}
175
176pub fn concat_elements_fixed_size_binary(
183 left: &FixedSizeBinaryArray,
184 right: &FixedSizeBinaryArray,
185) -> Result<FixedSizeBinaryArray, ArrowError> {
186 if left.len() != right.len() {
187 return Err(ArrowError::ComputeError(format!(
188 "Arrays must have the same length: {} != {}",
189 left.len(),
190 right.len()
191 )));
192 }
193
194 let left_size: usize = left.value_length().try_into().map_err(|_| {
195 ArrowError::InvalidArgumentError(format!(
196 "Invalid size of FixedSizeBinaryArray({})",
197 left.value_length()
198 ))
199 })?;
200 let right_size: usize = right.value_length().try_into().map_err(|_| {
201 ArrowError::InvalidArgumentError(format!(
202 "Invalid size of FixedSizeBinaryArray({})",
203 right.value_length()
204 ))
205 })?;
206 let output_size = left_size.checked_add(right_size).ok_or_else(|| {
207 ArrowError::InvalidArgumentError(
208 "Concatenated FixedSizeBinary value length overflow".into(),
209 )
210 })?;
211 let output_value_length = i32::try_from(output_size).map_err(|_| {
212 ArrowError::InvalidArgumentError(format!(
213 "Concatenated FixedSizeBinary value length {output_size} exceeds i32"
214 ))
215 })?;
216
217 let nulls = NullBuffer::union(left.nulls(), right.nulls());
219
220 let mut result = FixedSizeBinaryBuilder::with_capacity(left.len(), output_value_length);
221 let mut buffer = MutableBuffer::try_with_capacity(output_size)
222 .map_err(|e| ArrowError::MemoryError(e.to_string()))?;
223 for i in 0..left.len() {
224 if nulls.as_ref().is_some_and(|n| n.is_null(i)) {
225 result.append_null();
226 } else {
227 buffer.clear();
228 buffer.extend_from_slice(left.value(i));
229 buffer.extend_from_slice(right.value(i));
230 result.append_value(&buffer)?;
231 }
232 }
233
234 Ok(result.finish())
235}
236
237struct ConcatByteViewBuilder<T>
238where
239 T: ByteViewType,
240{
241 views: Vec<u128>,
242 data: Vec<u8>,
243 inline: Vec<u8>,
244 phantom: PhantomData<T>,
245}
246
247impl<T> ConcatByteViewBuilder<T>
248where
249 T: ByteViewType,
250{
251 fn concat_elements_view_array(
253 left: &GenericByteViewArray<T>,
254 right: &GenericByteViewArray<T>,
255 ) -> Result<GenericByteViewArray<T>, ArrowError> {
256 let len = left.len();
257 if len != right.len() {
258 return Err(ArrowError::ComputeError(format!(
259 "Arrays must have the same length: {} != {}",
260 len,
261 right.len()
262 )));
263 }
264
265 let null_buffer = NullBuffer::union(left.nulls(), right.nulls());
266
267 let inline_max = MAX_INLINE_VIEW_LEN as usize;
271 let data_size: usize = match &null_buffer {
272 None => left
273 .lengths()
274 .zip(right.lengths())
275 .map(|(l, r)| l as usize + r as usize)
276 .filter(|len| *len > inline_max)
277 .sum(),
278 Some(nb) => left
279 .lengths()
280 .zip(right.lengths())
281 .zip(nb.iter())
282 .filter(|((_, _), not_null)| *not_null)
283 .map(|((l, r), _)| l as usize + r as usize)
284 .filter(|len| *len > inline_max)
285 .sum(),
286 };
287
288 if data_size > i32::MAX as usize {
289 return Err(ArrowError::ArithmeticOverflow(
290 "byte array offset overflow".to_string(),
291 ));
292 }
293 let mut builder = Self::with_capacity(len, data_size);
294
295 match &null_buffer {
296 None => {
297 for (l, r) in left.bytes_iter().zip(right.bytes_iter()) {
298 builder.append_concat_view(l, r);
299 }
300 }
301 Some(nb) => {
302 for ((l, r), not_null) in left.bytes_iter().zip(right.bytes_iter()).zip(nb.iter()) {
303 if not_null {
304 builder.append_concat_view(l, r);
305 } else {
306 builder.append_empty_view();
307 }
308 }
309 }
310 }
311
312 builder.finish(null_buffer)
313 }
314
315 fn with_capacity(item_capacity: usize, data_capacity: usize) -> Self {
316 Self {
317 views: Vec::with_capacity(item_capacity),
318 data: Vec::with_capacity(data_capacity),
319 inline: Vec::with_capacity(MAX_INLINE_VIEW_LEN as usize),
320 phantom: PhantomData,
321 }
322 }
323
324 fn append_concat_view(&mut self, left: &[u8], right: &[u8]) {
326 let total_len = left.len() + right.len();
327 if total_len > MAX_INLINE_VIEW_LEN as usize {
328 let offset = self.data.len();
329
330 debug_assert!(i32::try_from(offset).is_ok());
335 let view_offset: u32 = offset as u32;
336
337 self.data.extend_from_slice(left);
338 self.data.extend_from_slice(right);
339 self.views
340 .push(make_view(&self.data[offset..], 0, view_offset));
341 } else {
342 self.inline.extend_from_slice(left);
343 self.inline.extend_from_slice(right);
344 self.views.push(make_view(&self.inline, 0, 0));
345 self.inline.clear();
346 }
347 }
348
349 #[inline]
351 fn append_empty_view(&mut self) {
352 self.views.push(0);
353 }
354
355 fn finish(
356 self,
357 null_buffer: Option<NullBuffer>,
358 ) -> Result<GenericByteViewArray<T>, ArrowError> {
359 if let Some(ref nulls) = null_buffer
360 && nulls.len() != self.views.len()
361 {
362 return Err(ArrowError::ComputeError(format!(
363 "Null buffer length ({}) must match row count ({})",
364 nulls.len(),
365 self.views.len()
366 )));
367 }
368
369 let buffers = if self.data.is_empty() {
370 Arc::from([])
371 } else {
372 Arc::from([Buffer::from(self.data)])
373 };
374
375 let array = unsafe {
379 GenericByteViewArray::<T>::new_unchecked(
380 ScalarBuffer::from(self.views),
381 buffers,
382 null_buffer,
383 )
384 };
385 Ok(array)
386 }
387}
388
389pub fn concat_elements_binary_view_array(
396 left: &BinaryViewArray,
397 right: &BinaryViewArray,
398) -> Result<BinaryViewArray, ArrowError> {
399 ConcatByteViewBuilder::concat_elements_view_array(left, right)
400}
401
402pub fn concat_elements_string_view_array(
410 left: &StringViewArray,
411 right: &StringViewArray,
412) -> Result<StringViewArray, ArrowError> {
413 ConcatByteViewBuilder::concat_elements_view_array(left, right)
414}
415
416pub fn concat_elements_dyn(left: &dyn Array, right: &dyn Array) -> Result<ArrayRef, ArrowError> {
427 match (left.data_type(), right.data_type()) {
428 (DataType::Utf8, DataType::Utf8) => {
429 let left = left.as_any().downcast_ref::<StringArray>().unwrap();
430 let right = right.as_any().downcast_ref::<StringArray>().unwrap();
431 Ok(Arc::new(concat_elements_utf8(left, right)?))
432 }
433 (DataType::Utf8View, DataType::Utf8View) => {
434 let left = left.as_any().downcast_ref::<StringViewArray>().unwrap();
435 let right = right.as_any().downcast_ref::<StringViewArray>().unwrap();
436 Ok(Arc::new(concat_elements_string_view_array(left, right)?))
437 }
438 (DataType::LargeUtf8, DataType::LargeUtf8) => {
439 let left = left.as_any().downcast_ref::<LargeStringArray>().unwrap();
440 let right = right.as_any().downcast_ref::<LargeStringArray>().unwrap();
441 Ok(Arc::new(concat_elements_utf8(left, right)?))
442 }
443 (DataType::Binary, DataType::Binary) => {
444 let left = left.as_any().downcast_ref::<BinaryArray>().unwrap();
445 let right = right.as_any().downcast_ref::<BinaryArray>().unwrap();
446 Ok(Arc::new(concat_element_binary(left, right)?))
447 }
448 (DataType::BinaryView, DataType::BinaryView) => {
449 let left = left.as_any().downcast_ref::<BinaryViewArray>().unwrap();
450 let right = right.as_any().downcast_ref::<BinaryViewArray>().unwrap();
451 Ok(Arc::new(concat_elements_binary_view_array(left, right)?))
452 }
453 (DataType::LargeBinary, DataType::LargeBinary) => {
454 let left = left.as_any().downcast_ref::<LargeBinaryArray>().unwrap();
455 let right = right.as_any().downcast_ref::<LargeBinaryArray>().unwrap();
456 Ok(Arc::new(concat_element_binary(left, right)?))
457 }
458 (DataType::FixedSizeBinary(_), DataType::FixedSizeBinary(_)) => {
459 let left = left
460 .as_any()
461 .downcast_ref::<FixedSizeBinaryArray>()
462 .unwrap();
463 let right = right
464 .as_any()
465 .downcast_ref::<FixedSizeBinaryArray>()
466 .unwrap();
467 Ok(Arc::new(concat_elements_fixed_size_binary(left, right)?))
468 }
469 (l, r) => {
471 if l != r {
472 Err(ArrowError::ComputeError(format!(
473 "Cannot concat arrays of different types: {l} != {r}"
474 )))
475 } else {
476 Err(ArrowError::NotYetImplemented(format!(
477 "concat not supported for {}",
478 left.data_type()
479 )))
480 }
481 }
482 }
483}
484
485#[cfg(test)]
486mod tests {
487 use super::*;
488 use arrow_array::cast::AsArray;
489 use arrow_buffer::Buffer;
490
491 #[test]
492 fn test_string_concat() {
493 let left = [Some("foo"), Some("bar"), None]
494 .into_iter()
495 .collect::<StringArray>();
496 let right = [None, Some("yyy"), Some("zzz")]
497 .into_iter()
498 .collect::<StringArray>();
499
500 let output = concat_elements_dyn(&left, &right).unwrap();
501
502 let expected = [None, Some("baryyy"), None]
503 .into_iter()
504 .collect::<StringArray>();
505
506 assert_eq!(output.as_string(), &expected);
507 }
508
509 #[test]
510 fn test_string_concat_empty_string() {
511 let left = [Some("foo"), Some(""), Some("bar")]
512 .into_iter()
513 .collect::<StringArray>();
514 let right = [Some("baz"), Some(""), Some("")]
515 .into_iter()
516 .collect::<StringArray>();
517
518 let output = concat_elements_dyn(&left, &right).unwrap();
519
520 let expected = [Some("foobaz"), Some(""), Some("bar")]
521 .into_iter()
522 .collect::<StringArray>();
523
524 assert_eq!(output.as_string(), &expected);
525 }
526
527 #[test]
528 fn test_string_concat_no_null() {
529 let left = StringArray::from(vec!["foo", "bar"]);
530 let right = StringArray::from(vec!["bar", "baz"]);
531
532 let output = concat_elements_dyn(&left, &right).unwrap();
533
534 let expected = StringArray::from(vec!["foobar", "barbaz"]);
535
536 assert_eq!(output.as_string(), &expected);
537 }
538
539 #[test]
540 fn test_string_concat_error() {
541 let left = StringArray::from(vec!["foo", "bar"]);
542 let right = StringArray::from(vec!["baz"]);
543
544 let output = concat_elements_dyn(&left, &right);
545
546 assert_eq!(
547 output.unwrap_err().to_string(),
548 "Compute error: Arrays must have the same length: 2 != 1".to_string()
549 );
550 }
551
552 #[test]
553 fn test_string_concat_slice() {
554 let left = &StringArray::from(vec![None, Some("foo"), Some("bar"), Some("baz")]);
555 let right = &StringArray::from(vec![Some("boo"), None, Some("far"), Some("faz")]);
556
557 let left_slice = left.slice(0, 3);
558 let right_slice = right.slice(1, 3);
559 let output = concat_elements_dyn(
560 left_slice
561 .as_any()
562 .downcast_ref::<GenericStringArray<i32>>()
563 .unwrap(),
564 right_slice
565 .as_any()
566 .downcast_ref::<GenericStringArray<i32>>()
567 .unwrap(),
568 )
569 .unwrap();
570
571 let expected = [None, Some("foofar"), Some("barfaz")]
572 .into_iter()
573 .collect::<StringArray>();
574
575 assert_eq!(output.as_string(), &expected);
576
577 let left_slice = left.slice(2, 2);
578 let right_slice = right.slice(1, 2);
579
580 let output = concat_elements_dyn(
581 left_slice
582 .as_any()
583 .downcast_ref::<GenericStringArray<i32>>()
584 .unwrap(),
585 right_slice
586 .as_any()
587 .downcast_ref::<GenericStringArray<i32>>()
588 .unwrap(),
589 )
590 .unwrap();
591
592 let expected = [None, Some("bazfar")].into_iter().collect::<StringArray>();
593
594 assert_eq!(output.as_string(), &expected);
595 }
596
597 #[test]
598 fn test_concat_slice_capacity() {
599 let left = StringArray::from(vec!["hello"; 8]).slice(2, 3);
600 let right = StringArray::from(vec![" world"; 8]).slice(4, 3);
601
602 let pair = concat_elements_utf8(&left, &right).unwrap();
603 assert_eq!(pair, StringArray::from(vec!["hello world"; 3]));
604 assert_eq!(pair.values().capacity(), 33);
605
606 let many = concat_elements_utf8_many(&[&left, &right, &left]).unwrap();
607 assert_eq!(many, StringArray::from(vec!["hello worldhello"; 3]));
608 assert_eq!(many.values().capacity(), 48);
609 }
610
611 #[test]
612 fn test_string_concat_error_empty() {
613 assert_eq!(
614 concat_elements_utf8_many::<i32>(&[])
615 .unwrap_err()
616 .to_string(),
617 "Compute error: concat requires input of at least one array".to_string()
618 );
619 }
620
621 #[test]
622 fn test_string_concat_one() {
623 let expected = [None, Some("baryyy"), None]
624 .into_iter()
625 .collect::<StringArray>();
626
627 let output = concat_elements_utf8_many(&[&expected]).unwrap();
628
629 assert_eq!(output, expected);
630 }
631
632 #[test]
633 fn test_string_concat_many() {
634 let foo = StringArray::from(vec![Some("f"), Some("o"), Some("o"), None]);
635 let bar = StringArray::from(vec![None, Some("b"), Some("a"), Some("r")]);
636 let baz = StringArray::from(vec![Some("b"), None, Some("a"), Some("z")]);
637
638 let output = concat_elements_utf8_many(&[&foo, &bar, &baz]).unwrap();
639
640 let expected = [None, None, Some("oaa"), None]
641 .into_iter()
642 .collect::<StringArray>();
643
644 assert_eq!(output, expected);
645 }
646
647 #[test]
648 fn test_fixed_size_binary_concat() {
649 let left = FixedSizeBinaryArray::try_from(vec![Some(b"foo" as &[u8]), Some(b"bar"), None])
650 .unwrap();
651 let right = FixedSizeBinaryArray::try_from(vec![None, Some(b"yyy" as &[u8]), Some(b"zzz")])
652 .unwrap();
653
654 let output = concat_elements_dyn(&left, &right).unwrap();
655
656 let expected =
657 FixedSizeBinaryArray::try_from(vec![None, Some(b"baryyy" as &[u8]), None]).unwrap();
658 assert_eq!(output.as_fixed_size_binary(), &expected);
659 }
660
661 #[test]
662 fn test_mixed_fixed_size_binary_concat() {
663 let left =
664 FixedSizeBinaryArray::try_from(vec![Some(b"foobar" as &[u8]), Some(b"barbaz"), None])
665 .unwrap();
666 let right = FixedSizeBinaryArray::try_from(vec![None, Some(b"yyy" as &[u8]), Some(b"zzz")])
667 .unwrap();
668
669 let output = concat_elements_dyn(&left, &right).unwrap();
670
671 let expected =
672 FixedSizeBinaryArray::try_from(vec![None, Some(b"barbazyyy" as &[u8]), None]).unwrap();
673 assert_eq!(output.as_fixed_size_binary(), &expected);
674 }
675
676 #[test]
677 fn test_fixed_size_binary_concat_no_null() {
678 let left = FixedSizeBinaryArray::try_from(vec![b"ab" as &[u8], b"cd"]).unwrap();
679 let right = FixedSizeBinaryArray::try_from(vec![b"12" as &[u8], b"34"]).unwrap();
680
681 let output = concat_elements_dyn(&left, &right).unwrap();
682
683 let expected = FixedSizeBinaryArray::try_from(vec![b"ab12" as &[u8], b"cd34"]).unwrap();
684 assert_eq!(output.as_fixed_size_binary(), &expected);
685 }
686
687 #[test]
688 fn test_fixed_size_binary_concat_error() {
689 let left = FixedSizeBinaryArray::try_from(vec![b"ab" as &[u8], b"cd"]).unwrap();
690 let right = FixedSizeBinaryArray::try_from(vec![b"12" as &[u8]]).unwrap();
691
692 let output = concat_elements_dyn(&left, &right);
693 assert_eq!(
694 output.unwrap_err().to_string(),
695 "Compute error: Arrays must have the same length: 2 != 1".to_string()
696 );
697 }
698
699 #[test]
700 fn test_fixed_size_binary_concat_width_overflow() {
701 let width = 0x7000_0000_i32;
702 let left =
703 FixedSizeBinaryArray::try_new(width, Buffer::from(Vec::<u8>::new()), None).unwrap();
704 let right =
705 FixedSizeBinaryArray::try_new(width, Buffer::from(Vec::<u8>::new()), None).unwrap();
706
707 let output = concat_elements_fixed_size_binary(&left, &right);
708 assert_eq!(
709 output.unwrap_err().to_string(),
710 "Invalid argument error: Concatenated FixedSizeBinary value length 3758096384 exceeds i32".to_string()
711 );
712 }
713
714 #[test]
715 fn test_fixed_size_binary_concat_empty() {
716 let left = FixedSizeBinaryArray::new(0, Buffer::from(&[]), None);
717 let right = FixedSizeBinaryArray::new(0, Buffer::from(&[]), None);
718
719 let output = concat_elements_dyn(&left, &right).unwrap();
720
721 let expected = FixedSizeBinaryArray::new(0, Buffer::from(&[]), None);
722 assert_eq!(output.as_fixed_size_binary(), &expected);
723 }
724
725 #[test]
726 fn test_binary_view_concat() {
727 let long = b"ThisStringIsLongerThan12Bytes" as &[u8];
728 let left = BinaryViewArray::from_iter(vec![
729 Some(b"foo" as &[u8]),
730 Some(b"bar"),
731 None,
732 Some(b"foofoofoo"),
733 Some(b"foo"),
734 Some(long),
735 Some(long),
736 ]);
737 let right = BinaryViewArray::from_iter(vec![
738 None,
739 Some(b"yyy" as &[u8]),
740 Some(b"zzz"),
741 Some(b"barbarbar"),
742 Some(long),
743 Some(b"bar"),
744 Some(long),
745 ]);
746
747 let output = concat_elements_binary_view_array(&left, &right).unwrap();
748
749 let expected = BinaryViewArray::from_iter(vec![
750 None,
751 Some(b"baryyy" as &[u8]),
752 None,
753 Some(b"foofoofoobarbarbar"),
754 Some(b"fooThisStringIsLongerThan12Bytes"),
755 Some(b"ThisStringIsLongerThan12Bytesbar"),
756 Some(b"ThisStringIsLongerThan12BytesThisStringIsLongerThan12Bytes"),
757 ]);
758 assert_eq!(output, expected);
759 }
760
761 #[test]
762 fn test_string_view_concat() {
763 let long = "ThisStringIsLongerThan12Bytes";
764 let left = StringViewArray::from_iter(vec![
765 Some("foo"),
766 Some("bar"),
767 None,
768 Some("foofoofoo"),
769 Some("foo"),
770 Some(long),
771 Some(long),
772 ]);
773 let right = StringViewArray::from_iter(vec![
774 None,
775 Some("yyy"),
776 Some("zzz"),
777 Some("barbarbar"),
778 Some(long),
779 Some("bar"),
780 Some(long),
781 ]);
782
783 let output = concat_elements_dyn(&left, &right).unwrap();
784
785 let expected = StringViewArray::from_iter(vec![
786 None,
787 Some("baryyy"),
788 None,
789 Some("foofoofoobarbarbar"),
790 Some("fooThisStringIsLongerThan12Bytes"),
791 Some("ThisStringIsLongerThan12Bytesbar"),
792 Some("ThisStringIsLongerThan12BytesThisStringIsLongerThan12Bytes"),
793 ]);
794 assert_eq!(output.as_string_view(), &expected);
795
796 let left = StringViewArray::from_iter(vec![
797 Some("a"),
798 Some("b"),
799 Some("foofoofoo"),
800 Some("a"),
801 Some(long),
802 Some(long),
803 ]);
804 let right = StringViewArray::from_iter(vec![
805 Some("c"),
806 Some("d"),
807 Some("barbarbar"),
808 Some(long),
809 Some("d"),
810 Some(long),
811 ]);
812
813 let output = concat_elements_dyn(&left, &right).unwrap();
814
815 let expected = StringViewArray::from_iter(vec![
816 Some("ac"),
817 Some("bd"),
818 Some("foofoofoobarbarbar"),
819 Some("aThisStringIsLongerThan12Bytes"),
820 Some("ThisStringIsLongerThan12Bytesd"),
821 Some("ThisStringIsLongerThan12BytesThisStringIsLongerThan12Bytes"),
822 ]);
823 assert_eq!(output.as_string_view(), &expected);
824 }
825
826 #[test]
827 fn test_binary_view_concat_no_null() {
828 let left = BinaryViewArray::from_iter(vec![
829 Some(b"foo" as &[u8]),
830 Some(b"bar"),
831 Some(b""),
832 Some(b"baz"),
833 ]);
834 let right = BinaryViewArray::from_iter(vec![
835 Some(b"bar" as &[u8]),
836 Some(b"baz"),
837 Some(b""),
838 Some(b""),
839 ]);
840
841 let output = concat_elements_dyn(&left, &right).unwrap();
842
843 let expected = BinaryViewArray::from_iter(vec![
844 Some(b"foobar" as &[u8]),
845 Some(b"barbaz"),
846 Some(b""),
847 Some(b"baz"),
848 ]);
849 assert_eq!(output.as_binary_view(), &expected);
850 }
851
852 #[test]
853 fn test_binary_view_concat_error() {
854 let left = BinaryViewArray::from_iter(vec![Some(b"foo" as &[u8]), Some(b"bar")]);
855 let right = BinaryViewArray::from_iter(vec![Some(b"baz" as &[u8])]);
856
857 let output = concat_elements_dyn(&left, &right);
858 assert_eq!(
859 output.unwrap_err().to_string(),
860 "Compute error: Arrays must have the same length: 2 != 1".to_string()
861 );
862 }
863
864 #[test]
865 fn test_binary_view_concat_empty() {
866 let left = BinaryViewArray::from_iter(vec![] as Vec<Option<&[u8]>>);
867 let right = BinaryViewArray::from_iter(vec![] as Vec<Option<&[u8]>>);
868
869 let output = concat_elements_dyn(&left, &right).unwrap();
870 let expected = BinaryViewArray::from_iter(vec![] as Vec<Option<&[u8]>>);
871 assert_eq!(output.as_binary_view(), &expected);
872 }
873
874 #[test]
875 fn test_concat_dyn_same_type() {
876 let left = StringArray::from(vec![Some("foo"), Some("bar"), None]);
878 let right = StringArray::from(vec![None, Some("yyy"), Some("zzz")]);
879
880 let output = concat_elements_dyn(&left, &right).unwrap();
881 let expected = StringArray::from(vec![None, Some("baryyy"), None]);
882 assert_eq!(output.as_string(), &expected);
883
884 let left = LargeStringArray::from(vec![Some("foo"), Some("bar"), None]);
886 let right = LargeStringArray::from(vec![None, Some("yyy"), Some("zzz")]);
887
888 let output = concat_elements_dyn(&left, &right).unwrap();
889 let expected = LargeStringArray::from(vec![None, Some("baryyy"), None]);
890 assert_eq!(output.as_string(), &expected);
891
892 let left = BinaryArray::from_opt_vec(vec![Some(b"foo"), Some(b"bar"), None]);
894 let right = BinaryArray::from_opt_vec(vec![None, Some(b"yyy"), Some(b"zzz")]);
895 let output = concat_elements_dyn(&left, &right).unwrap();
896 let expected = BinaryArray::from_opt_vec(vec![None, Some(b"baryyy"), None]);
897 assert_eq!(output.as_binary(), &expected);
898
899 let left = LargeBinaryArray::from_opt_vec(vec![Some(b"foo"), Some(b"bar"), None]);
901 let right = LargeBinaryArray::from_opt_vec(vec![None, Some(b"yyy"), Some(b"zzz")]);
902 let output = concat_elements_dyn(&left, &right).unwrap();
903 let expected = LargeBinaryArray::from_opt_vec(vec![None, Some(b"baryyy"), None]);
904 assert_eq!(output.as_binary(), &expected);
905
906 let long = b"ThisStringIsLongerThan12Bytes" as &[u8];
908 let left = BinaryViewArray::from_iter(vec![
909 Some(b"foo" as &[u8]),
910 Some(b"bar"),
911 None,
912 Some(b"foofoofoo"),
913 Some(b"foo"),
914 Some(long),
915 Some(long),
916 ]);
917 let right = BinaryViewArray::from_iter(vec![
918 None,
919 Some(b"yyy" as &[u8]),
920 Some(b"zzz"),
921 Some(b"barbarbar"),
922 Some(long),
923 Some(b"bar"),
924 Some(long),
925 ]);
926 let output = concat_elements_dyn(&left, &right).unwrap();
927 let expected = BinaryViewArray::from_iter(vec![
928 None,
929 Some(b"baryyy" as &[u8]),
930 None,
931 Some(b"foofoofoobarbarbar"),
932 Some(b"fooThisStringIsLongerThan12Bytes"),
933 Some(b"ThisStringIsLongerThan12Bytesbar"),
934 Some(b"ThisStringIsLongerThan12BytesThisStringIsLongerThan12Bytes"),
935 ]);
936 assert_eq!(output.as_binary_view(), &expected);
937
938 let long = "ThisStringIsLongerThan12Bytes";
940 let left = StringViewArray::from_iter(vec![
941 Some("foo"),
942 Some("bar"),
943 None,
944 Some("foofoofoo"),
945 Some("foo"),
946 Some(long),
947 Some(long),
948 ]);
949 let right = StringViewArray::from_iter(vec![
950 None,
951 Some("yyy"),
952 Some("zzz"),
953 Some("barbarbar"),
954 Some(long),
955 Some("bar"),
956 Some(long),
957 ]);
958 let output = concat_elements_dyn(&left, &right).unwrap();
959 let expected = StringViewArray::from_iter(vec![
960 None,
961 Some("baryyy"),
962 None,
963 Some("foofoofoobarbarbar"),
964 Some("fooThisStringIsLongerThan12Bytes"),
965 Some("ThisStringIsLongerThan12Bytesbar"),
966 Some("ThisStringIsLongerThan12BytesThisStringIsLongerThan12Bytes"),
967 ]);
968 assert_eq!(output.as_string_view(), &expected);
969
970 let left = FixedSizeBinaryArray::try_from(vec![Some(b"foo" as &[u8]), Some(b"bar"), None])
972 .unwrap();
973 let right = FixedSizeBinaryArray::try_from(vec![None, Some(b"yyy" as &[u8]), Some(b"zzz")])
974 .unwrap();
975 let output = concat_elements_dyn(&left, &right).unwrap();
976 let expected =
977 FixedSizeBinaryArray::try_from(vec![None, Some(b"baryyy" as &[u8]), None]).unwrap();
978 assert_eq!(output.as_fixed_size_binary(), &expected);
979 }
980
981 #[test]
982 fn test_concat_dyn_different_type() {
983 let left = StringArray::from(vec![Some("foo"), Some("bar"), None]);
984 let right = LargeStringArray::from(vec![None, Some("1"), Some("2")]);
985
986 let output = concat_elements_dyn(&left, &right);
987 assert_eq!(
988 output.unwrap_err().to_string(),
989 "Compute error: Cannot concat arrays of different types: Utf8 != LargeUtf8".to_string()
990 );
991 }
992}