diff --git a/datafusion/core/benches/sql_planner.rs b/datafusion/core/benches/sql_planner.rs
index ecdd59d8b2492..f949f30b912a9 100644
--- a/datafusion/core/benches/sql_planner.rs
+++ b/datafusion/core/benches/sql_planner.rs
@@ -38,7 +38,7 @@ fn plan(ctx: Arc<Mutex<SessionContext>>, sql: &str) {
 /// Create schema representing a large table
 pub fn create_schema(column_prefix: &str) -> Schema {
     let fields = (0..200)
-        .map(|i| Field::new(&format!("{}{}", column_prefix, i), DataType::Int32, true))
+        .map(|i| Field::new(format!("{}{}", column_prefix, i), DataType::Int32, true))
         .collect();
     Schema::new(fields)
 }
diff --git a/datafusion/core/src/avro_to_arrow/schema.rs b/datafusion/core/src/avro_to_arrow/schema.rs
index c71db3c15612b..b50816f52f967 100644
--- a/datafusion/core/src/avro_to_arrow/schema.rs
+++ b/datafusion/core/src/avro_to_arrow/schema.rs
@@ -131,7 +131,7 @@ fn schema_to_field_with_props(
         }
         AvroSchema::Enum { symbols, name, .. } => {
             return Ok(Field::new_dict(
-                &name.fullname(None),
+                name.fullname(None),
                 index_type(symbols.len()),
                 false,
                 0,
diff --git a/datafusion/core/src/physical_plan/file_format/mod.rs b/datafusion/core/src/physical_plan/file_format/mod.rs
index bcdc3221ddafa..7eb9730c92acc 100644
--- a/datafusion/core/src/physical_plan/file_format/mod.rs
+++ b/datafusion/core/src/physical_plan/file_format/mod.rs
@@ -523,17 +523,14 @@ impl From<ObjectMeta> for FileMeta {
 pub(crate) fn get_output_ordering(
     base_config: &FileScanConfig,
 ) -> Option<&[PhysicalSortExpr]> {
-    if let Some(output_ordering) = base_config.output_ordering.as_ref() {
-        if base_config.file_groups.iter().any(|group| group.len() > 1) {
+    base_config.output_ordering.as_ref()
+        .map(|output_ordering| if base_config.file_groups.iter().any(|group| group.len() > 1) {
             debug!("Skipping specified output ordering {:?}. Some file group had more than one file: {:?}",
                    output_ordering, base_config.file_groups);
             None
         } else {
-            Some(output_ordering)
-        }
-    } else {
-        None
-    }
+            Some(output_ordering.as_slice())
+        }).unwrap_or_else(|| None)
 }
 
 #[cfg(test)]
diff --git a/datafusion/core/src/physical_plan/udaf.rs b/datafusion/core/src/physical_plan/udaf.rs
index 659ff560d140c..2b9ab65e694e3 100644
--- a/datafusion/core/src/physical_plan/udaf.rs
+++ b/datafusion/core/src/physical_plan/udaf.rs
@@ -80,7 +80,7 @@ impl AggregateExpr for AggregateFunctionExpr {
             .enumerate()
             .map(|(i, data_type)| {
                 Field::new(
-                    &format_state_name(&self.name, &format!("{}", i)),
+                    format_state_name(&self.name, &format!("{}", i)),
                     data_type.clone(),
                     true,
                 )
diff --git a/datafusion/expr/src/field_util.rs b/datafusion/expr/src/field_util.rs
index 629f3952d86e4..94efeda806483 100644
--- a/datafusion/expr/src/field_util.rs
+++ b/datafusion/expr/src/field_util.rs
@@ -28,7 +28,7 @@ use datafusion_common::{DataFusionError, Result, ScalarValue};
 pub fn get_indexed_field(data_type: &DataType, key: &ScalarValue) -> Result<Field> {
     match (data_type, key) {
         (DataType::List(lt), ScalarValue::Int64(Some(i))) => {
-            Ok(Field::new(&i.to_string(), lt.data_type().clone(), true))
+            Ok(Field::new(i.to_string(), lt.data_type().clone(), true))
         }
         (DataType::Struct(fields), ScalarValue::Utf8(Some(s))) => {
             if s.is_empty() {
diff --git a/datafusion/optimizer/src/push_down_filter.rs b/datafusion/optimizer/src/push_down_filter.rs
index fc2a2d84ad361..2bcb60a6b2ce4 100644
--- a/datafusion/optimizer/src/push_down_filter.rs
+++ b/datafusion/optimizer/src/push_down_filter.rs
@@ -635,7 +635,7 @@ impl OptimizerRule for PushDownFilter {
                 let group_expr_columns = agg
                     .group_expr
                     .iter()
-                    .map(|e| Ok(Column::from_qualified_name(&(e.display_name()?))))
+                    .map(|e| Ok(Column::from_qualified_name(e.display_name()?)))
                     .collect::<Result<HashSet<_>>>()?;
 
                 let predicates = utils::split_conjunction_owned(utils::cnf_rewrite(
diff --git a/datafusion/optimizer/src/single_distinct_to_groupby.rs b/datafusion/optimizer/src/single_distinct_to_groupby.rs
index e4878bd16441a..2230033f041f1 100644
--- a/datafusion/optimizer/src/single_distinct_to_groupby.rs
+++ b/datafusion/optimizer/src/single_distinct_to_groupby.rs
@@ -174,7 +174,7 @@ impl OptimizerRule for SingleDistinctToGroupBy {
                     let mut alias_expr: Vec<Expr> = Vec::new();
                     for (alias, original_field) in group_expr_alias {
                         alias_expr
-                            .push(col(&alias).alias(original_field.qualified_name()));
+                            .push(col(alias).alias(original_field.qualified_name()));
                     }
                     for (i, expr) in new_aggr_exprs.iter().enumerate() {
                         alias_expr.push(columnize_expr(
diff --git a/datafusion/physical-expr/src/aggregate/approx_distinct.rs b/datafusion/physical-expr/src/aggregate/approx_distinct.rs
index 698f619a97318..e327f39076d92 100644
--- a/datafusion/physical-expr/src/aggregate/approx_distinct.rs
+++ b/datafusion/physical-expr/src/aggregate/approx_distinct.rs
@@ -73,7 +73,7 @@ impl AggregateExpr for ApproxDistinct {
 
     fn state_fields(&self) -> Result<Vec<Field>> {
         Ok(vec![Field::new(
-            &format_state_name(&self.name, "hll_registers"),
+            format_state_name(&self.name, "hll_registers"),
             DataType::Binary,
             false,
         )])
diff --git a/datafusion/physical-expr/src/aggregate/approx_percentile_cont.rs b/datafusion/physical-expr/src/aggregate/approx_percentile_cont.rs
index 006688a669881..b768c07256fb4 100644
--- a/datafusion/physical-expr/src/aggregate/approx_percentile_cont.rs
+++ b/datafusion/physical-expr/src/aggregate/approx_percentile_cont.rs
@@ -188,32 +188,32 @@ impl AggregateExpr for ApproxPercentileCont {
     fn state_fields(&self) -> Result<Vec<Field>> {
         Ok(vec![
             Field::new(
-                &format_state_name(&self.name, "max_size"),
+                format_state_name(&self.name, "max_size"),
                 DataType::UInt64,
                 false,
             ),
             Field::new(
-                &format_state_name(&self.name, "sum"),
+                format_state_name(&self.name, "sum"),
                 DataType::Float64,
                 false,
             ),
             Field::new(
-                &format_state_name(&self.name, "count"),
+                format_state_name(&self.name, "count"),
                 DataType::Float64,
                 false,
             ),
             Field::new(
-                &format_state_name(&self.name, "max"),
+                format_state_name(&self.name, "max"),
                 DataType::Float64,
                 false,
             ),
             Field::new(
-                &format_state_name(&self.name, "min"),
+                format_state_name(&self.name, "min"),
                 DataType::Float64,
                 false,
             ),
             Field::new(
-                &format_state_name(&self.name, "centroids"),
+                format_state_name(&self.name, "centroids"),
                 DataType::List(Box::new(Field::new("item", DataType::Float64, true))),
                 false,
             ),
diff --git a/datafusion/physical-expr/src/aggregate/array_agg.rs b/datafusion/physical-expr/src/aggregate/array_agg.rs
index e436789ee6e4d..e68603ae9bf88 100644
--- a/datafusion/physical-expr/src/aggregate/array_agg.rs
+++ b/datafusion/physical-expr/src/aggregate/array_agg.rs
@@ -75,7 +75,7 @@ impl AggregateExpr for ArrayAgg {
 
     fn state_fields(&self) -> Result<Vec<Field>> {
         Ok(vec![Field::new(
-            &format_state_name(&self.name, "array_agg"),
+            format_state_name(&self.name, "array_agg"),
             DataType::List(Box::new(Field::new(
                 "item",
                 self.input_data_type.clone(),
diff --git a/datafusion/physical-expr/src/aggregate/array_agg_distinct.rs b/datafusion/physical-expr/src/aggregate/array_agg_distinct.rs
index a9dd3fe350f8d..29a9ed7182053 100644
--- a/datafusion/physical-expr/src/aggregate/array_agg_distinct.rs
+++ b/datafusion/physical-expr/src/aggregate/array_agg_distinct.rs
@@ -84,7 +84,7 @@ impl AggregateExpr for DistinctArrayAgg {
 
     fn state_fields(&self) -> Result<Vec<Field>> {
         Ok(vec![Field::new(
-            &format_state_name(&self.name, "distinct_array_agg"),
+            format_state_name(&self.name, "distinct_array_agg"),
             DataType::List(Box::new(Field::new(
                 "item",
                 self.input_data_type.clone(),
diff --git a/datafusion/physical-expr/src/aggregate/average.rs b/datafusion/physical-expr/src/aggregate/average.rs
index 2d2ee5a871789..afb0791f213cb 100644
--- a/datafusion/physical-expr/src/aggregate/average.rs
+++ b/datafusion/physical-expr/src/aggregate/average.rs
@@ -84,12 +84,12 @@ impl AggregateExpr for Avg {
     fn state_fields(&self) -> Result<Vec<Field>> {
         Ok(vec![
             Field::new(
-                &format_state_name(&self.name, "count"),
+                format_state_name(&self.name, "count"),
                 DataType::UInt64,
                 true,
             ),
             Field::new(
-                &format_state_name(&self.name, "sum"),
+                format_state_name(&self.name, "sum"),
                 self.data_type.clone(),
                 true,
             ),
diff --git a/datafusion/physical-expr/src/aggregate/correlation.rs b/datafusion/physical-expr/src/aggregate/correlation.rs
index 55389e1997e41..6211c578f447d 100644
--- a/datafusion/physical-expr/src/aggregate/correlation.rs
+++ b/datafusion/physical-expr/src/aggregate/correlation.rs
@@ -72,32 +72,32 @@ impl AggregateExpr for Correlation {
     fn state_fields(&self) -> Result<Vec<Field>> {
         Ok(vec![
             Field::new(
-                &format_state_name(&self.name, "count"),
+                format_state_name(&self.name, "count"),
                 DataType::UInt64,
                 true,
             ),
             Field::new(
-                &format_state_name(&self.name, "mean1"),
+                format_state_name(&self.name, "mean1"),
                 DataType::Float64,
                 true,
             ),
             Field::new(
-                &format_state_name(&self.name, "m2_1"),
+                format_state_name(&self.name, "m2_1"),
                 DataType::Float64,
                 true,
             ),
             Field::new(
-                &format_state_name(&self.name, "mean2"),
+                format_state_name(&self.name, "mean2"),
                 DataType::Float64,
                 true,
             ),
             Field::new(
-                &format_state_name(&self.name, "m2_2"),
+                format_state_name(&self.name, "m2_2"),
                 DataType::Float64,
                 true,
             ),
             Field::new(
-                &format_state_name(&self.name, "algo_const"),
+                format_state_name(&self.name, "algo_const"),
                 DataType::Float64,
                 true,
             ),
diff --git a/datafusion/physical-expr/src/aggregate/count.rs b/datafusion/physical-expr/src/aggregate/count.rs
index 1f8e03e55cd5d..d8dd6b9b30f12 100644
--- a/datafusion/physical-expr/src/aggregate/count.rs
+++ b/datafusion/physical-expr/src/aggregate/count.rs
@@ -76,7 +76,7 @@ impl AggregateExpr for Count {
 
     fn state_fields(&self) -> Result<Vec<Field>> {
         Ok(vec![Field::new(
-            &format_state_name(&self.name, "count"),
+            format_state_name(&self.name, "count"),
             self.data_type.clone(),
             true,
         )])
diff --git a/datafusion/physical-expr/src/aggregate/count_distinct.rs b/datafusion/physical-expr/src/aggregate/count_distinct.rs
index 06966f7127539..2a2c7e940cd30 100644
--- a/datafusion/physical-expr/src/aggregate/count_distinct.rs
+++ b/datafusion/physical-expr/src/aggregate/count_distinct.rs
@@ -81,7 +81,7 @@ impl AggregateExpr for DistinctCount {
             .iter()
             .map(|state_data_type| {
                 Field::new(
-                    &format_state_name(&self.name, "count distinct"),
+                    format_state_name(&self.name, "count distinct"),
                     DataType::List(Box::new(Field::new(
                         "item",
                         state_data_type.clone(),
diff --git a/datafusion/physical-expr/src/aggregate/covariance.rs b/datafusion/physical-expr/src/aggregate/covariance.rs
index 74a8b3c797fa3..3963ba64357e7 100644
--- a/datafusion/physical-expr/src/aggregate/covariance.rs
+++ b/datafusion/physical-expr/src/aggregate/covariance.rs
@@ -86,22 +86,22 @@ impl AggregateExpr for Covariance {
     fn state_fields(&self) -> Result<Vec<Field>> {
         Ok(vec![
             Field::new(
-                &format_state_name(&self.name, "count"),
+                format_state_name(&self.name, "count"),
                 DataType::UInt64,
                 true,
             ),
             Field::new(
-                &format_state_name(&self.name, "mean1"),
+                format_state_name(&self.name, "mean1"),
                 DataType::Float64,
                 true,
             ),
             Field::new(
-                &format_state_name(&self.name, "mean2"),
+                format_state_name(&self.name, "mean2"),
                 DataType::Float64,
                 true,
             ),
             Field::new(
-                &format_state_name(&self.name, "algo_const"),
+                format_state_name(&self.name, "algo_const"),
                 DataType::Float64,
                 true,
             ),
@@ -154,22 +154,22 @@ impl AggregateExpr for CovariancePop {
     fn state_fields(&self) -> Result<Vec<Field>> {
         Ok(vec![
             Field::new(
-                &format_state_name(&self.name, "count"),
+                format_state_name(&self.name, "count"),
                 DataType::UInt64,
                 true,
             ),
             Field::new(
-                &format_state_name(&self.name, "mean1"),
+                format_state_name(&self.name, "mean1"),
                 DataType::Float64,
                 true,
             ),
             Field::new(
-                &format_state_name(&self.name, "mean2"),
+                format_state_name(&self.name, "mean2"),
                 DataType::Float64,
                 true,
             ),
             Field::new(
-                &format_state_name(&self.name, "algo_const"),
+                format_state_name(&self.name, "algo_const"),
                 DataType::Float64,
                 true,
             ),
diff --git a/datafusion/physical-expr/src/aggregate/grouping.rs b/datafusion/physical-expr/src/aggregate/grouping.rs
index 4c704b2138f45..9ddd17c035e84 100644
--- a/datafusion/physical-expr/src/aggregate/grouping.rs
+++ b/datafusion/physical-expr/src/aggregate/grouping.rs
@@ -70,7 +70,7 @@ impl AggregateExpr for Grouping {
 
     fn state_fields(&self) -> Result<Vec<Field>> {
         Ok(vec![Field::new(
-            &format_state_name(&self.name, "grouping"),
+            format_state_name(&self.name, "grouping"),
             self.data_type.clone(),
             true,
         )])
diff --git a/datafusion/physical-expr/src/aggregate/median.rs b/datafusion/physical-expr/src/aggregate/median.rs
index f2c56515c0957..2e2675ce62cf5 100644
--- a/datafusion/physical-expr/src/aggregate/median.rs
+++ b/datafusion/physical-expr/src/aggregate/median.rs
@@ -75,7 +75,7 @@ impl AggregateExpr for Median {
         let data_type = DataType::List(Box::new(field));
 
         Ok(vec![Field::new(
-            &format_state_name(&self.name, "median"),
+            format_state_name(&self.name, "median"),
             data_type,
             true,
         )])
diff --git a/datafusion/physical-expr/src/aggregate/min_max.rs b/datafusion/physical-expr/src/aggregate/min_max.rs
index 5762dead76d77..da67071243ca0 100644
--- a/datafusion/physical-expr/src/aggregate/min_max.rs
+++ b/datafusion/physical-expr/src/aggregate/min_max.rs
@@ -98,7 +98,7 @@ impl AggregateExpr for Max {
 
     fn state_fields(&self) -> Result<Vec<Field>> {
         Ok(vec![Field::new(
-            &format_state_name(&self.name, "max"),
+            format_state_name(&self.name, "max"),
             self.data_type.clone(),
             true,
         )])
@@ -664,7 +664,7 @@ impl AggregateExpr for Min {
 
     fn state_fields(&self) -> Result<Vec<Field>> {
         Ok(vec![Field::new(
-            &format_state_name(&self.name, "min"),
+            format_state_name(&self.name, "min"),
             self.data_type.clone(),
             true,
         )])
diff --git a/datafusion/physical-expr/src/aggregate/stddev.rs b/datafusion/physical-expr/src/aggregate/stddev.rs
index 18a69478b46b8..05dc56cff2c6f 100644
--- a/datafusion/physical-expr/src/aggregate/stddev.rs
+++ b/datafusion/physical-expr/src/aggregate/stddev.rs
@@ -76,20 +76,16 @@ impl AggregateExpr for Stddev {
     fn state_fields(&self) -> Result<Vec<Field>> {
         Ok(vec![
             Field::new(
-                &format_state_name(&self.name, "count"),
+                format_state_name(&self.name, "count"),
                 DataType::UInt64,
                 true,
             ),
             Field::new(
-                &format_state_name(&self.name, "mean"),
-                DataType::Float64,
-                true,
-            ),
-            Field::new(
-                &format_state_name(&self.name, "m2"),
+                format_state_name(&self.name, "mean"),
                 DataType::Float64,
                 true,
             ),
+            Field::new(format_state_name(&self.name, "m2"), DataType::Float64, true),
         ])
     }
 
@@ -135,20 +131,16 @@ impl AggregateExpr for StddevPop {
     fn state_fields(&self) -> Result<Vec<Field>> {
         Ok(vec![
             Field::new(
-                &format_state_name(&self.name, "count"),
+                format_state_name(&self.name, "count"),
                 DataType::UInt64,
                 true,
             ),
             Field::new(
-                &format_state_name(&self.name, "mean"),
-                DataType::Float64,
-                true,
-            ),
-            Field::new(
-                &format_state_name(&self.name, "m2"),
+                format_state_name(&self.name, "mean"),
                 DataType::Float64,
                 true,
             ),
+            Field::new(format_state_name(&self.name, "m2"), DataType::Float64, true),
         ])
     }
 
diff --git a/datafusion/physical-expr/src/aggregate/sum.rs b/datafusion/physical-expr/src/aggregate/sum.rs
index e72f48ca355a7..f40c85a39f273 100644
--- a/datafusion/physical-expr/src/aggregate/sum.rs
+++ b/datafusion/physical-expr/src/aggregate/sum.rs
@@ -87,12 +87,12 @@ impl AggregateExpr for Sum {
     fn state_fields(&self) -> Result<Vec<Field>> {
         Ok(vec![
             Field::new(
-                &format_state_name(&self.name, "sum"),
+                format_state_name(&self.name, "sum"),
                 self.data_type.clone(),
                 self.nullable,
             ),
             Field::new(
-                &format_state_name(&self.name, "count"),
+                format_state_name(&self.name, "count"),
                 DataType::UInt64,
                 self.nullable,
             ),
diff --git a/datafusion/physical-expr/src/aggregate/sum_distinct.rs b/datafusion/physical-expr/src/aggregate/sum_distinct.rs
index b9f8759b68595..e9e220e5f10ff 100644
--- a/datafusion/physical-expr/src/aggregate/sum_distinct.rs
+++ b/datafusion/physical-expr/src/aggregate/sum_distinct.rs
@@ -68,7 +68,7 @@ impl AggregateExpr for DistinctSum {
     fn state_fields(&self) -> Result<Vec<Field>> {
         // State field is a List which stores items to rebuild hash set.
         Ok(vec![Field::new(
-            &format_state_name(&self.name, "sum distinct"),
+            format_state_name(&self.name, "sum distinct"),
             DataType::List(Box::new(Field::new("item", self.data_type.clone(), true))),
             false,
         )])
diff --git a/datafusion/physical-expr/src/aggregate/tdigest.rs b/datafusion/physical-expr/src/aggregate/tdigest.rs
index c25566077e003..73fe8788a6994 100644
--- a/datafusion/physical-expr/src/aggregate/tdigest.rs
+++ b/datafusion/physical-expr/src/aggregate/tdigest.rs
@@ -152,8 +152,8 @@ impl TDigest {
             max_size,
             sum: 0_f64,
             count: 0_f64,
-            max: std::f64::NAN,
-            min: std::f64::NAN,
+            max: f64::NAN,
+            min: f64::NAN,
         }
     }
 
@@ -202,8 +202,8 @@ impl Default for TDigest {
             max_size: 100,
             sum: 0_f64,
             count: 0_f64,
-            max: std::f64::NAN,
-            min: std::f64::NAN,
+            max: f64::NAN,
+            min: f64::NAN,
         }
     }
 }
@@ -220,13 +220,10 @@ impl TDigest {
     }
 
     fn clamp(v: f64, lo: f64, hi: f64) -> f64 {
-        if v > hi {
-            hi
-        } else if v < lo {
-            lo
-        } else {
-            v
+        if lo.is_nan() && hi.is_nan() {
+            return v;
         }
+        v.clamp(lo, hi)
     }
 
     #[cfg(test)]
@@ -382,8 +379,8 @@ impl TDigest {
         let mut starts: Vec<usize> = Vec::with_capacity(digests.len());
 
         let mut count: f64 = 0.0;
-        let mut min = std::f64::INFINITY;
-        let mut max = std::f64::NEG_INFINITY;
+        let mut min = f64::INFINITY;
+        let mut max = f64::NEG_INFINITY;
 
         let mut start: usize = 0;
         for digest in digests.iter() {
diff --git a/datafusion/physical-expr/src/aggregate/variance.rs b/datafusion/physical-expr/src/aggregate/variance.rs
index 512166385b9d5..d1ccea7e1d7a5 100644
--- a/datafusion/physical-expr/src/aggregate/variance.rs
+++ b/datafusion/physical-expr/src/aggregate/variance.rs
@@ -82,20 +82,16 @@ impl AggregateExpr for Variance {
     fn state_fields(&self) -> Result<Vec<Field>> {
         Ok(vec![
             Field::new(
-                &format_state_name(&self.name, "count"),
+                format_state_name(&self.name, "count"),
                 DataType::UInt64,
                 true,
             ),
             Field::new(
-                &format_state_name(&self.name, "mean"),
-                DataType::Float64,
-                true,
-            ),
-            Field::new(
-                &format_state_name(&self.name, "m2"),
+                format_state_name(&self.name, "mean"),
                 DataType::Float64,
                 true,
             ),
+            Field::new(format_state_name(&self.name, "m2"), DataType::Float64, true),
         ])
     }
 
@@ -143,20 +139,16 @@ impl AggregateExpr for VariancePop {
     fn state_fields(&self) -> Result<Vec<Field>> {
         Ok(vec![
             Field::new(
-                &format_state_name(&self.name, "count"),
+                format_state_name(&self.name, "count"),
                 DataType::UInt64,
                 true,
             ),
             Field::new(
-                &format_state_name(&self.name, "mean"),
-                DataType::Float64,
-                true,
-            ),
-            Field::new(
-                &format_state_name(&self.name, "m2"),
+                format_state_name(&self.name, "mean"),
                 DataType::Float64,
                 true,
             ),
+            Field::new(format_state_name(&self.name, "m2"), DataType::Float64, true),
         ])
     }
 
diff --git a/datafusion/physical-expr/src/type_coercion.rs b/datafusion/physical-expr/src/type_coercion.rs
index dca6ad0862fea..7b8d2c40a1cef 100644
--- a/datafusion/physical-expr/src/type_coercion.rs
+++ b/datafusion/physical-expr/src/type_coercion.rs
@@ -78,7 +78,7 @@ mod tests {
             Schema::new(
                 t.iter()
                     .enumerate()
-                    .map(|(i, t)| Field::new(&format!("c{}", i), t.clone(), true))
+                    .map(|(i, t)| Field::new(format!("c{}", i), t.clone(), true))
                     .collect(),
             )
         };
diff --git a/datafusion/sql/src/planner.rs b/datafusion/sql/src/planner.rs
index 13a4fb0a704fa..58c7229bca041 100644
--- a/datafusion/sql/src/planner.rs
+++ b/datafusion/sql/src/planner.rs
@@ -690,7 +690,7 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
                 .iter()
                 .any(|x| x.option == ColumnOption::Null);
             fields.push(Field::new(
-                &normalize_ident(column.name),
+                normalize_ident(column.name),
                 data_type,
                 allow_null,
             ));