minor: Remove more clones from the planner

datafusion/common/src/column.rs

@@ -51,11 +51,12 @@ impl Column {
     }
 
     /// Deserialize a fully qualified name string into a column
-    pub fn from_qualified_name(flat_name: &str) -> Self {
+    pub fn from_qualified_name(flat_name: impl Into<String>) -> Self {
+        let flat_name = flat_name.into();
         use sqlparser::tokenizer::Token;
 
         let dialect = sqlparser::dialect::GenericDialect {};
-        let mut tokenizer = sqlparser::tokenizer::Tokenizer::new(&dialect, flat_name);
+        let mut tokenizer = sqlparser::tokenizer::Tokenizer::new(&dialect, &flat_name);
         if let Ok(tokens) = tokenizer.tokenize() {
             if let [Token::Word(relation), Token::Period, Token::Word(name)] =
                 tokens.as_slice()
@@ -70,7 +71,7 @@ impl Column {
         // name
         Column {
             relation: None,
-            name: String::from(flat_name),
+            name: flat_name,
         }
     }
 
@@ -145,6 +146,20 @@ impl From<&str> for Column {
     }
 }
 
+/// Create a column, cloning the string
+impl From<&String> for Column {
+    fn from(c: &String) -> Self {
+        Self::from_qualified_name(c)
+    }
+}
+
+/// Create a column, reusing the existing string
+impl From<String> for Column {
+    fn from(c: String) -> Self {
+        Self::from_qualified_name(c)
+    }
+}
+
 impl FromStr for Column {
     type Err = Infallible;
 

datafusion/expr/src/expr_fn.rs

@@ -25,11 +25,17 @@ use crate::{
     ScalarFunctionImplementation, ScalarUDF, Signature, StateTypeFunction, Volatility,
 };
 use arrow::datatypes::DataType;
-use datafusion_common::Result;
+use datafusion_common::{Column, Result};
 use std::sync::Arc;
 
 /// Create a column expression based on a qualified or unqualified column name
-pub fn col(ident: &str) -> Expr {
+///
+/// example:
+/// ```
+/// # use datafusion_expr::col;
+/// let c = col("my_column");
+/// ```
+pub fn col(ident: impl Into<Column>) -> Expr {
     Expr::Column(ident.into())
 }
 

datafusion/expr/src/logical_plan/builder.rs

@@ -306,7 +306,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)?))
     }
 
@@ -977,7 +977,10 @@ 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> {
     Ok(LogicalPlan::SubqueryAlias(SubqueryAlias::try_new(
         plan.clone(),
         alias,

datafusion/sql/src/planner.rs

@@ -1965,7 +1965,7 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
 
             SQLExpr::MapAccess { column, keys } => {
                 if let SQLExpr::Identifier(id) = *column {
-                    plan_indexed(col(&normalize_ident(id)), keys)
+                    plan_indexed(col(normalize_ident(id)), keys)
                 } else {
                     Err(DataFusionError::NotImplemented(format!(
                         "map access requires an identifier, found column {} instead",