Struct BatchTaskExecution

pub struct BatchTaskExecution<C> {
    task_id: TaskId,
    plan: PlanFragment,
    state: Mutex<TaskStatus>,
    receivers: Mutex<Vec<Option<ChanReceiverImpl>>>,
    sender: ChanSenderImpl,
    context: C,
    failure: Arc<Mutex<Option<Arc<BatchError>>>>,
    epoch: BatchQueryEpoch,
    runtime: Arc<BackgroundShutdownRuntime>,
    shutdown_tx: ShutdownSender,
    shutdown_rx: ShutdownToken,
    heartbeat_join_handle: Mutex<Option<JoinHandle<()>>>,
}

BatchTaskExecution represents a single task execution.

Fields

task_id: TaskId

Task id.

plan: PlanFragment

Inner plan to execute.

state: Mutex<TaskStatus>

Task state.

receivers: Mutex<Vec<Option<ChanReceiverImpl>>>

Receivers data of the task.

sender: ChanSenderImpl

Sender for sending chunks between different executors.

context: C

Context for task execution

failure: Arc<Mutex<Option<Arc<BatchError>>>>

The execution failure.

epoch: BatchQueryEpoch

runtime: Arc<BackgroundShutdownRuntime>

Runtime for the batch tasks.

shutdown_tx: ShutdownSender

shutdown_rx: ShutdownToken

heartbeat_join_handle: Mutex<Option<JoinHandle<()>>>

Implementations

impl<C: BatchTaskContext> BatchTaskExecution<C>

pub fn new( prost_tid: &PbTaskId, plan: PlanFragment, context: C, epoch: BatchQueryEpoch, runtime: Arc<BackgroundShutdownRuntime>, ) -> Result<Self>

pub fn get_task_id(&self) -> &TaskId

pub async fn async_execute( self: Arc<Self>, state_tx: Option<StateReporter>, tracing_context: TracingContext, expr_context: ExprContext, ) -> Result<()>

async_execute executes the task in background, it spawns a tokio coroutine and returns immediately. The result produced by the task will be sent to one or more channels, according to a particular shuffling strategy. For example, in hash shuffling, the result will be hash partitioned across multiple channels. To obtain the result, one must pick one of the channels to consume via TaskOutputId. As such, parallel consumers are able to consume the result independently.

pub async fn change_state_notify( &self, task_status: TaskStatus, state_tx: Option<&mut StateReporter>, err_str: Option<String>, ) -> Result<()>

Change state and notify frontend for task status via streaming GRPC.

pub fn change_state(&self, task_status: TaskStatus)

async fn run( &self, root: BoxedExecutor, sender: ChanSenderImpl, state_tx: Option<&mut StateReporter>, )

pub fn abort(&self, err_msg: String)

pub fn cancel(&self)

pub fn get_task_output(&self, output_id: &PbTaskOutputId) -> Result<TaskOutput>

pub fn check_if_running(&self) -> Result<()>

pub fn check_if_aborted(&self) -> Result<bool>

pub fn is_end(&self) -> bool

Check the task status: whether has ended.

impl<C> BatchTaskExecution<C>

pub(crate) fn set_heartbeat_join_handle(&self, join_handle: JoinHandle<()>)

pub(crate) fn heartbeat_join_handle(&self) -> Option<JoinHandle<()>>