Fix clippy::uninlined_format_args warnings

mlafeldt · Maxxen · commit d69a5b62bd4d · 2025-06-19T13:00:15.000+02:00
diff --git a/crates/duckdb-loadable-macros/src/lib.rs b/crates/duckdb-loadable-macros/src/lib.rs
@@ -58,10 +58,10 @@ pub fn duckdb_entrypoint_c_api(attr: TokenStream, item: TokenStream) -> TokenStr
 
     match ast {
         Item::Fn(func) => {
-            let c_entrypoint = Ident::new(format!("{}_init_c_api", extension_name).as_str(), Span::call_site());
+            let c_entrypoint = Ident::new(format!("{extension_name}_init_c_api").as_str(), Span::call_site());
             let prefixed_original_function = func.sig.ident.clone();
             let c_entrypoint_internal = Ident::new(
-                format!("{}_init_c_api_internal", extension_name).as_str(),
+                format!("{extension_name}_init_c_api_internal").as_str(),
                 Span::call_site(),
             );
 
@@ -132,7 +132,7 @@ pub fn duckdb_entrypoint(_attr: TokenStream, item: TokenStream) -> TokenStream {
             );
 
             let original_funcname = func.sig.ident.to_string();
-            func.sig.ident = Ident::new(format!("_{}", original_funcname).as_str(), func.sig.ident.span());
+            func.sig.ident = Ident::new(format!("_{original_funcname}").as_str(), func.sig.ident.span());
 
             let prefixed_original_function = func.sig.ident.clone();
 
diff --git a/crates/duckdb/src/appender/mod.rs b/crates/duckdb/src/appender/mod.rs
@@ -303,7 +303,7 @@ mod test {
             Err(crate::Error::DuckDBFailure(.., Some(msg))) => {
                 assert_eq!(msg, "Call to EndRow before all columns have been appended to!")
             }
-            Err(err) => panic!("unexpected error: {:?}", err),
+            Err(err) => panic!("unexpected error: {err:?}"),
             Ok(_) => panic!("expected an error but got Ok"),
         }
         Ok(())
diff --git a/crates/duckdb/src/raw_statement.rs b/crates/duckdb/src/raw_statement.rs
@@ -183,7 +183,7 @@ impl RawStatement {
                 // Therefore, we return None when encountering this error.
                 match err {
                     polars::error::PolarsError::ComputeError(_) => return None,
-                    _ => panic!("Failed to import arrow2 Array from C: {}", err),
+                    _ => panic!("Failed to import arrow2 Array from C: {err}"),
                 }
             }
 
diff --git a/crates/duckdb/src/test_all_types.rs b/crates/duckdb/src/test_all_types.rs
@@ -30,7 +30,7 @@ fn test_with_database(database: &Connection) -> crate::Result<()> {
         "SELECT * EXCLUDE ({}) FROM test_all_types()",
         excluded
             .iter()
-            .map(|s| format!("'{}'", s))
+            .map(|s| format!("'{s}'"))
             .collect::<Vec<String>>()
             .join(",")
     ))?;
diff --git a/crates/duckdb/src/vscalar/mod.rs b/crates/duckdb/src/vscalar/mod.rs
@@ -182,7 +182,7 @@ mod test {
         ) -> Result<(), Box<dyn std::error::Error>> {
             let mut msg = input.flat_vector(0).as_slice_with_len::<duckdb_string_t>(input.len())[0];
             let string = DuckString::new(&mut msg).as_str();
-            Err(format!("Error: {}", string).into())
+            Err(format!("Error: {string}").into())
         }
 
         fn signatures() -> Vec<ScalarFunctionSignature> {
diff --git a/crates/duckdb/src/vtab/arrow.rs b/crates/duckdb/src/vtab/arrow.rs
@@ -161,7 +161,7 @@ pub fn to_duckdb_type_id(data_type: &DataType) -> Result<LogicalTypeId, Box<dyn
         DataType::Decimal256(_, _) => Double,
         DataType::Map(_, _) => Map,
         _ => {
-            return Err(format!("Unsupported data type: {:?}", data_type).into());
+            return Err(format!("Unsupported data type: {data_type:?}").into());
         }
     };
     Ok(type_id)
@@ -636,8 +636,7 @@ pub fn write_arrow_array_to_vector(
         }
         dt => {
             return Err(format!(
-                "column with data_type {} is not supported yet, please file an issue https://github.com/duckdb/duckdb-rs",
-                dt
+                "column with data_type {dt} is not supported yet, please file an issue https://github.com/duckdb/duckdb-rs"
             )
             .into());
         }
@@ -858,7 +857,7 @@ fn decimal_array_to_vector(array: &Decimal128Array, out: &mut FlatVector, width:
             }
         }
         // This should never happen, arrow only supports 1-38 decimal digits
-        _ => panic!("Invalid decimal width: {}", width),
+        _ => panic!("Invalid decimal width: {width}"),
     }
 
     // Set nulls
@@ -1995,7 +1994,7 @@ mod test {
         check_map_array_roundtrip(map_array)?;
 
         // Test 2 - large MapArray of 4000 elements to test buffers capacity adjustment
-        let keys: Vec<String> = (0..4000).map(|i| format!("key-{}", i)).collect();
+        let keys: Vec<String> = (0..4000).map(|i| format!("key-{i}")).collect();
         let values_data = UInt32Array::from(
             (0..4000)
                 .map(|i| if i % 5 == 0 { None } else { Some(i as u32) })
diff --git a/crates/duckdb/src/vtab/excel.rs b/crates/duckdb/src/vtab/excel.rs
@@ -35,7 +35,7 @@ impl VTab for ExcelVTab {
         let mut workbook = open_workbook_auto(path)?;
         let range = workbook
             .worksheet_range(&sheet)
-            .unwrap_or_else(|| panic!("Can't find sheet: {} ?", sheet))?;
+            .unwrap_or_else(|| panic!("Can't find sheet: {sheet} ?"))?;
         let _column_count = range.get_size().1;
         let mut rows = range.rows();
         let header = rows.next().unwrap();
@@ -62,39 +62,39 @@ impl VTab for ExcelVTab {
                         bind.add_result_column(
                             header[idx]
                                 .get_string()
-                                .unwrap_or_else(|| panic!("idx {} header empty?", idx)),
+                                .unwrap_or_else(|| panic!("idx {idx} header empty?")),
                             LogicalTypeHandle::from(LogicalTypeId::Varchar),
                         );
                     }
                     DataType::Float(_) => {
                         bind.add_result_column(
                             header[idx]
                                 .get_string()
-                                .unwrap_or_else(|| panic!("idx {} header empty?", idx)),
+                                .unwrap_or_else(|| panic!("idx {idx} header empty?")),
                             LogicalTypeHandle::from(LogicalTypeId::Double),
                         );
                     }
                     DataType::Int(_) => {
                         bind.add_result_column(
                             header[idx]
                                 .get_string()
-                                .unwrap_or_else(|| panic!("idx {} header empty?", idx)),
+                                .unwrap_or_else(|| panic!("idx {idx} header empty?")),
                             LogicalTypeHandle::from(LogicalTypeId::Bigint),
                         );
                     }
                     DataType::Bool(_) => {
                         bind.add_result_column(
                             header[idx]
                                 .get_string()
-                                .unwrap_or_else(|| panic!("idx {} header empty?", idx)),
+                                .unwrap_or_else(|| panic!("idx {idx} header empty?")),
                             LogicalTypeHandle::from(LogicalTypeId::Boolean),
                         );
                     }
                     DataType::DateTime(_) => {
                         bind.add_result_column(
                             header[idx]
                                 .get_string()
-                                .unwrap_or_else(|| panic!("idx {} header empty?", idx)),
+                                .unwrap_or_else(|| panic!("idx {idx} header empty?")),
                             LogicalTypeHandle::from(LogicalTypeId::Date),
                         );
                     }
diff --git a/crates/duckdb/src/vtab/function.rs b/crates/duckdb/src/vtab/function.rs
@@ -74,7 +74,7 @@ impl BindInfo {
         unsafe {
             let ptr = duckdb_bind_get_parameter(self.ptr, param_index);
             if ptr.is_null() {
-                panic!("{} is out of range for function definition", param_index);
+                panic!("{param_index} is out of range for function definition");
             } else {
                 Value::from(ptr)
             }

Original file line number	Diff line number	Diff line change
`@@ -303,7 +303,7 @@ mod test {`
`303`	`303`	`Err(crate::Error::DuckDBFailure(.., Some(msg))) => {`
`304`	`304`	`assert_eq!(msg, "Call to EndRow before all columns have been appended to!")`
`305`	`305`	`}`
`306`		`- Err(err) => panic!("unexpected error: {:?}", err),`
	`306`	`+ Err(err) => panic!("unexpected error: {err:?}"),`
`307`	`307`	`Ok(_) => panic!("expected an error but got Ok"),`
`308`	`308`	`}`
`309`	`309`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -183,7 +183,7 @@ impl RawStatement {`
`183`	`183`	`// Therefore, we return None when encountering this error.`
`184`	`184`	`match err {`
`185`	`185`	`polars::error::PolarsError::ComputeError(_) => return None,`
`186`		`- _ => panic!("Failed to import arrow2 Array from C: {}", err),`
	`186`	`+ _ => panic!("Failed to import arrow2 Array from C: {err}"),`
`187`	`187`	`}`
`188`	`188`	`}`
`189`	`189`
Original file line number	Diff line number	Diff line change
`@@ -182,7 +182,7 @@ mod test {`
`182`	`182`	`) -> Result<(), Box<dyn std::error::Error>> {`
`183`	`183`	`let mut msg = input.flat_vector(0).as_slice_with_len::<duckdb_string_t>(input.len())[0];`
`184`	`184`	`let string = DuckString::new(&mut msg).as_str();`
`185`		`- Err(format!("Error: {}", string).into())`
	`185`	`+ Err(format!("Error: {string}").into())`
`186`	`186`	`}`
`187`	`187`
`188`	`188`	`fn signatures() -> Vec<ScalarFunctionSignature> {`
Original file line number	Diff line number	Diff line change
`@@ -161,7 +161,7 @@ pub fn to_duckdb_type_id(data_type: &DataType) -> Result<LogicalTypeId, Box<dyn`
`161`	`161`	`DataType::Decimal256(_, _) => Double,`
`162`	`162`	`DataType::Map(_, _) => Map,`
`163`	`163`	`_ => {`
`164`		`- return Err(format!("Unsupported data type: {:?}", data_type).into());`
	`164`	`+ return Err(format!("Unsupported data type: {data_type:?}").into());`
`165`	`165`	`}`
`166`	`166`	`};`
`167`	`167`	`Ok(type_id)`
`@@ -636,8 +636,7 @@ pub fn write_arrow_array_to_vector(`
`636`	`636`	`}`
`637`	`637`	`dt => {`
`638`	`638`	`return Err(format!(`
`639`		`- "column with data_type {} is not supported yet, please file an issue https://github.com/duckdb/duckdb-rs",`
`640`		`- dt`
	`639`	`+ "column with data_type {dt} is not supported yet, please file an issue https://github.com/duckdb/duckdb-rs"`
`641`	`640`	`)`
`642`	`641`	`.into());`
`643`	`642`	`}`
`@@ -858,7 +857,7 @@ fn decimal_array_to_vector(array: &Decimal128Array, out: &mut FlatVector, width:`
`858`	`857`	`}`
`859`	`858`	`}`
`860`	`859`	`// This should never happen, arrow only supports 1-38 decimal digits`
`861`		`- _ => panic!("Invalid decimal width: {}", width),`
	`860`	`+ _ => panic!("Invalid decimal width: {width}"),`
`862`	`861`	`}`
`863`	`862`
`864`	`863`	`// Set nulls`
`@@ -1995,7 +1994,7 @@ mod test {`
`1995`	`1994`	`check_map_array_roundtrip(map_array)?;`
`1996`	`1995`
`1997`	`1996`	`// Test 2 - large MapArray of 4000 elements to test buffers capacity adjustment`
`1998`		`- let keys: Vec<String> = (0..4000).map(\|i\| format!("key-{}", i)).collect();`
	`1997`	`+ let keys: Vec<String> = (0..4000).map(\|i\| format!("key-{i}")).collect();`
`1999`	`1998`	`let values_data = UInt32Array::from(`
`2000`	`1999`	`(0..4000)`
`2001`	`2000`	`.map(\|i\| if i % 5 == 0 { None } else { Some(i as u32) })`
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ impl BindInfo {`
`74`	`74`	`unsafe {`
`75`	`75`	`let ptr = duckdb_bind_get_parameter(self.ptr, param_index);`
`76`	`76`	`if ptr.is_null() {`
`77`		`- panic!("{} is out of range for function definition", param_index);`
	`77`	`+ panic!("{param_index} is out of range for function definition");`
`78`	`78`	`} else {`
`79`	`79`	`Value::from(ptr)`
`80`	`80`	`}`