Enum QueryItem 

pub enum QueryItem {
    Key(Vec<u8>),
    Range(Range<Vec<u8>>),
    RangeInclusive(RangeInclusive<Vec<u8>>),
    RangeFull(RangeFull),
    RangeFrom(RangeFrom<Vec<u8>>),
    RangeTo(RangeTo<Vec<u8>>),
    RangeToInclusive(RangeToInclusive<Vec<u8>>),
    RangeAfter(RangeFrom<Vec<u8>>),
    RangeAfterTo(Range<Vec<u8>>),
    RangeAfterToInclusive(RangeInclusive<Vec<u8>>),
    AggregateCountOnRange(Box<QueryItem>),
}

A QueryItem represents a key or a range of keys to be included in a proof.

This enum allows specifying different ways of selecting keys, including exact matches, open-ended ranges, and boundary-based selections.

Variants:

• Key(Vec<u8>) → A specific key.
• Range(Range<Vec<u8>>) → A range of keys (exclusive upper bound).
• RangeInclusive(RangeInclusive<Vec<u8>>) → A range of keys (inclusive upper bound).
• RangeFull(RangeFull) → A full range, including all keys.
• RangeFrom(RangeFrom<Vec<u8>>) → A range starting from a key (inclusive).
• RangeTo(RangeTo<Vec<u8>>) → A range up to a key (exclusive).
• RangeToInclusive(RangeToInclusive<Vec<u8>>) → A range up to a key (inclusive).
• RangeAfter(RangeFrom<Vec<u8>>) → A range starting after a key (exclusive).
• RangeAfterTo(Range<Vec<u8>>) → A range between two keys, starting after the lower bound.
• RangeAfterToInclusive(RangeInclusive<Vec<u8>>) → A range between two

Variants

Key(Vec<u8>)

A specific key to be included in the proof.

Range(Range<Vec<u8>>)

A range of keys, excluding the upper bound (start..end).

RangeInclusive(RangeInclusive<Vec<u8>>)

A range of keys, including the upper bound (start..=end).

RangeFull(RangeFull)

Represents a full range, covering all possible keys.

RangeFrom(RangeFrom<Vec<u8>>)

A range starting from a key, inclusive (start..).

RangeTo(RangeTo<Vec<u8>>)

A range up to a key, exclusive (..end).

RangeToInclusive(RangeToInclusive<Vec<u8>>)

A range up to a key, inclusive (..=end).

RangeAfter(RangeFrom<Vec<u8>>)

A range starting after a specific key, exclusive ((key, ∞)).

RangeAfterTo(Range<Vec<u8>>)

A range starting after a key and extending to another key, exclusive.

RangeAfterToInclusive(RangeInclusive<Vec<u8>>)

A range starting after a key and extending to another key, inclusive.

AggregateCountOnRange(Box<QueryItem>)

A count-only meta-query that wraps another QueryItem describing the range to count.

When this variant appears in a Query, the query is interpreted as “return the number of elements matched by the inner range” instead of returning the elements themselves. The proof is shaped accordingly: boundary nodes are emitted as KVDigestCount, fully-inside subtree roots as KVHashCount, and fully-outside subtrees as opaque Hash.

This variant is only valid against ProvableCountTree / ProvableCountSumTree (and their NonCounted* wrapper variants), and it must be the only item in the surrounding Query (no subqueries, no pagination, no other range items). The inner QueryItem may not be Key, RangeFull, or another AggregateCountOnRange.

Implementations

impl QueryItem

pub fn intersect(&self, other: &QueryItem) -> QueryItemIntersectionResult

Computes the intersection of two query items, returning the shared region and any leftover portions.

pub fn to_range_set(&self) -> RangeSet

Converts this query item into an owned [RangeSet] for intersection operations.

pub fn to_range_set_borrowed(&self) -> Option<RangeSetBorrowed<'_>>

Converts this query item into a borrowed [RangeSetBorrowed] for zero-allocation range checks.

pub fn intersect_many_ordered( ours: &mut Vec<QueryItem>, theirs: Vec<QueryItem>, ) -> QueryItemManyIntersectionResult

Intersects two ordered sets of query items, returning items in both, ours-only, and theirs-only. Both input vectors must be sorted.

impl QueryItem

pub fn merge(&self, other: &QueryItem) -> QueryItem

Merge two overlapping query items into one that covers both ranges.

pub fn merge_assign(&mut self, other: &QueryItem)

Merges another QueryItem into this one in-place.

impl QueryItem

pub fn processing_footprint(&self) -> u32

Returns an approximate byte size of this query item for cost estimation.

pub fn lower_bound(&self) -> (Option<&[u8]>, bool)

Returns the lower bound of this query item as (bound, is_exclusive). None means the lower bound is unbounded.

pub fn lower_unbounded(&self) -> bool

Returns true if this query item has no lower bound (extends to -inf).

pub fn upper_bound(&self) -> (Option<&[u8]>, bool)

Returns the upper bound of this query item as (bound, is_inclusive). None means the upper bound is unbounded.

pub fn upper_unbounded(&self) -> bool

Returns true if this query item has no upper bound (extends to +inf).

pub fn contains(&self, key: &[u8]) -> bool

Returns true if the given key falls within this query item’s bounds.

pub fn enum_value(&self) -> u32

Returns a numeric discriminant for this query item variant.

pub const fn is_key(&self) -> bool

Returns true if this query item is a single key lookup.

pub const fn is_range(&self) -> bool

Returns true if this query item is any kind of range (not a single key). AggregateCountOnRange counts as a range — it describes a range to count over.

pub const fn is_single(&self) -> bool

Returns true if this query item matches exactly one key.

pub fn is_unbounded_range(&self) -> bool

Returns true if this query item is a range with at least one unbounded end (e.g., RangeFull, RangeFrom, RangeTo, etc.). For AggregateCountOnRange, delegates to the inner item.

pub const fn is_aggregate_count_on_range(&self) -> bool

Returns true if this query item is the count-only meta-variant.

pub fn aggregate_count_inner(&self) -> Option<&QueryItem>

If this is AggregateCountOnRange, returns a reference to the inner QueryItem describing the range to count. Otherwise returns None.

pub fn keys(&self) -> Result<Vec<Vec<u8>>, Error>

Enumerates all distinct keys in this query item. Only works for Key, Range, and RangeInclusive with single-byte boundaries; returns an error for unbounded ranges.

pub fn keys_consume(self) -> Result<Vec<Vec<u8>>, Error>

Like keys but consumes self, avoiding clones.

pub fn seek_for_iter<I>( &self, iter: &mut I, left_to_right: bool, ) -> CostContext<()>

where I: RawIterator,

Positions a storage iterator to the start of this query item, seeking forward or backward based on left_to_right.

pub fn compare(a: &[u8], b: &[u8]) -> Ordering

Lexicographically compares two byte slices.

pub fn iter_is_valid_for_type<I>( &self, iter: &I, limit: Option<u16>, aggregate_limit: Option<i64>, left_to_right: bool, ) -> CostContext<bool>

where I: RawIterator,

Returns true if the iterator is currently positioned at a valid key within this query item’s bounds, respecting direction and limit.

pub fn collides_with(&self, other: &QueryItem) -> bool

Returns true if this query item overlaps with other in any way.

Trait Implementations

impl<'de, Context> BorrowDecode<'de, Context> for QueryItem

fn borrow_decode<D>(decoder: &mut D) -> Result<QueryItem, DecodeError>

where D: BorrowDecoder<'de, Context = Context>,

Attempt to decode this type with the given BorrowDecode.

impl Clone for QueryItem

fn clone(&self) -> QueryItem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QueryItem

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

Formats the value using the given formatter.

impl<Context> Decode<Context> for QueryItem

fn decode<D>(decoder: &mut D) -> Result<QueryItem, DecodeError>

where D: Decoder<Context = Context>,

Attempt to decode this type with the given Decode.

impl Display for QueryItem

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

Formats the value using the given formatter.

impl Encode for QueryItem

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

where E: Encoder,

Encode a given type.

impl From<Vec<u8>> for QueryItem

fn from(key: Vec<u8>) -> QueryItem

Converts to this type from the input type.

impl Hash for QueryItem

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for QueryItem

fn cmp(&self, other: &QueryItem) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq<&[u8]> for QueryItem

fn eq(&self, other: &&[u8]) -> 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 PartialEq for QueryItem

fn eq(&self, other: &QueryItem) -> 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 PartialOrd<&[u8]> for QueryItem

fn partial_cmp(&self, other: &&[u8]) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd for QueryItem

fn partial_cmp(&self, other: &QueryItem) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for QueryItem

impl StructuralPartialEq for QueryItem