clippy

ahmed-mez · ahmed-mez · commit 1b331721c235 · 2025-11-21T13:13:47.000+01:00
diff --git a/src/common/ttl_map.rs b/src/common/ttl_map.rs
@@ -409,7 +409,7 @@ mod tests {
             }
             tokio::time::sleep(Duration::from_millis(10)).await;
         }
-        panic!("Assertion failed within {:?}", timeout);
+        panic!("Assertion failed within {timeout:?}");
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 8)]
@@ -543,9 +543,9 @@ mod tests {
         let elapsed = start_time.elapsed();
 
         println!("\n=== TTLMap Lock Contention Benchmark ===");
-        println!("Tasks: {}", task_count);
-        println!("Total time: {:.2?}", elapsed);
-        println!("Average latency: {:.2} ns per operation", avg_time);
+        println!("Tasks: {task_count}");
+        println!("Total time: {elapsed:.2?}");
+        println!("Average latency: {avg_time:.2} ns per operation");
         println!("Entries remaining: {}", ttl_map.data.len());
         println!(
             "DashMap Lock contention time: {}ms",
diff --git a/src/execution_plans/network_shuffle.rs b/src/execution_plans/network_shuffle.rs
@@ -112,6 +112,7 @@ use tonic::metadata::MetadataMap;
 /// 2. Ready: runs within a distributed stage and queries the next input stage over the network
 ///    using Arrow Flight.
 #[derive(Debug, Clone)]
+#[allow(clippy::large_enum_variant)]
 pub enum NetworkShuffleExec {
     Pending(NetworkShufflePendingExec),
     Ready(NetworkShuffleReadyExec),
diff --git a/src/execution_plans/partition_isolator.rs b/src/execution_plans/partition_isolator.rs
@@ -50,6 +50,7 @@ use std::{fmt::Formatter, sync::Arc};
 /// └───────────────────────────┘  └───────────────────────────┘ └───────────────────────────┘     ■
 /// ```
 #[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
 pub enum PartitionIsolatorExec {
     Pending(PartitionIsolatorPendingExec),
     Ready(PartitionIsolatorReadyExec),
@@ -223,7 +224,7 @@ impl ExecutionPlan for PartitionIsolatorExec {
         // then look up that index in our group and execute that partition, in this
         // example partition 8
 
-        let output_stream = match partition_group.get(partition) {
+        match partition_group.get(partition) {
             Some(actual_partition_number) => {
                 if *actual_partition_number >= input_partitions {
                     //trace!("{} returning empty stream", ctx_name);
@@ -239,8 +240,7 @@ impl ExecutionPlan for PartitionIsolatorExec {
                 Box::pin(EmptyRecordBatchStream::new(self_ready.input.schema()))
                     as SendableRecordBatchStream,
             ),
-        };
-        output_stream
+        }
     }
 }
 
diff --git a/src/metrics/metrics_collecting_stream.rs b/src/metrics/metrics_collecting_stream.rs
@@ -47,7 +47,7 @@ where
 
         let metadata =
             FlightAppMetadata::decode(flight_data.app_metadata.as_ref()).map_err(|e| {
-                FlightError::ProtocolError(format!("failed to decode app_metadata: {}", e))
+                FlightError::ProtocolError(format!("failed to decode app_metadata: {e}"))
             })?;
 
         let Some(content) = metadata.content else {
diff --git a/src/metrics/proto.rs b/src/metrics/proto.rs
@@ -440,38 +440,33 @@ mod tests {
         let roundtrip_count = roundtrip_metrics_set.iter().count();
         assert_eq!(
             original_count, roundtrip_count,
-            "roundtrip should preserve metrics count for {}",
-            test_name
+            "roundtrip should preserve metrics count for {test_name}"
         );
 
         // Verify equivalence of each metric.
         for (original, roundtrip) in metrics_set.iter().zip(roundtrip_metrics_set.iter()) {
             assert_eq!(
                 original.partition(),
                 roundtrip.partition(),
-                "partition mismatch in {}",
-                test_name
+                "partition mismatch in {test_name}"
             );
 
             assert_eq!(
                 original.labels().len(),
                 roundtrip.labels().len(),
-                "label count mismatch in {}",
-                test_name
+                "label count mismatch in {test_name}"
             );
 
             for (orig_label, rt_label) in original.labels().iter().zip(roundtrip.labels().iter()) {
                 assert_eq!(
                     orig_label.name(),
                     rt_label.name(),
-                    "label name mismatch in {}",
-                    test_name
+                    "label name mismatch in {test_name}"
                 );
                 assert_eq!(
                     orig_label.value(),
                     rt_label.value(),
-                    "label value mismatch in {}",
-                    test_name
+                    "label value mismatch in {test_name}"
                 );
             }
 
diff --git a/src/protobuf/errors/arrow_error.rs b/src/protobuf/errors/arrow_error.rs
@@ -207,10 +207,7 @@ mod tests {
     fn test_arrow_error_roundtrip() {
         let test_cases = vec![
             ArrowError::NotYetImplemented("test not implemented".to_string()),
-            ArrowError::ExternalError(Box::new(std::io::Error::new(
-                ErrorKind::Other,
-                "external error",
-            ))),
+            ArrowError::ExternalError(Box::new(std::io::Error::other("external error"))),
             ArrowError::CastError("cast error".to_string()),
             ArrowError::MemoryError("memory error".to_string()),
             ArrowError::ParseError("parse error".to_string()),
@@ -242,8 +239,8 @@ mod tests {
             let (recovered_error, recovered_ctx) = proto.to_arrow_error();
 
             if original_error.to_string() != recovered_error.to_string() {
-                println!("original error: {}", original_error);
-                println!("recovered error: {}", recovered_error);
+                println!("original error: {original_error}");
+                println!("recovered error: {recovered_error}");
             }
 
             assert_eq!(original_error.to_string(), recovered_error.to_string());
diff --git a/src/protobuf/errors/datafusion_error.rs b/src/protobuf/errors/datafusion_error.rs
@@ -313,7 +313,7 @@ mod tests {
             ),
             DataFusionError::Execution("execution error".to_string()),
             DataFusionError::ResourcesExhausted("resources exhausted".to_string()),
-            DataFusionError::External(Box::new(std::io::Error::new(ErrorKind::Other, "external"))),
+            DataFusionError::External(Box::new(std::io::Error::other("external"))),
             DataFusionError::Context(
                 "context message".to_string(),
                 Box::new(DataFusionError::Internal("nested".to_string())),
diff --git a/src/protobuf/errors/objectstore_error.rs b/src/protobuf/errors/objectstore_error.rs
@@ -267,7 +267,7 @@ mod tests {
             // Use known store names that will be preserved
             ObjectStoreError::Generic {
                 store: "S3",
-                source: Box::new(std::io::Error::new(ErrorKind::Other, "generic error")),
+                source: Box::new(std::io::Error::other("generic error")),
             },
             ObjectStoreError::NotFound {
                 path: "test/path".to_string(),
@@ -279,14 +279,14 @@ mod tests {
             },
             ObjectStoreError::Precondition {
                 path: "precondition/path".to_string(),
-                source: Box::new(std::io::Error::new(ErrorKind::Other, "precondition failed")),
+                source: Box::new(std::io::Error::other("precondition failed")),
             },
             ObjectStoreError::NotSupported {
                 source: Box::new(std::io::Error::new(ErrorKind::Unsupported, "not supported")),
             },
             ObjectStoreError::NotModified {
                 path: "not/modified".to_string(),
-                source: Box::new(std::io::Error::new(ErrorKind::Other, "not modified")),
+                source: Box::new(std::io::Error::other("not modified")),
             },
             ObjectStoreError::NotImplemented,
             ObjectStoreError::PermissionDenied {
@@ -298,7 +298,7 @@ mod tests {
             },
             ObjectStoreError::Unauthenticated {
                 path: "auth/path".to_string(),
-                source: Box::new(std::io::Error::new(ErrorKind::Other, "unauthenticated")),
+                source: Box::new(std::io::Error::other("unauthenticated")),
             },
             ObjectStoreError::UnknownConfigurationKey {
                 key: "unknown_key".to_string(),
diff --git a/src/protobuf/errors/parquet_error.rs b/src/protobuf/errors/parquet_error.rs
@@ -104,10 +104,7 @@ mod tests {
             ParquetError::EOF("end of file".to_string()),
             ParquetError::ArrowError("arrow error".to_string()),
             ParquetError::IndexOutOfBound(42, 100),
-            ParquetError::External(Box::new(std::io::Error::new(
-                std::io::ErrorKind::Other,
-                "external error",
-            ))),
+            ParquetError::External(Box::new(std::io::Error::other("external error"))),
             ParquetError::NeedMoreData(1024),
         ];
 
diff --git a/src/stage.rs b/src/stage.rs
@@ -343,10 +343,9 @@ pub fn display_plan_graphviz(plan: Arc<dyn ExecutionPlan>) -> Result<String> {
         f,
         "digraph G {{
   rankdir=BT
-  edge[colorscheme={}, penwidth=2.0]
+  edge[colorscheme={COLOR_SCHEME}, penwidth=2.0]
   splines=false
-",
-        COLOR_SCHEME
+"
     )?;
 
     if plan.as_any().is::<DistributedExec>() {
@@ -367,7 +366,7 @@ pub fn display_plan_graphviz(plan: Arc<dyn ExecutionPlan>) -> Result<String> {
         for stage in &all_stages {
             for i in 0..stage.tasks.iter().len() {
                 let p = display_single_task(stage, i)?;
-                writeln!(f, "{}", p)?;
+                writeln!(f, "{p}")?;
             }
         }
         // now draw edges between the tasks
@@ -390,7 +389,7 @@ pub fn display_plan_graphviz(plan: Arc<dyn ExecutionPlan>) -> Result<String> {
         // single plan, not a stage tree
         writeln!(f, "node[shape=none]")?;
         let p = display_plan(&plan, 0, 1, 0)?;
-        writeln!(f, "{}", p)?;
+        writeln!(f, "{p}")?;
     }
 
     writeln!(f, "}}")?;
@@ -457,7 +456,7 @@ fn display_plan(
     while let Some(plan) = queue.pop_front() {
         node_index += 1;
         let p = display_single_plan(plan.as_ref(), stage_num, task_i, node_index)?;
-        writeln!(f, "{}", p)?;
+        writeln!(f, "{p}")?;
 
         if plan.is_network_boundary() {
             continue;
@@ -605,7 +604,7 @@ pub fn display_single_plan(
     )?;
 
     for i in 0..output_partitions {
-        writeln!(f, "                        <TD PORT='t{}'></TD>", i)?;
+        writeln!(f, "                        <TD PORT='t{i}'></TD>")?;
     }
 
     writeln!(
@@ -631,7 +630,7 @@ pub fn display_single_plan(
     )?;
 
     for i in 0..input_partitions {
-        writeln!(f, "                        <TD PORT='b{}'></TD>", i)?;
+        writeln!(f, "                        <TD PORT='b{i}'></TD>")?;
     }
 
     writeln!(
diff --git a/src/test_utils/session_context.rs b/src/test_utils/session_context.rs
@@ -32,7 +32,7 @@ pub async fn register_temp_parquet_table(
 
     let temp_dir = std::env::temp_dir();
     let file_id = Uuid::new_v4();
-    let temp_file_path = temp_dir.join(format!("{}_{}.parquet", table_name, file_id,));
+    let temp_file_path = temp_dir.join(format!("{table_name}_{file_id}.parquet",));
 
     let file = std::fs::File::create(&temp_file_path)?;
     let schema = batches[0].schema();
diff --git a/src/test_utils/tpch.rs b/src/test_utils/tpch.rs
@@ -21,7 +21,7 @@ use tpchgen_arrow::{
 pub fn tpch_query_from_dir(queries_dir: &std::path::Path, num: u8) -> String {
     let query_path = queries_dir.join(format!("q{num}.sql"));
     fs::read_to_string(query_path)
-        .unwrap_or_else(|_| panic!("Failed to read TPCH query file: q{}.sql", num))
+        .unwrap_or_else(|_| panic!("Failed to read TPCH query file: q{num}.sql"))
         .trim()
         .to_string()
 }
@@ -137,7 +137,7 @@ fn generate_table<A>(
 where
     A: Iterator<Item = RecordBatch>,
 {
-    let output_path = data_dir.join(format!("{}.parquet", table_name));
+    let output_path = data_dir.join(format!("{table_name}.parquet"));
 
     if let Some(first_batch) = data_source.next() {
         let file = fs::File::create(&output_path)?;
diff --git a/tests/distributed_aggregation.rs b/tests/distributed_aggregation.rs
@@ -236,8 +236,8 @@ mod tests {
 +----------+--------+-----+";
 
         // Print them out, the error message from `assert_eq` is otherwise hard to read.
-        println!("{}", expected_result);
-        println!("{}", actual_result);
+        println!("{expected_result}");
+        println!("{actual_result}");
 
         // Compare against result. The regression this is testing for would have NULL values in
         // the second and third column.

Original file line number	Diff line number	Diff line change
`@@ -409,7 +409,7 @@ mod tests {`
`409`	`409`	`}`
`410`	`410`	`tokio::time::sleep(Duration::from_millis(10)).await;`
`411`	`411`	`}`
`412`		`- panic!("Assertion failed within {:?}", timeout);`
	`412`	`+ panic!("Assertion failed within {timeout:?}");`
`413`	`413`	`}`
`414`	`414`
`415`	`415`	`#[tokio::test(flavor = "multi_thread", worker_threads = 8)]`
`@@ -543,9 +543,9 @@ mod tests {`
`543`	`543`	`let elapsed = start_time.elapsed();`
`544`	`544`
`545`	`545`	`println!("\n=== TTLMap Lock Contention Benchmark ===");`
`546`		`- println!("Tasks: {}", task_count);`
`547`		`- println!("Total time: {:.2?}", elapsed);`
`548`		`- println!("Average latency: {:.2} ns per operation", avg_time);`
	`546`	`+ println!("Tasks: {task_count}");`
	`547`	`+ println!("Total time: {elapsed:.2?}");`
	`548`	`+ println!("Average latency: {avg_time:.2} ns per operation");`
`549`	`549`	`println!("Entries remaining: {}", ttl_map.data.len());`
`550`	`550`	`println!(`
`551`	`551`	`"DashMap Lock contention time: {}ms",`