Enum DocumentCountMode 

pub enum DocumentCountMode {
    Total,
    PerInValue,
    RangeNoProof,
    RangeProof,
    RangeDistinctProof,
    PointLookupProof,
    RangeAggregateCarrierProof,
}

Classification of a count query’s shape, used to dispatch to the right executor. Returned by DriveDocumentCountQuery::detect_mode.

The discriminator is purely a function of the where-clause operators + the caller’s CountMode + prove; it does not depend on the contract’s index set. Picking a covering index for the chosen mode is a separate step that requires the document type’s BTreeMap<String, Index>.

Variants

Total

No range, no In — single summed entry with empty key. Reads the CountTree count directly at the indexed path.

PerInValue

Exactly one In clause, no range — one entry per (deduped) In value, each computed as the count at that single value. The In doubles as the per-value split signal.

RangeNoProof

Exactly one range clause, no proof — walks the property-name ProvableCountTree’s children inside the range. Returns either a single summed entry or per-distinct-value entries depending on whether the caller’s CountMode requires a distinct walk (CountMode::GroupByRange / CountMode::GroupByCompound) or not (CountMode::Aggregate).

RangeProof

Exactly one range clause + prove = true + CountMode::Aggregate — produces a grovedb AggregateCountOnRange proof that verifies to a single u64. The merk-level primitive returns one aggregate; per-distinct- value entries with proof go through Self::RangeDistinctProof instead.

RangeDistinctProof

Exactly one range clause + prove = true + CountMode::GroupByRange or CountMode::GroupByCompound — produces a regular range proof against the property-name ProvableCountTree. The proof’s KVCount(key, value, count) ops carry per-distinct- value counts, each cryptographically committed via node_hash_with_count to the merk root. The verifier walks the proof op stream and emits a per-key count map, no opt-in aggregate-collapse wrapper. Proof size is O(distinct values matched) rather than the O(log n) of Self::RangeProof, but still much smaller than materialize-and-count.

PointLookupProof

No range clause + prove = true — produces a per-branch Element::CountTree proof. Either an unfiltered total (documents_countable: true fast path, proving the doctype’s primary-key CountTree directly) or a covered Equal/In lookup against a countable: true index (proving one CountTree element per matched branch via DriveDocumentCountQuery::point_lookup_count_path_query). Proof size is O(k × log n) where k is the number of covered branches (1 for the empty-where fast path and Equal-only fully-covered case; ≤ |In values| for In-on-prefix). No document materialization, no u16::MAX matching-docs cap — the merk-level count_value IS the result, the SDK extracts it via verify_point_lookup_count_proof.

RangeAggregateCarrierProof

Exactly one In clause + one range clause + prove = true

• CountMode::GroupByIn — produces a grovedb carrier AggregateCountOnRange proof: one outer-key descent per In value, each terminating in an ACOR boundary walk over the per-branch range subtree. Returns one (in_key, u64) pair per resolved In branch — same per-key aggregate semantics as the no-proof per-In fan-out, just verifiable.

Proof size is O(|In values| · (log B + log C')) where B is the In-property’s distinct-value count and C' is the terminator subtree’s distinct-value count. Smaller than the alternative Self::RangeDistinctProof (which scales with the number of distinct in-range terminator values per branch, not per-branch log-bound boundary nodes) and preserves per-In aggregate granularity that GROUP BY [in_field, range_field] can’t express.

Path-query shape (see DriveDocumentCountQuery::carrier_aggregate_count_path_query): outer Keys = serialized In values; subquery_path = ranged property name; subquery = ACOR(range). Verified via [grovedb::GroveDb::verify_aggregate_count_query_per_key] (returns Vec<(Vec<u8>, u64)>).

Enabled by grovedb PR #663 (“allow AggregateCountOnRange as carrier subquery”). Before that PR this shape was rejected in [Self::detect_mode] with the message “range count queries with an in clause are not supported on the aggregate prove path”.

Trait Implementations

impl Clone for DocumentCountMode

fn clone(&self) -> DocumentCountMode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DocumentCountMode

impl Debug for DocumentCountMode

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

Formats the value using the given formatter.

impl Eq for DocumentCountMode

impl PartialEq for DocumentCountMode

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