Enum Validity 

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

Validity information for an array

Variants

NonNullable

Items can’t be null

AllValid

All items are valid

AllInvalid

All items are null

Array(ArrayRef)

The validity of each position in the array is determined by a boolean array.

True values are valid, false values are invalid (“null”).

Implementations

impl Validity

pub fn execute(self, ctx: &mut ExecutionCtx) -> VortexResult<Validity>

Make a step towards canonicalising validity if necessary

impl Validity

pub const DTYPE: DType

The DType of the underlying validity array (if it exists).

pub fn to_array(&self, len: usize) -> ArrayRef

Convert the validity to an array representation.

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

If Validity is Validity::Array, returns the array, otherwise returns None.

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

If Validity is Validity::Array, returns a reference to the array array, otherwise returns None.

pub fn nullability(&self) -> Nullability

pub fn no_nulls(&self) -> bool

Returns true if this validity guarantees no null values, i.e. it is either Validity::NonNullable or Validity::AllValid.

pub fn union_nullability(self, nullability: Nullability) -> Self

The union nullability and validity.

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

Returns whether the index item is valid.

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

pub fn slice(&self, range: Range<usize>) -> VortexResult<Self>

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

pub fn not(&self) -> VortexResult<Self>

pub fn filter(&self, mask: &Mask) -> VortexResult<Self>

Lazily filters a Validity with a selection mask, which keeps only the entries for which the mask is true.

The result has length equal to the number of true values in mask.

If the validity is a Validity::Array, then this lazily wraps it in a FilterArray instead of eagerly filtering the values immediately.

pub fn to_mask( &self, length: usize, ctx: &mut ExecutionCtx, ) -> VortexResult<Mask>

👎Deprecated:

Use execute_mask

Converts this validity into a Mask of the given length.

Valid elements are true and invalid elements are false.

pub fn execute_mask( &self, length: usize, ctx: &mut ExecutionCtx, ) -> VortexResult<Mask>

pub fn mask_eq( &self, other: &Validity, ctx: &mut ExecutionCtx, ) -> VortexResult<bool>

Compare two Validity values of the same length by executing them into masks if necessary.

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

Logically & two Validity values of the same length

pub fn patch( self, len: usize, indices_offset: usize, indices: &ArrayRef, patches: &Validity, ctx: &mut ExecutionCtx, ) -> VortexResult<Self>

pub fn into_nullable(self) -> Validity

Convert into a nullable variant.

pub fn into_non_nullable( self, len: usize, ctx: &mut ExecutionCtx, ) -> Option<Validity>

Convert into a non-nullable variant, computing statistics if necessary.

Returns None when the array contains invalid values (so the cast cannot be performed), either because it is Validity::AllInvalid or because the validity array’s minimum is false.

pub fn trivial_into_non_nullable( self, len: usize, ) -> VortexResult<Option<Validity>>

Convert into a non-nullable variant without running execution.

This is the cheap counterpart to Self::into_non_nullable: it inspects already-computed statistics rather than triggering execution.

Return values:

• Ok(Some(NonNullable)) — the cast is provably safe.
• Ok(None) — We need to perform compute to determine whether cast is valid. Callers should fall back to Self::into_non_nullable, typically by returning Ok(None) from a CastReduce rule so the corresponding CastKernel runs.
• Err(_) — we know the cast must fail (e.g. Validity::AllInvalid).

pub fn cast_nullability( self, nullability: Nullability, len: usize, ctx: &mut ExecutionCtx, ) -> VortexResult<Validity>

Convert into a variant compatible with the given nullability.

This is the execution-time half of the nullability-cast pair. It is paired with Self::trivial_cast_nullability, which is used by CastReduce rules. The pattern is:

• CastReduce rules (metadata-only rewrites in the optimizer) call Self::trivial_cast_nullability. If it returns Ok(None), the rule returns Ok(None) and the cast is deferred to execution.
• CastKernel impls (executed via ExecuteParentKernel) call this method, which may run the underlying validity array to compute statistics.

Returns Err when nullability cannot be cast (for example, casting to non-nullable while invalid values are present).

pub fn trivial_cast_nullability( self, nullability: Nullability, len: usize, ) -> VortexResult<Option<Validity>>

Best-effort, non-executing variant of Self::cast_nullability.

Use this from CastReduce rules — they run inside the optimizer where execution is not available. The pairing with Self::cast_nullability is symmetric: every encoding that implements CastReduce and inspects validity should also implement CastKernel so that the harder cases (where statistics are not yet cached) can still be handled at execution time.

Return values:

• Ok(Some(_)) — the cast is provably safe and the new Validity is returned.
• Ok(None) — the cast cannot be reduced cheaply (the CastKernel should be tried via Self::cast_nullability).
• Err(_) — the cast is provably impossible.

Typical usage inside a CastReduce:

let Some(new_validity) = array
    .validity()?
    .trivial_cast_nullability(dtype.nullability(), array.len())?
else {
    return Ok(None);
};

pub fn maybe_len(&self) -> Option<usize>

Returns the length of the validity array, if it exists.

impl Validity

pub fn concat(validities: Vec<(Validity, usize)>) -> Option<Self>

Concatenate one or more validities together.

Returns None if the vector is empty.

impl Validity

pub fn from_bit_buffer(buffer: BitBuffer, nullability: Nullability) -> Self

pub fn from_mask(mask: Mask, nullability: Nullability) -> Self

Trait Implementations

impl ArrayEq for Validity

fn array_eq(&self, other: &Self, precision: Precision) -> bool

impl ArrayHash for Validity

fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision)

impl Clone for Validity

fn clone(&self) -> Validity

Returns a duplicate 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<&Nullability> for Validity

fn from(value: &Nullability) -> Self

Converts to this type from the input type.

impl From<BitBuffer> for Validity

fn from(value: BitBuffer) -> Self

Converts to this type from the input type.

impl From<Nullability> for Validity

fn from(value: Nullability) -> Self

Converts to this type from the input type.

impl FromIterator<Mask> for Validity

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

Creates a value from an iterator.

impl FromIterator<bool> for Validity

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

Creates a value from an iterator.