Trait datafusion_physical_expr_common::physical_expr::PhysicalExpr

source ·

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

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

Expand description

See create_physical_expr for examples of creating PhysicalExpr from Expr

Required Methods§

source

fn as_any(&self) -> &dyn Any

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

source

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

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

source

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

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

source

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

Evaluate an expression against a RecordBatch

source

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

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

source

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

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

source

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§

source

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

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

source

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

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].

source

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

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.

source

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

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.