Struct SeqScan 

pub struct SeqScan {
    properties: ScannerProperties,
    stream_ctx: Arc<StreamContext>,
    pruner: Arc<Pruner>,
    metrics_list: PartitionMetricsList,
}

Scans a region and returns rows in a sorted sequence.

The output order is always order by primary keys, time index inside every [PartitionRange]. Each “partition” may contains many [PartitionRange]s.

Fields

properties: ScannerProperties

Properties of the scanner.

stream_ctx: Arc<StreamContext>

Context of streams.

pruner: Arc<Pruner>

Shared pruner for file range building.

metrics_list: PartitionMetricsList

Metrics for each partition. The scanner only sets in query and keeps it empty during compaction.

Implementations

impl SeqScan

pub(crate) fn new(input: ScanInput) -> Self

Creates a new SeqScan with the given input. If input.compaction is true, the scanner will not attempt to split ranges.

pub fn build_stream(&self) -> Result<SendableRecordBatchStream, BoxedError>

Builds a stream for the query.

The returned stream is not partitioned and will contains all the data. If want partitioned scan, use [RegionScanner::scan_partition].

pub(crate) fn scan_all_partitions(&self) -> Result<ScanBatchStream>

Scan [Batch] in all partitions one by one.

pub async fn build_flat_reader_for_compaction( &self, ) -> Result<BoxedRecordBatchStream>

Builds a BoxedRecordBatchStream from sequential scan for flat format compaction.

Panics

Panics if the compaction flag is not set.

async fn merge_all_flat_ranges_for_compaction( stream_ctx: &Arc<StreamContext>, partition_ranges: &[PartitionRange], part_metrics: &PartitionMetrics, pruner: Arc<Pruner>, ) -> Result<BoxedRecordBatchStream>

Builds a merge reader that reads all flat ranges. Callers MUST not split ranges before calling this method.

pub(crate) async fn build_flat_reader_from_sources( stream_ctx: &StreamContext, sources: Vec<BoxedRecordBatchStream>, semaphore: Option<Arc<Semaphore>>, part_metrics: Option<&PartitionMetrics>, skip_dedup: bool, channel_size: usize, ) -> Result<BoxedRecordBatchStream>

Builds a flat reader to read sources that returns RecordBatch. If semaphore is provided, reads sources in parallel if possible. If skip_dedup is true, the merged stream is returned without applying flat dedup.

pub(crate) async fn build_flat_partition_range_read( stream_ctx: &Arc<StreamContext>, part_range: &PartitionRange, compaction: bool, part_metrics: &PartitionMetrics, partition_pruner: Arc<PartitionPruner>, file_scan_semaphore: Option<Arc<Semaphore>>, merge_semaphore: Option<Arc<Semaphore>>, ) -> Result<(BoxedRecordBatchStream, usize)>

Builds a flat read stream for one partition range.

fn scan_partition_impl( &self, ctx: &QueryScanContext, metrics_set: &ExecutionPlanMetricsSet, partition: usize, ) -> Result<SendableRecordBatchStream>

Scans the given partition when the part list is set properly. Otherwise the returned stream might not contains any data.

fn scan_flat_batch_in_partition( &self, partition: usize, part_metrics: PartitionMetrics, ) -> Result<ScanBatchStream>

fn new_semaphore(&self) -> Option<Arc<Semaphore>>

fn new_partition_metrics( &self, explain_verbose: bool, metrics_set: &ExecutionPlanMetricsSet, partition: usize, ) -> PartitionMetrics

Creates a new partition metrics instance. Sets the partition metrics for the given partition if it is not for compaction.

fn max_files_in_partition( ranges: &[RangeMeta], partition_ranges: &[PartitionRange], ) -> usize

Finds the maximum number of files to read in a single partition range.

pub(crate) fn check_scan_limit(&self) -> Result<()>

Checks resource limit for the scanner.

Trait Implementations

impl Debug for SeqScan

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl DisplayAs for SeqScan

fn fmt_as(&self, t: DisplayFormatType, f: &mut Formatter<'_>) -> Result

Format according to DisplayFormatType, used when verbose representation looks different from the default one

impl RegionScanner for SeqScan

fn name(&self) -> &str

fn properties(&self) -> &ScannerProperties

Returns the properties of the scanner.

fn schema(&self) -> SchemaRef

Returns the schema of the record batches.

fn metadata(&self) -> RegionMetadataRef

Returns the metadata of the region.

fn scan_partition( &self, ctx: &QueryScanContext, metrics_set: &ExecutionPlanMetricsSet, partition: usize, ) -> Result<SendableRecordBatchStream, BoxedError>

Scans the partition and returns a stream of record batches.

fn prepare(&mut self, request: PrepareRequest) -> Result<(), BoxedError>

Prepares the scanner with the given partition ranges.

fn has_predicate_without_region(&self) -> bool

Check if there is any predicate exclude region partition exprs that may be executed in this scanner.

fn add_dyn_filter_to_predicate( &mut self, filter_exprs: Vec<Arc<dyn PhysicalExpr>>, ) -> Vec<bool>

Add the given dynamic filter expressions to the predicate of the scanner. Returns a vector of booleans indicating which filter expressions were applied. true indicates the filter expression was applied(will be use by scanner to prune by stat for row group), false otherwise.

fn set_logical_region(&mut self, logical_region: bool)

Sets whether the scanner is reading a logical region.

fn snapshot_sequence(&self) -> Option<u64>