Repository: pola-rs/polars
File: crates/polars-compute/src/cast/binview_to.rs (Rust)

Code before:
    T: FromBytes + NativeType,
    for<'a> &'a <T as FromBytes>::Bytes: TryFrom<&'a [u8]>,
{
    let from = from.as_any().downcast_ref().unwrap();
    Ok(Box::new(binview_to_primitive::<T>(
        from,
        to,
        is_little_endian,
    )))
}

/// Casts a [`BinaryArray`] to a [`FixedSizeListArray`], making any un-castable value a Null.
///
/// # Arguments
///
/// * `array_items`: The number of items in each `Array`.
pub(super) fn try_binview_to_fixed_size_list<T, const IS_LITTLE_ENDIAN: bool>(
    from: &BinaryViewArray,
    array_items: usize,
) -> PolarsResult<FixedSizeListArray>
where
    T: FromBytes + NativeType,
    for<'a> &'a <T as FromBytes>::Bytes: TryFrom<&'a [u8]>,
{
    let element_size = std::mem::size_of::<T>();
    let from_bytes = if IS_LITTLE_ENDIAN {
        <T as FromBytes>::from_le_bytes
    } else {
        <T as FromBytes>::from_be_bytes
    };

    // It would be nice to have a fast path that just use a memory copy.
    // However, that is only possible if all the binaryviews are the correct
    // length, and checking that requires iterating over all of them, so it's
    // not obvious that would actually be much of a speed up.
    let primitive_length = from.len() * array_items;
    let mut out: Vec<T> = Vec::with_capacity(primitive_length);
    let mut validity = MutableBitmap::from_len_set(from.len());

    // Values for primitive array when values are NULL, so we don't leave
    // uninitialized memory.
    let empty = vec![T::default(); array_items];

    for (index, value) in from.iter().enumerate() {
        if let Some(value) = value
            && value.len() == element_size * array_items
        {
            for j in 0..array_items {
                let jth_bytes = &value[(j * element_size)..((j + 1) * element_size)];
                // # Safety
                // We just made sure that the slice has length `element_size`

Review comment (performance):
The `let from_bytes` becomes an `fn` pointer type here - please in-line this code into the loop below instead:

```
if IS_LITTLE_ENDIAN {
  from_le_bytes(bytes.try_into().unwrap())
else {
  from_be_bytes(bytes.try_into().unwrap())
}
```

We want to avoid unnecessarily using `fn` function pointer types since they are also used to generically represent FFI pointers. Even though in this case, the compiler generates the same optimized code (https://godbolt.org/z/zjK31qh9z), I'd rather avoid needing to check this at all.


Code after:
    let from = from.as_any().downcast_ref().unwrap();
    Ok(Box::new(binview_to_primitive::<T>(
        from,
        to,
        is_little_endian,
    )))
}

/// Casts a [`BinaryViewArray`] to a [`FixedSizeListArray`], making any un-castable value a Null.
///
/// # Arguments
///
/// * `from`: The array to reinterpret.
/// * `array_width`: The number of items in each `Array`.
pub(super) fn try_binview_to_fixed_size_list<T, const IS_LITTLE_ENDIAN: bool>(
    from: &BinaryViewArray,
    array_width: usize,
) -> PolarsResult<FixedSizeListArray>
where
    T: FromBytes + NativeType,
    for<'a> &'a <T as FromBytes>::Bytes: TryFrom<&'a [u8]>,
{
    let element_size = std::mem::size_of::<T>();
    // The maximum number of primitives in the result:
    let primitive_length = from.len().checked_mul(array_width).ok_or_else(|| {
        polars_err!(
            InvalidOperation:
            "array chunk length * number of items ({} * {}) is too large",
            from.len(),
            array_width
        )
    })?;
    // The size of each array, in bytes:
    let row_size_bytes = element_size.checked_mul(array_width).ok_or_else(|| {
        polars_err!(
            InvalidOperation:
            "array size in bytes ({} * {}) is too large",
            element_size,
            array_width
        )
    })?;

    let mut out: Vec<T> = vec![T::zeroed(); primitive_length];
    let (out_u8_ptr, out_len_bytes) = {
        let out_u8_slice = cast_slice_mut::<_, u8>(out.as_mut());
        (out_u8_slice.as_mut_ptr(), out_u8_slice.len())
    };
    assert_eq!(out_len_bytes, row_size_bytes * from.len());
    let mut validity = MutableBitmap::from_len_set(from.len());

    for (index, value) in from.iter().enumerate() {