Enum LogicalPlanLite 

pub enum LogicalPlanLite {
    Scan {
        table: String,
        predicate: Option<String>,
        projection: Vec<String>,
    },
    Aggregate {
        input: Box<LogicalPlanLite>,
        group_by: Vec<String>,
        aggregates: Vec<AggregateExpr>,
    },
    Join {
        left: Box<LogicalPlanLite>,
        right: Box<LogicalPlanLite>,
        on: Vec<JoinKey>,
    },
    Sort {
        input: Box<LogicalPlanLite>,
        keys: Vec<SortKey>,
        limit: Option<usize>,
    },
    Limit {
        input: Box<LogicalPlanLite>,
        limit: usize,
    },
}

The simplified logical IR distribute lowers onto tablets.

This is the seam documented at the module level: the DataFusion integration wave lowers real DataFusion plans onto this enum; this wave plans from it directly.

Variants

Scan

Base-table scan with an optional opaque predicate and projection.

Fields

table: String

Table name.

predicate: Option<String>

Opaque predicate text (pushed down verbatim; not interpreted in this wave).

projection: Vec<String>

Projected column names; empty = all columns.

Aggregate

Grouped aggregation.

Fields

input: Box<LogicalPlanLite>

Input subtree.

group_by: Vec<String>

Group-by columns.

aggregates: Vec<AggregateExpr>

Aggregate expressions.

Join

Equi-join.

Fields

left: Box<LogicalPlanLite>

Left input subtree.

right: Box<LogicalPlanLite>

Right input subtree.

on: Vec<JoinKey>

Equality key pairs.

Sort

Sort with an optional limit (ORDER BY ... [LIMIT k]).

Fields

input: Box<LogicalPlanLite>

Input subtree.

keys: Vec<SortKey>

Sort keys, most significant first.

limit: Option<usize>

Optional limit.

Limit

Limit without an ordering.

Fields

input: Box<LogicalPlanLite>

Input subtree.

limit: usize

Row limit.

Trait Implementations

impl Clone for LogicalPlanLite

fn clone(&self) -> LogicalPlanLite

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LogicalPlanLite

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LogicalPlanLite

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for LogicalPlanLite

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for LogicalPlanLite

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for LogicalPlanLite