fix: clippy (#254)

Author: slvrtrn

examples/inserter.rs

@@ -151,7 +151,7 @@ async fn main() -> Result<()> {
 
     // Prints 10 batches with 100 rows in each.
     for (insertion_time, count) in fetch_batches(&client).await? {
-        println!("{}: {} rows", insertion_time, count);
+        println!("{insertion_time}: {count} rows");
     }
 
     client
@@ -166,7 +166,7 @@ async fn main() -> Result<()> {
 
     // Prints batches every 100±10ms.
     for (insertion_time, count) in fetch_batches(&client).await? {
-        println!("{}: {} rows", insertion_time, count);
+        println!("{insertion_time}: {count} rows");
     }
 
     Ok(())

examples/stream_arbitrary_format_rows.rs

@@ -28,6 +28,6 @@ async fn main() {
 
     while let Some(line) = lines.next_line().await.unwrap() {
         let value: serde_json::Value = serde_json::de::from_str(&line).unwrap();
-        println!("JSONEachRow value: {}", value);
+        println!("JSONEachRow value: {value}");
     }
 }

src/insert.rs

@@ -128,7 +128,7 @@ impl<T> Insert<T> {
 
         // TODO: what about escaping a table name?
         // https://clickhouse.com/docs/en/sql-reference/syntax#identifiers
-        let sql = format!("INSERT INTO {}({}) FORMAT RowBinary", table, fields);
+        let sql = format!("INSERT INTO {table}({fields}) FORMAT RowBinary");
 
         Ok(Self {
             state: InsertState::NotStarted {

src/row_metadata.rs

@@ -192,7 +192,7 @@ fn join_panic_schema_hint<T: Display>(col: &[T]) -> String {
         return String::default();
     }
     col.iter()
-        .map(|c| format!("- {}", c))
+        .map(|c| format!("- {c}"))
         .collect::<Vec<String>>()
         .join("\n")
 }

src/rowbinary/validation.rs

@@ -72,31 +72,27 @@ impl<'cursor, R: Row> DataTypeValidator<'cursor, R> {
             RowKind::Primitive => {
                 panic!(
                     "While processing row as a primitive: attempting to deserialize \
-                    ClickHouse type {} as {} which is not compatible",
-                    data_type, serde_type
+                    ClickHouse type {data_type} as {serde_type} which is not compatible"
                 )
             }
             RowKind::Vec => {
                 panic!(
                     "While processing row as a vector: attempting to deserialize \
-                    ClickHouse type {} as {} which is not compatible",
-                    data_type, serde_type
+                    ClickHouse type {data_type} as {serde_type} which is not compatible"
                 )
             }
             RowKind::Tuple => {
                 panic!(
                     "While processing row as a tuple: attempting to deserialize \
-                    ClickHouse type {} as {} which is not compatible",
-                    data_type, serde_type
+                    ClickHouse type {data_type} as {serde_type} which is not compatible"
                 )
             }
             RowKind::Struct => {
                 if is_inner {
                     let (full_name, full_data_type) = self.get_current_column_name_and_type();
                     panic!(
-                        "While processing column {} defined as {}: attempting to deserialize \
-                        nested ClickHouse type {} as {} which is not compatible",
-                        full_name, full_data_type, data_type, serde_type
+                        "While processing column {full_name} defined as {full_data_type}: attempting to deserialize \
+                        nested ClickHouse type {data_type} as {serde_type} which is not compatible"
                     )
                 } else {
                     panic!(
@@ -143,8 +139,7 @@ impl<'cursor, R: Row> SchemaValidator<R> for DataTypeValidator<'cursor, R> {
                     _ => {
                         // should be unreachable
                         panic!(
-                            "While processing tuple row: expected serde type Tuple(N), got {}",
-                            serde_type
+                            "While processing tuple row: expected serde type Tuple(N), got {serde_type}"
                         );
                     }
                 }
@@ -302,9 +297,8 @@ impl<'cursor, R: Row> SchemaValidator<R> for Option<InnerDataTypeValidator<'_, '
                         let (full_name, full_data_type) =
                             inner.root.get_current_column_name_and_type();
                         panic!(
-                            "While processing column {} defined as {}: \
-                                attempting to deserialize {} while no more elements are allowed",
-                            full_name, full_data_type, serde_type
+                            "While processing column {full_name} defined as {full_data_type}: \
+                                attempting to deserialize {serde_type} while no more elements are allowed"
                         )
                     }
                 }
@@ -320,9 +314,8 @@ impl<'cursor, R: Row> SchemaValidator<R> for Option<InnerDataTypeValidator<'_, '
                 } else {
                     let (full_name, full_data_type) = inner.root.get_current_column_name_and_type();
                     panic!(
-                        "While processing root tuple element {} defined as {}: \
-                             attempting to deserialize {} while no more elements are allowed",
-                        full_name, full_data_type, serde_type
+                        "While processing root tuple element {full_name} defined as {full_data_type}: \
+                             attempting to deserialize {serde_type} while no more elements are allowed"
                     )
                 }
             }
@@ -564,9 +557,8 @@ fn validate_impl<'de, 'cursor, R: Row>(
                 } else {
                     let (full_name, full_data_type) = root.get_current_column_name_and_type();
                     panic!(
-                        "While processing column {} defined as {}: attempting to deserialize \
-                        nested ClickHouse type {} as {}",
-                        full_name, full_data_type, data_type, serde_type,
+                        "While processing column {full_name} defined as {full_data_type}: attempting to deserialize \
+                        nested ClickHouse type {data_type} as {serde_type}",
                     )
                 }
             }
@@ -599,10 +591,7 @@ fn validate_impl<'de, 'cursor, R: Row>(
                     kind: InnerDataTypeValidatorKind::Map(kv, MapValidatorState::Key),
                 })
             } else {
-                panic!(
-                    "Expected Map for {} call, but got {}",
-                    serde_type, data_type
-                )
+                panic!("Expected Map for {serde_type} call, but got {data_type}",)
             }
         }
         SerdeType::Enum => {
@@ -615,10 +604,7 @@ fn validate_impl<'de, 'cursor, R: Row>(
                     ),
                 })
             } else {
-                panic!(
-                    "Expected Variant for {} call, but got {}",
-                    serde_type, data_type
-                )
+                panic!("Expected Variant for {serde_type} call, but got {data_type}")
             }
         }
 

src/sql/ser.rs

@@ -112,13 +112,13 @@ impl<'a, W: Write> Serializer for SqlSerializer<'a, W> {
 
     #[inline]
     fn serialize_i128(self, value: i128) -> Result {
-        write!(self.writer, "{}::Int128", value)?;
+        write!(self.writer, "{value}::Int128")?;
         Ok(())
     }
 
     #[inline]
     fn serialize_u128(self, value: u128) -> Result {
-        write!(self.writer, "{}::UInt128", value)?;
+        write!(self.writer, "{value}::UInt128")?;
         Ok(())
     }
 

tests/it/cloud_jwt.rs

@@ -22,7 +22,6 @@ async fn test_invalid_jwt_auth() {
     let err_msg = format!("{}", result.expect_err("result should be an error"));
     assert!(
         err_msg.contains("JWT decoding error: invalid token supplied"),
-        "err_msg = {}",
-        err_msg
+        "err_msg = {err_msg}"
     );
 }

tests/it/cursor_error.rs

@@ -12,8 +12,7 @@ async fn wait_end_of_query() {
         let result = max_execution_time(client.clone(), wait_end_of_query).await;
         assert_eq!(
             result, expected_rows,
-            "wait_end_of_query: {}, expected_rows: {}",
-            wait_end_of_query, expected_rows
+            "wait_end_of_query: {wait_end_of_query}, expected_rows: {expected_rows}"
         );
     }
 }

tests/it/fetch_bytes.rs

@@ -58,7 +58,7 @@ async fn error() {
         .unwrap();
 
     let err = bytes_cursor.next().await;
-    println!("{:?}", err);
+    println!("{err:?}");
     assert!(matches!(err, Err(Error::BadResponse(_))));
 }
 

tests/it/https_errors.rs

@@ -23,8 +23,7 @@ async fn test_https_error_on_missing_feature() {
     ] {
         assert!(
             result.contains(fragment),
-            "TLS error message should contain `{}`",
-            fragment
+            "TLS error message should contain `{fragment}`"
         );
     }
 }