Enable inefficient_to_string Clippy lint (apache#17583)

Enable `inefficient_to_string` Clippy lint and update the code. The code
changes were done by Clippy `--fix`.

The lint addresses a Rust's type system or stdlib limitation, which
results in `(&&String).to_string()` being a lot slower than
`(&String).to_string()` and `(*(&&String)).to_string()`. The difference
is 40% in my measurements on 10-character long strings. The difference
comes from the fact that the faster code paths are optimized for
`String` and the `&&` double reference somehow prevents the compiler
from taking such specialized code path.

Author: findepi

Cargo.toml

@@ -223,6 +223,7 @@ used_underscore_binding = "warn"
 or_fun_call = "warn"
 unnecessary_lazy_evaluations = "warn"
 uninlined_format_args = "warn"
+inefficient_to_string = "warn"
 
 [workspace.lints.rust]
 unexpected_cfgs = { level = "warn", check-cfg = [

datafusion-examples/examples/parquet_embedded_index.rs

@@ -321,7 +321,7 @@ fn write_file_with_index(path: &Path, values: &[&str]) -> Result<()> {
 
     // compute the distinct index
     let distinct_index: DistinctIndex =
-        DistinctIndex::new(values.iter().map(|s| s.to_string()));
+        DistinctIndex::new(values.iter().map(|s| (*s).to_string()));
 
     let file = File::create(path)?;
 

datafusion/catalog/src/information_schema.rs

@@ -492,7 +492,7 @@ impl SchemaProvider for InformationSchemaProvider {
     fn table_names(&self) -> Vec<String> {
         INFORMATION_SCHEMA_TABLES
             .iter()
-            .map(|t| t.to_string())
+            .map(|t| (*t).to_string())
             .collect()
     }
 

datafusion/common/src/error.rs

@@ -455,12 +455,13 @@ impl DataFusionError {
     /// If backtrace enabled then error has a format "message" [`Self::BACK_TRACE_SEP`] "backtrace"
     /// The method strips the backtrace and outputs "message"
     pub fn strip_backtrace(&self) -> String {
-        self.to_string()
+        (*self
+            .to_string()
             .split(Self::BACK_TRACE_SEP)
             .collect::<Vec<&str>>()
             .first()
-            .unwrap_or(&"")
-            .to_string()
+            .unwrap_or(&""))
+        .to_string()
     }
 
     /// To enable optional rust backtrace in DataFusion:

datafusion/core/src/dataframe/parquet.rs

@@ -205,7 +205,7 @@ mod tests {
             &HashMap::from_iter(
                 [("datafusion.execution.batch_size", "10")]
                     .iter()
-                    .map(|(s1, s2)| (s1.to_string(), s2.to_string())),
+                    .map(|(s1, s2)| ((*s1).to_string(), (*s2).to_string())),
             ),
         )?);
         register_aggregate_csv(&ctx, "aggregate_test_100").await?;

datafusion/core/tests/fuzz_cases/aggregate_fuzz.rs

@@ -337,7 +337,7 @@ async fn run_aggregate_test(input1: Vec<RecordBatch>, group_by_columns: Vec<&str
         ];
     let expr = group_by_columns
         .iter()
-        .map(|elem| (col(elem, &schema).unwrap(), elem.to_string()))
+        .map(|elem| (col(elem, &schema).unwrap(), (*elem).to_string()))
         .collect::<Vec<_>>();
     let group_by = PhysicalGroupBy::new_single(expr);
 

datafusion/core/tests/fuzz_cases/aggregation_fuzzer/mod.rs

@@ -77,8 +77,8 @@ pub(crate) fn check_equality_of_batches(
         if lhs_row != rhs_row {
             return Err(InconsistentResult {
                 row_idx,
-                lhs_row: lhs_row.to_string(),
-                rhs_row: rhs_row.to_string(),
+                lhs_row: (*lhs_row).to_string(),
+                rhs_row: (*rhs_row).to_string(),
             });
         }
     }

datafusion/core/tests/fuzz_cases/equivalence/projection.rs

@@ -73,7 +73,7 @@ fn project_orderings_random() -> Result<()> {
             for proj_exprs in proj_exprs.iter().combinations(n_req) {
                 let proj_exprs = proj_exprs
                     .into_iter()
-                    .map(|(expr, name)| (Arc::clone(expr), name.to_string()))
+                    .map(|(expr, name)| (Arc::clone(expr), (*name).to_string()))
                     .collect::<Vec<_>>();
                 let (projected_batch, projected_eq) = apply_projection(
                     proj_exprs.clone(),
@@ -147,7 +147,7 @@ fn ordering_satisfy_after_projection_random() -> Result<()> {
             for proj_exprs in proj_exprs.iter().combinations(n_req) {
                 let proj_exprs = proj_exprs
                     .into_iter()
-                    .map(|(expr, name)| (Arc::clone(expr), name.to_string()));
+                    .map(|(expr, name)| (Arc::clone(expr), (*name).to_string()));
                 let (projected_batch, projected_eq) = apply_projection(
                     proj_exprs.clone(),
                     &table_data_with_properties,

datafusion/core/tests/fuzz_cases/sort_fuzz.rs

@@ -188,7 +188,7 @@ impl SortTest {
     }
 
     fn with_sort_columns(mut self, sort_columns: Vec<&str>) -> Self {
-        self.sort_columns = sort_columns.iter().map(|s| s.to_string()).collect();
+        self.sort_columns = sort_columns.iter().map(|s| (*s).to_string()).collect();
         self
     }
 

datafusion/core/tests/fuzz_cases/topk_filter_pushdown.rs

@@ -297,7 +297,7 @@ async fn test_fuzz_topk_filter_pushdown() {
                         order_vec.push(ordering);
                     }
                     None => {
-                        orders.insert(order_column.to_string(), vec![ordering]);
+                        orders.insert((*order_column).to_string(), vec![ordering]);
                     }
                 }
             }