Trait datafusion::physical_expr::PhysicalExpr
source · 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, Global>, Global>;
fn with_new_children(
self: Arc<Self, Global>,
children: Vec<Arc<dyn PhysicalExpr, Global>, Global>
) -> Result<Arc<dyn PhysicalExpr, Global>, 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<Vec<Option<Interval>, Global>, DataFusionError> { ... }
fn get_ordering(&self, _children: &[SortProperties]) -> SortProperties { ... }
}Expand description
Expression that can be evaluated against a RecordBatch A Physical expression knows its type, nullability and how to evaluate itself.
Required Methods§
sourcefn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
Returns the physical expression as Any so that it can be
downcast to a specific implementation.
sourcefn data_type(&self, input_schema: &Schema) -> Result<DataType, DataFusionError>
fn data_type(&self, input_schema: &Schema) -> Result<DataType, DataFusionError>
Get the data type of this expression, given the schema of the input
sourcefn nullable(&self, input_schema: &Schema) -> Result<bool, DataFusionError>
fn nullable(&self, input_schema: &Schema) -> Result<bool, DataFusionError>
Determine whether this expression is nullable, given the schema of the input
sourcefn evaluate(
&self,
batch: &RecordBatch
) -> Result<ColumnarValue, DataFusionError>
fn evaluate( &self, batch: &RecordBatch ) -> Result<ColumnarValue, DataFusionError>
Evaluate an expression against a RecordBatch
sourcefn children(&self) -> Vec<Arc<dyn PhysicalExpr, Global>, Global>
fn children(&self) -> Vec<Arc<dyn PhysicalExpr, Global>, Global>
Get a list of child PhysicalExpr that provide the input for this expr.
sourcefn with_new_children(
self: Arc<Self, Global>,
children: Vec<Arc<dyn PhysicalExpr, Global>, Global>
) -> Result<Arc<dyn PhysicalExpr, Global>, DataFusionError>
fn with_new_children( self: Arc<Self, Global>, children: Vec<Arc<dyn PhysicalExpr, Global>, Global> ) -> Result<Arc<dyn PhysicalExpr, Global>, DataFusionError>
Returns a new PhysicalExpr where all children were replaced by new exprs.
sourcefn dyn_hash(&self, _state: &mut dyn Hasher)
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§
sourcefn evaluate_selection(
&self,
batch: &RecordBatch,
selection: &BooleanArray
) -> Result<ColumnarValue, DataFusionError>
fn evaluate_selection( &self, batch: &RecordBatch, selection: &BooleanArray ) -> Result<ColumnarValue, DataFusionError>
Evaluate an expression against a RecordBatch after first applying a validity array
sourcefn evaluate_bounds(
&self,
_children: &[&Interval]
) -> Result<Interval, DataFusionError>
fn evaluate_bounds( &self, _children: &[&Interval] ) -> Result<Interval, DataFusionError>
Computes bounds for the expression using interval arithmetic.
sourcefn propagate_constraints(
&self,
_interval: &Interval,
_children: &[&Interval]
) -> Result<Vec<Option<Interval>, Global>, DataFusionError>
fn propagate_constraints( &self, _interval: &Interval, _children: &[&Interval] ) -> Result<Vec<Option<Interval>, Global>, DataFusionError>
Updates/shrinks bounds for the expression using interval arithmetic.
If constraint propagation reveals an infeasibility, returns None for
the child causing infeasibility. If none of the children intervals
change, may return an empty vector instead of cloning children.
sourcefn get_ordering(&self, _children: &[SortProperties]) -> SortProperties
fn get_ordering(&self, _children: &[SortProperties]) -> SortProperties
The order information of a PhysicalExpr can be estimated from its children. This is especially helpful for projection expressions. If we can ensure that the order of a PhysicalExpr to project matches with the order of SortExec, we can eliminate that SortExecs.
By recursively calling this function, we can obtain the overall order
information of the PhysicalExpr. Since SortOptions cannot fully handle
the propagation of unordered columns and literals, the SortProperties
struct is used.