Struct RecursiveUnnestRewriter 

struct RecursiveUnnestRewriter<'a> {
    root_expr: &'a Expr,
    top_most_unnest: Option<Unnest>,
    consecutive_unnest: Vec<Option<Unnest>>,
    inner_projection_exprs: &'a mut Vec<Expr>,
    columns_unnestings: &'a mut IndexMap<Column, Option<Vec<ColumnUnnestList>>>,
    transformed_root_exprs: Option<Vec<Expr>>,
}

Fields

root_expr: &'a Expr

top_most_unnest: Option<Unnest>

consecutive_unnest: Vec<Option<Unnest>>

inner_projection_exprs: &'a mut Vec<Expr>

columns_unnestings: &'a mut IndexMap<Column, Option<Vec<ColumnUnnestList>>>

transformed_root_exprs: Option<Vec<Expr>>

Implementations

impl RecursiveUnnestRewriter<'_>

fn get_latest_consecutive_unnest(&self) -> Vec<Unnest>

This struct stores the history of expr during its tree-traversal with a notation of [None,Unnest(exprA),Unnest(exprB),None,None] then this function will returns [Unnest(exprA),Unnest(exprB)]

The first item will be the inner most expr

fn transform( &mut self, level: usize, alias_name: String, expr_in_unnest: &Expr, struct_allowed: bool, input_schema: &DFSchema, ) -> Result<Vec<Expr>>

Trait Implementations

impl TreeNodeRewriterWithPayload for RecursiveUnnestRewriter<'_>

fn f_down( &mut self, expr: Expr, input_schema: &DFSchema, ) -> Result<Transformed<Expr>>

This downward traversal needs to keep track of:

• Whether or not some unnest expr has been visited from the top util the current node
• If some unnest expr has been visited, maintain a stack of such information, this is used to detect if some recursive unnest expr exists (e.g unnest(unnest(unnest(3d column))))

fn f_up( &mut self, expr: Expr, input_schema: &DFSchema, ) -> Result<Transformed<Expr>>

The rewriting only happens when the traversal has reached the top-most unnest expr within a sequence of consecutive unnest exprs node

For example an expr of unnest(unnest(column1)) + unnest(unnest(unnest(column2)))

                        ┌──────────────────┐
                        │    binaryexpr    │
                        │                  │
                        └──────────────────┘
               f_down  / /            │ │
                      / / f_up        │ │
                     / /        f_down│ │f_up
                 unnest               │ │
                                      │ │
      f_down  / / f_up(rewriting)     │ │
             / /
            / /                      unnest
        unnest
                          f_down  / / f_up(rewriting)
f_down / /f_up                   / /
      / /                       / /
     / /                    unnest
  column1
                    f_down / /f_up
                          / /
                         / /
                      column2

type Node = Expr

type Payload<'a> = &'a DFSchema