Enum AggregateOrderSensitivity 

pub enum AggregateOrderSensitivity {
    Insensitive,
    HardRequirement,
    SoftRequirement,
    Beneficial,
}

Represents the sensitivity of an aggregate expression to ordering.

Variants

Insensitive

Indicates that the aggregate expression is insensitive to ordering. Ordering at the input is not important for the result of the aggregator.

HardRequirement

Indicates that the aggregate expression has a hard requirement on ordering. The aggregator cannot produce a correct result unless its ordering requirement is satisfied.

SoftRequirement

Indicates that the aggregator is more efficient when the input is ordered but can still produce its result correctly regardless of the input ordering. This is similar to, but stronger than, Self::Beneficial.

Similarly to Self::HardRequirement, when possible DataFusion will insert a SortExec, to reorder the input to match the SoftRequirement. However, when such a SortExec cannot be inserted, (for example, due to conflicting Self::HardRequirement with other ordered aggregates in the query), the aggregate function will still execute, without the preferred order, unlike with Self::HardRequirement

Beneficial

Indicates that ordering is beneficial for the aggregate expression in terms of evaluation efficiency. The aggregator can produce its result efficiently when its required ordering is satisfied; however, it can still produce the correct result (albeit less efficiently) when its required ordering is not met.

Implementations

impl AggregateOrderSensitivity

pub fn is_insensitive(&self) -> bool

pub fn is_beneficial(&self) -> bool

pub fn hard_requires(&self) -> bool

Trait Implementations

impl Clone for AggregateOrderSensitivity

fn clone(&self) -> AggregateOrderSensitivity

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AggregateOrderSensitivity

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

Formats the value using the given formatter.

impl From<FFI_AggregateOrderSensitivity> for AggregateOrderSensitivity

fn from(value: FFI_AggregateOrderSensitivity) -> AggregateOrderSensitivity

Converts to this type from the input type.

impl PartialEq for AggregateOrderSensitivity

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

impl Eq for AggregateOrderSensitivity

impl StructuralPartialEq for AggregateOrderSensitivity