Enum vortex::validity::Validity

pub enum Validity {
    NonNullable,
    AllValid,
    AllInvalid,
    Array(Array),
}

Variants

NonNullable

AllValid

AllInvalid

Array(Array)

Implementations

impl Validity

pub const DTYPE: DType = _

pub fn into_array(self) -> Option<Array>

pub fn to_metadata(&self, length: usize) -> VortexResult<ValidityMetadata>

pub fn as_array(&self) -> Option<&Array>

pub fn nullability(&self) -> Nullability

pub fn is_valid(&self, index: usize) -> bool

pub fn is_null(&self, index: usize) -> bool

pub fn slice(&self, start: usize, stop: usize) -> VortexResult<Self>

pub fn take(&self, indices: &Array) -> VortexResult<Self>

pub fn filter(&self, predicate: &Array) -> VortexResult<Self>

pub fn to_logical(&self, length: usize) -> LogicalValidity

pub fn and(self, rhs: Validity) -> VortexResult<Validity>

Logically & two Validity values of the same length

pub fn into_nullable(self) -> Validity

Convert into a nullable variant

Trait Implementations

impl Clone for Validity

fn clone(&self) -> Validity

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Validity

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

Formats the value using the given formatter.

impl From<BooleanBuffer> for Validity

fn from(value: BooleanBuffer) -> Self

Converts to this type from the input type.

impl From<NullBuffer> for Validity

fn from(value: NullBuffer) -> Self

Converts to this type from the input type.

impl From<Vec<bool>> for Validity

fn from(bools: Vec<bool>) -> Self

Converts to this type from the input type.

impl<'a, E> FromIterator<&'a Option<E>> for Validity

fn from_iter<T: IntoIterator<Item = &'a Option<E>>>(iter: T) -> Self

Creates a value from an iterator.

impl FromIterator<LogicalValidity> for Validity

fn from_iter<T: IntoIterator<Item = LogicalValidity>>(iter: T) -> Self

Creates a value from an iterator.

impl PartialEq for Validity

fn eq(&self, other: &Self) -> 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.