Struct ProjectionMask

pub struct ProjectionMask {
    mask: Option<Vec<bool>>,
}

A ProjectionMask identifies a set of columns within a potentially nested schema to project

In particular, a ProjectionMask can be constructed from a list of leaf column indices or root column indices where:

• Root columns are the direct children of the root schema, enumerated in order
• Leaf columns are the child-less leaves of the schema as enumerated by a depth-first search

For example, the schema

message schema {
  REQUIRED boolean         leaf_1;
  REQUIRED GROUP group {
    OPTIONAL int32 leaf_2;
    OPTIONAL int64 leaf_3;
  }
}

Has roots ["leaf_1", "group"] and leaves ["leaf_1", "leaf_2", "leaf_3"]

For non-nested schemas, i.e. those containing only primitive columns, the root and leaves are the same

Fields

mask: Option<Vec<bool>>

If present a leaf column should be included if the value at the corresponding index is true

If None, include all columns

Implementations

impl ProjectionMask

pub fn all() -> Self

Create a ProjectionMask which selects all columns

pub fn leaves( schema: &SchemaDescriptor, indices: impl IntoIterator<Item = usize>, ) -> Self

Create a ProjectionMask which selects only the specified leaf columns

Note: repeated or out of order indices will not impact the final mask

i.e. [0, 1, 2] will construct the same mask as [1, 0, 0, 2]

pub fn roots( schema: &SchemaDescriptor, indices: impl IntoIterator<Item = usize>, ) -> Self

Create a ProjectionMask which selects only the specified root columns

Note: repeated or out of order indices will not impact the final mask

i.e. [0, 1, 2] will construct the same mask as [1, 0, 0, 2]

fn find_leaves( root: &Arc<Type>, parent: Option<&String>, paths: &mut Vec<String>, )

pub fn columns<'a>( schema: &SchemaDescriptor, names: impl IntoIterator<Item = &'a str>, ) -> Self

Create a ProjectionMask which selects only the named columns

All leaf columns that fall below a given name will be selected. For example, given the schema

message schema {
  OPTIONAL group a (MAP) {
    REPEATED group key_value {
      REQUIRED BYTE_ARRAY key (UTF8);  // leaf index 0
      OPTIONAL group value (MAP) {
        REPEATED group key_value {
          REQUIRED INT32 key;          // leaf index 1
          REQUIRED BOOLEAN value;      // leaf index 2
        }
      }
    }
  }
  REQUIRED INT32 b;                    // leaf index 3
  REQUIRED DOUBLE c;                   // leaf index 4
}

["a.key_value.value", "c"] would return leaf columns 1, 2, and 4. ["a"] would return columns 0, 1, and 2.

Note: repeated or out of order indices will not impact the final mask.

i.e. ["b", "c"] will construct the same mask as ["c", "b", "c"].

pub fn leaf_included(&self, leaf_idx: usize) -> bool

Returns true if the leaf column leaf_idx is included by the mask

pub fn union(&mut self, other: &Self)

Union two projection masks

Example:

mask1 = [true, false, true]
mask2 = [false, true, true]
union(mask1, mask2) = [true, true, true]

pub fn intersect(&mut self, other: &Self)

Intersect two projection masks

Example:

mask1 = [true, false, true]
mask2 = [false, true, true]
intersect(mask1, mask2) = [false, false, true]

Trait Implementations

impl Clone for ProjectionMask

fn clone(&self) -> ProjectionMask

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ProjectionMask

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

Formats the value using the given formatter.

impl PartialEq for ProjectionMask

fn eq(&self, other: &ProjectionMask) -> 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 Eq for ProjectionMask

impl StructuralPartialEq for ProjectionMask