Enum ExpressionPlacement 

pub enum ExpressionPlacement {
    Literal,
    Column,
    MoveTowardsLeafNodes,
    KeepInPlace,
}

Describes where an expression should be placed in the query plan for optimal execution. This is used by optimizers to make decisions about expression placement, such as whether to push expressions down through projections.

Variants

Literal

A constant literal value.

Column

A simple column reference.

MoveTowardsLeafNodes

A cheap expression that can be pushed to leaf nodes in the plan. Examples include get_field for struct field access. Pushing these expressions down in the plan can reduce data early at low compute cost. See ExpressionPlacement::should_push_to_leaves for details.

KeepInPlace

An expensive expression that should stay where it is in the plan. Examples include complex scalar functions or UDFs.

Implementations

impl ExpressionPlacement

pub fn should_push_to_leaves(&self) -> bool

Returns true if the expression can be pushed down to leaf nodes in the query plan.

This returns true for:

• ExpressionPlacement::Column: Simple column references can be pushed down. They do no compute and do not increase or decrease the amount of data being processed. A projection that reduces the number of columns can eliminate unnecessary data early, but this method only considers one expression at a time, not a projection as a whole.
• ExpressionPlacement::MoveTowardsLeafNodes: Cheap expressions can be pushed down to leaves to take advantage of early computation and potential optimizations at the data source level. For example struct_col['field'] is cheap to compute (just an Arc clone of the nested array for 'field') and thus can reduce data early in the plan at very low compute cost. It may even be possible to eliminate the expression entirely if the data source can project only the needed field (as e.g. Parquet can).

Trait Implementations

impl Clone for ExpressionPlacement

fn clone(&self) -> ExpressionPlacement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExpressionPlacement

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

Formats the value using the given formatter.

impl Hash for ExpressionPlacement

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ExpressionPlacement

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

impl Eq for ExpressionPlacement

impl StructuralPartialEq for ExpressionPlacement