Struct tidb_query_executors::BatchTopNExecutor

pub struct BatchTopNExecutor<Src: BatchExecutor> {
    heap: BinaryHeap<HeapItemUnsafe>,
    eval_columns_buffer_unsafe: Box<Vec<RpnStackNode<'static>>>,
    order_exprs: Box<[RpnExpression]>,
    order_exprs_field_type: Box<[FieldType]>,
    order_is_desc: Box<[bool]>,
    n: usize,
    context: EvalContext,
    src: Src,
    is_ended: bool,
}

Fields

heap: BinaryHeap<HeapItemUnsafe>

The heap, which contains N rows at most.

This field is placed before eval_columns_buffer_unsafe, order_exprs, order_is_desc and src because it relies on data in those fields and we want this field to be dropped first.

eval_columns_buffer_unsafe: Box<Vec<RpnStackNode<'static>>>

A collection of all evaluated columns. This is to avoid repeated allocations in each next_batch().

DO NOT EVER try to read the content of the elements directly, since it is highly unsafe. The lifetime of elements is not really ’static. Certain elements are valid only if both of the following conditions are satisfied:

1. BatchTopNExecutor is valid (i.e. not dropped).

2. The referenced LazyBatchColumnVec of the element must be valid, which only happens when at least one of the row is in the heap. Note that rows may be swapped out from heap at any time.

This field is placed before order_exprs and src because it relies on data in those fields and we want this field to be dropped first.

order_exprs: Box<[RpnExpression]>

order_exprs_field_type: Box<[FieldType]>

This field stores the field type of the results evaluated by the exprs in order_exprs.

order_is_desc: Box<[bool]>

Whether or not it is descending order for each order by column.

n: usize

context: EvalContext

src: Src

is_ended: bool

Implementations

impl BatchTopNExecutor<Box<dyn BatchExecutor<StorageStats = ()>>>

pub fn check_supported(descriptor: &TopN) -> Result<()>

Checks whether this executor can be used.

impl<Src: BatchExecutor> BatchTopNExecutor<Src>

pub fn new(
    config: Arc<EvalConfig>,
    src: Src,
    order_exprs_def: Vec<Expr>,
    order_is_desc: Vec<bool>,
    n: usize
) -> Result<Self>

fn handle_next_batch(&mut self) -> Result<Option<LazyBatchColumnVec>>

fn process_batch_input(
    &mut self,
    physical_columns: LazyBatchColumnVec,
    logical_rows: Vec<usize>
) -> Result<()>

fn heap_add_row(&mut self, row: HeapItemUnsafe) -> Result<()>

fn heap_take_all(&mut self) -> LazyBatchColumnVec

Trait Implementations

impl<Src: BatchExecutor> BatchExecutor for BatchTopNExecutor<Src>

type StorageStats = Src::StorageStats

fn schema(&self) -> &[FieldType]

Gets the schema of the output.

fn next_batch(&mut self, _scan_rows: usize) -> BatchExecuteResult

Pulls next several rows of data (stored by column).

fn collect_exec_stats(&mut self, dest: &mut ExecuteStats)

Collects execution statistics (including but not limited to metrics and execution summaries) accumulated during execution and prepares for next collection.

fn collect_storage_stats(&mut self, dest: &mut Self::StorageStats)

Collects underlying storage statistics accumulated during execution and prepares for next collection.

fn take_scanned_range(&mut self) -> IntervalRange

fn can_be_cached(&self) -> bool

fn collect_summary(
    self,
    output_index: usize
) -> WithSummaryCollector<ExecSummaryCollectorEnabled, Self> where
    Self: Sized, 

impl<Src: BatchExecutor> Send for BatchTopNExecutor<Src>

All NonNull pointers in BatchTopNExecutor cannot be accessed out of the struct and BatchTopNExecutor doesn’t leak the pointers to other threads. Therefore, with those NonNull pointers, BatchTopNExecutor still remains Send.