Struct WriteDispatcher 

pub struct WriteDispatcher {
    node_manager: NodeManagerRef,
    partition_manager: PartitionRuleManagerRef,
    retry: Option<WriteRetry>,
}

Dispatches already partitioned writes, retaining only failed payloads for retries.

Fields

node_manager: NodeManagerRef

partition_manager: PartitionRuleManagerRef

retry: Option<WriteRetry>

Implementations

impl WriteDispatcher

pub fn new( node_manager: NodeManagerRef, partition_manager: PartitionRuleManagerRef, ) -> Self

Creates an owned-request dispatcher without retries, including for standalone.

pub fn with_retry( self, options: WriteRetryOptions, catalog_manager: CatalogManagerRef, cache_invalidator: CacheInvalidatorRef, ) -> Self

Enables shared remote sends and retries using frontend configuration and caches.

pub async fn dispatch( &self, requests: Vec<RegionRequest>, ) -> Result<RegionResponse>

Writes planned requests without repeating admission, default values, or Flow side effects.

pub async fn dispatch_with_metrics( &self, requests: Vec<RegionRequest>, histogram: Histogram, ) -> Result<RegionResponse>

Records each datanode send attempt, including retries, in the supplied histogram.

pub(crate) async fn prepare( &self, requests: Vec<RegionRequest>, ) -> Result<Vec<(PeerRef, RegionRequest)>>

Resolves routes before writes are detached from the caller.

pub(crate) async fn execute( &self, writes: Vec<(PeerRef, RegionRequest)>, histogram: Option<Histogram>, cancellation: Option<&CancellationToken>, ) -> Result<RegionResponse>

Sends requests using routes already resolved by the caller. Cancellation stops future retries while allowing in-flight requests to complete.

pub(crate) async fn send( &self, peer: PeerRef, request: RegionRequest, histogram: Option<&Histogram>, ) -> WriteAttempt

Sends the first attempt immediately so bulk encoding can overlap other sends.

pub(crate) async fn finish( &self, attempts: Vec<WriteAttempt>, histogram: Option<&Histogram>, cancellation: Option<&CancellationToken>, ) -> Result<RegionResponse>

Collects first attempts and retries their failures together, refreshing routes once per round.

pub(crate) async fn resolve_peers( &self, regions: &[RegionId], ) -> Result<HashMap<RegionId, PeerRef>>

Resolves only the requested peers, loading each table route once.

async fn dispatch_inner( &self, requests: Vec<RegionRequest>, histogram: Option<Histogram>, ) -> Result<RegionResponse>