Struct ShreddingState 

pub struct ShreddingState {
    value: Option<BinaryViewArray>,
    typed_value: Option<ArrayRef>,
}

Represents the shredding state of a VariantArray

VariantArrays can be shredded according to the Parquet Variant Shredding Spec. Shredding means that the actual value is stored in a typed typed_field instead of the generic value field.

Both value and typed_value are optional fields used together to encode a single value. Values in the two fields must be interpreted according to the following table (see Parquet Variant Shredding Spec for more details):

value	typed_value	Meaning
NULL	NULL	The value is missing; only valid for shredded object fields
non-NULL	NULL	The value is present and may be any type, including [Variant::Null]
NULL	non-NULL	The value is present and is the shredded type
non-NULL	non-NULL	The value is present and is a partially shredded object

Applying the above rules to entire columns, we obtain the following:

value	typed_value	Meaning
–	–	Missing: The value is always missing; only valid for shredded object fields
exists	–	Unshredded: If present, the value may be any type, including [Variant::Null]
–	exists	Perfectly shredded: If present, the value is always the shredded type
exists	exists	Imperfectly shredded: The value might (not) be present and might (not) be the shredded type

NOTE: Partial shredding is a row-wise situation that can arise under imperfect shredding (a column-wise situation): When both columns exist (imperfect shredding) and the typed_value column is a struct, then both columns can be non-NULL for the same row if value is a variant object (partial shredding).

Fields

value: Option<BinaryViewArray>

typed_value: Option<ArrayRef>

Implementations

impl ShreddingState

pub fn new( value: Option<BinaryViewArray>, typed_value: Option<ArrayRef>, ) -> Self

Create a new ShreddingState from the given value and typed_value fields

Note you can create a ShreddingState from a &[StructArray] using ShreddingState::try_from(&struct_array), for example:

let struct_array: StructArray = get_struct_array();
let shredding_state = ShreddingState::try_from(&struct_array).unwrap();

pub fn value_field(&self) -> Option<&BinaryViewArray>

Return a reference to the value field, if present

pub fn typed_value_field(&self) -> Option<&ArrayRef>

Return a reference to the typed_value field, if present

pub fn borrow(&self) -> BorrowedShreddingState<'_>

Returns a borrowed version of this shredding state

pub fn slice(&self, offset: usize, length: usize) -> Self

Slice all the underlying arrays

Trait Implementations

impl Clone for ShreddingState

fn clone(&self) -> ShreddingState

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ShreddingState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<BorrowedShreddingState<'_>> for ShreddingState

fn from(state: BorrowedShreddingState<'_>) -> Self

Converts to this type from the input type.

impl PartialEq for ShreddingState

fn eq(&self, other: &ShreddingState) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<&StructArray> for ShreddingState

type Error = ArrowError

The type returned in the event of a conversion error.

fn try_from(inner_struct: &StructArray) -> Result<Self>

Performs the conversion.

impl StructuralPartialEq for ShreddingState