Enum Plan

pub enum Plan {
    Constant {
        rows: Vec<(Row, i64, i64)>,
    },
    Get {
        id: Id,
    },
    Let {
        id: LocalId,
        value: Box<TypedPlan>,
        body: Box<TypedPlan>,
    },
    Mfp {
        input: Box<TypedPlan>,
        mfp: MapFilterProject,
    },
    Reduce {
        input: Box<TypedPlan>,
        key_val_plan: KeyValPlan,
        reduce_plan: ReducePlan,
    },
    Join {
        inputs: Vec<TypedPlan>,
        plan: JoinPlan,
    },
    Union {
        inputs: Vec<TypedPlan>,
        consolidate_output: bool,
    },
}

TODO(discord9): support TableFunc（by define FlatMap that map 1 to n) Plan describe how to transform data in dataflow

This can be considered as a physical plan in dataflow, which describe how to transform data in a streaming manner.

Variants

Constant

A constant collection of rows.

Fields

rows: Vec<(Row, i64, i64)>

Get

Get CDC data from an source, be it external reference to an existing source or an internal reference to a Let identifier

Fields

id: Id

Let

Create a temporary collection from given value, and make this bind only available in scope of body

Similar to this rust code snippet:

{
   let id = value;
    body
}

Fields

id: LocalId

value: Box<TypedPlan>

body: Box<TypedPlan>

Mfp

Map, Filter, and Project operators. Chained together.

Fields

input: Box<TypedPlan>

The input collection.

mfp: MapFilterProject

Linear operator to apply to each record.

Reduce

Reduce operator, aggregation by key assembled from KeyValPlan

Fields

input: Box<TypedPlan>

The input collection.

key_val_plan: KeyValPlan

A plan for changing input records into key, value pairs.

reduce_plan: ReducePlan

A plan for performing the reduce.

The implementation of reduction has several different strategies based on the properties of the reduction, and the input itself.

Join

A multiway relational equijoin, with fused map, filter, and projection.

This stage performs a multiway join among inputs, using the equality constraints expressed in plan. The plan also describes the implementation strategy we will use, and any pushed down per-record work.

Fields

inputs: Vec<TypedPlan>

An ordered list of inputs that will be joined.

plan: JoinPlan

Detailed information about the implementation of the join.

This includes information about the implementation strategy, but also any map, filter, project work that we might follow the join with, but potentially pushed down into the implementation of the join.

Union

Adds the contents of the input collections.

Importantly, this is multiset union, so the multiplicities of records will add. This is in contrast to set union, where the multiplicities would be capped at one. A set union can be formed with Union followed by Reduce implementing the “distinct” operator.

Fields

inputs: Vec<TypedPlan>

The input collections

consolidate_output: bool

Whether to consolidate the output, e.g., cancel negated records.

Implementations

impl Plan

pub fn with_types(self, schema: RelationDesc) -> TypedPlan

impl Plan

pub fn get_nth_expr(&self, n: usize) -> Option<ScalarExpr>

Get nth expr using column ref

pub fn get_first_input_plan(&self) -> Option<&TypedPlan>

Get the first input plan if exists

pub fn get_mut_first_input_plan(&mut self) -> Option<&mut TypedPlan>

Get mutable ref to the first input plan if exists

pub fn find_used_collection(&self) -> BTreeSet<GlobalId>

Find all the used collection in the plan

Trait Implementations

impl Clone for Plan

fn clone(&self) -> Plan

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Plan

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

Formats the value using the given formatter.

impl Ord for Plan

fn cmp(&self, other: &Plan) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Plan

fn eq(&self, other: &Plan) -> 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 PartialOrd for Plan

fn partial_cmp(&self, other: &Plan) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Plan

impl StructuralPartialEq for Plan