Enum CountMode 

pub enum CountMode {
    Aggregate,
    GroupByIn,
    GroupByRange,
    GroupByCompound,
}

SQL-shaped count-query mode — names the response shape the caller asked for via (select, group_by) on the wire.

Two count-mode enums coexist in this module. This one names the output shape the request produces (single aggregate vs per-group entries). DocumentCountMode below names the executor strategy (which proof primitive / which walk path Drive uses to compute that shape). CountMode lives on DocumentCountRequest as the caller-supplied contract; DocumentCountMode is derived from (CountMode, where_clauses, prove) by DriveDocumentCountQuery::detect_mode just before dispatch.

The invariants below are enforced upstream (in drive-abci’s validate_and_route) before a DocumentCountRequest is built. They’re documented here so any new caller knows the shape-validity contract attached to each variant.

Variants

Aggregate

select=COUNT, group_by=[]. Single u64 result.

Where-clause shapes accepted:

• empty (relies on a documentsCountable: true doctype),
• Equal-only (fully covered by a countable: true index),
• one In (per-In fan-out, summed server-side),
• one range (uses AggregateCountOnRange for prove, RangeNoProof for no-proof),
• one In + one range on the no-proof path (per-In fan-out each doing a range walk; prove is rejected).

limit is structurally meaningless (aggregate is one row) and is rejected upstream when set.

GroupByIn

select=COUNT, group_by=[in_field]. One entry per In value.

Where-clause invariants: exactly one In clause whose field matches group_by[0]; no range clause.

limit is rejected upstream when set. The In array is already capped at 100 entries by WhereClause::in_values(), so the result size is bounded by construction; a separate limit would either be redundant (≤ 100) or would silently truncate the proof to fewer In branches than the caller asked for (because the PointLookupProof path can’t represent a partial-In-array selection in its SizedQuery). Callers that want fewer branches narrow the In array directly.

GroupByRange

select=COUNT, group_by=[range_field]. One entry per distinct value within the range.

Where-clause invariants: exactly one range clause whose field matches group_by[0]; no In clause. limit caps the number of distinct values; on the prove path it’s validated-not-clamped (oversized values rejected with InvalidLimit).

GroupByCompound

select=COUNT, group_by=[in_field, range_field]. One entry per (in_key, range_key) pair.

Where-clause invariants: exactly one In clause on group_by[0] AND exactly one range clause on group_by[1]. limit is a global cap on the emitted (in_key, key) lex stream, not per-In-branch. The executor pushes a single SizedQuery::limit over the compound walk, so a request with |In| = 3 and limit = 5 returns at most 5 entries total across all In branches (ordered by (in_key, key), direction from the first order_by clause). On the prove path it’s validated-not-clamped (oversized values rejected with InvalidLimit).

Implementations

impl CountMode

pub fn is_aggregate(self) -> bool

true for Self::Aggregate (single-row response); false for the three grouped variants. See each variant’s docstring for the per-shape semantics.

pub fn requires_distinct_walk(self) -> bool

true for Self::GroupByRange and Self::GroupByCompound — the two variants whose proof shape requires per-distinct- value KVCount ops. See each variant’s docstring for the per-shape proof routing.

pub fn accepts_limit(self) -> bool

true for Self::GroupByRange and Self::GroupByCompound — the two variants whose result size isn’t structurally bounded. Self::Aggregate and Self::GroupByIn reject limit upstream; see each variant’s docstring for the per-shape reasoning.

Trait Implementations

impl Clone for CountMode

fn clone(&self) -> CountMode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CountMode

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

Formats the value using the given formatter.

impl PartialEq for CountMode

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

impl Eq for CountMode

impl StructuralPartialEq for CountMode