Function rewrite_expr

datafusion/optimizer/src/optimize_projections/mod.rs:685–717

Rewrites a projection expression using the projection before it (i.e. its input) This is a subroutine to the `merge_consecutive_projections` function. # Parameters `expr` - A reference to the expression to rewrite. `input` - A reference to the input of the projection expression (itself a projection). # Returns A `Result` object with the following semantics: - `Ok(Some(Expr))`: Rewrite was suc

(expr: Expr, input: &Projection)

/// --Source(a, b)
/// ```
fn rewrite_expr(expr: Expr, input: &Projection) -> Result<Transformed<Expr>> {
    expr.transform_up(|expr| {
        match expr {
            //  remove any intermediate aliases if they do not carry metadata
            Expr::Alias(alias) => {
                match alias
                    .metadata
                    .as_ref()
                    .map(|h| h.is_empty())
                    .unwrap_or(true)
                {
                    true => Ok(Transformed::yes(*alias.expr)),
                    false => Ok(Transformed::no(Expr::Alias(alias))),
                }
            }
            Expr::Column(col) => {
                // Find index of column:
                let idx = input.schema.index_of_column(&col)?;
                // get the corresponding unaliased input expression
                //
                // For example:
                // * the input projection is [`a + b` as c, `d + e` as f]
                // * the current column is an expression "f"
                //
                // return the expression `d + e` (not `d + e` as f)
                let input_expr = input.expr[idx].clone().unalias_nested().data;
                Ok(Transformed::yes(input_expr))
            }
            // Unsupported type for consecutive projection merge analysis.
            _ => Ok(Transformed::no(expr)),
        }
    })
}

/// Splits requirement indices for a join into left and right children based on
/// the join type.