Struct DriveDocumentHavingQuery 

pub struct DriveDocumentHavingQuery<'a> {
    pub document_type: DocumentTypeRef<'a>,
    pub contract_id: [u8; 32],
    pub document_type_name: String,
    pub index: &'a Index,
    pub bounds: AxisRangeBounds,
    pub descending: bool,
    pub limit: u16,
    /* private fields */
}

A resolved having-range query. Shared by the prover and the verifier — both build the grove path through DriveDocumentHavingQuery::indexed_property_name_tree_path and the secondary query through AxisRangeBounds::merk_query, so the two cannot drift on which subtree or which range the proof is about.

Fields

document_type: DocumentTypeRef<'a>

The document type being filtered.

contract_id: [u8; 32]

The contract id (32 bytes). Separate from document_type so the verifier can build the query without the full contract.

document_type_name: String

The document type name — a path segment.

index: &'a Index

The covering ranked index. Its last property is the GROUP BY property and the final path segment; any leading properties are pinned by Self::prefix_branches.

bounds: AxisRangeBounds

Inclusive bounds on the aggregate. Carry the axis; the index must declare the matching ranked_* flag.

descending: bool

true walks the secondary from the largest matching aggregate down. Tie ordering is by group key in the direction of the walk, exactly as on the ranked surface.

limit: u16

Maximum number of matching groups to return. Fewer entries come back when fewer groups fall inside the bounds; that is not an error. More matching groups than limit are silently cut at limit — the walk stops, and nothing marks the cut. A caller can continue past distinct aggregate values by tightening the bound, but a cut inside a tie cannot be continued (see the module docs): groups tied at the boundary aggregate that fell past the limit stay unreachable until a composite-key cursor exists, so size the limit above the widest expected tie.

Implementations

impl DriveDocumentHavingQuery<'_>

pub fn execute_range_no_proof( &self, drive: &Drive, transaction: TransactionArg<'_, '_>, platform_version: &PlatformVersion, ) -> Result<Vec<RankedEntry>, Error>

Read the matching groups directly from the axis secondary: every group whose aggregate falls inside the bounds, up to limit, in axis order in the walk direction.

Fewer than limit entries is normal (fewer groups match) and is not an error; exactly limit entries may mean the match set was cut.

Missing paths follow the ranked surface’s rule. Under a single == pin (or no pins) a missing path is an error rather than an empty result: the indexed property-name tree is created at contract registration, so its absence means the contract-level state is not what the request claims. On an IN-pinned request, an element whose branch chain is missing at ANY depth — the branch key, or any deeper pinned segment under a present key — contributes an empty branch instead (union semantics, exactly as the proved envelope authenticates it), and the union is served from one committed state (a None read runs under a grovedb snapshot read transaction). An index with no documents has the tree, with an empty secondary, and yields an empty entry list.

pub fn execute_range_with_proof( &self, drive: &Drive, transaction: TransactionArg<'_, '_>, platform_version: &PlatformVersion, ) -> Result<Vec<u8>, Error>

Generate the grovedb indexed-axis range proof for this query.

The envelope commits the in-range secondary entries, the primary’s root hash, the sibling axes’ root hashes, and a per-ancestor attestation chain up to the grovedb root — so the client reconstructs the platform root hash from it. The bounds, direction and limit bind by RECONSTRUCTION: the verifier rebuilds the same Bounded axis PathQuery from the request ([AxisRangeBounds::inclusive_bounds_i128]) and re-executes the proof against it — which is why the bounds are validated rather than clamped upstream, and why completeness needs no extra machinery: a Merk range proof over a sorted keyspace commits its boundaries, so an in-range group the server omitted fails reconstruction.

Verified by DriveDocumentHavingQuery::verify_having_range_proof.

impl DriveDocumentHavingQuery<'_>

pub fn prefix_branches(&self) -> &[Vec<Vec<u8>>]

The resolved prefix branches, in canonical order — one per IN element (a single branch without an IN). Read-only: the field is crate-private so the resolver’s encoder invariants cannot be bypassed by construction or mutation.

impl DriveDocumentHavingQuery<'_>

pub fn indexed_property_name_tree_path( &self, branch: usize, ) -> Result<Vec<Vec<u8>>, Error>

Path of one branch’s terminal property-name tree — identical to the ranked surface’s path (including the pinned-prefix segments of a compound index), because both read the same indexed tree(s). See DriveDocumentRankedQuery::indexed_property_name_tree_path.

impl DriveDocumentHavingQuery<'_>

pub fn verify_having_range_proof( &self, proof: &[u8], platform_version: &PlatformVersion, ) -> Result<(RootHash, Vec<RankedEntry>), Error>

Verifies a grovedb indexed-axis range proof and returns (root_hash, entries).

Counterpart to the prover-side execute_range_with_proof. Both sides derive the proved subtree from indexed_property_name_tree_path and the same bounded axis PathQuery from AxisRangeBounds::i128_bounds, so the verifier cannot drift from the prover on which bound over which tree it is checking.

The returned entries are in axis order in the walk direction, exactly as the unproven execute_range_no_proof would return them. The caller combines root_hash with the surrounding tenderdash signature — see rs-drive-proof-verifier for the canonical composition.

Arguments

• proof — raw grovedb proof bytes.
• platform_version — selects the method version.

Trait Implementations

impl<'a> Clone for DriveDocumentHavingQuery<'a>

fn clone(&self) -> DriveDocumentHavingQuery<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for DriveDocumentHavingQuery<'a>

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

Formats the value using the given formatter.