remove project_with_alias.

datafusion/expr/src/logical_plan/builder.rs

@@ -274,19 +274,6 @@ impl LogicalPlanBuilder {
         )?))
     }
 
-    /// Apply a projection with alias
-    pub fn project_with_alias(
-        &self,
-        expr: impl IntoIterator<Item = impl Into<Expr>>,
-        alias: String,
-    ) -> Result<Self> {
-        Ok(Self::from(project_with_alias(
-            self.plan.clone(),
-            expr,
-            Some(alias),
-        )?))
-    }
-
     /// Apply a filter
     pub fn filter(&self, expr: impl Into<Expr>) -> Result<Self> {
         let expr = normalize_col(expr.into(), &self.plan)?;

datafusion/optimizer/src/decorrelate_where_in.rs

@@ -179,7 +179,8 @@ fn optimize_where_in(
     }
     let projection = alias_cols(&subqry_cols);
     let subqry_plan = subqry_plan
-        .project_with_alias(projection, subqry_alias.clone())?
+        .project(projection)?
+        .alias(&subqry_alias)?
         .build()?;
     debug!("subquery plan:\n{}", subqry_plan.display_indent());
 

datafusion/optimizer/src/inline_table_scan.rs

@@ -54,10 +54,9 @@ impl OptimizerRule for InlineTableScan {
                     // Recursively apply optimization
                     let plan =
                         utils::optimize_children(self, sub_plan, _optimizer_config)?;
-                    let plan = LogicalPlanBuilder::from(plan).project_with_alias(
-                        vec![Expr::Wildcard],
-                        table_name.to_string(),
-                    )?;
+                    let plan = LogicalPlanBuilder::from(plan)
+                        .project(vec![Expr::Wildcard])?
+                        .alias(table_name)?;
                     plan.build()
                 } else {
                     // No plan available, return with table scan as is

datafusion/optimizer/src/push_down_filter.rs

@@ -1124,7 +1124,8 @@ mod tests {
     fn union_all_on_projection() -> Result<()> {
         let table_scan = test_table_scan()?;
         let table = LogicalPlanBuilder::from(table_scan)
-            .project_with_alias(vec![col("a").alias("b")], "test2".to_string())?;
+            .project(vec![col("a").alias("b")])?
+            .alias("test2")?;
 
         let plan = table
             .union(table.build()?)?
@@ -2236,8 +2237,10 @@ mod tests {
     fn test_propagation_of_optimized_inner_filters_with_projections() -> Result<()> {
         // SELECT a FROM (SELECT 1 AS a) b WHERE b.a = 1
         let plan = LogicalPlanBuilder::empty(true)
-            .project_with_alias(vec![lit(0i64).alias("a")], "b".to_owned())?
-            .project_with_alias(vec![col("b.a")], "b".to_owned())?
+            .project(vec![lit(0i64).alias("a")])?
+            .alias("b")?
+            .project(vec![col("b.a")])?
+            .alias("b")?
             .filter(col("b.a").eq(lit(1i64)))?
             .project(vec![col("b.a")])?
             .build()?;

datafusion/optimizer/src/scalar_subquery_to_join.rs

@@ -271,7 +271,8 @@ fn optimize_scalar(
         .collect();
     let subqry_plan = subqry_plan
         .aggregate(group_by, aggr.aggr_expr.clone())?
-        .project_with_alias(proj, subqry_alias.clone())?
+        .project(proj)?
+        .alias(&subqry_alias)?
         .build()?;
 
     // qualify the join columns for outside the subquery

datafusion/optimizer/src/subquery_filter_to_join.rs

@@ -400,7 +400,8 @@ mod tests {
         let table_scan = test_table_scan()?;
         let plan = LogicalPlanBuilder::from(table_scan)
             .filter(in_subquery(col("c"), test_subquery_with_name("sq_inner")?))?
-            .project_with_alias(vec![col("b"), col("c")], "wrapped".to_string())?
+            .project(vec![col("b"), col("c")])?
+            .alias("wrapped")?
             .filter(or(
                 binary_expr(col("b"), Operator::Lt, lit(30_u32)),
                 in_subquery(col("c"), test_subquery_with_name("sq_outer")?),

datafusion/sql/src/planner.rs

@@ -932,14 +932,12 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
                 columns_alias.len(),
             )))
         } else {
-            Ok(LogicalPlanBuilder::from(plan.clone())
-                .project_with_alias(
-                    plan.schema().fields().iter().zip(columns_alias.iter()).map(
-                        |(field, ident)| col(field.name()).alias(normalize_ident(ident)),
-                    ),
-                    normalize_ident(&alias.name),
-                )?
-                .build()?)
+            LogicalPlanBuilder::from(plan.clone())
+                .project(plan.schema().fields().iter().zip(columns_alias.iter()).map(
+                    |(field, ident)| col(field.name()).alias(normalize_ident(ident)),
+                ))?
+                .alias(&normalize_ident(&alias.name))?
+                .build()
         }
     }