Struct tidb_query_executors::runner::BatchExecutorsRunner

pub struct BatchExecutorsRunner<SS> {
    deadline: Deadline,
    out_most_executor: Box<dyn BatchExecutor<StorageStats = SS>>,
    output_offsets: Vec<u32>,
    config: Arc<EvalConfig>,
    collect_exec_summary: bool,
    exec_stats: ExecuteStats,
    stream_row_limit: usize,
    encode_type: EncodeType,
}

Fields

deadline: Deadline

The deadline of this handler. For each check point (e.g. each iteration) we need to check whether or not the deadline is exceeded and break the process if so.

out_most_executor: Box<dyn BatchExecutor<StorageStats = SS>>

output_offsets: Vec<u32>

The offset of the columns need to be outputted. For example, TiDB may only needs a subset of the columns in the result so that unrelated columns don’t need to be encoded and returned back.

config: Arc<EvalConfig>

collect_exec_summary: bool

Whether or not execution summary need to be collected.

exec_stats: ExecuteStats

stream_row_limit: usize

Maximum rows to return in batch stream mode.

encode_type: EncodeType

The encoding method for the response. Possible encoding methods are:

1. default: result is encoded row by row using datum format.
2. chunk: result is encoded column by column using chunk format.

Implementations

impl BatchExecutorsRunner<()>

pub fn check_supported(exec_descriptors: &[Executor]) -> Result<()>

Given a list of executor descriptors and checks whether all executor descriptors can be used to build batch executors.

impl<SS: 'static> BatchExecutorsRunner<SS>

pub fn from_request<S: Storage<Statistics = SS> + 'static>(
    req: DagRequest,
    ranges: Vec<KeyRange>,
    storage: S,
    deadline: Deadline,
    stream_row_limit: usize,
    is_streaming: bool
) -> Result<Self>

fn batch_initial_size() -> usize

pub async fn handle_request(&mut self) -> Result<SelectResponse>

pub fn handle_streaming_request(
    &mut self
) -> Result<(Option<(StreamResponse, IntervalRange)>, bool)>

pub fn collect_storage_stats(&mut self, dest: &mut SS)

pub fn can_be_cached(&self) -> bool

fn internal_handle_request(
    &mut self,
    is_streaming: bool,
    batch_size: usize,
    chunk: &mut Chunk,
    warnings: &mut EvalWarnings,
    ctx: &mut EvalContext
) -> Result<(bool, usize)>

fn make_stream_response(
    &mut self,
    chunk: Chunk,
    warnings: EvalWarnings
) -> Result<StreamResponse>