Struct datafusion_physical_expr::window::AggregateWindowExpr

pub struct AggregateWindowExpr { /* private fields */ }

A window expr that takes the form of an aggregate function

Implementations

impl AggregateWindowExpr

pub fn new(
    aggregate: Arc<dyn AggregateExpr>,
    partition_by: &[Arc<dyn PhysicalExpr>],
    order_by: &[PhysicalSortExpr],
    window_frame: Option<Arc<WindowFrame>>
) -> Self

create a new aggregate window function expression

Trait Implementations

impl Debug for AggregateWindowExpr

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

Formats the value using the given formatter.

impl WindowExpr for AggregateWindowExpr

peer based evaluation based on the fact that batch is pre-sorted given the sort columns and then per partition point we’ll evaluate the peer group (e.g. SUM or MAX gives the same results for peers) and concatenate the results.

fn as_any(&self) -> &dyn Any

Return a reference to Any that can be used for downcasting

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

the field of the final result of this window function.

fn name(&self) -> &str

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

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

expressions that are passed to the WindowAccumulator. Functions which take a single input argument, such as sum, return a single datafusion_expr::expr::Expr, others (e.g. cov) return many.

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

evaluate the window function values against the batch

fn partition_by(&self) -> &[Arc<dyn PhysicalExpr>]

expressions that’s from the window function’s partition by clause, empty if absent

fn order_by(&self) -> &[PhysicalSortExpr]

expressions that’s from the window function’s order by clause, empty if absent

fn evaluate_args(&self, batch: &RecordBatch) -> Result<Vec<ArrayRef>>

evaluate the window function arguments against the batch and return array ref, normally the resulting vec is a single element one.

fn evaluate_partition_points(
    &self,
    num_rows: usize,
    partition_columns: &[SortColumn]
) -> Result<Vec<Range<usize>>>

evaluate the partition points given the sort columns; if the sort columns are empty then the result will be a single element vec of the whole column rows.

fn partition_columns(&self, batch: &RecordBatch) -> Result<Vec<SortColumn>>

get partition columns that can be used for partitioning, empty if absent

fn sort_columns(&self, batch: &RecordBatch) -> Result<Vec<SortColumn>>

get sort columns that can be used for peer evaluation, empty if absent