Struct CompositeSubQuery 

pub struct CompositeSubQuery {
    pub data_contract: Arc<DataContract>,
    pub document_type_name: String,
    pub kind: CompositeSubQueryKind,
    pub where_clauses: Vec<WhereClause>,
    pub order_by_clauses: Vec<OrderClause>,
    pub limit: Option<u32>,
    pub binding: Option<CompositeBinding>,
}

One sub-query of a composite request.

Fields

data_contract: Arc<DataContract>

The contract the sub-query targets — the page’s, or any other (profiles keyed by owner, names keyed by identity).

document_type_name: String

The document type queried.

kind: CompositeSubQueryKind

Documents or counts.

where_clauses: Vec<WhereClause>

The FIXED clauses — everything but the derived IN, which must not be named here.

order_by_clauses: Vec<OrderClause>

Ordering (documents only). Every component of the merged proof walks in the page’s direction: a bound field missing from here is appended in that direction by the node and the verifier alike, and an ordering that disagrees with the page’s direction is refused (turning a limited lookup around would change the rows it returns).

limit: Option<u32>

Required for a documents lookup on a non-unique index: it caps the rows the lookup returns in total, in walk order, like an ordinary IN query’s limit. Forbidden for a lookup already bounded by its values, a by-id join and a count.

binding: Option<CompositeBinding>

The derived clause, or None for a sibling: an independent documents query proven under the same root.

Implementations

impl CompositeSubQuery

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

A documents sub-query against document_type_name of data_contract. Unbound until Self::bound_to (a sibling otherwise).

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

A count sub-query against document_type_name of data_contract. Must be bound.

pub fn bound_to( self, source: CompositeBindingSource, source_property: impl Into<String>, field: impl Into<String>, ) -> Self

Bind field to the source_property values of source’s proven documents.

pub fn bound_to_page( self, source_property: impl Into<String>, field: impl Into<String>, ) -> Self

Bind field to the source_property values of the page’s proven documents.

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

Add a fixed where clause.

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

Add an order_by clause (documents only).

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

Set the total row limit of a documents lookup.

Trait Implementations

impl Clone for CompositeSubQuery

fn clone(&self) -> CompositeSubQuery

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompositeSubQuery

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CompositeSubQuery

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&DriveSubQuery<'_>> for CompositeSubQuery

fn from(sub: &DriveSubQuery<'_>) -> Self

Converts to this type from the input type.

impl PartialEq for CompositeSubQuery

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

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 CompositeSubQuery