Struct NegativeExpr

pub struct NegativeExpr { /* private fields */ }

Negative expression

Implementations

impl NegativeExpr

pub fn new(arg: Arc<dyn PhysicalExpr>) -> NegativeExpr

Create new not expression

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

Get the input expression

Trait Implementations

impl Debug for NegativeExpr

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

Formats the value using the given formatter.

impl Display for NegativeExpr

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

Formats the value using the given formatter.

impl Hash for NegativeExpr

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

where H: Hasher,

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 NegativeExpr

fn eq(&self, other: &NegativeExpr) -> 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 NegativeExpr

fn as_any(&self) -> &(dyn Any + 'static)

Return a reference to Any that can be used for downcasting

fn evaluate_bounds( &self, children: &[&Interval], ) -> Result<Interval, DataFusionError>

Given the child interval of a NegativeExpr, it calculates the NegativeExpr’s interval. It replaces the upper and lower bounds after multiplying them with -1. Ex: (a, b] => [-b, -a)

fn propagate_constraints( &self, interval: &Interval, children: &[&Interval], ) -> Result<Option<Vec<Interval>>, DataFusionError>

Returns a new Interval of a NegativeExpr that has the existing interval given that given the input interval is known to be children.

fn get_properties( &self, children: &[ExprProperties], ) -> Result<ExprProperties, DataFusionError>

The ordering of a NegativeExpr is simply the reverse of its child.

fn data_type(&self, input_schema: &Schema) -> Result<DataType, DataFusionError>

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

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

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

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

Evaluate an expression against a RecordBatch

fn return_field( &self, input_schema: &Schema, ) -> Result<Arc<Field>, DataFusionError>

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<NegativeExpr>, children: Vec<Arc<dyn PhysicalExpr>>, ) -> Result<Arc<dyn PhysicalExpr>, DataFusionError>

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

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

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

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

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 propagate_statistics( &self, parent: &Distribution, children: &[&Distribution], ) -> Result<Option<Vec<Distribution>>, DataFusionError>

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

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

impl Eq for NegativeExpr