Enum Step 

pub enum Step {
    Scan {
        table: String,
        alias: Option<String>,
        projections: Vec<Projection>,
        predicate: Option<Expr>,
        dependencies: Vec<StepId>,
    },
    Filter {
        predicate: Expr,
        projections: Vec<Projection>,
        dependencies: Vec<StepId>,
    },
    Project {
        projections: Vec<Projection>,
        dependencies: Vec<StepId>,
    },
    Aggregate {
        group_by: Vec<Expr>,
        aggregations: Vec<Projection>,
        projections: Vec<Projection>,
        dependencies: Vec<StepId>,
    },
    Sort {
        order_by: Vec<OrderByItem>,
        projections: Vec<Projection>,
        dependencies: Vec<StepId>,
    },
    Join {
        join_type: JoinType,
        condition: Option<Expr>,
        using_columns: Vec<String>,
        projections: Vec<Projection>,
        dependencies: Vec<StepId>,
    },
    Limit {
        limit: Option<Expr>,
        offset: Option<Expr>,
        projections: Vec<Projection>,
        dependencies: Vec<StepId>,
    },
    SetOperation {
        op: SetOperationType,
        all: bool,
        projections: Vec<Projection>,
        dependencies: Vec<StepId>,
    },
    Distinct {
        projections: Vec<Projection>,
        dependencies: Vec<StepId>,
    },
}

A single step in the logical execution plan.

Variants

Scan

Full table scan with optional filter pushdown.

Fields

table: String

Fully-qualified table name.

alias: Option<String>

Alias for the table (if any).

projections: Vec<Projection>

Projected columns.

predicate: Option<Expr>

Predicate pushed down to the scan.

dependencies: Vec<StepId>

IDs of steps this step depends on (always empty for a scan).

Filter

Filter (WHERE / HAVING) applied to its input.

Fields

predicate: Expr

The filter predicate.

projections: Vec<Projection>

Projected columns.

dependencies: Vec<StepId>

The single input step.

Project

Projection (SELECT list evaluation).

Fields

projections: Vec<Projection>

Output projections.

dependencies: Vec<StepId>

The single input step.

Aggregate

Aggregation (GROUP BY + aggregate functions).

Fields

group_by: Vec<Expr>

GROUP BY keys.

aggregations: Vec<Projection>

Aggregate expressions (COUNT, SUM, etc.).

projections: Vec<Projection>

Projected output columns.

dependencies: Vec<StepId>

The single input step.

Sort

Sort (ORDER BY).

Fields

order_by: Vec<OrderByItem>

Order-by items.

projections: Vec<Projection>

Projected columns (pass-through).

dependencies: Vec<StepId>

The single input step.

Join

Join two inputs.

Fields

join_type: JoinType

Type of join.

condition: Option<Expr>

Join condition (ON clause).

using_columns: Vec<String>

USING columns (if specified instead of ON).

projections: Vec<Projection>

Projected columns.

dependencies: Vec<StepId>

Two input steps: [left, right].

Limit

LIMIT / OFFSET.

Fields

limit: Option<Expr>

Row limit.

offset: Option<Expr>

Row offset.

projections: Vec<Projection>

Projected columns (pass-through).

dependencies: Vec<StepId>

The single input step.

SetOperation

UNION / INTERSECT / EXCEPT.

Fields

op: SetOperationType

The kind of set operation.

all: bool

Whether ALL (no deduplication).

projections: Vec<Projection>

Projected columns from the combined result.

dependencies: Vec<StepId>

Two input steps: [left, right].

Distinct

DISTINCT elimination.

Fields

projections: Vec<Projection>

Projected columns.

dependencies: Vec<StepId>

The single input step.

Implementations

impl Step

pub fn dependencies(&self) -> &[StepId]

Returns the list of step IDs this step depends on.

pub fn projections(&self) -> &[Projection]

Returns the projected columns of this step.

pub fn kind(&self) -> &'static str

A short human-readable label for the step type.

Trait Implementations

impl Clone for Step

fn clone(&self) -> Step

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Step

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

Formats the value using the given formatter.

impl PartialEq for Step

fn eq(&self, other: &Step) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Step