Method finalize

nodedb/src/data/executor/handlers/accum/finalize.rs:11–116

Consume the accumulator and produce the final `Value`.

(self, agg: &AggregateSpec)

impl AggAccum {
    /// Consume the accumulator and produce the final `Value`.
    pub(crate) fn finalize(self, agg: &AggregateSpec) -> Value {
        match self {
            AggAccum::Count { n } => Value::Integer(n as i64),
            AggAccum::SumAvg { sum, n, .. } => {
                if agg.function == "avg" {
                    if n == 0 {
                        Value::Null
                    } else {
                        Value::Float(sum / n as f64)
                    }
                } else {
                    Value::Float(sum)
                }
            }
            AggAccum::SumAvgDistinct { seen } => {
                let n = seen.len();
                // Kahan-compensated sum over the deduped values. Iteration
                // order is arbitrary, but a DISTINCT sum is order-independent
                // so the result is deterministic regardless.
                let mut sum = 0.0f64;
                let mut comp = 0.0f64;
                for &v in seen.values() {
                    let y = v - comp;
                    let t = sum + y;
                    comp = (t - sum) - y;
                    sum = t;
                }
                if agg.function == "avg_distinct" {
                    if n == 0 {
                        Value::Null
                    } else {
                        Value::Float(sum / n as f64)
                    }
                } else {
                    Value::Float(sum)
                }
            }
            AggAccum::Min { best } => best.unwrap_or(Value::Null),
            AggAccum::Max { best } => best.unwrap_or(Value::Null),
            AggAccum::CountDistinct { seen } => Value::Integer(seen.len() as i64),
            AggAccum::Welford { n, mean: _, m2 } => {
                if n < 2 {
                    return Value::Null;
                }
                let population = matches!(
                    agg.function.as_str(),
                    "stddev" | "stddev_pop" | "variance" | "var_pop"
                );
                let divisor = if population { n as f64 } else { (n - 1) as f64 };
                let variance = m2 / divisor;
                let result = if agg.function.contains("stddev") {
                    variance.sqrt()
                } else {
                    variance
                };
                Value::Float(result)
            }
            AggAccum::Hll { hll } => Value::Integer(hll.estimate().round() as i64),