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_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
fn as_any(&self) -> &dyn Any
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>
fn data_type(&self, input_schema: &Schema) -> Result<DataType>
Get the data type of this expression, given the schema of the input
sourcefn nullable(&self, input_schema: &Schema) -> Result<bool>
fn nullable(&self, input_schema: &Schema) -> Result<bool>
Determine whether this expression is nullable, given the schema of the input
sourcefn evaluate(&self, batch: &RecordBatch) -> Result<ColumnarValue>
fn evaluate(&self, batch: &RecordBatch) -> Result<ColumnarValue>
Evaluate an expression against a RecordBatch
sourcefn children(&self) -> Vec<Arc<dyn PhysicalExpr>>
fn children(&self) -> Vec<Arc<dyn PhysicalExpr>>
Get a list of child PhysicalExpr that provide the input for this expr.
sourcefn with_new_children(
self: Arc<Self>,
children: Vec<Arc<dyn PhysicalExpr>>
) -> Result<Arc<dyn PhysicalExpr>>
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.
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>
fn evaluate_selection( &self, batch: &RecordBatch, selection: &BooleanArray ) -> Result<ColumnarValue>
Evaluate an expression against a RecordBatch after first applying a validity array
sourcefn evaluate_bounds(&self, _children: &[&Interval]) -> Result<Interval>
fn evaluate_bounds(&self, _children: &[&Interval]) -> Result<Interval>
sourcefn propagate_constraints(
&self,
_interval: &Interval,
_children: &[&Interval]
) -> Result<Option<Vec<Interval>>>
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
intervalis the currently known interval for this expression.childrenare 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 would return [0, 2] and [2, 4] as b must be at
least 2 to make the output at least 4.
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.