Struct NativeColumnarPipeline 

pub struct NativeColumnarPipeline { /* private fields */ }

Native columnar execution pipeline.

This pipeline operates on data in columnar format throughout the execution, only converting to rows at the final output stage. This provides maximum performance for large-scale analytical queries.

Performance

Uses LLVM auto-vectorization for SIMD-accelerated operations.

Performance Characteristics

• Filter: SIMD-accelerated predicate evaluation (4-8x speedup)
• Projection: Zero-copy column selection
• Aggregation: SIMD reduction operations (10x speedup)
• GROUP BY: Hash-based grouping with columnar aggregation

When to Use

• Large datasets (>100k rows)
• TPC-H style analytical queries
• Simple GROUP BY with column references
• Single table scans without complex JOINs

Limitations

• No JOIN support (single table only)
• GROUP BY limited to simple column references
• No ROLLUP/CUBE/GROUPING SETS support
• Requires columnar storage format

Implementations

impl NativeColumnarPipeline

pub fn new() -> Self

Create a new native columnar pipeline.

pub fn with_storage(has_columnar_storage: bool) -> Self

Create a native columnar pipeline with explicit columnar storage availability.

Trait Implementations

impl Default for NativeColumnarPipeline

fn default() -> Self

Returns the “default value” for a type.

impl ExecutionPipeline for NativeColumnarPipeline

fn create_evaluator<'a>( &self, ctx: &'a ExecutionContext<'a>, ) -> CombinedExpressionEvaluator<'a>

Create an evaluator with context for native columnar execution.

fn apply_filter( &self, input: PipelineInput<'_>, predicate: Option<&Expression>, ctx: &ExecutionContext<'_>, ) -> Result<PipelineOutput, ExecutorError>

Apply WHERE clause filtering using SIMD-accelerated columnar operations.

This is the most optimized path:

1. Extracts simple predicates from WHERE clause
2. Applies SIMD filtering directly on column arrays
3. Returns filtered columnar batch (converted to rows for output)

fn apply_projection( &self, input: PipelineInput<'_>, select_items: &[SelectItem], ctx: &ExecutionContext<'_>, ) -> Result<PipelineOutput, ExecutorError>

Apply SELECT projection using columnar operations.

In native columnar execution, projection is typically implicit - we only compute the required columns. For explicit projection, we fall back to row-oriented processing only when necessary.

fn apply_aggregation( &self, input: PipelineInput<'_>, select_items: &[SelectItem], group_by: Option<&[Expression]>, having: Option<&Expression>, ctx: &ExecutionContext<'_>, ) -> Result<PipelineOutput, ExecutorError>

Execute aggregation using SIMD-accelerated columnar operations.

This is the most optimized aggregation path:

1. Extracts aggregate specifications from SELECT list
2. For simple aggregates without GROUP BY: Uses SIMD reductions
3. For GROUP BY: Uses hash-based grouping with columnar aggregation

fn supports_query_pattern( &self, has_aggregation: bool, _has_group_by: bool, has_joins: bool, ) -> bool

Native columnar supports simple aggregates with optional GROUP BY.

fn name(&self) -> &'static str

Get the name of this pipeline for debugging/logging.

fn apply_limit_offset( &self, input: PipelineOutput, limit: Option<u64>, offset: Option<u64>, ) -> Result<Vec<Row>, ExecutorError>

Apply LIMIT and OFFSET to the results.