Struct tidb_query_executors::runner::BatchExecutorsRunner

[+] Show declaration

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

[−] Expand description

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>

[−] Expand description

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

[−] Expand description

Whether or not execution summary need to be collected.

exec_stats: ExecuteStats

stream_row_limit: usize

[−] Expand description

Maximum rows to return in batch stream mode.

encode_type: EncodeType

[−] Expand description

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>