Method reconstruct_select_statement

datafusion/sql/src/unparser/plan.rs:232–334

Reconstructs a SELECT SQL statement from a logical plan by unprojecting column expressions found in a [Projection] node. This requires scanning the plan tree for relevant Aggregate and Window nodes and matching column expressions to the appropriate agg or window expressions.

(
        &self,
        plan: &LogicalPlan,
        p: &Projection,
        select: &mut SelectBuilder,
    )

    /// found in a [Projection] node. This requires scanning the plan tree for relevant Aggregate
    /// and Window nodes and matching column expressions to the appropriate agg or window expressions.
    fn reconstruct_select_statement(
        &self,
        plan: &LogicalPlan,
        p: &Projection,
        select: &mut SelectBuilder,
    ) -> Result<()> {
        let mut exprs = p.expr.clone();

        // If an Unnest node is found within the select, find and unproject the unnest column
        let flatten_alias = select.current_flatten_alias();
        if let Some(unnest) = find_unnest_node_within_select(plan) {
            if let Some(ref alias) = flatten_alias {
                exprs = exprs
                    .into_iter()
                    .map(|e| unproject_unnest_expr_as_flatten_value(e, unnest, alias))
                    .collect::<Result<Vec<_>>>()?;
            } else {
                exprs = exprs
                    .into_iter()
                    .map(|e| unproject_unnest_expr(e, unnest))
                    .collect::<Result<Vec<_>>>()?;
            }
        };

        // Rewrite column references that point to FLATTEN table aliases:
        // in Snowflake, FLATTEN output is accessed via .VALUE, not the
        // original column name.
        if !select.flatten_table_aliases_empty() {
            exprs = exprs
                .into_iter()
                .map(|e| {
                    e.transform(|expr| {
                        if let Expr::Column(ref col) = expr
                            && let Some(ref relation) = col.relation
                            && select.is_flatten_table_alias(relation.table())
                        {
                            return Ok(Transformed::yes(Expr::Column(Column::new(
                                Some(relation.clone()),
                                "VALUE",
                            ))));
                        }
                        Ok(Transformed::no(expr))
                    })
                    .map(|t| t.data)
                })
                .collect::<Result<Vec<_>>>()?;
        }

        match (
            find_agg_node_within_select(plan, true),
            find_window_nodes_within_select(plan, None, true),
        ) {
            (Some(agg), window) => {
                let window_option = window.as_deref();
                let items = exprs
                    .into_iter()
                    .map(|proj_expr| {
                        let unproj = unproject_agg_exprs(proj_expr, agg, window_option)?;