[arrow-datafusion] branch master updated: minor: Remove more clones from the planner (#4546)

[al...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

alamb pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/arrow-datafusion.git


The following commit(s) were added to refs/heads/master by this push:
     new 1ddcafeb3 minor: Remove more clones from the planner (#4546)
1ddcafeb3 is described below

commit 1ddcafeb305b17d6932e215bd3a4c1b599c1c536
Author: Andrew Lamb <an...@nerdnetworks.org>
AuthorDate: Tue Dec 13 07:14:36 2022 -0500

    minor: Remove more clones from the planner (#4546)
---
 datafusion/common/src/column.rs             | 21 ++++++++++++++++++---
 datafusion/expr/src/expr_fn.rs              | 10 ++++++++--
 datafusion/expr/src/logical_plan/builder.rs |  7 +++++--
 datafusion/sql/src/planner.rs               |  2 +-
 4 files changed, 32 insertions(+), 8 deletions(-)

diff --git a/datafusion/common/src/column.rs b/datafusion/common/src/column.rs
index d8adaacf2..42e1a8608 100644
--- a/datafusion/common/src/column.rs
+++ b/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;
 
diff --git a/datafusion/expr/src/expr_fn.rs b/datafusion/expr/src/expr_fn.rs
index f63de79f1..4ecc94f74 100644
--- a/datafusion/expr/src/expr_fn.rs
+++ b/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())
 }
 
diff --git a/datafusion/expr/src/logical_plan/builder.rs b/datafusion/expr/src/logical_plan/builder.rs
index d5bc64c40..1c3b813f7 100644
--- a/datafusion/expr/src/logical_plan/builder.rs
+++ b/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,
diff --git a/datafusion/sql/src/planner.rs b/datafusion/sql/src/planner.rs
index 86057aa62..ca3d20893 100644
--- a/datafusion/sql/src/planner.rs
+++ b/datafusion/sql/src/planner.rs
@@ -1966,7 +1966,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",