Enum Accum

enum Accum {
    Bool {
        trues: Diff,
        falses: Diff,
    },
    SimpleNumber {
        accum: Overflowing<i128>,
        non_nulls: Diff,
    },
    Float {
        accum: Overflowing<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

Accumulates boolean values.

Fields

trues: Diff

The number of true values observed.

falses: Diff

The number of false values observed.

SimpleNumber

Accumulates simple numeric values.

Fields

accum: Overflowing<i128>

The accumulation of all non-NULL values observed.

non_nulls: Diff

The number of non-NULL values observed.

Float

Accumulates float values.

Fields

accum: Overflowing<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

Numeric

Accumulates arbitrary precision decimals.

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

Trait Implementations

impl Clone for Accum

fn clone(&self) -> Accum

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Columnation for Accum

type InnerRegion = CopyRegion<Accum>

The type of region capable of absorbing allocations owned by the Self type. Note: not allocations of Self, but of the things that it owns.

impl Debug for Accum

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Accum

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl IsZero for Accum

fn is_zero(&self) -> bool

Returns true if the element is the additive identity.

impl Multiply<Overflowing<i64>> for Accum

type Output = Accum

Output type per the Mul trait.

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

Core method per the Mul trait.

impl Ord for Accum

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Accum

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

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Semigroup for Accum

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

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

impl Serialize for Accum

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Accum

impl Eq for Accum

impl StructuralPartialEq for Accum