Struct SerializedPlan 

pub struct SerializedPlan {
    pub protocol_version: u32,
    pub plan_id: PlanId,
    pub plan: ExecutionPlan,
    pub input: Option<InputSource>,
    pub filters: Vec<SerializedFilter>,
    pub mode: ExecutionMode,
    pub seed: Option<i64>,
    pub metadata: Value,
}

A serialized plan ready for remote execution.

Fields

protocol_version: u32

What the sender speaks. See PROTOCOL_VERSION.

plan_id: PlanId

Identifies this execution end to end — results, events and cancellations all refer back to it.

plan: ExecutionPlan

The compiled plan the worker will execute.

input: Option<InputSource>

Input data — inline for small values, DataRef for large ones.

filters: Vec<SerializedFilter>

Filter definitions for the worker to reconstruct.

mode: ExecutionMode

Fit or Forward.

seed: Option<i64>

The run’s experiment seed, folded into every cache key on the worker exactly as it is locally. Absent (the pre-seed wire format) means unseeded — which shares cache lines across a sweep’s seeds, the bug this field exists to close.

metadata: Value

Free-form annotations that travel with the plan (experiment name, submitter, …). The worker carries them; it never interprets them.

Implementations

impl SerializedPlan

pub fn new(plan_id: impl Into<PlanId>, plan: ExecutionPlan) -> Self

A plan tagged with the version this build speaks.

Callers build plans through this rather than the literal, so the version cannot be forgotten at one of the six construction sites.

pub fn with_input(self, input: InputSource) -> Self

Attach the plan’s input data — inline or by reference.

pub fn with_filters(self, filters: Vec<SerializedFilter>) -> Self

Attach the filter payloads the worker must reconstruct before the plan can run.

pub fn with_mode(self, mode: ExecutionMode) -> Self

Choose fit or forward execution (the default is ExecutionMode::Forward).

pub fn with_metadata(self, metadata: Value) -> Self

Replace the free-form metadata (defaults to {}).

pub fn check_version(&self) -> Result<(), String>

Can this build execute the plan as its sender meant it?

Refusing is the point. Executing a plan you only partly understand produces a number, and nothing downstream can tell it apart from a correct one.

Trait Implementations

impl Clone for SerializedPlan

fn clone(&self) -> SerializedPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SerializedPlan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SerializedPlan

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SerializedPlan

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

where __S: Serializer,

Serialize this value into the given Serde serializer.