Struct partiql_logical::LogicalPlan

pub struct LogicalPlan<T>where
    T: Default,{ /* private fields */ }

Represents a PartiQL logical plan.

Implementations

impl<T> LogicalPlan<T>where T: Default,

pub fn new() -> Self

Creates a new default logical plan.

pub fn add_operator(&mut self, op: T) -> OpId

Adds a new operator to the plan.

pub fn add_flow(&mut self, src: OpId, dst: OpId)

Adds a data flow to the plan.

pub fn add_flow_with_branch_num(&mut self, src: OpId, dst: OpId, branch_num: u8)

Adds a data flow with a branch number.

pub fn extend_with_flows(&mut self, flows: &[(OpId, OpId)])

Extends the logical plan with the given data flows. #Examples:

use partiql_logical::{BindingsOp, GroupBy, GroupingStrategy, LimitOffset, LogicalPlan, OrderBy};
let mut p: LogicalPlan<BindingsOp> = LogicalPlan::new();

let a = p.add_operator(BindingsOp::OrderBy(OrderBy{specs: vec![]}));
let b = p.add_operator(BindingsOp::Sink);
let c = p.add_operator(BindingsOp::LimitOffset(LimitOffset{limit:None, offset:None}));
let d = p.add_operator(BindingsOp::GroupBy(GroupBy {
    strategy: GroupingStrategy::GroupFull,
    exprs: Default::default(),
    aggregate_exprs: vec![],
    group_as_alias: None,
}));

p.add_flow(a, b);

p.extend_with_flows(&[(a,c), (c, d)]);
assert_eq!(3, p.flows().len());

pub fn operator_count(&self) -> usize

Returns the number of operators in the plan.

pub fn operators(&self) -> &Vec<T>

Returns the operators of the plan.

pub fn operators_by_id(&self) -> impl Iterator<Item = (OpId, &T)>

Returns the operators of the plan with their OpId.

pub fn flows(&self) -> &Vec<(OpId, OpId, u8)>

Returns the data flows of the plan.

pub fn operator(&self, id: OpId) -> Option<&T>

pub fn operator_as_mut(&mut self, id: OpId) -> Option<&mut T>

Trait Implementations

impl<T> Clone for LogicalPlan<T>where T: Default + Clone,

fn clone(&self) -> LogicalPlan<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for LogicalPlan<T>where T: Default + Debug,

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

Formats the value using the given formatter.

impl<T> Default for LogicalPlan<T>where T: Default + Default,

fn default() -> LogicalPlan<T>

Returns the “default value” for a type.

impl<T> Display for LogicalPlan<T>where T: Default + Debug,

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

Formats the value using the given formatter.

impl<T> PartialEq<LogicalPlan<T>> for LogicalPlan<T>where T: Default + PartialEq,

fn eq(&self, other: &LogicalPlan<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T> Eq for LogicalPlan<T>where T: Default + Eq,

impl<T> StructuralEq for LogicalPlan<T>where T: Default,

impl<T> StructuralPartialEq for LogicalPlan<T>where T: Default,