Trait PhysicalExpr

pub trait PhysicalExpr:
    Send
    + Sync
    + Display
    + Debug
    + PartialEq<dyn Any> {
    // Required methods
    fn as_any(&self) -> &(dyn Any + 'static);
    fn data_type(
        &self,
        input_schema: &Schema,
    ) -> Result<DataType, DataFusionError>;
    fn nullable(&self, input_schema: &Schema) -> Result<bool, DataFusionError>;
    fn evaluate(
        &self,
        batch: &RecordBatch,
    ) -> Result<ColumnarValue, DataFusionError>;
    fn children(&self) -> Vec<&Arc<dyn PhysicalExpr>>;
    fn with_new_children(
        self: Arc<Self>,
        children: Vec<Arc<dyn PhysicalExpr>>,
    ) -> Result<Arc<dyn PhysicalExpr>, DataFusionError>;
    fn dyn_hash(&self, _state: &mut dyn Hasher);

    // Provided methods
    fn evaluate_selection(
        &self,
        batch: &RecordBatch,
        selection: &BooleanArray,
    ) -> Result<ColumnarValue, DataFusionError> { ... }
    fn evaluate_bounds(
        &self,
        _children: &[&Interval],
    ) -> Result<Interval, DataFusionError> { ... }
    fn propagate_constraints(
        &self,
        _interval: &Interval,
        _children: &[&Interval],
    ) -> Result<Option<Vec<Interval>>, DataFusionError> { ... }
    fn get_properties(
        &self,
        _children: &[ExprProperties],
    ) -> Result<ExprProperties, DataFusionError> { ... }
}

PhysicalExprs represent expressions such as A + 1 or CAST(c1 AS int).

PhysicalExpr knows its type, nullability and can be evaluated directly on a RecordBatch (see Self::evaluate).

PhysicalExpr are the physical counterpart to Expr used in logical planning. They are typically created from Expr by a PhysicalPlanner invoked from a higher level API

Some important examples of PhysicalExpr are:

• Column: Represents a column at a given index in a RecordBatch

To create PhysicalExpr from Expr, see

• SessionContext::create_physical_expr: A high level API
• create_physical_expr: A low level API

Required Methods

fn as_any(&self) -> &(dyn Any + 'static)

Returns the physical expression as Any so that it can be downcast to a specific implementation.

fn data_type(&self, input_schema: &Schema) -> Result<DataType, DataFusionError>

Get the data type of this expression, given the schema of the input

fn nullable(&self, input_schema: &Schema) -> Result<bool, DataFusionError>

Determine whether this expression is nullable, given the schema of the input

fn evaluate( &self, batch: &RecordBatch, ) -> Result<ColumnarValue, DataFusionError>

Evaluate an expression against a RecordBatch

fn children(&self) -> Vec<&Arc<dyn PhysicalExpr>>

Get a list of child PhysicalExpr that provide the input for this expr.

fn with_new_children( self: Arc<Self>, children: Vec<Arc<dyn PhysicalExpr>>, ) -> Result<Arc<dyn PhysicalExpr>, DataFusionError>

Returns a new PhysicalExpr where all children were replaced by new exprs.

fn dyn_hash(&self, _state: &mut dyn Hasher)

Update the hash state with this expression requirements from Hash.

This method is required to support hashing PhysicalExprs. To implement it, typically the type implementing PhysicalExpr implements Hash and then the following boiler plate is used:

Example:

// User defined expression that derives Hash
#[derive(Hash, Debug, PartialEq, Eq)]
struct MyExpr {
  val: u64
}

// impl PhysicalExpr {
// ...
  // Boiler plate to call the derived Hash impl
  fn dyn_hash(&self, state: &mut dyn std::hash::Hasher) {
    use std::hash::Hash;
    let mut s = state;
    self.hash(&mut s);
  }
// }

Note: PhysicalExpr is not constrained by Hash directly because it must remain object safe.

Provided Methods

fn evaluate_selection( &self, batch: &RecordBatch, selection: &BooleanArray, ) -> Result<ColumnarValue, DataFusionError>

Evaluate an expression against a RecordBatch after first applying a validity array

fn evaluate_bounds( &self, _children: &[&Interval], ) -> Result<Interval, DataFusionError>

Computes the output interval for the expression, given the input intervals.

Arguments

• children are the intervals for the children (inputs) of this expression.

Example

If the expression is a + b, and the input intervals are a: [1, 2] and b: [3, 4], then the output interval would be [4, 6].

fn propagate_constraints( &self, _interval: &Interval, _children: &[&Interval], ) -> Result<Option<Vec<Interval>>, DataFusionError>

Updates bounds for child expressions, given a known interval for this expression.

This is used to propagate constraints down through an expression tree.

Arguments

• interval is the currently known interval for this expression.
• children are the current intervals for the children of this expression.

Returns

A Vec of new intervals for the children, in order.

If constraint propagation reveals an infeasibility for any child, returns None. If none of the children intervals change as a result of propagation, may return an empty vector instead of cloning children. This is the default (and conservative) return value.

Example

If the expression is a + b, the current interval is [4, 5] and the inputs a and b are respectively given as [0, 2] and [-∞, 4], then propagation would return [0, 2] and [2, 4] as b must be at least 2 to make the output at least 4.

fn get_properties( &self, _children: &[ExprProperties], ) -> Result<ExprProperties, DataFusionError>

Calculates the properties of this PhysicalExpr based on its children’s properties (i.e. order and range), recursively aggregating the information from its children. In cases where the PhysicalExpr has no children (e.g., Literal or Column), these properties should be specified externally, as the function defaults to unknown properties.

Trait Implementations

impl AsRef<dyn PhysicalExpr> for PhysicalSortExpr

Access the PhysicalSortExpr as a PhysicalExpr

fn as_ref(&self) -> &(dyn PhysicalExpr + 'static)

Converts this type into a shared reference of the (usually inferred) input type.

impl DynTreeNode for dyn PhysicalExpr

fn arc_children(&self) -> Vec<&Arc<dyn PhysicalExpr>>

Returns all children of the specified TreeNode.

fn with_new_arc_children( &self, arc_self: Arc<dyn PhysicalExpr>, new_children: Vec<Arc<dyn PhysicalExpr>>, ) -> Result<Arc<dyn PhysicalExpr>, DataFusionError>

Constructs a new node with the specified children.

impl Hash for dyn PhysicalExpr

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

where H: Hasher,

Feeds this value into the given Hasher.

Implementations on Foreign Types

impl PhysicalExpr for ScalarFunctionExpr

fn as_any(&self) -> &(dyn Any + 'static)

Return a reference to Any that can be used for downcasting

fn data_type(&self, _input_schema: &Schema) -> Result<DataType, DataFusionError>

fn nullable(&self, _input_schema: &Schema) -> Result<bool, DataFusionError>

fn evaluate( &self, batch: &RecordBatch, ) -> Result<ColumnarValue, DataFusionError>

fn children(&self) -> Vec<&Arc<dyn PhysicalExpr>>

fn with_new_children( self: Arc<ScalarFunctionExpr>, children: Vec<Arc<dyn PhysicalExpr>>, ) -> Result<Arc<dyn PhysicalExpr>, DataFusionError>

fn evaluate_bounds( &self, children: &[&Interval], ) -> Result<Interval, DataFusionError>

fn propagate_constraints( &self, interval: &Interval, children: &[&Interval], ) -> Result<Option<Vec<Interval>>, DataFusionError>

fn dyn_hash(&self, state: &mut dyn Hasher)

fn get_properties( &self, children: &[ExprProperties], ) -> Result<ExprProperties, DataFusionError>

Implementors

impl PhysicalExpr for BinaryExpr

impl PhysicalExpr for CaseExpr

impl PhysicalExpr for CastExpr

impl PhysicalExpr for Column

impl PhysicalExpr for InListExpr

impl PhysicalExpr for IsNotNullExpr

impl PhysicalExpr for IsNullExpr

impl PhysicalExpr for LikeExpr

impl PhysicalExpr for Literal

impl PhysicalExpr for NegativeExpr

impl PhysicalExpr for NoOp

impl PhysicalExpr for NotExpr

impl PhysicalExpr for TryCastExpr

impl PhysicalExpr for UnKnownColumn