Struct RequiredIndices 

pub(super) struct RequiredIndices {
    indices: Vec<usize>,
    projection_beneficial: bool,
}

Represents columns in a schema which are required (used) by a plan node

Also carries a flag indicating if putting a projection above children is beneficial for the parent. For example LogicalPlan::Filter benefits from small tables. Hence for filter child this flag would be true. Defaults to false

Invariant

Indices are always in order and without duplicates. For example, if these indices were added [3, 2, 4, 3, 6, 1], the instance would be represented by [1, 2, 3, 4, 6].

Fields

indices: Vec<usize>

The indices of the required columns in the

projection_beneficial: bool

If putting a projection above children is beneficial for the parent. Defaults to false.

Implementations

impl RequiredIndices

pub fn new() -> Self

Create a new, empty instance

pub fn new_for_all_exprs(plan: &LogicalPlan) -> Self

Create a new instance that requires all columns from the specified plan

pub fn new_from_indices(indices: Vec<usize>) -> Self

Create a new instance with the specified indices as required

pub fn into_inner(self) -> Vec<usize>

Convert the instance to its inner indices

pub fn with_projection_beneficial(self) -> Self

Set the projection beneficial flag

pub fn projection_beneficial(&self) -> bool

Return the value of projection beneficial flag

pub fn indices(&self) -> &[usize]

Return a reference to the underlying indices

pub fn with_plan_exprs( self, plan: &LogicalPlan, schema: &DFSchemaRef, ) -> Result<Self>

Add required indices for all exprs used in plan

fn add_expr(&mut self, input_schema: &DFSchemaRef, expr: &Expr)

Adds the indices of the fields referred to by the given expression expr within the given schema (input_schema).

Self is NOT compacted (and thus this method is not pub)

Parameters

• input_schema: The input schema to analyze for index requirements.
• expr: An expression for which we want to find necessary field indices.

pub fn with_exprs<'a>( self, schema: &DFSchemaRef, exprs: impl IntoIterator<Item = &'a Expr>, ) -> Self

Adds the indices of the fields referred to by the given expressions `within the given schema.

Parameters

• input_schema: The input schema to analyze for index requirements.
• exprs: the expressions for which we want to find field indices.

pub fn append(self, indices: &[usize]) -> Self

Adds all indices into this instance.

pub fn split_off(self, n: usize) -> (Self, Self)

Splits this instance into a tuple with two instances:

• The first n indices
• The remaining indices, adjusted down by n

fn partition<F>(&self, f: F) -> (Self, Self)

where F: Fn(usize) -> bool,

Partitions the indices in this instance into two groups based on the given predicate function f.

fn map_indices<F>(self, f: F) -> Self

where F: Fn(usize) -> usize,

Map the indices in this instance to a new set of indices based on the given function f, returning the mapped indices

Not pub as it might not preserve the invariant of compacted indices

pub fn into_mapped_indices<F>(self, f: F) -> Vec<usize>

where F: Fn(usize) -> usize,

Apply the given function f to each index in this instance, returning the mapped indices

pub fn get_at_indices(&self, exprs: &[Expr]) -> Vec<Expr>

Returns the Exprs from exprs that are at the indices in this instance

pub fn get_required_exprs(&self, input_schema: &DFSchemaRef) -> Vec<Expr>

Generates the required expressions (columns) that reside at indices of the given input_schema.

fn compact(self) -> Self

Compacts the indices of this instance so they are sorted (ascending) and deduplicated.

Trait Implementations

impl Clone for RequiredIndices

fn clone(&self) -> RequiredIndices

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RequiredIndices

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

Formats the value using the given formatter.

impl Default for RequiredIndices

fn default() -> RequiredIndices

Returns the “default value” for a type.