Enum PlanTree 

pub enum PlanTree {
    Leaf(Stage),
    Unary {
        stage: Stage,
        input: Box<PlanTree>,
    },
    Binary {
        stage: Stage,
        left: Box<PlanTree>,
        right: Box<PlanTree>,
    },
}

The pipeline as a TREE, which is what it actually is.

Every stage has one input except a join, which has two. Tests assert over this rather than over rendered text, because the bug that shipped in the first EXPLAIN was a TOPOLOGY bug: a join’s two scans were printed at different depths, so pg_class read as a child of the scan of pg_namespace. Every assertion at the time checked content — which relation, how many rows — and content was correct. Structure was not.

  Join            is NOT        Join
  ├── Scan A                    └── Scan A
  └── Scan B                        └── Scan B

A string assertion can be made to pass by either shape. A tree assertion cannot.

Variants

Leaf(Stage)

Unary

Fields

stage: Stage

input: Box<PlanTree>

Binary

Fields

stage: Stage

left: Box<PlanTree>

right: Box<PlanTree>

Implementations

impl PlanTree

pub fn stage(&self) -> &Stage

pub fn children(&self) -> Vec<&PlanTree>

Inputs, in the order PostgreSQL prints them: outer side first.

pub fn size(&self) -> usize

Total node count, so a test can assert nothing was dropped.

pub fn depth(&self) -> usize

The deepest path length, which is what distinguishes siblings from nesting: two scans under a join give depth 2, one nested under the other gives depth 3.

Trait Implementations

impl Clone for PlanTree

fn clone(&self) -> PlanTree

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PlanTree

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

Formats the value using the given formatter.

impl Eq for PlanTree

impl PartialEq for PlanTree

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for PlanTree