Method new

datafusion/physical-expr/src/expressions/lambda.rs:77–133

(params: Vec<String>, body: Arc<dyn PhysicalExpr>)

    }

    fn new(params: Vec<String>, body: Arc<dyn PhysicalExpr>) -> Self {
        let mut used_column_indices = HashSet::new();

        body.apply(|node| {
            if let Some(col) = node.downcast_ref::<Column>() {
                used_column_indices.insert(col.index());
            } else if let Some(var) = node.downcast_ref::<LambdaVariable>() {
                used_column_indices.insert(var.index());
            }

            Ok(TreeNodeRecursion::Continue)
        })
        .expect("closure should be infallible");

        let mut projection = used_column_indices.into_iter().collect::<Vec<_>>();

        projection.sort();

        let column_index_map = projection
            .iter()
            .enumerate()
            .map(|(projected, original)| (*original, projected))
            .collect::<HashMap<_, _>>();

        let projected_body = Arc::clone(&body)
            .transform_down(|e| {
                if let Some(column) = e.downcast_ref::<Column>() {
                    let original = column.index();
                    let projected = *column_index_map.get(&original).unwrap();
                    if projected != original {
                        return Ok(Transformed::yes(Arc::new(Column::new(
                            column.name(),
                            projected,
                        ))));
                    }
                } else if let Some(lambda_variable) = e.downcast_ref::<LambdaVariable>() {
                    let original = lambda_variable.index();
                    let projected = *column_index_map.get(&original).unwrap();
                    if projected != original {
                        return Ok(Transformed::yes(Arc::new(LambdaVariable::new(
                            projected,
                            Arc::clone(lambda_variable.field()),
                        ))));
                    }
                }
                Ok(Transformed::no(e))
            })
            .expect("closure should be infallible")
            .data;

        Self {
            params,
            body,
            projected_body,
            projection,
        }
    }