Skip to main content

arrow_string/
concat_elements.rs

1// SPDX-License-Identifier: Apache-2.0
2// SPDX-FileCopyrightText: See the NOTICE file distributed with this work for additional information regarding copyright ownership
3// SPDX-FileContributor: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements
4
5//! Provides utility functions for concatenation of elements in arrays.
6
7use 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
17/// Returns the elementwise concatenation of a [`GenericByteArray`].
18///
19/// # Errors
20///
21/// Returns an error if the arrays have different lengths, or if the concatenated
22/// data is too long for the offset type.
23pub 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    // SAFETY - offsets valid by construction
68    Ok(unsafe { builder.build_unchecked() }.into())
69}
70
71/// Returns the elementwise concatenation of a [`GenericStringArray`].
72///
73/// An index of the resulting [`GenericStringArray`] is null if any of
74/// `StringArray` are null at that location.
75///
76/// ```text
77/// e.g:
78///
79///   ["Hello"] + ["World"] = ["HelloWorld"]
80///
81///   ["a", "b"] + [None, "c"] = [None, "bc"]
82/// ```
83///
84/// An error will be returned if `left` and `right` have different lengths
85pub 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
92/// Returns the elementwise concatenation of a [`GenericBinaryArray`].
93pub 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
100/// Returns the elementwise concatenation of [`StringArray`].
101/// ```text
102/// e.g:
103///   ["a", "b"] + [None, "c"] + [None, "d"] = [None, "bcd"]
104/// ```
105///
106/// An error will be returned if the [`StringArray`] are of different lengths
107///
108/// # Errors
109///
110/// Returns an error if the arrays have different lengths, or if the concatenated
111/// data is too long for the offset type.
112pub 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    // SAFETY - offsets valid by construction
173    Ok(unsafe { builder.build_unchecked() }.into())
174}
175
176/// Returns the elementwise concatenation of a [`FixedSizeBinaryArray`].
177///
178/// The result has `value_length = left.value_length() + right.value_length()`.
179/// An index is null if either input is null at that position.
180///
181/// An error will be returned if `left` and `right` have different lengths.
182pub 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    // Pre-compute combined null bitmap so the per-row NULL check is efficient
218    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    /// Returns the elementwise concatenation of two [`GenericByteViewArray`]s.
252    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        // Compute the required data buffer size, excluding any elements that are null
268        // or are small enough to be stored inline. Both lengths are `u32`, and a
269        // pair of them can sum past that, so the addition is done in `usize`.
270        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    /// Append a view containing the concatenation of `left` and `right`.
325    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            // SAFETY: we've checked that the total data size is within i32::MAX
331            // in `concat_elements_view_array`, so offset cannot exceed it.
332            // Not using `u32::try_from` on each insertion makes a ~5% difference
333            // in benchmarking
334            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    /// Append an empty view.
350    #[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        // SAFETY: views were constructed with correct lengths, offsets, and
376        // prefixes. UTF-8 validity is implicitly guaranteed by never concatenating
377        // arrays with mixed ByteViewTypes.
378        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
389/// Concatenates two `BinaryViewArray`s element-wise.
390/// If either element is `Null`, the result element is also `Null`.
391///
392/// # Errors
393/// - Returns an error if the input arrays have different lengths.
394/// - Returns an error if any concatenated value exceeds `u32::MAX` in length.
395pub 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
402/// Concatenates two `StringViewArray`s element-wise.
403/// If either element is `Null`, the result element is also `Null`.
404///
405/// # Errors
406/// - Returns an error if the input arrays have different lengths.
407/// - Returns an error if any concatenated value exceeds `u32::MAX` in length.
408/// - Returns an error if concatenated strings do not result in a proper UTF-8 string
409pub 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
416/// Returns the elementwise concatenation of [`Array`]s.
417///
418/// The output array will have the same type as the input arrays (which must have the same type).
419///
420/// Concatenation of `FixedSizeBinaryArray` instances with different sizes is supported. The output
421/// type is `FixedSizeBinaryArray` with the sum of the sizes of the two input arrays as size.
422///
423/// # Errors
424///
425/// This function errors if the arrays are of different types.
426pub 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        // unimplemented
470        (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        // test for StringArray
877        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        // test for LargeStringArray
885        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        // test for BinaryArray
893        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        // test for LargeBinaryArray
900        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        // test for BinaryViewArray
907        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        // test for StringViewArray
939        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        // test for FixedSizeBinaryArray
971        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}