Struct CastColumnExpr 

pub struct CastColumnExpr { /* private fields */ }

A physical expression that applies cast_column to its input.

CastColumnExpr extends the regular CastExpr by retaining schema metadata for both the input and output fields. This allows the evaluator to perform struct-aware casts that honour nested field ordering, preserve nullability, and fill missing fields with null values.

This expression is intended for schema rewriting scenarios where the planner already resolved the input column but needs to adapt its physical representation to a new arrow::datatypes::Field. It mirrors the behaviour of the datafusion_common::nested_struct::cast_column helper while integrating with the PhysicalExpr trait so it can participate in the execution plan like any other column expression.

Implementations

impl CastColumnExpr

pub fn new( expr: Arc<dyn PhysicalExpr>, input_field: FieldRef, target_field: FieldRef, cast_options: Option<CastOptions<'static>>, ) -> Self

Create a new CastColumnExpr.

pub fn expr(&self) -> &Arc<dyn PhysicalExpr>

The expression that produces the value to be cast.

pub fn input_field(&self) -> &FieldRef

Field metadata describing the resolved input column.

pub fn target_field(&self) -> &FieldRef

Field metadata describing the output column after casting.

Trait Implementations

impl Clone for CastColumnExpr

fn clone(&self) -> CastColumnExpr

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CastColumnExpr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for CastColumnExpr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for CastColumnExpr

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

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CastColumnExpr

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 PhysicalExpr for CastColumnExpr

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 return_field(&self, _input_schema: &Schema) -> Result<FieldRef>

The output field associated with this expression

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.

fn fmt_sql(&self, f: &mut Formatter<'_>) -> Result

Format this PhysicalExpr in nice human readable “SQL” format

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.

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.

fn evaluate_statistics( &self, children: &[&Distribution], ) -> Result<Distribution, DataFusionError>

Computes the output statistics for the expression, given the input statistics.

fn propagate_statistics( &self, parent: &Distribution, children: &[&Distribution], ) -> Result<Option<Vec<Distribution>>, DataFusionError>

Updates children statistics using the given parent statistic for this expression.

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.

fn snapshot(&self) -> Result<Option<Arc<dyn PhysicalExpr>>, DataFusionError>

Take a snapshot of this PhysicalExpr, if it is dynamic.

fn snapshot_generation(&self) -> u64

Returns the generation of this PhysicalExpr for snapshotting purposes. The generation is an arbitrary u64 that can be used to track changes in the state of the PhysicalExpr over time without having to do an exhaustive comparison. This is useful to avoid unnecessary computation or serialization if there are no changes to the expression. In particular, dynamic expressions that may change over time; this allows cheap checks for changes. Static expressions that do not change over time should return 0, as does the default implementation. You should not call this method directly as it does not handle recursion. Instead use snapshot_generation to handle recursion and capture the full state of the PhysicalExpr.

fn is_volatile_node(&self) -> bool

Returns true if the expression node is volatile, i.e. whether it can return different results when evaluated multiple times with the same input.

impl Eq for CastColumnExpr