Struct datafusion_physical_expr::expressions::UnKnownColumn

pub struct UnKnownColumn { /* private fields */ }

Implementations

impl UnKnownColumn

pub fn new(name: &str) -> Self

Create a new unknown column expression

pub fn name(&self) -> &str

Get the column name

Trait Implementations

impl Clone for UnKnownColumn

fn clone(&self) -> UnKnownColumn

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for UnKnownColumn

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

Formats the value using the given formatter.

impl Display for UnKnownColumn

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

Formats the value using the given formatter.

impl Hash for UnKnownColumn

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<dyn Any> for UnKnownColumn

fn eq(&self, other: &dyn Any) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for UnKnownColumn

fn eq(&self, other: &UnKnownColumn) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PhysicalExpr for UnKnownColumn

fn as_any(&self) -> &dyn Any

Return a reference to Any that can be used for downcasting

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>

Decide whehter this expression is nullable, given the schema of the input

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

Evaluate the 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 dyn_hash(&self, state: &mut dyn Hasher)

Update the hash state with this expression requirements from Hash.

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

impl Eq for UnKnownColumn

impl StructuralPartialEq for UnKnownColumn