Enum AxisRangeBounds 

pub enum AxisRangeBounds {
    Count {
        lo: u64,
        hi: u64,
    },
    Sum {
        lo: i64,
        hi: i64,
    },
    Avg {
        lo: i128,
        hi: i128,
    },
}

Inclusive numeric bounds on one axis of an indexed tree — the resolved form of a HAVING <aggregate> <operator> <value> clause.

One variant per axis because the three axes have three value types (u64 count, i64 sum, i128 fixed-point average) and the bound arithmetic (operator translation, successor/predecessor at exclusive bounds) must be exact in the axis’s own domain. Both bounds are inclusive; the operator translation in mode_detection normalizes every supported operator to this form, rejecting translations that would overflow (> MAX) or invert (lo > hi) instead of serving a silently-empty range.

Variants

Count

COUNT(*) ∈ [lo, hi].

Fields

lo: u64

Inclusive lower bound.

hi: u64

Inclusive upper bound.

Sum

SUM(field) ∈ [lo, hi].

Fields

lo: i64

Inclusive lower bound.

hi: i64

Inclusive upper bound.

Avg

AVG(field) ∈ [lo, hi], in the fixed-point domain described on super::drive_document_ranked_query::RANKED_AVG_SCALE.

Fields

lo: i128

Inclusive lower bound (fixed point).

hi: i128

Inclusive upper bound (fixed point).

Implementations

impl AxisRangeBounds

pub fn axis(&self) -> RankedAxis

The axis these bounds constrain.

pub fn inclusive_bounds_i128(&self) -> (i128, i128)

The bounds as inclusive i128 values in the axis’s own domain — the form AxisTraversal::Bounded carries in the unified PathQuery. Count and sum widen losslessly; avg is already i128 fixed point.

pub fn secondary_key_bounds(&self) -> (Vec<u8>, Option<Vec<u8>>)

The bounds as a byte range over the axis secondary’s keyspace: (inclusive_lower, exclusive_upper), with None for an upper bound at the axis’s type maximum (no representable successor — the range is unbounded above).

Secondary keys are (sort_key ‖ group_key) with order-preserving fixed-width sort keys, so the inclusive numeric range [lo, hi] is exactly the byte range [encode(lo), encode(hi + 1)): the exclusive upper at the next sort key admits every group-key suffix under hi and nothing above it. This mirrors — and must stay identical to — the bound construction inside grovedb’s indexed_*_range read primitives, so the no-proof read and the proved read answer the same question.

The + 1 cannot overflow: the hi == MAX case returns None first.

pub fn merk_query(&self, descending: bool) -> Query

The Merk query over the axis secondary that reads exactly these bounds, walking in the requested direction.

This is the prover/verifier-agreement artifact of the having surface: grovedb’s range-proof envelope is generated against this query and verified against the verifier’s own reconstruction of it, so both sides must build it from the same bounds through this one function — a divergence surfaces as a failed verification, not a wrong answer.

Trait Implementations

impl Clone for AxisRangeBounds

fn clone(&self) -> AxisRangeBounds

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for AxisRangeBounds

impl Debug for AxisRangeBounds

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

Formats the value using the given formatter.

impl Eq for AxisRangeBounds

impl PartialEq for AxisRangeBounds

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