Add cast support for (Large)ListView <-> (Large)List

Author: vegarsti

arrow-array/src/array/list_view_array.rs

@@ -24,7 +24,10 @@ use std::sync::Arc;
 
 use crate::array::{make_array, print_long_array};
 use crate::iterator::GenericListViewArrayIter;
-use crate::{Array, ArrayAccessor, ArrayRef, FixedSizeListArray, OffsetSizeTrait, new_empty_array};
+use crate::{
+    Array, ArrayAccessor, ArrayRef, FixedSizeListArray, GenericListArray, OffsetSizeTrait,
+    new_empty_array,
+};
 
 /// A [`GenericListViewArray`] of variable size lists, storing offsets as `i32`.
 pub type ListViewArray = GenericListViewArray<i32>;
@@ -454,6 +457,36 @@ impl<OffsetSize: OffsetSizeTrait> std::fmt::Debug for GenericListViewArray<Offse
     }
 }
 
+impl<OffsetSize: OffsetSizeTrait> From<GenericListArray<OffsetSize>>
+    for GenericListViewArray<OffsetSize>
+{
+    fn from(value: GenericListArray<OffsetSize>) -> Self {
+        let field = match value.data_type() {
+            DataType::List(f) | DataType::LargeList(f) => f.clone(),
+            _ => panic!(
+                "Expected infallible creation of GenericListViewArray from GenericList failed"
+            ),
+        };
+
+        let offsets = value.value_offsets();
+        let len = offsets.len() - 1;
+        let mut sizes = Vec::with_capacity(len);
+        let mut view_offsets = Vec::with_capacity(len);
+        for (i, offset) in offsets.iter().enumerate().take(len) {
+            view_offsets.push(*offset);
+            sizes.push(value.value_length(i));
+        }
+
+        Self::new(
+            field,
+            ScalarBuffer::from(view_offsets),
+            ScalarBuffer::from(sizes),
+            value.values().clone(),
+            value.nulls().cloned(),
+        )
+    }
+}
+
 impl<OffsetSize: OffsetSizeTrait> From<GenericListViewArray<OffsetSize>> for ArrayData {
     fn from(array: GenericListViewArray<OffsetSize>) -> Self {
         let len = array.len();

arrow-cast/src/cast/list.rs

@@ -50,6 +50,15 @@ pub(crate) fn cast_single_element_fixed_size_list_to_values(
     cast_with_options(values, to, cast_options)
 }
 
+pub(crate) fn cast_list_to_list_view<OffsetSize>(array: &dyn Array) -> Result<ArrayRef, ArrowError>
+where
+    OffsetSize: OffsetSizeTrait,
+{
+    let list = array.as_list::<OffsetSize>();
+    let list_view: GenericListViewArray<OffsetSize> = list.clone().into();
+    Ok(Arc::new(list_view))
+}
+
 pub(crate) fn cast_fixed_size_list_to_list<OffsetSize>(
     array: &dyn Array,
 ) -> Result<ArrayRef, ArrowError>
@@ -160,6 +169,70 @@ pub(crate) fn cast_list_values<O: OffsetSizeTrait>(
     )?))
 }
 
+/// Helper function to cast a list view to a list
+pub(crate) fn cast_list_view_to_list<O: OffsetSizeTrait>(
+    array: &dyn Array,
+    to: &FieldRef,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    let list_view = array.as_list_view::<O>();
+    let list_view_offsets = list_view.offsets();
+    let sizes = list_view.sizes();
+    let source_values = list_view.values();
+
+    // Construct the indices and offsets for the new list array by iterating over the list view subarrays
+    let mut indices = Vec::with_capacity(list_view.values().len());
+    let mut offsets = Vec::with_capacity(list_view.len() + 1);
+    // Add the offset for the first subarray
+    offsets.push(O::usize_as(0));
+    for i in 0..list_view.len() {
+        // For each subarray, add the indices of the values to take
+        let offset = list_view_offsets[i].as_usize();
+        let size = sizes[i].as_usize();
+        let end = offset + size;
+        for j in offset..end {
+            indices.push(j as i32);
+        }
+        // Add the offset for the next subarray
+        offsets.push(O::usize_as(indices.len()));
+    }
+
+    // Take the values from the source values using the indices, creating a new array
+    let values = arrow_select::take::take(source_values, &Int32Array::from(indices), None)?;
+
+    // Cast the values to the target data type
+    let values = cast_with_options(&values, to.data_type(), cast_options)?;
+
+    Ok(Arc::new(GenericListArray::<O>::try_new(
+        to.clone(),
+        OffsetBuffer::new(offsets.into()),
+        values,
+        list_view.nulls().cloned(),
+    )?))
+}
+
+pub(crate) fn cast_list_view<I: OffsetSizeTrait, O: OffsetSizeTrait>(
+    array: &dyn Array,
+    to_field: &FieldRef,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    let list_view = array.as_list_view::<I>();
+    let (_field, offsets, sizes, values, nulls) = list_view.clone().into_parts();
+
+    // Recursively cast values
+    let values = cast_with_options(&values, to_field.data_type(), cast_options)?;
+
+    let new_offsets: Vec<_> = offsets.iter().map(|x| O::usize_as(x.as_usize())).collect();
+    let new_sizes: Vec<_> = sizes.iter().map(|x| O::usize_as(x.as_usize())).collect();
+    Ok(Arc::new(GenericListViewArray::<O>::try_new(
+        to_field.clone(),
+        new_offsets.into(),
+        new_sizes.into(),
+        values,
+        nulls,
+    )?))
+}
+
 /// Cast the container type of List/Largelist array along with the inner datatype
 pub(crate) fn cast_list<I: OffsetSizeTrait, O: OffsetSizeTrait>(
     array: &dyn Array,