Struct query::range_select::plan::RangeFirstListValue

struct RangeFirstListValue {
    expr: Arc<dyn PhysicalExpr>,
    order_bys: Vec<PhysicalSortExpr>,
}

Implementation of first_value/last_value aggregate function adapted to range query

Fields

expr: Arc<dyn PhysicalExpr>

calculate expr

order_bys: Vec<PhysicalSortExpr>

Implementations

impl RangeFirstListValue

pub fn new_aggregate_expr( expr: Arc<dyn PhysicalExpr>, order_bys: Vec<PhysicalSortExpr>, ) -> Arc<dyn AggregateExpr>

Trait Implementations

impl AggregateExpr for RangeFirstListValue

fn as_any(&self) -> &dyn Any

Returns the aggregate expression as Any so that it can be downcast to a specific implementation.

fn create_accumulator(&self) -> DataFusionResult<Box<dyn Accumulator>>

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 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 field(&self) -> DataFusionResult<Field>

the field of the final result of this aggregation.

fn state_fields(&self) -> DataFusionResult<Vec<Field>>

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

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 order_sensitivity(&self) -> AggregateOrderSensitivity

Indicates whether aggregator can produce the correct result with any arbitrary input ordering. By default, we assume that aggregate expressions are order insensitive.

fn with_beneficial_ordering( self: Arc<Self>, _requirement_satisfied: bool, ) -> Result<Option<Arc<dyn AggregateExpr>>, DataFusionError>

Sets the indicator whether ordering requirements of the aggregator is satisfied by its input. If this is not the case, aggregators with order sensitivity AggregateOrderSensitivity::Beneficial can still produce the correct result with possibly more work internally.

fn name(&self) -> &str

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

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.

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 all_expressions(&self) -> AggregatePhysicalExpressions

Returns all expressions used in the [AggregateExpr]. These expressions are (1)function arguments, (2) order by expressions.

fn with_new_expressions( &self, _args: Vec<Arc<dyn PhysicalExpr>>, _order_by_exprs: Vec<Arc<dyn PhysicalExpr>>, ) -> Option<Arc<dyn AggregateExpr>>

Rewrites [AggregateExpr], with new expressions given. The argument should be consistent with the return value of the [AggregateExpr::all_expressions] method. Returns Some(Arc<dyn AggregateExpr>) if re-write is supported, otherwise returns None.

impl Debug for RangeFirstListValue

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

Formats the value using the given formatter.

impl PartialEq<dyn Any> for RangeFirstListValue

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.