From 685e75cac2abd7ceaa42490dc1d13766783befc9 Mon Sep 17 00:00:00 2001
From: Andrew Lamb <andrew@nerdnetworks.org>
Date: Wed, 7 Dec 2022 14:34:39 -0500
Subject: [PATCH] minor: Remove more clones from the planner

---
 datafusion/expr/src/logical_plan/builder.rs | 17 ++++++++++++-----
 datafusion/sql/src/planner.rs               |  8 ++++----
 2 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/datafusion/expr/src/logical_plan/builder.rs b/datafusion/expr/src/logical_plan/builder.rs
index d03fbdf06557a..3ec6df6e7fc69 100644
--- a/datafusion/expr/src/logical_plan/builder.rs
+++ b/datafusion/expr/src/logical_plan/builder.rs
@@ -294,7 +294,7 @@ impl LogicalPlanBuilder {
     }
 
     /// Apply an alias
-    pub fn alias(&self, alias: &str) -> Result<Self> {
+    pub fn alias(&self, alias: impl Into<String>) -> Result<Self> {
         Ok(Self::from(subquery_alias(&self.plan, alias)?))
     }
 
@@ -965,16 +965,23 @@ pub fn project(
 }
 
 /// Create a SubqueryAlias to wrap a LogicalPlan.
-pub fn subquery_alias(plan: &LogicalPlan, alias: &str) -> Result<LogicalPlan> {
+pub fn subquery_alias(
+    plan: &LogicalPlan,
+    alias: impl Into<String>,
+) -> Result<LogicalPlan> {
     subquery_alias_owned(plan.clone(), alias)
 }
 
-pub fn subquery_alias_owned(plan: LogicalPlan, alias: &str) -> Result<LogicalPlan> {
+pub fn subquery_alias_owned(
+    plan: LogicalPlan,
+    alias: impl Into<String>,
+) -> Result<LogicalPlan> {
+    let alias = alias.into();
     let schema: Schema = plan.schema().as_ref().clone().into();
-    let schema = DFSchemaRef::new(DFSchema::try_from_qualified_schema(alias, &schema)?);
+    let schema = DFSchemaRef::new(DFSchema::try_from_qualified_schema(&alias, &schema)?);
     Ok(LogicalPlan::SubqueryAlias(SubqueryAlias {
         input: Arc::new(plan),
-        alias: alias.to_string(),
+        alias,
         schema,
     }))
 }
diff --git a/datafusion/sql/src/planner.rs b/datafusion/sql/src/planner.rs
index 36689201b0603..dfeb4eb27090b 100644
--- a/datafusion/sql/src/planner.rs
+++ b/datafusion/sql/src/planner.rs
@@ -914,7 +914,7 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
                         self.schema_provider.get_table_provider((&table_ref).into()),
                     ) {
                         (Some(cte_plan), _) => match table_alias {
-                            Some(cte_alias) => subquery_alias(cte_plan, &cte_alias),
+                            Some(cte_alias) => subquery_alias(cte_plan, cte_alias),
                             _ => Ok(cte_plan.clone()),
                         },
                         (_, Ok(provider)) => {
@@ -943,7 +943,7 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
                 let normalized_alias =
                     alias.as_ref().map(|a| normalize_ident(a.name.clone()));
                 let plan = match normalized_alias {
-                    Some(alias) => subquery_alias_owned(logical_plan, &alias)?,
+                    Some(alias) => subquery_alias_owned(logical_plan, alias)?,
                     _ => logical_plan,
                 };
                 (plan, alias)
@@ -993,7 +993,7 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
         } else {
             subquery_alias_owned(
                 Self::apply_expr_alias(plan, alias.columns)?,
-                &normalize_ident(alias.name),
+                normalize_ident(alias.name),
             )
         }
     }
@@ -1256,7 +1256,7 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
         // final projection
         let mut plan = project(plan, select_exprs_post_aggr)?;
         plan = match alias {
-            Some(alias) => subquery_alias_owned(plan, &alias)?,
+            Some(alias) => subquery_alias_owned(plan, alias)?,
             None => plan,
         };