Trait PhysicalExpr

pub trait PhysicalExpr:
    Send
    + Sync
    + Display
    + Debug
    + DynEq
    + DynHash {
    // 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>>;

    // 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> { ... }
}

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

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>

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

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

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

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

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

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

Provided Methods

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

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

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

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.

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.

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<Self>>

Returns all children of the specified TreeNode.

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

Constructs a new node with the specified children.

impl Hash for dyn PhysicalExpr

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

Feeds this value into the given Hasher.

impl PartialEq for dyn PhysicalExpr

fn eq(&self, other: &Self) -> 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 Eq for dyn PhysicalExpr

Implementors