Struct tikv_client::request::PlanBuilder

pub struct PlanBuilder<PdC: PdClient, P: Plan, Ph: PlanBuilderPhase> { /* private fields */ }

Builder type for plans (see that module for more).

Implementations

impl<PdC: PdClient, Req: KvRequest> PlanBuilder<PdC, Dispatch<Req>, NoTarget>

pub fn new(pd_client: Arc<PdC>, encoded_request: EncodedRequest<Req>) -> Self

impl<PdC: PdClient, P: Plan> PlanBuilder<PdC, P, Targetted>

pub fn plan(self) -> P

Return the built plan, note that this can only be called once the plan has a target.

impl<PdC: PdClient, P: Plan, Ph: PlanBuilderPhase> PlanBuilder<PdC, P, Ph>

pub fn resolve_lock( self, backoff: Backoff ) -> PlanBuilder<PdC, ResolveLock<P, PdC>, Ph>where P::Result: HasLocks,

If there is a lock error, then resolve the lock and retry the request.

pub fn cleanup_locks( self, ctx: ResolveLocksContext, options: ResolveLocksOptions, backoff: Backoff ) -> PlanBuilder<PdC, CleanupLocks<P, PdC>, Ph>where P: Shardable + NextBatch, P::Result: HasLocks + HasNextBatch + HasRegionError + HasKeyErrors,

pub fn merge<In, M: Merge<In>>( self, merge: M ) -> PlanBuilder<PdC, MergeResponse<P, In, M>, Ph>where In: Clone + Send + Sync + 'static, P: Plan<Result = Vec<Result<In>>>,

Merge the results of a request. Usually used where a request is sent to multiple regions to combine the responses from each region.

pub fn post_process_default( self ) -> PlanBuilder<PdC, ProcessResponse<P, DefaultProcessor>, Ph>where P: Plan, DefaultProcessor: Process<P::Result>,

Apply the default processing step to a response (usually only needed if the request is sent to a single region because post-porcessing can be incorporated in the merge step for multi-region requests).

impl<PdC: PdClient, P: Plan + Shardable> PlanBuilder<PdC, P, NoTarget>where P::Result: HasKeyErrors + HasRegionError,

pub fn retry_multi_region( self, backoff: Backoff ) -> PlanBuilder<PdC, RetryableMultiRegion<P, PdC>, Targetted>

Split the request into shards sending a request to the region of each shard.

pub fn retry_multi_region_preserve_results( self, backoff: Backoff ) -> PlanBuilder<PdC, RetryableMultiRegion<P, PdC>, Targetted>

Preserve all results, even some of them are Err. To pass all responses to merge, and handle partial successful results correctly.

impl<PdC: PdClient, R: KvRequest> PlanBuilder<PdC, Dispatch<R>, NoTarget>

pub async fn single_region_with_store( self, store: RegionStore ) -> Result<PlanBuilder<PdC, Dispatch<R>, Targetted>>

Target the request at a single region; caller supplies the store to target.

impl<PdC: PdClient, P: Plan + StoreRequest> PlanBuilder<PdC, P, NoTarget>where P::Result: HasKeyErrors + HasRegionError,

pub fn all_stores( self, backoff: Backoff ) -> PlanBuilder<PdC, RetryableAllStores<P, PdC>, Targetted>

impl<PdC: PdClient, P: Plan + Shardable> PlanBuilder<PdC, P, NoTarget>where P::Result: HasKeyErrors,

pub fn preserve_shard(self) -> PlanBuilder<PdC, PreserveShard<P>, NoTarget>

impl<PdC: PdClient, P: Plan> PlanBuilder<PdC, P, Targetted>where P::Result: HasKeyErrors + HasRegionErrors,

pub fn extract_error(self) -> PlanBuilder<PdC, ExtractError<P>, Targetted>