Enum PipelineInput 

pub enum PipelineInput<'a> {
    Rows(&'a [Row]),
    RowsOwned(Vec<Row>),
    Batch(ColumnarBatch),
    NativeColumnar {
        table_name: String,
        column_indices: Vec<usize>,
    },
    Empty,
}

Polymorphic input for pipeline stages.

Different execution strategies work with different data representations:

• Row-oriented: Works with borrowed or owned row vectors
• Columnar: Works with columnar batches (Arrow-like format)
• Native columnar: Works directly with table storage

This enum allows pipeline stages to accept any of these formats and convert as needed for their specific execution path.

Example

use vibesql_executor::pipeline::{PipelineInput, PipelineOutput};

// Row-based input (borrowed)
let rows = vec![Row::new(vec![SqlValue::Integer(1)])];
let input = PipelineInput::from_rows(&rows);

// Columnar batch input
let batch = ColumnarBatch::from_rows(&rows)?;
let input = PipelineInput::from_batch(batch);

// Convert to rows when needed
let rows = input.into_rows();

Variants

Rows(&'a [Row])

Borrowed slice of rows (zero-copy for row-oriented)

RowsOwned(Vec<Row>)

Owned vector of rows (when ownership transfer is needed)

Batch(ColumnarBatch)

Columnar batch for SIMD-accelerated execution

This variant enables high-performance columnar operations without row-by-row iteration. Use this for aggregations, filters, and projections that can benefit from SIMD vectorization.

NativeColumnar

Native columnar access (zero-copy from storage) Contains table reference and column indices to project

Fields

table_name: String

Table name for storage lookup

column_indices: Vec<usize>

Column indices to project (empty = all columns)

Empty

Empty input (for expression-only queries like SELECT 1+1)

Implementations

impl<'a> PipelineInput<'a>

pub fn from_rows(rows: &'a [Row]) -> Self

Create input from a borrowed row slice.

pub fn from_rows_owned(rows: Vec<Row>) -> Self

Create input from an owned row vector.

pub fn from_batch(batch: ColumnarBatch) -> Self

Create input from a columnar batch.

This enables SIMD-accelerated execution for pipelines that support it.

pub fn empty() -> Self

Create empty input for expression-only queries.

pub fn native_columnar(table_name: String, column_indices: Vec<usize>) -> Self

Create native columnar input.

pub fn into_rows(self) -> Vec<Row>

Convert to owned rows, consuming the input.

This is used when the pipeline stage needs ownership of the data. For columnar batches, this performs a materialization to rows.

Performance

• Rows: Clones the slice (O(n))
• RowsOwned: Zero-copy move (O(1))
• Batch: Materializes to rows (O(n * m) where m = columns)
• NativeColumnar: Returns empty (should be handled at storage layer)
• Empty: Returns single empty row

pub fn row_count(&self) -> usize

Get the number of rows in the input.

For native columnar, this may require a table lookup.

pub fn is_empty(&self) -> bool

Check if the input is empty.

pub fn as_rows(&self) -> Option<&[Row]>

Try to get rows as a slice (only works for row-based inputs).

Returns None for Batch and NativeColumnar variants. Use into_rows() if you need rows from those variants.

pub fn as_batch(&self) -> Option<&ColumnarBatch>

Try to get the columnar batch (only works for Batch variant).

Returns None for row-based and native columnar variants.

pub fn into_batch(self) -> Option<ColumnarBatch>

Consume and return the columnar batch if this is a Batch variant.

Returns None for other variants.

pub fn is_batch(&self) -> bool

Check if this input is in columnar batch format.

pub fn is_rows(&self) -> bool

Check if this input is in row format (borrowed or owned).

pub fn is_native_columnar(&self) -> bool

Check if this input is native columnar format.

Trait Implementations

impl<'a> Debug for PipelineInput<'a>

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

Formats the value using the given formatter.