Enum mz_compute_client::protocol::response::ComputeResponse

pub enum ComputeResponse<T = Timestamp> {
    FrontierUppers(Vec<(GlobalId, Antichain<T>)>),
    PeekResponse(Uuid, PeekResponse, OpenTelemetryContext),
    SubscribeResponse(GlobalId, SubscribeResponse<T>),
}

Compute protocol responses, sent by replicas to the compute controller.

Replicas send ComputeResponses in response to ComputeCommands they previously received from the compute controller.

Variants

FrontierUppers(Vec<(GlobalId, Antichain<T>)>)

FrontierUppers announces the advancement of the upper frontiers of the specified compute collections. The response contains a mapping of collection IDs to their new upper frontiers.

Upon receiving a FrontierUppers response, the controller may assume that the replica has finished computing the given collections up to at least the given frontiers. It may also assume that the replica has finished reading from the collections’ inputs up to those frontiers.

Replicas must send FrontierUppers responses for compute collections that are indexes or storage sinks. Replicas must not send FrontierUppers responses for subscribes.

Replicas must never report regressing frontiers. Specifically:

• The first frontier reported for a collection must not be less than that collection’s initial as_of frontier.
• Subsequent reported frontiers for a collection must not be less than any frontier reported previously for the same collection.

Replicas must send a FrontierUppers response reporting advancement to the empty frontier for a collection in two cases:

• The collection has advanced to the empty frontier (e.g. because its inputs have advanced to the empty frontier).
• The collection was dropped in response to an AllowCompaction command that advanced its read frontier to the empty frontier. (#16275)

Once a collection was reported to have been advanced to the empty upper frontier:

• It must no longer read from its inputs.
• The replica must not send further FrontierUppers responses for that collection.

The replica must not send FrontierUppers responses for collections that have not been created previously by a CreateDataflows command or by a CreateInstance command. An exception are FrontierUppers responses that report the empty frontier. (#16247)

PeekResponse(Uuid, PeekResponse, OpenTelemetryContext)

PeekResponse reports the result of a previous Peek command. The peek is identified by a Uuid that matches the command’s Peek::uuid.

The replica must send exactly one PeekResponse for every Peek command it received.

If the replica did not receive a CancelPeeks command for a peek, it must not send a Canceled response for that peek. If the replica did receive a CancelPeeks command for a peek, it may send any of the three PeekResponse variants.

The replica must not send PeekResponses for peek IDs that were not previously specified in a Peek command.

SubscribeResponse(GlobalId, SubscribeResponse<T>)

SubscribeResponse reports the results emitted by an active subscribe over some time interval.

For each subscribe that was installed by a previous CreateDataflows command, the replica must emit Batch responses that cover the entire time interval from the subscribe dataflow’s as_of until the subscribe advances to the empty frontier or is dropped. The time intervals of consecutive Batches must be increasing, contiguous, non-overlapping, and non-empty. All updates transmitted in a batch must have times within that batch’s time interval. The upper of the first Batch of a subscribe must not be less than that subscribe’s initial as_of frontier.

The replica must send DroppedAt responses if the subscribe was dropped in response to an AllowCompaction command that advanced its read frontier to the empty frontier. The DroppedAt frontier must be the upper frontier of the last emitted batch.

The replica must not send a DroppedAt response if the subscribe’s upper frontier (reported by Batch responses) has advanced to the empty frontier (e.g. because its inputs advanced to the empty frontier).

Once a subscribe was reported to have advanced to the empty frontier, or has been dropped:

• It must no longer read from its inputs.
• The replica must not send further SubscribeResponses for that subscribe.

The replica must not send Batch responses for subscribes that have not been created previously by a CreateDataflows command. The replica may send DroppedAt responses for subscribes that have not been created previously by a CreateDataflows command. (#16247)

Trait Implementations

impl Arbitrary for ComputeResponse<Timestamp>

type Strategy = Union<BoxedStrategy<ComputeResponse<Timestamp>>>

The type of Strategy used to generate values of type Self.

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

fn arbitrary_with(_: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl<T: Clone> Clone for ComputeResponse<T>

fn clone(&self) -> ComputeResponse<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ComputeResponse<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for ComputeResponse<T>where
    T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Send> GenericClient<ComputeCommand<T>, ComputeResponse<T>> for Box<dyn ComputeClient<T>>

fn send<'life0, 'async_trait>(
    &'life0 mut self,
    cmd: ComputeCommand<T>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Sends a command to the dataflow server.

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<ComputeResponse<T>>, Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Receives the next response from the dataflow server.

fn as_stream<'a>(
    &'a mut self
) -> Pin<Box<dyn Stream<Item = Result<R, Error>> + Send + 'a, Global>>where
    R: 'a + Send,

Returns an adapter that treats the client as a stream.

impl<T: PartialEq> PartialEq<ComputeResponse<T>> for ComputeResponse<T>

fn eq(&self, other: &ComputeResponse<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Partitionable<ComputeCommand<T>, ComputeResponse<T>> for (ComputeCommand<T>, ComputeResponse<T>)where
    T: Timestamp + Lattice,

type PartitionedState = PartitionedComputeState<T>

The type which functions as the state machine for the partitioning.

fn new(parts: usize) -> PartitionedComputeState<T>

Construct a PartitionedState for the command–response pair.

impl<T> PartitionedState<ComputeCommand<T>, ComputeResponse<T>> for PartitionedComputeState<T>where
    T: Timestamp + Lattice,

fn split_command(
    &mut self,
    command: ComputeCommand<T>
) -> Vec<Option<ComputeCommand<T>>>

Splits a command into multiple partitions.

fn absorb_response(
    &mut self,
    shard_id: usize,
    message: ComputeResponse<T>
) -> Option<Result<ComputeResponse<T>, Error>>

Absorbs a response from a single partition.

impl RustType<ProtoComputeResponse> for ComputeResponse<Timestamp>

fn into_proto(&self) -> ProtoComputeResponse

Convert a Self into a Proto value.

fn from_proto(proto: ProtoComputeResponse) -> Result<Self, TryFromProtoError>

Consume and convert a Proto back into a Self value.

impl<T> Serialize for ComputeResponse<T>where
    T: Serialize,

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

Serialize this value into the given Serde serializer.

impl<T> StructuralPartialEq for ComputeResponse<T>