Struct DocumentCountRequest 

pub struct DocumentCountRequest<'a> {
    pub contract: &'a DataContract,
    pub document_type: DocumentTypeRef<'a>,
    pub raw_where_value: Value,
    pub raw_order_by_value: Value,
    pub mode: CountMode,
    pub limit: Option<u32>,
    pub prove: bool,
    pub drive_config: &'a DriveConfig,
}

All inputs required for the unified document-count entry point Drive::execute_document_count_request. Built by the gRPC handler from a GetDocumentsCountRequestV0 after CBOR-decoding + contract lookup; drive owns everything past this point including mode detection, index picking, and per-mode dispatch.

raw_where_value and raw_order_by_value arrive as CBOR-decoded Values and the dispatcher parses them once into structured Vec<WhereClause> / Vec<OrderClause> for mode detection + per-mode executors. None of the count executors consume the raw Value form — the structured parse is the single source of truth past the dispatcher entry point.

Fields

contract: &'a DataContract

Live contract (already loaded by the handler).

document_type: DocumentTypeRef<'a>

Resolved document type within contract.

raw_where_value: Value

Decoded where value as it came off the wire (after CBOR decode). The dispatcher parses this into Vec<WhereClause> once (where_clauses_from_value) for every downstream consumer — mode detection, index picking, and the per-mode executors all operate on the structured form.

Mirrors how the regular query_documents_v0 handler delegates where-clause decomposition to drive: the abci layer just CBOR-decodes and hands the raw value down.

raw_order_by_value: Value

Decoded order_by value as it came off the wire. Parsed once via order_clauses_from_value into Vec<OrderClause>. The first clause’s direction governs split-mode entry ordering (per-In-value / per-distinct- value-in-range) and, on the RangeDistinctProof prove path, is part of the path-query bytes the SDK reconstructs to verify the proof. PointLookupProof and the no-proof Total / PerInValue paths don’t read order_by.

Value::Null (empty order_by field on the wire) → no clauses. The dispatcher synthesizes a default direction of “ascending” for split-mode response ordering when no clauses are present.

mode: CountMode

SQL-shaped output mode — the caller’s (select, group_by) contract resolved into one of four shapes (Aggregate, GroupByIn, GroupByRange, GroupByCompound). The dispatcher uses this to distinguish e.g. “aggregate count with In fan-out” (which does NOT accept limit) from “per-In-value entries” (which does) — they’re otherwise indistinguishable from the where clauses alone. See [CountMode] for the per-variant where-clause and limit invariants.

limit: Option<u32>

Limit cap from the request. Callers SHOULD pre-clamp against their server-side max_query_limit policy, but Drive also enforces a defense-in-depth clamp before forwarding to the distinct-mode walk: an Option::None here is normalized to drive_config.default_query_limit and any Some(value) is reduced to drive_config.max_query_limit if larger. After dispatch, the limit forwarded to RangeCountOptions::limit is always Some(_) ≤ system cap.

prove: bool

Whether to produce a proof (vs. raw counts).

drive_config: &'a DriveConfig

Drive-side query config — only consumed by the materialize-and- count fallback.