Struct ActiveSubscribe 

pub struct ActiveSubscribe {
    pub owner: ActiveSubscribeOwner,
    pub cluster_id: ClusterId,
    pub depends_on: BTreeSet<GlobalId>,
    pub channel: UnboundedSender<PeekResponseUnary>,
    pub backlog_accounting: Arc<Mutex<SubscribeBacklogAccounting>>,
    pub max_buffered_bytes: usize,
    pub emit_progress: bool,
    pub as_of: Timestamp,
    pub arity: usize,
    pub start_time: EpochMillis,
    pub output: SubscribeOutput,
    pub internal: bool,
}

A description of an active subscribe from coord’s perspective

Fields

owner: ActiveSubscribeOwner

The owner responsible for retiring the subscribe.

cluster_id: ClusterId

The ID of the cluster on which the subscribe is running.

depends_on: BTreeSet<GlobalId>

The IDs of the objects on which the subscribe depends.

channel: UnboundedSender<PeekResponseUnary>

Channel on which to send responses to the client.

backlog_accounting: Arc<Mutex<SubscribeBacklogAccounting>>

Footprints of the messages queued in channel but not yet drained by the client writer. Shared with the receiver side, which pops as it drains.

The producer runs on the non-blockable coordinator loop and cannot block on a slow client, so instead of applying backpressure the coordinator watches backlog_size against max_buffered_bytes and retires the subscribe once the backlog exceeds it.

max_buffered_bytes: usize

Budget for the buffered backlog. A snapshot of subscribe_max_buffered_bytes taken when the subscribe was created.

emit_progress: bool

Whether progress information should be emitted.

as_of: Timestamp

The logical timestamp at which the subscribe began execution.

arity: usize

The number of columns in the relation that was subscribed to.

start_time: EpochMillis

The time when the subscribe started.

output: SubscribeOutput

How to present the subscribe’s output.

internal: bool

If true, this is an internal subscribe that should not appear in introspection tables like mz_subscriptions.

Implementations

impl ActiveSubscribe

pub fn introspection_session_uuid(&self) -> Option<Uuid>

The session uuid for this subscribe’s mz_subscriptions row, or None if it does not appear there.

pub fn connection_id(&self) -> Option<&ConnectionId>

Returns the owning connection, if this is a session subscribe.

pub fn initialize(&self)

Initializes the subscription.

This method must be called exactly once, after constructing an ActiveSubscribe and before calling process_response.

fn send_progress_message(&self, upper: &Antichain<Timestamp>)

pub fn process_response(&self, batch: SubscribeBatch) -> bool

Processes a subscribe response from the controller.

Returns true if the subscribe is finished.

pub fn retire(self, reason: ActiveComputeSinkRetireReason)

Retires the subscribe with the specified reason.

This method must be called on every subscribe before it is dropped. It informs the end client that the subscribe is finished for the specified reason.

fn send(&self, response: PeekResponseUnary, bytes: usize)

Sends a message to the client if the subscribe has not already completed and if the client has not already gone away.

bytes is the message’s payload size. Its footprint (payload plus a fixed per-message overhead) is recorded in backlog_accounting here and released by the receiver side when the message is drained. Overflow of the budget is detected by the coordinator after process_response returns, not here, because this method cannot retire the sink.

Trait Implementations

impl Debug for ActiveSubscribe

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

Formats the value using the given formatter.