Enum mz_dataflow_types::client::ComputeCommand

pub enum ComputeCommand<T = Timestamp> {
    CreateInstance(InstanceConfig),
    DropInstance,
    CreateDataflows(Vec<DataflowDescription<Plan<T>, CollectionMetadata, T>>),
    AllowCompaction(Vec<(GlobalId, Antichain<T>)>),
    Peek(Peek<T>),
    CancelPeeks {
        uuids: BTreeSet<Uuid>,
    },
}

Commands related to the computation and maintenance of views.

Variants

CreateInstance(InstanceConfig)

Indicates the creation of an instance, and is the first command for its compute instance.

DropInstance

Indicates the termination of an instance, and is the last command for its compute instance.

CreateDataflows(Vec<DataflowDescription<Plan<T>, CollectionMetadata, T>>)

Create a sequence of dataflows.

Each of the dataflows must contain as_of members that are valid for each of the referenced arrangements, meaning AllowCompaction should be held back to those values until the command. Subsequent commands may arbitrarily compact the arrangements; the dataflow runners are responsible for ensuring that they can correctly maintain the dataflows.

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

Enable compaction in compute-managed collections.

Each entry in the vector names a collection and provides a frontier after which accumulations must be correct. The workers gain the liberty of compacting the corresponding maintained traces up through that frontier.

Peek(Peek<T>)

Peek at an arrangement.

CancelPeeks

Fields

uuids: BTreeSet<Uuid>

The identifiers of the peek requests to cancel.

Cancel the peeks associated with the given uuids.

Implementations

impl<T> ComputeCommand<T>

pub fn frontier_tracking(
    &self,
    start: &mut Vec<GlobalId>,
    cease: &mut Vec<GlobalId>
)

Indicates which global ids should start and cease frontier tracking.

Identifiers added to start will install frontier tracking, and identifiers added to cease will uninstall frontier tracking.

Trait Implementations

impl Arbitrary for ComputeCommand<Timestamp>

type Strategy = BoxedStrategy<Self>

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 ComputeCommand<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ComputeCommand<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for ComputeCommand<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> GenericClient<ComputeCommand<T>, ActiveReplicationResponse<T>> for ActiveReplication<T> where
    T: Timestamp + Lattice + Debug, 

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

The ADAPTER layer’s isolation from COMPUTE depends on the fact that this function is essentially non-blocking, i.e. the ADAPTER blindly awaits calls to this function. This lets the ADAPTER continue operating even in the face of unhealthy or absent replicas.

If this function every become blocking (e.g. making networking calls), the ADAPTER must amend its contract with COMPUTE.

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<ActiveReplicationResponse<T>>, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: '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: 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
    'life0: 'async_trait,
    Self: '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
    'life0: 'async_trait,
    Self: '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, C> GenericClient<ComputeCommand<T>, ComputeResponse<T>> for ComputeCommandReconcile<T, C> where
    C: ComputeClient<T>,
    T: Timestamp + Copy, 

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

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

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

fn ne(&self, other: &ComputeCommand<T>) -> bool

This method tests for !=.

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

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 + Copy, 

fn split_command(
    &mut self,
    command: ComputeCommand<T>
) -> Vec<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<ProtoComputeCommand> for ComputeCommand<Timestamp>

fn into_proto(&self) -> ProtoComputeCommand

Convert a Self into a Proto value.

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

Consume and convert a Proto back into a Self value.

impl<T> Serialize for ComputeCommand<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 ComputeCommand<T>