Method try_value

parquet-variant-compute/src/variant_array.rs:398–421

Return the [`Variant`] instance stored at the given row Note: This method does not check for nulls and the value is arbitrary (but still well-defined) if [`is_null`](Self::is_null) returns true for the index. # Panics Panics if the index is out of bounds the array value is null # Errors Errors if - the data in `typed_value` cannot be interpreted as a valid `Variant` If this is a shredded var

(&self, index: usize)

    /// Note: Does not do deep validation of the [`Variant`], so it is up to the
    /// caller to ensure that the metadata and value were constructed correctly.
    pub fn try_value(&self, index: usize) -> Result<Variant<'_, '_>> {
        match (self.typed_value_field(), self.value_field()) {
            // Always prefer typed_value, if available
            (Some(typed_value), value) if typed_value.is_valid(index) => {
                typed_value_to_variant(typed_value, value, index)
            }
            // Otherwise fall back to value, if available
            (_, Some(value)) if value.is_valid(index) => variant_from_arrays_at(
                &self.metadata,
                value,
                index,
            )
            .ok_or_else(|| {
                ArrowError::InvalidArgumentError(format!(
                    "metadata and value fields must be binary-like arrays, instead got {} and {}",
                    self.metadata.data_type(),
                    value.data_type()
                ))
            }),
            // It is technically invalid for neither value nor typed_value fields to be available,
            // but the spec specifically requires readers to return Variant::Null in this case.
            _ => Ok(Variant::Null),
        }
    }

    /// Return a reference to the metadata field of the [`StructArray`]
    pub fn metadata_field(&self) -> &ArrayRef {