Enum PlanNode 

pub enum PlanNode {
    Scan {
        path: PathBuf,
        format: FileFormat,
        projection: Option<Vec<String>>,
    },
    Filter {
        input: Box<PlanNode>,
        predicate: Expr,
    },
    Select {
        input: Box<PlanNode>,
        columns: Vec<String>,
    },
    WithColumn {
        input: Box<PlanNode>,
        name: String,
        expr: Expr,
    },
    Limit {
        input: Box<PlanNode>,
        count: usize,
    },
    MaxScan {
        input: Box<PlanNode>,
        count: usize,
    },
    Join {
        left: Box<PlanNode>,
        right: Box<PlanNode>,
        join_type: JoinType,
        on: Vec<String>,
    },
}

A node in the logical plan tree

Each node represents a single operation. Nodes form a tree where operations flow from leaves (scans) to the root (final output).

Variants

Scan

Scan a file from disk

This is always a leaf node - the source of data

Fields

path: PathBuf

Path to the file

format: FileFormat

File format

projection: Option<Vec<String>>

Optional projection (which columns to read)

Filter

Filter records by predicate

Only records where the predicate evaluates to true are kept

Fields

input: Box<PlanNode>

Input plan to filter

predicate: Expr

Predicate expression

Select

Select/project specific columns

Reduces the output to only the specified columns

Fields

input: Box<PlanNode>

Input plan

columns: Vec<String>

Column names to keep

WithColumn

Add a computed column

Fields

input: Box<PlanNode>

Input plan

name: String

New column name

expr: Expr

Expression to compute column value

Limit

Limit number of records

Fields

input: Box<PlanNode>

Input plan

count: usize

Maximum number of records

MaxScan

Maximum number of records to scan (before filtering)

This limits how many records are read from the source, regardless of how many pass filters. Useful for sampling large files without processing the entire dataset.

Fields

input: Box<PlanNode>

Input plan

count: usize

Maximum number of records to scan

Join

Join two plans (future support)

Fields

left: Box<PlanNode>

Left input

right: Box<PlanNode>

Right input

join_type: JoinType

Join type

on: Vec<String>

Join keys

Implementations

impl PlanNode

pub fn format(&self) -> Option<FileFormat>

Get the file format if this is or contains a Scan node

pub fn filters(&self) -> Vec<&Expr>

Get all filter predicates in this plan

pub fn has_filters(&self) -> bool

Check if this plan contains any filters

Trait Implementations

impl Clone for PlanNode

fn clone(&self) -> PlanNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PlanNode

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

Formats the value using the given formatter.