Enum mz_compute::render::reduce::AccumInner

enum AccumInner {
    Bool {
        trues: Diff,
        falses: Diff,
    },
    SimpleNumber {
        accum: i128,
        non_nulls: Diff,
    },
    Float {
        accum: i128,
        pos_infs: Diff,
        neg_infs: Diff,
        nans: Diff,
        non_nulls: Diff,
    },
    Numeric {
        accum: OrderedDecimal<NumericAgg>,
        pos_infs: Diff,
        neg_infs: Diff,
        nans: Diff,
        non_nulls: Diff,
    },
}

Accumulates values for the various types of accumulable aggregations.

We assume that there are not more than 2^32 elements for the aggregation. Thus we can perform a summation over i32 in an i64 accumulator and not worry about exceeding its bounds.

The float accumulator performs accumulation in fixed point arithmetic. The fixed point representation has less precision than a double. It is entirely possible that the values of the accumulator overflow, thus we have to use wrapping arithmetic to preserve group guarantees.

Variants

Bool

Fields

trues: Diff

The number of true values observed.

falses: Diff

The number of false values observed.

Accumulates boolean values.

SimpleNumber

Fields

accum: i128

The accumulation of all non-NULL values observed.

non_nulls: Diff

The number of non-NULL values observed.

Accumulates simple numeric values.

Float

Fields

accum: i128

Accumulates non-special float values, mapped to a fixed precision i128 domain to preserve associativity and commutativity

pos_infs: Diff

Counts +inf

neg_infs: Diff

Counts -inf

nans: Diff

Counts NaNs

non_nulls: Diff

Counts non-NULL values

Accumulates float values.

Numeric

Fields

accum: OrderedDecimal<NumericAgg>

Accumulates non-special values

pos_infs: Diff

Counts +inf

neg_infs: Diff

Counts -inf

nans: Diff

Counts NaNs

non_nulls: Diff

Counts non-NULL values

Accumulates arbitrary precision decimals.

Trait Implementations

impl Clone for AccumInner

fn clone(&self) -> AccumInner

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AccumInner

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AccumInner

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Multiply<i64> for AccumInner

type Output = AccumInner

Output type per the Mul trait.

fn multiply(self, factor: &Diff) -> AccumInner

Core method per the Mul trait.

impl Ord for AccumInner

fn cmp(&self, other: &AccumInner) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<AccumInner> for AccumInner

fn eq(&self, other: &AccumInner) -> 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.

impl PartialOrd<AccumInner> for AccumInner

fn partial_cmp(&self, other: &AccumInner) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Semigroup for AccumInner

fn is_zero(&self) -> bool

Returns true if the element is the additive identity.

fn plus_equals(&mut self, other: &AccumInner)

The method of std::ops::AddAssign, for types that do not implement AddAssign.

impl Serialize for AccumInner

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for AccumInner

impl StructuralEq for AccumInner

impl StructuralPartialEq for AccumInner