Method reverse_expr

datafusion/physical-expr/src/aggregate.rs:916–971

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

(&self)

    /// For aggregates that do not support calculation in reverse,
    /// returns None (which is the default value).
    pub fn reverse_expr(&self) -> Option<AggregateFunctionExpr> {
        match self.fun.reverse_udf() {
            ReversedUDAF::NotSupported => None,
            ReversedUDAF::Identical => Some(self.clone()),
            ReversedUDAF::Reversed(reverse_udf) => {
                let was_aliased = self.human_display_alias().is_some();
                let mut name = self.name().to_string();
                let mut human_display = self.human_display.clone();
                // Reversing display follows two paths:
                // - aliased display keeps the output `name` unchanged and rewrites only
                //   the lowered expression in `human_display`.
                // - non-aliased display rewrites the canonical `name`, and rewrites
                //   `human_display` only when present.
                // If the function is changed, we need to reverse order_by clause as well
                // i.e. First(a order by b asc null first) -> Last(a order by b desc null last)
                if !was_aliased && self.fun().name() != reverse_udf.name() {
                    replace_order_by_clause(&mut name);
                }
                if !was_aliased {
                    replace_fn_name_clause(
                        &mut name,
                        self.fun.name(),
                        reverse_udf.name(),
                    );
                }

                if let Some(human_display) = human_display.as_mut() {
                    if self.fun().name() != reverse_udf.name() {
                        replace_order_by_clause(&mut human_display.expression);
                    }
                    replace_fn_name_clause(
                        &mut human_display.expression,
                        self.fun.name(),
                        reverse_udf.name(),
                    );
                }

                let mut builder =
                    AggregateExprBuilder::new(reverse_udf, self.args.to_vec())
                        .order_by(self.order_bys.iter().map(|e| e.reverse()).collect())
                        .schema(Arc::new(self.schema.clone()))
                        .alias(name)
                        .output_metadata(self.return_field_metadata())
                        .with_ignore_nulls(self.ignore_nulls)
                        .with_distinct(self.is_distinct)
                        .with_reversed(!self.is_reversed);
                if let Some(human_display) = human_display {
                    builder = builder.human_display(human_display.expression);
                    if let Some(alias) = human_display.alias {
                        builder = builder.human_display_alias(alias);
                    }
                }
                builder.build().ok()
            }
        }
    }

    /// Returns all expressions used in the [`AggregateFunctionExpr`].