Trait ChunkComponentSlicer

pub trait ChunkComponentSlicer {
    type Item<'a>;

    // Required method
    fn slice<'a>(
        component_descriptor: ComponentDescriptor,
        array: &'a dyn ArrowArray,
        component_spans: impl Iterator<Item = Span<usize>> + 'a,
    ) -> impl Iterator<Item = Self::Item<'a>> + 'a;
}

A ChunkComponentSlicer knows how to efficiently slice component batches out of a Chunk column.

See Chunk::iter_slices and Chunk::iter_slices_from_struct_field.

Required Associated Types

type Item<'a>

Required Methods

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl ChunkComponentSlicer for &[f32]

type Item<'a> = Vec<ScalarBuffer<f32>>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for &[f64]

type Item<'a> = Vec<ScalarBuffer<f64>>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for &[i8]

type Item<'a> = Vec<ScalarBuffer<i8>>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for &[i16]

type Item<'a> = Vec<ScalarBuffer<i16>>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for &[i32]

type Item<'a> = Vec<ScalarBuffer<i32>>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for &[i64]

type Item<'a> = Vec<ScalarBuffer<i64>>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for &[u8]

type Item<'a> = Vec<ScalarBuffer<u8>>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for &[u16]

type Item<'a> = Vec<ScalarBuffer<u16>>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for &[u32]

type Item<'a> = Vec<ScalarBuffer<u32>>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for &[u64]

type Item<'a> = Vec<ScalarBuffer<u64>>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for &[f16]

type Item<'a> = Vec<ScalarBuffer<f16>>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for bool

type Item<'a> = BooleanBuffer

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for f32

type Item<'a> = &'a [f32]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for f64

type Item<'a> = &'a [f64]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for i8

type Item<'a> = &'a [i8]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for i16

type Item<'a> = &'a [i16]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for i32

type Item<'a> = &'a [i32]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for i64

type Item<'a> = &'a [i64]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for u8

type Item<'a> = &'a [u8]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for u16

type Item<'a> = &'a [u16]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for u32

type Item<'a> = &'a [u32]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for u64

type Item<'a> = &'a [u64]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl ChunkComponentSlicer for String

type Item<'a> = Vec<ArrowString>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Vec<ArrowString>> + 'a

impl ChunkComponentSlicer for f16

type Item<'a> = &'a [f16]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[f32; N]]

where [f32; N]: Pod,

type Item<'a> = Vec<&'a [[f32; N]]>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[f64; N]]

where [f64; N]: Pod,

type Item<'a> = Vec<&'a [[f64; N]]>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[i8; N]]

where [i8; N]: Pod,

type Item<'a> = Vec<&'a [[i8; N]]>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[i16; N]]

where [i16; N]: Pod,

type Item<'a> = Vec<&'a [[i16; N]]>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[i32; N]]

where [i32; N]: Pod,

type Item<'a> = Vec<&'a [[i32; N]]>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[i64; N]]

where [i64; N]: Pod,

type Item<'a> = Vec<&'a [[i64; N]]>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[u8; N]]

where [u8; N]: Pod,

type Item<'a> = Vec<&'a [[u8; N]]>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[u16; N]]

where [u16; N]: Pod,

type Item<'a> = Vec<&'a [[u16; N]]>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[u32; N]]

where [u32; N]: Pod,

type Item<'a> = Vec<&'a [[u32; N]]>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[u64; N]]

where [u64; N]: Pod,

type Item<'a> = Vec<&'a [[u64; N]]>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[f16; N]]

where [f16; N]: Pod,

type Item<'a> = Vec<&'a [[f16; N]]>

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [f32; N]

where [f32; N]: Pod,

type Item<'a> = &'a [[f32; N]]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [f64; N]

where [f64; N]: Pod,

type Item<'a> = &'a [[f64; N]]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [i8; N]

where [i8; N]: Pod,

type Item<'a> = &'a [[i8; N]]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [i16; N]

where [i16; N]: Pod,

type Item<'a> = &'a [[i16; N]]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [i32; N]

where [i32; N]: Pod,

type Item<'a> = &'a [[i32; N]]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [i64; N]

where [i64; N]: Pod,

type Item<'a> = &'a [[i64; N]]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [u8; N]

where [u8; N]: Pod,

type Item<'a> = &'a [[u8; N]]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [u16; N]

where [u16; N]: Pod,

type Item<'a> = &'a [[u16; N]]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [u32; N]

where [u32; N]: Pod,

type Item<'a> = &'a [[u32; N]]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [u64; N]

where [u64; N]: Pod,

type Item<'a> = &'a [[u64; N]]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [f16; N]

where [f16; N]: Pod,

type Item<'a> = &'a [[f16; N]]

fn slice<'a>( component_descriptor: ComponentDescriptor, array: &'a dyn ArrowArray, component_spans: impl Iterator<Item = Span<usize>> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

Implementors