Struct mz_dataflow_types::client::controller::ComputeControllerMut

pub struct ComputeControllerMut<'a, T> { /* private fields */ }

A mutable controller for a compute instance.

Implementations

impl<'a, T> ComputeControllerMut<'a, T> where
    T: Timestamp + Lattice + Codec64, 

pub fn as_ref<'b>(&'b self) -> ComputeController<'b, T>

Constructs an immutable handle from this mutable handle.

pub fn storage_mut(&mut self) -> &mut dyn StorageController<Timestamp = T>

Acquires a mutable handle to a controller for the storage instance.

pub fn add_replica(&mut self, id: ReplicaId, client: Box<dyn ComputeClient<T>>)

Adds a new instance replica, by name.

pub fn get_replica_ids(&self) -> impl Iterator<Item = ReplicaId> + '_

pub fn remove_replica(&mut self, id: ReplicaId)

Removes an existing instance replica, by name.

pub async fn create_dataflows(
    &mut self,
    dataflows: Vec<DataflowDescription<Plan<T>, (), T>>
) -> Result<(), ComputeError>

Creates and maintains the described dataflows, and initializes state for their output.

This method creates dataflows whose inputs are still readable at the dataflow as_of frontier, and initializes the outputs as readable from that frontier onward. It installs read dependencies from the outputs to the inputs, so that the input read capabilities will be held back to the output read capabilities, ensuring that we are always able to return to a state that can serve the output read capabilities.

pub async fn drop_sinks(
    &mut self,
    identifiers: Vec<GlobalId>
) -> Result<(), ComputeError>

Drops the read capability for the sinks and allows their resources to be reclaimed.

pub async fn drop_indexes(
    &mut self,
    identifiers: Vec<GlobalId>
) -> Result<(), ComputeError>

Drops the read capability for the indexes and allows their resources to be reclaimed.

pub async fn peek(
    &mut self,
    id: GlobalId,
    key: Option<Row>,
    uuid: Uuid,
    timestamp: T,
    finishing: RowSetFinishing,
    map_filter_project: SafeMfpPlan,
    target_replica: Option<ReplicaId>
) -> Result<(), ComputeError>

Initiate a peek request for the contents of id at timestamp.

pub async fn cancel_peeks(
    &mut self,
    uuids: &BTreeSet<Uuid>
) -> Result<(), ComputeError>

Cancels existing peek requests.

Canceling a peek is best effort. The caller may see any of the following after canceling a peek request:

• A PeekResponse::Rows indicating that the cancellation request did not take effect in time and the query succeeded.

• A PeekResponse::Canceled affirming that the peek was canceled.

• No PeekResponse at all.

pub async fn set_read_policy(
    &mut self,
    policies: Vec<(GlobalId, ReadPolicy<T>)>
) -> Result<(), ComputeError>

Assigns a read policy to specific identifiers.

The policies are assigned in the order presented, and repeated identifiers should conclude with the last policy. Changing a policy will immediately downgrade the read capability if appropriate, but it will not “recover” the read capability if the prior capability is already ahead of it.

Identifiers not present in policies retain their existing read policies.

Trait Implementations

impl<'a, T: Debug> Debug for ComputeControllerMut<'a, T>

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

Formats the value using the given formatter.