Struct DeferNode 

pub struct DeferNode {
    pub primary: PrimaryDeferBlock,
    pub deferred: Vec<DeferredDeferBlock>,
}

A DeferNode corresponds to one or more @defer applications at the same level of “nestedness” in the planned query.

It contains a “primary block” and a vector of “deferred blocks”. The “primary block” represents the part of the query that is not deferred (so the part of the query up until we reach the @defer(s) this handles), while each “deferred block” correspond to the deferred part of one of the @defer(s) handled by the node.

Note that DeferNodes are only generated if defer support is enabled for the query planner. Also note that if said support is enabled, then DeferNodes are always generated if the query has a @defer application, even if in some cases generated plan may not “truly” defer the underlying fetches (i.e. in cases where deferred[*].node are all undefined). This currently happens because some specific cases of defer cannot be handled, but could later also happen if we implement more advanced server-side heuristics to decide if deferring is judicious or not. This allows the executor of the plan to consistently send a defer-abiding multipart response to the client.

Fields

primary: PrimaryDeferBlock

The “primary” part of a defer, that is the non-deferred part (though could be deferred itself for a nested defer).

deferred: Vec<DeferredDeferBlock>

The “deferred” parts of the defer (note that it’s a vector). Each of those deferred elements will correspond to a different chunk of the response to the client (after the initial on-deferred one that is).

Trait Implementations

impl Clone for DeferNode

fn clone(&self) -> DeferNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DeferNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DeferNode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for DeferNode

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

Formats the value using the given formatter.

impl PartialEq for DeferNode

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

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 DeferNode