Struct deltalake::datafusion::physical_expr::expressions::FirstValue

pub struct FirstValue { /* private fields */ }

FIRST_VALUE aggregate expression

Implementations

impl FirstValue

pub fn new( expr: Arc<dyn PhysicalExpr>, name: impl Into<String>, input_data_type: DataType, ordering_req: Vec<PhysicalSortExpr>, order_by_data_types: Vec<DataType> ) -> FirstValue

Creates a new FIRST_VALUE aggregation function.

pub fn with_ignore_nulls(self, ignore_nulls: bool) -> FirstValue

pub fn name(&self) -> &str

Returns the name of the aggregate expression.

pub fn input_data_type(&self) -> &DataType

Returns the input data type of the aggregate expression.

pub fn order_by_data_types(&self) -> &Vec<DataType>

Returns the data types of the order-by columns.

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

Returns the expression associated with the aggregate function.

pub fn ordering_req(&self) -> &Vec<PhysicalSortExpr>

Returns the lexical ordering requirements of the aggregate expression.

pub fn with_requirement_satisfied( self, requirement_satisfied: bool ) -> FirstValue

pub fn convert_to_last(self) -> LastValue

Trait Implementations

impl AggregateExpr for FirstValue

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

Return a reference to Any that can be used for downcasting

fn field(&self) -> Result<Field, DataFusionError>

the field of the final result of this aggregation.

fn create_accumulator(&self) -> Result<Box<dyn Accumulator>, DataFusionError>

the accumulator used to accumulate values from the expressions. the accumulator expects the same number of arguments as expressions and must return states with the same description as state_fields

fn state_fields(&self) -> Result<Vec<Field>, DataFusionError>

the fields that encapsulate the Accumulator’s state the number of fields here equals the number of states that the accumulator contains

fn expressions(&self) -> Vec<Arc<dyn PhysicalExpr>>

expressions that are passed to the Accumulator. Single-column aggregations such as sum return a single value, others (e.g. cov) return many.

fn order_bys(&self) -> Option<&[PhysicalSortExpr]>

Order by requirements for the aggregate function By default it is None (there is no requirement) Order-sensitive aggregators, such as FIRST_VALUE(x ORDER BY y) should implement this

fn name(&self) -> &str

Human readable name such as "MIN(c2)". The default implementation returns placeholder text.

fn reverse_expr(&self) -> Option<Arc<dyn AggregateExpr>>

Construct an expression that calculates the aggregate in reverse. Typically the “reverse” expression is itself (e.g. SUM, COUNT). For aggregates that do not support calculation in reverse, returns None (which is the default value).

fn create_sliding_accumulator( &self ) -> Result<Box<dyn Accumulator>, DataFusionError>

Creates accumulator implementation that supports retract

fn groups_accumulator_supported(&self) -> bool

If the aggregate expression has a specialized GroupsAccumulator implementation. If this returns true, [Self::create_groups_accumulator] will be called.

fn create_groups_accumulator( &self ) -> Result<Box<dyn GroupsAccumulator>, DataFusionError>

Return a specialized GroupsAccumulator that manages state for all groups.

impl Clone for FirstValue

fn clone(&self) -> FirstValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for FirstValue

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

Formats the value using the given formatter.

impl PartialEq<dyn Any> for FirstValue

fn eq(&self, other: &(dyn Any + 'static)) -> 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.