Struct SizedQuery 

pub struct SizedQuery {
    pub query: Query,
    pub limit: Option<u16>,
    pub offset: Option<u16>,
}

Holds a query to apply to a tree and an optional limit/offset value. Limit and offset values affect the size of the result set.

Fields

query: Query

Query

limit: Option<u16>

Limit

offset: Option<u16>

Offset

Implementations

impl SizedQuery

pub const fn new( query: Query, limit: Option<u16>, offset: Option<u16>, ) -> SizedQuery

New sized query

pub fn new_single_key(key: Vec<u8>) -> SizedQuery

New sized query with one key

pub fn new_single_query_item(query_item: QueryItem) -> SizedQuery

New sized query with one key

pub fn validate_aggregate_count_on_range(&self) -> Result<&QueryItem, Error>

Validates that this sized query is a well-formed AggregateCountOnRange query in either the leaf or carrier shape. On success, returns a reference to the leaf inner range item (the QueryItem wrapped by the underlying AggregateCountOnRange, whether at this level for leaf queries or inside the default_subquery_branch.subquery for carrier queries).

This is the SizedQuery-level entry point: it forwards to Query::validate_aggregate_count_on_range and additionally enforces the appropriate per-shape size-constraint rules:

• Leaf shape (single AggregateCountOnRange(_) item, no subqueries): both SizedQuery::limit and SizedQuery::offset are rejected. A leaf returns a single u64; pagination would silently change the answer.
• Carrier shape (outer Key/Range* items routing to a leaf AggregateCountOnRange subquery): SizedQuery::limit is allowed and caps the number of outer-key matches the carrier walks (each matched outer key still produces a complete leaf-ACOR u64). SizedQuery::offset is still rejected — skipping outer matches changes which (outer_key, u64) pairs end up in the proof, and the use case for that hasn’t been designed yet.

pub fn validate_leaf_aggregate_count_on_range( &self, ) -> Result<&QueryItem, Error>

Strict variant of Self::validate_aggregate_count_on_range that only accepts the leaf shape (single AggregateCountOnRange(_) item, no subqueries). Used by entry points that produce a single u64 and need to reject the carrier shape up front. Pagination (SizedQuery::limit / SizedQuery::offset) is rejected — see Self::check_leaf_aggregate_count_size_constraints.

Trait Implementations

impl<'__de, __Context> BorrowDecode<'__de, __Context> for SizedQuery

fn borrow_decode<__D>(decoder: &mut __D) -> Result<SizedQuery, DecodeError>

where __D: BorrowDecoder<'__de, Context = __Context>,

Attempt to decode this type with the given BorrowDecode.

impl Clone for SizedQuery

fn clone(&self) -> SizedQuery

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SizedQuery

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for SizedQuery

fn decode<__D>(decoder: &mut __D) -> Result<SizedQuery, DecodeError>

where __D: Decoder<Context = __Context>,

Attempt to decode this type with the given Decode.

impl Display for SizedQuery

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

Formats the value using the given formatter.

impl Encode for SizedQuery

fn encode<__E>(&self, encoder: &mut __E) -> Result<(), EncodeError>

where __E: Encoder,

Encode a given type.

impl PartialEq for SizedQuery

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