Struct DocumentQuery 

pub struct DocumentQuery {
    pub select: SelectProjection,
    pub data_contract: Arc<DataContract>,
    pub document_type_name: String,
    pub where_clauses: Vec<WhereClause>,
    pub time_range_clauses: Vec<TimeRangeClause>,
    pub group_by: Vec<String>,
    pub having: Vec<HavingClause>,
    pub order_by_clauses: Vec<OrderClause>,
    pub limit: u32,
    pub offset: Option<u32>,
    pub start: Option<Start>,
}

Request that is used to query documents from the Dash Platform.

This is an abstraction layer built on top of [GetDocumentsRequest] to address issues with missing details required to correctly verify proofs returned by the Dash Platform.

Conversions are implemented between this type, [GetDocumentsRequest] and [DriveDocumentQuery] using TryFrom trait.

Fields

select: SelectProjection

SQL-shaped SELECT projection — (function, field) pair. Documents returns matched rows; Count / Sum / Avg return either a single aggregate (empty group_by) or per-group entries (non-empty group_by). Defaults to SelectProjection::documents() so callers that don’t opt into the SQL-shaped surface get plain document-fetch semantics.

#[serde(default)] here (and on group_by / having below) is wire-format-compat for mock vectors captured before the SQL-shaped surface was added: default SelectProjection is documents(), Vec defaults to empty — together those mean an old fixture without these fields deserializes to the documents-fetch shape it was originally captured under. New fixtures should serialize the fields explicitly.

data_contract: Arc<DataContract>

Data contract

document_type_name: String

Document type for the data contract

where_clauses: Vec<WhereClause>

where clauses for the query

time_range_clauses: Vec<TimeRangeClause>

Time-range (IN_TIME_RANGE) selections on a timestamp field covered by a timeRange index. These are emitted as IN_TIME_RANGE clauses on the v1 wire and resolved server-side from the current block time; the verifier re-derives the same bucket from the quorum-signed response metadata time. v1-only (the v0 wire has no IN_TIME_RANGE operator). See Self::with_time_range and Self::with_time_range_grid.

group_by: Vec<String>

SQL GROUP BY field names, in left-to-right order. Empty = no explicit grouping (aggregate count for select=Count). Only meaningful when select=Count; non-empty with select=Documents is rejected by the server as unsupported.

having: Vec<HavingClause>

SQL HAVING clauses — boolean aggregate filters that apply to the grouped rows produced by select = Count | Sum | Avg with a non-empty group_by. Unlike where_clauses, the left side is an aggregate (COUNT(*), SUM(field), AVG(field)) rather than a raw row field. See [HavingClause] / [drive::query::HavingAggregate] / [drive::query::HavingOperator] for the catalogs. Multiple entries combine with implicit AND.

Served from protocol version 14, for exactly one clause bounding the selected aggregate with a contiguous-range operator (=, >, >=, <, <=, BETWEEN*) — the having-range surface, fetched as DocumentHavingEntries and served as a value-bounded range read of the covering ranked index’s axis secondary (the index must declare the matching rankedCountable / rankedSummable / rankedAverageable keyword). Everything else — multiple clauses (implicit AND), a clause on an aggregate the select does not project, != / IN — is still rejected with QuerySyntaxError::Unsupported, as is any non-empty value at protocol version 13 and earlier.

having does not express ranking. “The n highest-scoring groups” is Self::order_by_selected_aggregate + Self::with_limit — SQL’s own ORDER BY <agg> DESC LIMIT n — which is also served from protocol version 14. The two compose only in the one shape the having grammar allows: an ORDER BY naming the selected aggregate sets the having range’s walk direction.

order_by_clauses: Vec<OrderClause>

order_by clauses for the query.

For select = Documents these order the matched rows. For the ranked surface a single clause naming the selected aggregate orders the groups — see Self::order_by_selected_aggregate, which builds it.

limit: u32

queryset limit. 0 is the sentinel for “unset / default” and is translated to None on the V1 wire (optional uint32).

offset: Option<u32>

SQL OFFSET — how many result rows to skip before the returned page. None leaves the field unset on the wire.

Served on exactly one path: the ranked surface (protocol version 14+), where it skips that many ranks, so .order_by_selected_aggregate(Descending).with_limit(1) .with_offset(4) is the 5th-best group. Everywhere else the server rejects a set offset with Unsupported("OFFSET pagination is not yet implemented").

#[serde(default)] for the same mock-vector compatibility reason as select / group_by / having: a fixture captured before offsets existed deserializes to None.

start: Option<Start>

first object to start with

Implementations

impl DocumentQuery

pub fn new<C: Into<Arc<DataContract>>>( contract: C, document_type_name: &str, ) -> Result<Self, Error>

Create new DocumentQuery for provided contract and document type name.

pub fn new_with_drive_query(d: &DriveDocumentQuery<'_>) -> Result<Self, Error>

Create new document query based on a [DriveDocumentQuery].

Fails when the drive query carries time-range resolution provenance (resolved_time_ranges): the resolved bucket equality cannot be represented without it — see the TryFrom impl. Build the query with Self::with_time_range / Self::with_time_range_grid instead for time-range selections.

pub fn with_document_id(self, document_id: &Identifier) -> Self

Point to a specific document ID.

pub fn with_where(self, clause: WhereClause) -> Self

Add new where clause to the query.

Existing where clauses will be preserved.

pub fn with_time_range( self, field: impl Into<String>, selector: TimeRangeSelector, ) -> Self

Restrict the query to a single time-range bucket of field (a timestamp covered by a timeRange index), selecting either the [TimeRangeSelector::Newest] or [TimeRangeSelector::Oldest] currently active range. Emitted as an IN_TIME_RANGE clause on the v1 wire and resolved server-side from the current block time; the proof verifier re-derives the identical bucket from the quorum-signed response metadata time. Requires protocol version 14+ — the first version whose contract grammar hosts timeRange indexes.

The bare selector is unambiguous only while exactly one grid buckets field; when the contract declares several grids over it, use Self::with_time_range_grid to name one.

Existing time-range selections are preserved.

pub fn with_time_range_grid( self, field: impl Into<String>, selector: TimeRangeSelector, grid: TimeRangeGridSpec, ) -> Self

Self::with_time_range naming a specific grid — required when the contract buckets field with more than one timeRange grid. The spec’s range / step / phase are the contract’s own declared seconds, verbatim.

Existing time-range selections are preserved.

pub fn with_order_by(self, clause: OrderClause) -> Self

Add order by clause to the query.

Existing order by clauses will be preserved.

pub fn with_select(self, select: SelectProjection) -> Self

Set the SQL-shaped SELECT projection.

Construct the [SelectProjection] via its helpers: [SelectProjection::documents] (the default — matched rows), [SelectProjection::count_star] for COUNT(*), [SelectProjection::count_field] for COUNT(field), [SelectProjection::sum] for SUM(field), [SelectProjection::avg] for AVG(field). Pair the count/sum/avg projections with [DocumentCount::fetch] (single aggregate, empty group_by) or [DocumentSplitCounts::fetch] (per-group entries, non-empty group_by).

Server capability today: Documents, COUNT(*), SUM(<field>), and AVG(<field>) are evaluated end-to-end. COUNT(<field>), MIN(<field>), and MAX(<field>) are accepted by the SDK but rejected by the server with Unsupported("SELECT … is not yet implemented") — the surface is shipped first and execution lands later.

pub fn with_group_by<S: Into<String>>(self, field: S) -> Self

Set the GROUP BY field to a single field name.

Convenience wrapper around Self::with_group_by_fields. Replaces any previously set group_by. Pair with Self::with_select (e.g. with_select(SelectProjection::count_star())) for the per-group entries shape.

pub fn with_group_by_fields<I, S>(self, fields: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Set the full GROUP BY field list (replaces any previously set group_by).

Multi-field group_by is only accepted by the server for (in_field, range_field) matching a compound In + range where clause against a rangeCountable: true index. Other non-empty shapes return QuerySyntaxError::Unsupported.

pub fn with_having(self, having: Vec<HavingClause>) -> Self

Set the HAVING clauses (replaces any prior value).

From protocol version 14, a grouped aggregate query carrying exactly one clause that bounds the selected aggregate with a contiguous-range operator (=, >, >=, <, <=, the BETWEEN variants) is served as a value-bounded range read of the covering ranked index’s axis secondary — fetch the result through DocumentHavingEntries::fetch, which verifies the proof including its completeness. The server still rejects multiple clauses, a clause on a different aggregate than the select’s, and the non-contiguous operators (!=, IN); protocol version 13 and earlier reject every non-empty having.

This is not how you ask for a ranking — see Self::order_by_selected_aggregate.

pub fn order_by_selected_aggregate(self, direction: RankingDirection) -> Self

Order the GROUP BY groups by the aggregate this query selects — the ranked surface, ORDER BY <the selected aggregate> [ASC|DESC] (protocol version 14+).

Replaces any previously set order_by, because a ranked query takes exactly one ordering clause and a second one is rejected rather than combined.

The ordered field name is derived from the current Self::select by rs-drive’s own [ranked_order_key] — SUM(f) / AVG(f) are named by f, and COUNT(*) by the $count sentinel. Calling Self::with_select after this method leaves a stale field name behind and the server will refuse the request; set the select first, which is also how the query reads.

Pair with Self::with_limit (the ranking’s n, 1 ..= 100) and optionally Self::with_offset, then fetch with DocumentRankedEntries.

The 5th-best group

// SELECT avg(grade) GROUP BY restaurantId
//   ORDER BY avg(grade) DESC LIMIT 1 OFFSET 4
let query = DocumentQuery::new(contract, "review")?
    .with_select(SelectProjection::avg("grade"))
    .with_group_by("restaurantId")
    .order_by_selected_aggregate(RankingDirection::Descending)
    .with_limit(1)
    .with_offset(4);

pub fn with_offset(self, offset: u32) -> Self

Set the SQL OFFSET — how many ranks to skip before the returned page.

Only the ranked surface honours it (see Self::order_by_selected_aggregate); on every other path the server rejects a set offset with Unsupported. There is no ceiling: grovedb counts the skipped region from the subtree aggregates instead of walking it, on both prove settings, so the cost of a deep offset does not scale with the offset. It is not identical to a shallow one — offset = 0 keeps a sequential fast path, a positive offset descends the tree in O(log n), and an offset at or past the population is answered from the root without descending at all — but nothing here grows with how far you page, which is why there is no ceiling. Only a proved response additionally attests the count.

An offset past the end of the ranking is a legitimate answer rather than an error — the page comes back empty, and on a proved fetch its starting_rank is the ranking’s attested total population.

pub fn with_limit(self, limit: u32) -> Self

Set the query limit. 0 means “unset” — translated to None on the V1 wire (the proto field is optional uint32).

On select=Count with non-empty group_by against the prove path, the server validates rather than clamps: limit > max_query_limit is rejected with InvalidLimit rather than silently truncated, since clamping would invisibly break proof verification. Leaving the limit unset (0) falls back to drive::config::DEFAULT_QUERY_LIMIT on the proof verifier side, keeping proof bytes deterministic across operators.

pub fn try_into_request_for_version( self, platform_version: &PlatformVersion, ) -> Result<GetDocumentsRequest, Error>

Convert into the wire-format [GetDocumentsRequest] using a specific [PlatformVersion] to pick V0 vs V1. The dispatch boundary is the document_query feature-version on the platform_version: 0 → V0, 1 → V1.

Trait Implementations

impl Clone for DocumentQuery

fn clone(&self) -> DocumentQuery

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DocumentQuery

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DocumentQuery

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromProof<DocumentQuery> for DocumentAverage

type Request = DocumentQuery

Request type for which this trait is implemented.

type Response = GetDocumentsResponse

Response type for which this trait is implemented.

fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>( request: I, response: O, _network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>

where Self: 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn maybe_from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Option<Self>, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Self, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof.

fn from_proof_with_metadata<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

fn from_proof_with_metadata_and_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata, Proof), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

impl FromProof<DocumentQuery> for DocumentCount

type Request = DocumentQuery

Request type for which this trait is implemented.

type Response = GetDocumentsResponse

Response type for which this trait is implemented.

fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>( request: I, response: O, _network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>

where Self: 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn maybe_from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Option<Self>, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Self, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof.

fn from_proof_with_metadata<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

fn from_proof_with_metadata_and_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata, Proof), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

impl FromProof<DocumentQuery> for DocumentHavingEntries

type Request = DocumentQuery

Request type for which this trait is implemented.

type Response = GetDocumentsResponse

Response type for which this trait is implemented.

fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>( request: I, response: O, _network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>

where Self: 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn maybe_from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Option<Self>, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Self, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof.

fn from_proof_with_metadata<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

fn from_proof_with_metadata_and_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata, Proof), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

impl FromProof<DocumentQuery> for Document

type Request = DocumentQuery

Request type for which this trait is implemented.

type Response = GetDocumentsResponse

Response type for which this trait is implemented.

fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>

where Self: Sized + 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn maybe_from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Option<Self>, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Self, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof.

fn from_proof_with_metadata<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

fn from_proof_with_metadata_and_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata, Proof), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

impl FromProof<DocumentQuery> for Documents

type Request = DocumentQuery

Request type for which this trait is implemented.

type Response = GetDocumentsResponse

Response type for which this trait is implemented.

fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>

where Self: Sized + 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn maybe_from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Option<Self>, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Self, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof.

fn from_proof_with_metadata<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

fn from_proof_with_metadata_and_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata, Proof), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

impl FromProof<DocumentQuery> for DocumentRankedEntries

type Request = DocumentQuery

Request type for which this trait is implemented.

type Response = GetDocumentsResponse

Response type for which this trait is implemented.

fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>( request: I, response: O, _network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>

where Self: 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn maybe_from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Option<Self>, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Self, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof.

fn from_proof_with_metadata<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

fn from_proof_with_metadata_and_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata, Proof), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

impl FromProof<DocumentQuery> for DocumentSplitAverages

type Request = DocumentQuery

Request type for which this trait is implemented.

type Response = GetDocumentsResponse

Response type for which this trait is implemented.

fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>( request: I, response: O, _network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>

where Self: 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn maybe_from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Option<Self>, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Self, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof.

fn from_proof_with_metadata<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

fn from_proof_with_metadata_and_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata, Proof), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

impl FromProof<DocumentQuery> for DocumentSplitCounts

type Request = DocumentQuery

Request type for which this trait is implemented.

type Response = GetDocumentsResponse

Response type for which this trait is implemented.

fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>( request: I, response: O, _network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>

where Self: 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn maybe_from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Option<Self>, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Self, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof.

fn from_proof_with_metadata<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

fn from_proof_with_metadata_and_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata, Proof), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

impl FromProof<DocumentQuery> for DocumentSplitSums

type Request = DocumentQuery

Request type for which this trait is implemented.

type Response = GetDocumentsResponse

Response type for which this trait is implemented.

fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>( request: I, response: O, _network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>

where Self: 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn maybe_from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Option<Self>, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Self, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof.

fn from_proof_with_metadata<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

fn from_proof_with_metadata_and_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata, Proof), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

impl FromProof<DocumentQuery> for DocumentSum

type Request = DocumentQuery

Request type for which this trait is implemented.

type Response = GetDocumentsResponse

Response type for which this trait is implemented.

fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>( request: I, response: O, _network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>

where Self: 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn maybe_from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Option<Self>, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn from_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Self, Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof.

fn from_proof_with_metadata<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

fn from_proof_with_metadata_and_proof<'a, I, O>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata, Proof), Error>

where I: Into<Self::Request>, O: Into<Self::Response>, Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

impl Mockable for DocumentQuery

fn mock_serialize(&self) -> Option<Vec<u8>>

Serialize the message to bytes for mocking purposes.

fn mock_deserialize(data: &[u8]) -> Option<Self>

Deserialize the message serialized with [mock_serialize()].

impl PartialEq for DocumentQuery

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DocumentQuery

impl<'a> TryFrom<&'a DocumentQuery> for DriveDocumentQuery<'a>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(request: &'a DocumentQuery) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<&'a DriveDocumentQuery<'a>> for DocumentQuery

fn try_from(value: &'a DriveDocumentQuery<'a>) -> Result<Self, Self::Error>

Fallible by necessity: a drive query carrying resolved_time_ranges holds bucket-start equalities whose meaning lives in the provenance, and DocumentQuery has no field to carry it — the original IN_TIME_RANGE selector cannot be reconstructed from the resolved query. Serializing such a query would silently demote the bucket equality to a raw-timestamp predicate: a transformed-index-only contract then rejects the request, while a contract with a competing plain index returns a different — but validly proven — result.

type Error = Error

The type returned in the event of a conversion error.

impl<'a> TryFrom<DriveDocumentQuery<'a>> for DocumentQuery

fn try_from(value: DriveDocumentQuery<'a>) -> Result<Self, Self::Error>

By-value twin of the by-reference conversion above — same provenance rejection, same rationale.

type Error = Error

The type returned in the event of a conversion error.

impl TryFromPlatformVersioned<DocumentQuery> for GetDocumentsRequest

Version-aware encoder. The dispatch is driven by the drive_abci.query.document_query feature-version on [PlatformVersion]: 0 → V0 wire (used by v3.0 testnet), 1 → V1 wire (introduced in v3.1).

V0 lacks selects / group_by / having / offset and the optional-limit semantics — callers that set those features get Error::Config with a clear “requires Platform v3.1+” message rather than a silently-truncated request. Time-range clauses are additionally gated on the v14 contract grammar — see the 1 => arm.

type Error = Error

The type returned in the event of a conversion error.

fn try_from_platform_versioned( value: DocumentQuery, platform_version: &PlatformVersion, ) -> Result<Self, Self::Error>

Performs the conversion.