Apache DataFusion SQL Query Engine
Enable more clippy lints (#24466)
Emil Ernerfeldtf75c5032af76
diff --git a/Cargo.toml b/Cargo.tomlindex 65bc0bcd20..f9b2cac5c5 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -213,123 +213,126 @@ zstd = { version = "0.13", default-features = false }# See https://github.com/apache/datafusion/issues/18467 for the ongoing effort of# picking useful non-default lints.[workspace.lints.clippy]+all = { level = "warn", priority = -1 }+pedantic = { level = "warn", priority = -1 }+# https://github.com/apache/datafusion/issues/18881allow_attributes = "warn"as_ptr_cast_mut = "warn"-assigning_clones = "warn"-bool_to_int_with_if = "warn"branches_sharing_code = "warn"-checked_conversions = "warn"clear_with_drain = "warn"coerce_container_to_any = "warn"debug_assert_with_mut_call = "warn"-decimal_bitwise_operands = "warn"default_union_representation = "warn"doc_include_without_cfg = "warn"-duration_suboptimal_units = "warn"-elidable_lifetime_names = "warn"empty_enum_variants_with_brackets = "warn"-empty_enums = "warn"equatable_if_let = "warn"exit = "warn"-expl_impl_clone_on_copy = "warn"-explicit_deref_methods = "warn"-filter_map_next = "warn"-flat_map_option = "warn"-fn_params_excessive_bools = "warn"fn_to_numeric_cast_any = "warn"-ignore_without_reason = "warn"imprecise_flops = "warn"-inconsistent_struct_constructor = "warn"-index_refutable_slice = "warn"-inefficient_to_string = "warn"infinite_loop = "warn"-into_iter_without_iter = "warn"-invalid_upcast_comparisons = "warn"-ip_constant = "warn"-iter_filter_is_ok = "warn"-iter_filter_is_some = "warn"-iter_not_returning_iterator = "warn"iter_on_empty_collections = "warn"iter_on_single_items = "warn"-iter_without_into_iter = "warn"-# Detects large stack-allocated futures that may cause stack overflow crashes (see threshold in clippy.toml)-large_futures = "warn"large_include_file = "warn"-# Like `large_futures`, these guard against stack overflows-large_stack_arrays = "warn"+# Guards against stack overflowslarge_stack_frames = "warn"-large_types_passed_by_value = "warn"-linkedlist = "warn"# Catches `"{foo}"` where the string is never actually formattedliteral_string_with_formatting_args = "warn"-macro_use_imports = "warn"-manual_assert = "warn"-manual_ilog2 = "warn"-manual_instant_elapsed = "warn"-manual_is_power_of_two = "warn"-manual_is_variant_and = "warn"-# `(a + b) / 2` can overflow; `a.midpoint(b)` cannot-manual_midpoint = "warn"-match_wild_err_arm = "warn"mem_forget = "warn"-mismatching_type_param_order = "warn"-mut_mut = "warn"-# https://github.com/apache/datafusion/issues/18503-needless_pass_by_value = "warn"needless_type_cast = "warn"negative_feature_names = "warn"-# Prefer `std::sync::LazyLock` over the `lazy_static`/`once_cell` crates-non_std_lazy_statics = "warn"non_zero_suggestions = "warn"nonstandard_macro_braces = "warn"-option_as_ref_cloned = "warn"-option_option = "warn"or_fun_call = "warn"path_buf_push_overwrite = "warn"pathbuf_init_then_push = "warn"precedence_bits = "warn"-ptr_cast_constness = "warn"-pub_underscore_fields = "warn"pub_without_shorthand = "warn"rc_mutex = "warn"-ref_as_ptr = "warn"-ref_option_ref = "warn"rest_pat_in_fully_bound_structs = "warn"-# Catches copy-paste bugs in `if`/`else if` chains-same_functions_in_if_condition = "warn"-same_length_and_capacity = "warn"-# Catches a `&self` argument that is only threaded through recursive calls-self_only_used_in_recursion = "warn"# Avoids hashing the key twiceset_contains_or_insert = "warn"single_option_map = "warn"-str_split_at_newline = "warn"-string_add_assign = "warn"string_lit_as_bytes = "warn"string_lit_chars_any = "warn"suspicious_xor_used_as_pow = "warn"trailing_empty_array = "warn"trait_duplication_in_bounds = "warn"-transmute_ptr_to_ptr = "warn"-# Subtracting `Instant`s panics on overflow; use `saturating_duration_since`-unchecked_time_subtraction = "warn"uninhabited_references = "warn"-uninlined_format_args = "warn"-unnecessary_box_returns = "warn"-# `{:?}` on a `Path` quotes and escapes it; `{}` on `.display()` does not-unnecessary_debug_formatting = "warn"-unnecessary_lazy_evaluations = "warn"unnecessary_safety_doc = "warn"unnecessary_self_imports = "warn"unnecessary_struct_initialization = "warn"-unused_async = "warn"unused_peekable = "warn"unused_rounding = "warn"-used_underscore_binding = "warn"verbose_file_reads = "warn"wildcard_dependencies = "warn"-zero_sized_map_values = "warn"++# Pedantic lints we opt out of, with the number of hits at the time we enabled `pedantic`.+# Some of these we should consider enabling.+borrow_as_ptr = "allow" # 6 hits+case_sensitive_file_extension_comparisons = "allow" # 1 hit+cast_lossless = "allow" # 361 hits+cast_possible_truncation = "allow" # 911 hits+cast_possible_wrap = "allow" # 493 hits+cast_precision_loss = "allow" # 266 hits+cast_ptr_alignment = "allow" # 5 hits+cast_sign_loss = "allow" # 440 hits+cloned_instead_of_copied = "allow" # 38 hits+default_trait_access = "allow" # 221 hits+doc_comment_double_space_linebreaks = "allow" # 6 hits+doc_link_with_quotes = "allow" # 25 hits+doc_markdown = "allow" # 4933 hits; needs a long `doc-valid-idents` list in `clippy.toml`+enum_glob_use = "allow" # 98 hits+explicit_into_iter_loop = "allow" # 55 hits+explicit_iter_loop = "allow" # 189 hits+float_cmp = "allow" # 8 hits; exact float comparisons are often intentional here+format_collect = "allow" # 4 hits+format_push_string = "allow" # 34 hits+from_iter_instead_of_collect = "allow" # 51 hits+if_not_else = "allow" # 133 hits+ignored_unit_patterns = "allow" # 52 hits+implicit_clone = "allow" # 198 hits+implicit_hasher = "allow" # 17 hits+inline_always = "allow" # 45 hits+items_after_statements = "allow" # 171 hits+large_digit_groups = "allow" # 3 hits+manual_string_new = "allow" # 84 hits+many_single_char_names = "allow" # 12 hits; short names are idiomatic in the numeric kernels+map_unwrap_or = "allow" # 198 hits+match_bool = "allow" # 46 hits+match_same_arms = "allow" # 261 hits+match_wildcard_for_single_variants = "allow" # 132 hits+missing_errors_doc = "allow" # 1807 hits+missing_fields_in_debug = "allow" # 29 hits+missing_panics_doc = "allow" # 244 hits+must_use_candidate = "allow" # 2726 hits+needless_bitwise_bool = "allow" # 1 hit+needless_continue = "allow" # 37 hits+needless_raw_string_hashes = "allow" # 540 hits+no_effect_underscore_binding = "allow" # 1 hit+ptr_as_ptr = "allow" # 83 hits+redundant_closure_for_method_calls = "allow" # 686 hits+redundant_else = "allow" # 48 hits+ref_option = "allow" # 36 hits+return_self_not_must_use = "allow" # 644 hits+semicolon_if_nothing_returned = "allow" # 1353 hits+similar_names = "allow" # 228 hits; too many false positives, e.g. `expr`/`exprs`+single_char_pattern = "allow" # 23 hits+single_match_else = "allow" # 155 hits+struct_excessive_bools = "allow" # 24 hits+struct_field_names = "allow" # 14 hits+too_many_lines = "allow" # 484 hits+trivially_copy_pass_by_ref = "allow" # 74 hits+unicode_not_nfc = "allow" # 2 hits+unnecessary_literal_bound = "allow" # 471 hits+unnecessary_semicolon = "allow" # 185 hits+unnecessary_trailing_comma = "allow" # 49 hits+unnecessary_wraps = "allow" # 427 hits+unnested_or_patterns = "allow" # 68 hits+unreadable_literal = "allow" # 502 hits+unused_self = "allow" # 69 hits+used_underscore_items = "allow" # 28 hits+wildcard_imports = "allow" # 48 hits; `use crate::prelude::*` is idiomatic[workspace.lints.rust]unexpected_cfgs = { level = "warn", check-cfg = [diff --git a/benchmarks/src/sort_pushdown.rs b/benchmarks/src/sort_pushdown.rsindex 77f889e702..3c7bf7d4fa 100644--- a/benchmarks/src/sort_pushdown.rs+++ b/benchmarks/src/sort_pushdown.rs@@ -122,7 +122,7 @@ impl RunOpt {}}}- ids.sort();+ ids.sort_unstable();ids}diff --git a/benchmarks/src/sql_benchmark_runner.rs b/benchmarks/src/sql_benchmark_runner.rsindex b321881fbf..550c1d383f 100644--- a/benchmarks/src/sql_benchmark_runner.rs+++ b/benchmarks/src/sql_benchmark_runner.rs@@ -238,9 +238,9 @@ pub async fn load_benchmark_definitions_for_query(}pub fn sort_benchmarks(benchmarks: &mut BTreeMap<String, Vec<SqlBenchmark>>) {- benchmarks- .values_mut()- .for_each(|benchmarks| benchmarks.sort_by(|a, b| a.name().cmp(b.name())));+ for benchmarks in benchmarks.values_mut() {+ benchmarks.sort_by(|a, b| a.name().cmp(b.name()));+ }}/// Applies benchmark, subgroup, and query filters to discovered benchmark groups.diff --git a/datafusion-cli/src/helper.rs b/datafusion-cli/src/helper.rsindex db3e80efad..e1e26701a2 100644--- a/datafusion-cli/src/helper.rs+++ b/datafusion-cli/src/helper.rs@@ -75,14 +75,11 @@ impl CliHelper {fn validate_input(&self, input: &str) -> Result<ValidationResult> {if let Some(sql) = input.strip_suffix(';') {- let dialect = match dialect_from_str(self.dialect) {- Some(dialect) => dialect,- None => {- return Ok(ValidationResult::Invalid(Some(format!(- " 🤔 Invalid dialect: {}",- self.dialect- ))));- }+ let Some(dialect) = dialect_from_str(self.dialect) else {+ return Ok(ValidationResult::Invalid(Some(format!(+ " 🤔 Invalid dialect: {}",+ self.dialect+ ))));};let lines = split_from_semicolon(sql);for line in lines {diff --git a/datafusion-examples/examples/data_io/json_shredding.rs b/datafusion-examples/examples/data_io/json_shredding.rsindex 72fbb56773..79023d5581 100644--- a/datafusion-examples/examples/data_io/json_shredding.rs+++ b/datafusion-examples/examples/data_io/json_shredding.rs@@ -223,13 +223,10 @@ impl ScalarUDFImpl for JsonGetStr {args.args.len() == 2,"json_get_str requires exactly 2 arguments");- let key = match &args.args[0] {- ColumnarValue::Scalar(ScalarValue::Utf8(Some(key))) => key,- _ => {- return Err(exec_datafusion_err!(- "json_get_str first argument must be a string"- ));- }+ let ColumnarValue::Scalar(ScalarValue::Utf8(Some(key))) = &args.args[0] else {+ return Err(exec_datafusion_err!(+ "json_get_str first argument must be a string"+ ));};// We expect a string array that contains JSON stringslet json_array = match &args.args[1] {diff --git a/datafusion-examples/examples/data_io/parquet_exec_visitor.rs b/datafusion-examples/examples/data_io/parquet_exec_visitor.rsindex d1951b2d99..ca93f37c22 100644--- a/datafusion-examples/examples/data_io/parquet_exec_visitor.rs+++ b/datafusion-examples/examples/data_io/parquet_exec_visitor.rs@@ -110,9 +110,8 @@ impl ExecutionPlanVisitor for ParquetExecVisitor {{self.file_groups = Some(file_config.file_groups.clone());- let metrics = match data_source_exec.metrics() {- None => return Ok(true),- Some(metrics) => metrics,+ let Some(metrics) = data_source_exec.metrics() else {+ return Ok(true);};self.bytes_scanned = metrics.sum_by_name("bytes_scanned");}diff --git a/datafusion/common/src/dfschema.rs b/datafusion/common/src/dfschema.rsindex 262f1dcf61..690cf99c1c 100644--- a/datafusion/common/src/dfschema.rs+++ b/datafusion/common/src/dfschema.rs@@ -1340,9 +1340,8 @@ impl SchemaExt for Schema {/// `format!("{q}.{name}")` when `qualifier` is `Some`, or just `name` when/// `None`. We avoid going through the `fmt` machinery for performance reasons.pub fn qualified_name(qualifier: Option<&TableReference>, name: &str) -> String {- let qualifier = match qualifier {- None => return name.to_string(),- Some(q) => q,+ let Some(qualifier) = qualifier else {+ return name.to_string();};let (first, second, third) = match qualifier {TableReference::Bare { table } => (table.as_ref(), None, None),diff --git a/datafusion/common/src/functional_dependencies.rs b/datafusion/common/src/functional_dependencies.rsindex 8b15c49c56..e8275aac2d 100644--- a/datafusion/common/src/functional_dependencies.rs+++ b/datafusion/common/src/functional_dependencies.rs@@ -541,7 +541,7 @@ pub fn get_target_functional_dependencies(}(!combined_target_indices.is_empty()).then_some({let mut result = combined_target_indices.into_iter().collect::<Vec<_>>();- result.sort();+ result.sort_unstable();result})}@@ -563,7 +563,7 @@ pub fn get_required_group_by_exprs_indices(}).collect::<Option<Vec<_>>>()?;- groupby_expr_indices.sort();+ groupby_expr_indices.sort_unstable();for FunctionalDependence {source_indices,target_indices,diff --git a/datafusion/common/src/hash_utils.rs b/datafusion/common/src/hash_utils.rsindex cfe5799968..e9ca02cd20 100644--- a/datafusion/common/src/hash_utils.rs+++ b/datafusion/common/src/hash_utils.rs@@ -214,14 +214,14 @@ fn hash_null<S: HashState>(multi_col: bool,) {if multi_col {- hashes_buffer.iter_mut().for_each(|hash| {+ for hash in hashes_buffer {// stable hash for null value*hash = combine_hashes(random_state.hash_one(1), *hash);- })+ }} else {- hashes_buffer.iter_mut().for_each(|hash| {+ for hash in hashes_buffer {*hash = random_state.hash_one(1);- })+ }}}diff --git a/datafusion/common/src/hash_utils/build_hasher.rs b/datafusion/common/src/hash_utils/build_hasher.rsindex 12258beb11..23ee6f12e3 100644--- a/datafusion/common/src/hash_utils/build_hasher.rs+++ b/datafusion/common/src/hash_utils/build_hasher.rs@@ -193,9 +193,9 @@ fn hash_null_with_hasher<S: BuildHasher>(let null_hash = hash_builder.hash_one(1);if multi_col {- hashes_buffer.iter_mut().for_each(|hash| {+ for hash in hashes_buffer {*hash = combine_hashes(null_hash, *hash);- })+ }} else {hashes_buffer.fill(null_hash);}diff --git a/datafusion/common/src/scalar/mod.rs b/datafusion/common/src/scalar/mod.rsindex a7397e3542..fb08ef2842 100644--- a/datafusion/common/src/scalar/mod.rs+++ b/datafusion/common/src/scalar/mod.rs@@ -8558,7 +8558,7 @@ mod tests {let array = array.downcast::<Int64Array>().unwrap();assert_eq!(array.into_iter().collect::<Vec<_>>(),- expected_values[i..i + 1]+ expected_values[i..=i]);}}diff --git a/datafusion/common/src/utils/mod.rs b/datafusion/common/src/utils/mod.rsindex 71bd87b54d..142d3cd8e2 100644--- a/datafusion/common/src/utils/mod.rs+++ b/datafusion/common/src/utils/mod.rs@@ -1032,7 +1032,7 @@ pub fn merge_and_order_indices<T: Borrow<usize>, S: Borrow<usize>>(.collect::<HashSet<_>>().into_iter().collect();- result.sort();+ result.sort_unstable();result}diff --git a/datafusion/core/src/bin/print_functions_docs.rs b/datafusion/core/src/bin/print_functions_docs.rsindex c4b5fc4ef6..da9399e99f 100644--- a/datafusion/core/src/bin/print_functions_docs.rs+++ b/datafusion/core/src/bin/print_functions_docs.rs@@ -136,9 +136,9 @@ fn print_docs(let names = get_names_and_aliases(&providers);// write out the list of function names and aliases- names.iter().for_each(|name| {+ for name in &names {let _ = writeln!(docs, "- [{name}](#{name})");- });+ }// write out each function and alias in the order of the sorted name listfor name in names {diff --git a/datafusion/core/src/execution/session_state.rs b/datafusion/core/src/execution/session_state.rsindex a9d6198f95..0c2e561cd4 100644--- a/datafusion/core/src/execution/session_state.rs+++ b/datafusion/core/src/execution/session_state.rs@@ -1723,21 +1723,21 @@ impl SessionStateBuilder {}if let Some(aggregate_functions) = aggregate_functions {- aggregate_functions.into_iter().for_each(|udaf| {+ for udaf in aggregate_functions {let existing_udf = state.register_udaf(udaf);if let Ok(Some(existing_udf)) = existing_udf {debug!("Overwrote an existing UDF: {}", existing_udf.name());}- });+ }}if let Some(window_functions) = window_functions {- window_functions.into_iter().for_each(|udwf| {+ for udwf in window_functions {let existing_udf = state.register_udwf(udwf);if let Ok(Some(existing_udf)) = existing_udf {debug!("Overwrote an existing UDF: {}", existing_udf.name());}- });+ }}if let Some(extension_types) = extension_types {diff --git a/datafusion/core/src/execution/session_state_defaults.rs b/datafusion/core/src/execution/session_state_defaults.rsindex 584879cb19..3b46ed2523 100644--- a/datafusion/core/src/execution/session_state_defaults.rs+++ b/datafusion/core/src/execution/session_state_defaults.rs@@ -195,9 +195,8 @@ impl SessionStateDefaults {) {let url = config.options().catalog.location.as_ref();let format = config.options().catalog.format.as_ref();- let (url, format) = match (url, format) {- (Some(url), Some(format)) => (url, format),- _ => return,+ let (Some(url), Some(format)) = (url, format) else {+ return;};let url = url.to_string();let format = format.to_string();@@ -211,13 +210,11 @@ impl SessionStateDefaults {let path = object_store::path::Path::parse(path).expect("Can't parse path");let store = ObjectStoreUrl::parse(authority.as_str()).expect("Invalid default catalog url");- let store = match runtime.object_store(store) {- Ok(store) => store,- _ => return,+ let Ok(store) = runtime.object_store(store) else {+ return;};- let factory = match table_factories.get(format.as_str()) {- Some(factory) => factory,- _ => return,+ let Some(factory) = table_factories.get(format.as_str()) else {+ return;};let schema = ListingSchemaProvider::new(authority,diff --git a/datafusion/core/src/physical_planner.rs b/datafusion/core/src/physical_planner.rsindex bd1c29aa6d..2792c9c7a6 100644--- a/datafusion/core/src/physical_planner.rs+++ b/datafusion/core/src/physical_planner.rs@@ -620,14 +620,11 @@ impl DefaultPhysicalPlanner {.await?;}- let plan = match maybe_plan {- Some(plan) => plan,- None => {- return plan_err!(- "No installed planner was able to plan TableScan for custom TableSource: {:?}",- scan.table_name- );- }+ let Some(plan) = maybe_plan else {+ return plan_err!(+ "No installed planner was able to plan TableScan for custom TableSource: {:?}",+ scan.table_name+ );};self.ensure_schema_matches(projected_schema, &plan, || {@@ -2056,7 +2053,9 @@ fn create_cube_physical_expr(for null_count in 1..=num_of_exprs {for null_idx in (0..num_of_exprs).combinations(null_count) {let mut next_group: Vec<bool> = vec![false; num_of_exprs];- null_idx.into_iter().for_each(|i| next_group[i] = true);+ for i in null_idx {+ next_group[i] = true;+ }groups.push(next_group);}}diff --git a/datafusion/core/tests/fuzz_cases/aggregate_fuzz.rs b/datafusion/core/tests/fuzz_cases/aggregate_fuzz.rsindex f9e7f2e10e..5efdfd0d45 100644--- a/datafusion/core/tests/fuzz_cases/aggregate_fuzz.rs+++ b/datafusion/core/tests/fuzz_cases/aggregate_fuzz.rs@@ -432,17 +432,17 @@ pub(crate) fn make_staggered_batches<const STREAM: bool>(let mut rng = StdRng::seed_from_u64(random_seed);let mut input123: Vec<(i64, i64, i64)> = vec![(0, 0, 0); len];let mut input4: Vec<i64> = vec![0; len];- input123.iter_mut().for_each(|v| {+ for v in &mut input123 {*v = (rng.random_range(0..n_distinct) as i64,rng.random_range(0..n_distinct) as i64,rng.random_range(0..n_distinct) as i64,)- });- input4.iter_mut().for_each(|v| {+ }+ for v in &mut input4 {*v = rng.random_range(0..n_distinct) as i64;- });- input123.sort();+ }+ input123.sort_unstable();let input1 = Int64Array::from_iter_values(input123.clone().into_iter().map(|k| k.0));let input2 = Int64Array::from_iter_values(input123.clone().into_iter().map(|k| k.1));let input3 = Int64Array::from_iter_values(input123.clone().into_iter().map(|k| k.2));diff --git a/datafusion/core/tests/fuzz_cases/join_fuzz.rs b/datafusion/core/tests/fuzz_cases/join_fuzz.rsindex fce6999fd0..4fc17f1ebd 100644--- a/datafusion/core/tests/fuzz_cases/join_fuzz.rs+++ b/datafusion/core/tests/fuzz_cases/join_fuzz.rs@@ -949,9 +949,13 @@ impl JoinFuzzTestCase {if join_tests.contains(&NljHj) && nlj_rows != hj_rows {println!("=============== HashJoinExec ==================");- hj_formatted_sorted.iter().for_each(|s| println!("{s}"));+ for s in &hj_formatted_sorted {+ println!("{s}");+ }println!("=============== NestedLoopJoinExec ==================");- nlj_formatted_sorted.iter().for_each(|s| println!("{s}"));+ for s in &nlj_formatted_sorted {+ println!("{s}");+ }Self::save_partitioned_batches_as_parquet(&nlj_collected,out_dir_name,@@ -966,9 +970,13 @@ impl JoinFuzzTestCase {if join_tests.contains(&HjSmj) && smj_rows != hj_rows {println!("=============== HashJoinExec ==================");- hj_formatted_sorted.iter().for_each(|s| println!("{s}"));+ for s in &hj_formatted_sorted {+ println!("{s}");+ }println!("=============== SortMergeJoinExec ==================");- smj_formatted_sorted.iter().for_each(|s| println!("{s}"));+ for s in &smj_formatted_sorted {+ println!("{s}");+ }Self::save_partitioned_batches_as_parquet(&hj_collected,@@ -1272,9 +1280,9 @@ fn make_staggered_batches_i32(len: usize, with_extra_column: bool) -> Vec<Recordlet mut input12: Vec<(i32, i32)> = vec![(0, 0); len];let mut input3: Vec<i32> = vec![0; len];let mut input4: Vec<i32> = vec![0; len];- input12- .iter_mut()- .for_each(|v| *v = (rng.random_range(0..100), rng.random_range(0..100)));+ for v in &mut input12 {+ *v = (rng.random_range(0..100), rng.random_range(0..100));+ }rng.fill(&mut input3[..]);rng.fill(&mut input4[..]);input12.sort_unstable();@@ -1503,7 +1511,7 @@ async fn pwmj_collect_ids(ids.extend((0..col.len()).map(|i| col.value(i)));}}- ids.sort();+ ids.sort_unstable();ids}diff --git a/datafusion/core/tests/fuzz_cases/sort_preserving_repartition_fuzz.rs b/datafusion/core/tests/fuzz_cases/sort_preserving_repartition_fuzz.rsindex a1f38f161d..f8ebde3597 100644--- a/datafusion/core/tests/fuzz_cases/sort_preserving_repartition_fuzz.rs+++ b/datafusion/core/tests/fuzz_cases/sort_preserving_repartition_fuzz.rs@@ -438,14 +438,14 @@ mod sp_repartition_fuzz_tests {// use a random number generator to pick a random sized outputlet mut rng = StdRng::seed_from_u64(random_seed);let mut input123: Vec<(i64, i64, i64)> = vec![(0, 0, 0); len];- input123.iter_mut().for_each(|v| {+ for v in &mut input123 {*v = (rng.random_range(0..n_distinct) as i64,rng.random_range(0..n_distinct) as i64,rng.random_range(0..n_distinct) as i64,)- });- input123.sort();+ }+ input123.sort_unstable();let input1 =Int64Array::from_iter_values(input123.clone().into_iter().map(|k| k.0));let input2 =diff --git a/datafusion/core/tests/fuzz_cases/window_fuzz.rs b/datafusion/core/tests/fuzz_cases/window_fuzz.rsindex 82b6d0e4e9..f69b5e9a41 100644--- a/datafusion/core/tests/fuzz_cases/window_fuzz.rs+++ b/datafusion/core/tests/fuzz_cases/window_fuzz.rs@@ -769,18 +769,18 @@ pub(crate) fn make_staggered_batches<const STREAM: bool>(let mut input123: Vec<(i32, i32, i32)> = vec![(0, 0, 0); len];let mut input4: Vec<i32> = vec![0; len];let mut input5: Vec<String> = vec!["".to_string(); len];- input123.iter_mut().for_each(|v| {+ for v in &mut input123 {*v = (rng.random_range(0..n_distinct) as i32,rng.random_range(0..n_distinct) as i32,rng.random_range(0..n_distinct) as i32,)- });- input123.sort();+ }+ input123.sort_unstable();rng.fill(&mut input4[..]);- input5.iter_mut().for_each(|v| {+ for v in &mut input5 {*v = generate_random_string(&mut rng, 1);- });+ }input5.sort();let input1 = Int32Array::from_iter_values(input123.iter().map(|k| k.0));let input2 = Int32Array::from_iter_values(input123.iter().map(|k| k.1));diff --git a/datafusion/core/tests/physical_optimizer/pushdown_utils.rs b/datafusion/core/tests/physical_optimizer/pushdown_utils.rsindex e11573b95f..852cf3bf18 100644--- a/datafusion/core/tests/physical_optimizer/pushdown_utils.rs+++ b/datafusion/core/tests/physical_optimizer/pushdown_utils.rs@@ -495,7 +495,7 @@ impl ExecutionPlan for TestNode {children: Vec<Arc<dyn ExecutionPlan>>,_: ReplaceChildrenOptions,) -> Result<Arc<dyn ExecutionPlan>> {- assert!(children.len() == 1);+ assert_eq!(children.len(), 1);Ok(Arc::new(TestNode::new(self.inject_filter,children[0].clone(),diff --git a/datafusion/core/tests/sql/path_partition.rs b/datafusion/core/tests/sql/path_partition.rsindex 82a15eb401..f8701ccc56 100644--- a/datafusion/core/tests/sql/path_partition.rs+++ b/datafusion/core/tests/sql/path_partition.rs@@ -761,16 +761,13 @@ impl ObjectStore for MirroringObjectStore {let mut objects = vec![];for k in &self.files {- let mut parts = match k.prefix_match(prefix) {- Some(parts) => parts,- None => continue,+ let Some(mut parts) = k.prefix_match(prefix) else {+ continue;};// Pop first element- let common_prefix = match parts.next() {- Some(p) => p,- // Should only return children of the prefix- None => continue,+ let Some(common_prefix) = parts.next() else {+ continue;};if parts.next().is_some() {diff --git a/datafusion/core/tests/user_defined/user_defined_scalar_functions.rs b/datafusion/core/tests/user_defined/user_defined_scalar_functions.rsindex da71ffb10e..a4d8af5e0c 100644--- a/datafusion/core/tests/user_defined/user_defined_scalar_functions.rs+++ b/datafusion/core/tests/user_defined/user_defined_scalar_functions.rs@@ -1022,7 +1022,7 @@ impl TryFrom<CreateFunction> for ScalarFunctionWrapper {Some(pos) => {let mut type_signatures: Vec<TypeSignature> = vec![];// Generate all valid signatures- for n in pos..defaults.len() + 1 {+ for n in pos..=defaults.len() {if n == 0 {type_signatures.push(TypeSignature::Nullary)} else {diff --git a/datafusion/datasource-arrow/src/source.rs b/datafusion/datasource-arrow/src/source.rsindex dff3c6ffae..b909263748 100644--- a/datafusion/datasource-arrow/src/source.rs+++ b/datafusion/datasource-arrow/src/source.rs@@ -444,13 +444,12 @@ impl ArrowSource {use datafusion_datasource::source::DataSourceExec;use datafusion_proto_models::protobuf;- let scan = match &node.physical_plan_type {- Some(protobuf::physical_plan_node::PhysicalPlanType::ArrowScan(scan)) => scan,- _ => {- return datafusion_common::internal_err!(- "PhysicalPlanNode is not an ArrowScan"- );- }+ let Some(protobuf::physical_plan_node::PhysicalPlanType::ArrowScan(scan)) =+ &node.physical_plan_type+ else {+ return datafusion_common::internal_err!(+ "PhysicalPlanNode is not an ArrowScan"+ );};let base_conf = scan.base_conf.as_ref().ok_or_else(|| {diff --git a/datafusion/datasource-avro/src/source.rs b/datafusion/datasource-avro/src/source.rsindex db98e167ab..7c29adad2b 100644--- a/datafusion/datasource-avro/src/source.rs+++ b/datafusion/datasource-avro/src/source.rs@@ -208,13 +208,12 @@ impl AvroSource {use datafusion_datasource::source::DataSourceExec;use datafusion_proto_models::protobuf;- let scan = match &node.physical_plan_type {- Some(protobuf::physical_plan_node::PhysicalPlanType::AvroScan(scan)) => scan,- _ => {- return datafusion_common::internal_err!(- "PhysicalPlanNode is not an AvroScan"- );- }+ let Some(protobuf::physical_plan_node::PhysicalPlanType::AvroScan(scan)) =+ &node.physical_plan_type+ else {+ return datafusion_common::internal_err!(+ "PhysicalPlanNode is not an AvroScan"+ );};let base_conf = scan.base_conf.as_ref().ok_or_else(|| {diff --git a/datafusion/datasource-csv/src/source.rs b/datafusion/datasource-csv/src/source.rsindex 08e4607498..04533d8c78 100644--- a/datafusion/datasource-csv/src/source.rs+++ b/datafusion/datasource-csv/src/source.rs@@ -593,13 +593,10 @@ impl CsvSource {use datafusion_datasource::source::DataSourceExec;use datafusion_proto_models::protobuf;- let scan = match &node.physical_plan_type {- Some(protobuf::physical_plan_node::PhysicalPlanType::CsvScan(scan)) => scan,- _ => {- return datafusion_common::internal_err!(- "PhysicalPlanNode is not a CsvScan"- );- }+ let Some(protobuf::physical_plan_node::PhysicalPlanType::CsvScan(scan)) =+ &node.physical_plan_type+ else {+ return datafusion_common::internal_err!("PhysicalPlanNode is not a CsvScan");};let base_conf = scan.base_conf.as_ref().ok_or_else(|| {diff --git a/datafusion/datasource-json/src/source.rs b/datafusion/datasource-json/src/source.rsindex 47241c9d99..15840223cc 100644--- a/datafusion/datasource-json/src/source.rs+++ b/datafusion/datasource-json/src/source.rs@@ -274,13 +274,12 @@ impl JsonSource {use datafusion_datasource::source::DataSourceExec;use datafusion_proto_models::protobuf;- let scan = match &node.physical_plan_type {- Some(protobuf::physical_plan_node::PhysicalPlanType::JsonScan(scan)) => scan,- _ => {- return datafusion_common::internal_err!(- "PhysicalPlanNode is not a JsonScan"- );- }+ let Some(protobuf::physical_plan_node::PhysicalPlanType::JsonScan(scan)) =+ &node.physical_plan_type+ else {+ return datafusion_common::internal_err!(+ "PhysicalPlanNode is not a JsonScan"+ );};let base_conf = scan.base_conf.as_ref().ok_or_else(|| {diff --git a/datafusion/datasource-parquet/src/projection_read_plan.rs b/datafusion/datasource-parquet/src/projection_read_plan.rsindex c00478f562..bc917510d6 100644--- a/datafusion/datasource-parquet/src/projection_read_plan.rs+++ b/datafusion/datasource-parquet/src/projection_read_plan.rs@@ -249,13 +249,10 @@ impl<'schema> PushdownChecker<'schema> {}fn check_single_column(&mut self, column_name: &str) -> Option<TreeNodeRecursion> {- let idx = match self.file_schema.index_of(column_name) {- Ok(idx) => idx,- Err(_) => {- // Column does not exist in the file schema, so we can't push this down.- self.projected_columns = true;- return Some(TreeNodeRecursion::Jump);- }+ let Ok(idx) = self.file_schema.index_of(column_name) else {+ // Column does not exist in the file schema, so we can't push this down.+ self.projected_columns = true;+ return Some(TreeNodeRecursion::Jump);};// Duplicates are handled by dedup() in into_sorted_columns()diff --git a/datafusion/datasource-parquet/src/source.rs b/datafusion/datasource-parquet/src/source.rsindex 097b4563af..c5506dd449 100644--- a/datafusion/datasource-parquet/src/source.rs+++ b/datafusion/datasource-parquet/src/source.rs@@ -1119,15 +1119,12 @@ impl ParquetSource {use datafusion_execution::object_store::ObjectStoreUrl;use datafusion_proto_models::protobuf;- let scan = match &node.physical_plan_type {- Some(protobuf::physical_plan_node::PhysicalPlanType::ParquetScan(scan)) => {- scan- }- _ => {- return datafusion_common::internal_err!(- "PhysicalPlanNode is not a ParquetScan"- );- }+ let Some(protobuf::physical_plan_node::PhysicalPlanType::ParquetScan(scan)) =+ &node.physical_plan_type+ else {+ return datafusion_common::internal_err!(+ "PhysicalPlanNode is not a ParquetScan"+ );};let base_conf = scan.base_conf.as_ref().ok_or_else(|| {diff --git a/datafusion/datasource/src/boundary_stream.rs b/datafusion/datasource/src/boundary_stream.rsindex 7b1cfb814d..496a740853 100644--- a/datafusion/datasource/src/boundary_stream.rs+++ b/datafusion/datasource/src/boundary_stream.rs@@ -342,9 +342,9 @@ impl Stream for AlignedBoundaryStream {.position(|&b| b == this.terminator){this.phase = Phase::Done;- return Poll::Ready(Some(Ok(- chunk.slice(..search_from + rel + 1)- )));+ return Poll::Ready(Some(+ Ok(chunk.slice(..=(search_from + rel))),+ ));}// No terminator found; continue scanning in EndScan.@@ -383,7 +383,7 @@ impl Stream for AlignedBoundaryStream {chunk.iter().position(|&b| b == this.terminator){this.phase = Phase::Done;- return Poll::Ready(Some(Ok(chunk.slice(..pos + 1))));+ return Poll::Ready(Some(Ok(chunk.slice(..=pos))));}// No terminator yet; yield and keep scanning.return Poll::Ready(Some(Ok(chunk)));diff --git a/datafusion/datasource/src/file_stream/scan_state.rs b/datafusion/datasource/src/file_stream/scan_state.rsindex 21125cd088..d1e57604f9 100644--- a/datafusion/datasource/src/file_stream/scan_state.rs+++ b/datafusion/datasource/src/file_stream/scan_state.rs@@ -266,9 +266,8 @@ impl ScanState {}// No outstanding work remains, so begin planning the next unopened file.- let part_file = match self.work_source.pop_front() {- Some(part_file) => part_file,- None => return ScanAndReturn::Done(None),+ let Some(part_file) = self.work_source.pop_front() else {+ return ScanAndReturn::Done(None);};self.metrics.time_opening.start();diff --git a/datafusion/datasource/src/statistics.rs b/datafusion/datasource/src/statistics.rsindex 491b4e54e8..4218823026 100644--- a/datafusion/datasource/src/statistics.rs+++ b/datafusion/datasource/src/statistics.rs@@ -96,17 +96,15 @@ impl MinMaxStatistics {.cloned().zip(s.column_statistics[i].max_value.get_value().cloned()).ok_or_else(|| plan_datafusion_err!("statistics not found"))+ } else if let Some(partition_value) =+ pv.get(i - s.column_statistics.len())+ {+ Ok((partition_value.clone(), partition_value.clone()))} else {- if let Some(partition_value) =- pv.get(i - s.column_statistics.len())- {- Ok((partition_value.clone(), partition_value.clone()))- } else {- Err(plan_datafusion_err!(- "statistics not found for partition, expected at most {}",- s.column_statistics.len()- ))- }+ Err(plan_datafusion_err!(+ "statistics not found for partition, expected at most {}",+ s.column_statistics.len()+ ))}}).collect::<Result<Vec<_>>>()?@@ -901,14 +899,10 @@ mod tests {file_with_stats("f2.parquet", Statistics::default()),];- let err = match MinMaxStatistics::new_from_files(- &sort_order,- &schema,- None,- files.iter(),- ) {- Ok(_) => panic!("expected missing statistics error"),- Err(err) => err,+ let Err(err) =+ MinMaxStatistics::new_from_files(&sort_order, &schema, None, files.iter())+ else {+ panic!("expected missing statistics error")};assert!(diff --git a/datafusion/doc/src/lib.rs b/datafusion/doc/src/lib.rsindex 11b63ff661..914df27cb8 100644--- a/datafusion/doc/src/lib.rs+++ b/datafusion/doc/src/lib.rs@@ -124,39 +124,44 @@ impl Documentation {let st_arg_token = " expression to operate on. Can be a constant, column, or function, and any combination of operators.";// Standard Argumentsif let Some(args) = self.arguments.clone() {- args.iter().for_each(|(name, value)| {+ for (name, value) in &args {if value.contains(st_arg_token) {if name.starts_with("The ") {- result.push_str(format!("\n standard_argument(\n name = \"{name}\"),").as_ref());+ result.push_str(+ format!(+ "\n standard_argument(\n name = \"{name}\"),"+ )+ .as_ref(),+ );} else {result.push_str(format!("\n standard_argument(\n name = \"{}\",\n prefix = \"{}\"\n ),", name, value.replace(st_arg_token, "")).as_ref());}}- });+ }}// Argumentsif let Some(args) = self.arguments.clone() {- args.iter().for_each(|(name, value)| {+ for (name, value) in &args {if !value.contains(st_arg_token) {result.push_str(format!("\n argument(\n name = \"{name}\",\n description = \"{value}\"\n ),").as_ref());}- });+ }}if let Some(alt_syntax) = self.alternative_syntax.clone() {- alt_syntax.iter().for_each(|syntax| {+ for syntax in &alt_syntax {result.push_str(format!("\n alternative_syntax = \"{syntax}\",").as_ref(),);- });+ }}// Related UDFsif let Some(related_udf) = self.related_udfs.clone() {- related_udf.iter().for_each(|udf| {+ for udf in &related_udf {result.push_str(format!("\n related_udf(name = \"{udf}\"),").as_ref());- });+ }}result.push_str("\n)]");diff --git a/datafusion/expr/src/expr_rewriter/order_by.rs b/datafusion/expr/src/expr_rewriter/order_by.rsindex 720788113c..5ac17480cb 100644--- a/datafusion/expr/src/expr_rewriter/order_by.rs+++ b/datafusion/expr/src/expr_rewriter/order_by.rs@@ -89,9 +89,7 @@ fn rewrite_in_terms_of_projection(// (e.g. "c1" --> "t.c1") because that normalization is done// at the input of the aggregate.- let normalized_expr = if let Ok(e) = normalize_col(expr.clone(), input) {- e- } else {+ let Ok(normalized_expr) = normalize_col(expr.clone(), input) else {// The expr is not based on Aggregate plan output. Skip it.return Ok(Transformed::no(expr));};diff --git a/datafusion/expr/src/higher_order_function.rs b/datafusion/expr/src/higher_order_function.rsindex c300be8f6f..9744e55205 100644--- a/datafusion/expr/src/higher_order_function.rs+++ b/datafusion/expr/src/higher_order_function.rs@@ -1565,9 +1565,8 @@ mod tests {unreachable!()};- let list_field = match list.data_type() {- DataType::List(field) => field,- _ => unreachable!(),+ let DataType::List(list_field) = list.data_type() else {+ unreachable!()};Ok(match (step, merge) {diff --git a/datafusion/expr/src/logical_plan/plan.rs b/datafusion/expr/src/logical_plan/plan.rsindex 6bd75c11c8..ab3c26795e 100644--- a/datafusion/expr/src/logical_plan/plan.rs+++ b/datafusion/expr/src/logical_plan/plan.rs@@ -428,11 +428,11 @@ impl LogicalPlan {pub fn all_out_ref_exprs(self: &LogicalPlan) -> Vec<Expr> {let mut exprs = vec![];self.apply_expressions(|e| {- find_out_reference_exprs(e).into_iter().for_each(|e| {+ for e in find_out_reference_exprs(e) {if !exprs.contains(&e) {exprs.push(e)}- });+ }Ok(TreeNodeRecursion::Continue)})// closure always returns OK@@ -4080,7 +4080,7 @@ impl Aggregate {exprs.push(&INTERNAL_ID_EXPR);}exprs.extend(self.aggr_expr.iter());- debug_assert!(exprs.len() == self.schema.fields().len());+ debug_assert_eq!(exprs.len(), self.schema.fields().len());Ok(exprs)}@@ -4387,9 +4387,8 @@ impl Join {right: Arc<LogicalPlan>,column_on: (Vec<Column>, Vec<Column>),) -> Result<(Self, bool)> {- let original_join = match original {- LogicalPlan::Join(join) => join,- _ => return plan_err!("Could not create join with project input"),+ let LogicalPlan::Join(original_join) = original else {+ return plan_err!("Could not create join with project input");};let mut left_sch = LogicalPlanBuilder::from(Arc::clone(&left));diff --git a/datafusion/expr/src/utils.rs b/datafusion/expr/src/utils.rsindex 7f79c5cf18..6c1dbacf4b 100644--- a/datafusion/expr/src/utils.rs+++ b/datafusion/expr/src/utils.rs@@ -224,9 +224,7 @@ pub fn enumerate_grouping_sets(group_expr: Vec<Expr>) -> Result<Vec<Expr>> {let size = group_exprs.len();let slice = group_exprs.as_slice();check_grouping_sets_size_limit(size * (size + 1) / 2 + 1)?;- (0..(size + 1))- .map(|i| slice[0..i].iter().collect())- .collect()+ (0..=size).map(|i| slice[0..i].iter().collect()).collect()}expr => vec![vec![expr]],};@@ -529,7 +527,7 @@ pub fn generate_sort_key(let mut final_sort_keys = vec![];let mut is_partition_flag = vec![];- partition_by.iter().for_each(|e| {+ for e in partition_by {// By default, create sort key with ASC is true and NULLS LAST to be consistent with// PostgreSQL's rule: https://www.postgresql.org/docs/current/queries-order.htmllet e = e.clone().sort(true, false);@@ -543,14 +541,14 @@ pub fn generate_sort_key(final_sort_keys.push(e);is_partition_flag.push(true);}- });+ }- order_by.iter().for_each(|e| {+ for e in order_by {if !final_sort_keys.contains(e) {final_sort_keys.push(e.clone());is_partition_flag.push(false);}- });+ }let res = final_sort_keys.into_iter().zip(is_partition_flag)diff --git a/datafusion/ffi/src/table_provider.rs b/datafusion/ffi/src/table_provider.rsindex e9271f61ce..dbb3994046 100644--- a/datafusion/ffi/src/table_provider.rs+++ b/datafusion/ffi/src/table_provider.rs@@ -689,14 +689,11 @@ impl TableProvider for ForeignTableProvider {filters: &[&Expr],) -> Result<Vec<TableProviderFilterPushDown>> {unsafe {- let pushdown_fn = match self.0.supports_filters_pushdown {- Some(func) => func,- None => {- return Ok(vec![- TableProviderFilterPushDown::Unsupported;- filters.len()- ]);- }+ let Some(pushdown_fn) = self.0.supports_filters_pushdown else {+ return Ok(vec![+ TableProviderFilterPushDown::Unsupported;+ filters.len()+ ]);};let codec: Arc<dyn LogicalExtensionCodec> = (&self.0.logical_codec).into();diff --git a/datafusion/ffi/src/util.rs b/datafusion/ffi/src/util.rsindex 3ab8aec5af..acb7dda2ff 100644--- a/datafusion/ffi/src/util.rs+++ b/datafusion/ffi/src/util.rs@@ -157,13 +157,13 @@ pub(crate) mod tests {let returned_ok_result = df_result!(ok_r_result);assert!(returned_ok_result.is_ok());- assert!(*returned_ok_result.unwrap() == *VALID_VALUE);+ assert_eq!(*returned_ok_result.unwrap(), *VALID_VALUE);let returned_err_result = df_result!(err_r_result);assert!(returned_err_result.is_err());- assert!(- returned_err_result.unwrap_err().strip_backtrace()- == format!("FFI error: {ERROR_VALUE}")+ assert_eq!(+ returned_err_result.unwrap_err().strip_backtrace(),+ format!("FFI error: {ERROR_VALUE}"));let ok_result: Result<String, DataFusionError> = Ok(VALID_VALUE.to_string());@@ -172,7 +172,7 @@ pub(crate) mod tests {let returned_ok_r_result = wrap_result(ok_result);let std_result: Result<String, SString> = returned_ok_r_result.into();- assert!(std_result == Ok(VALID_VALUE.into()));+ assert_eq!(std_result, Ok(VALID_VALUE.into()));let returned_err_r_result = wrap_result(err_result);let std_result: Result<String, SString> = returned_err_r_result.into();diff --git a/datafusion/ffi/tests/ffi_udf.rs b/datafusion/ffi/tests/ffi_udf.rsindex 10e0bb5cc1..73fafef134 100644--- a/datafusion/ffi/tests/ffi_udf.rs+++ b/datafusion/ffi/tests/ffi_udf.rs@@ -60,8 +60,8 @@ mod tests {("abs_b", Float64, vec![5., 4., 3., 2., 1.]))?;- assert!(result.len() == 1);- assert!(result[0] == expected);+ assert_eq!(result.len(), 1);+ assert_eq!(result[0], expected);Ok(())}@@ -83,7 +83,7 @@ mod tests {let result = df.collect().await?;- assert!(result.len() == 1);+ assert_eq!(result.len(), 1);assert_eq!(result[0].column_by_name("time_now").unwrap().data_type(),&DataType::Float64@@ -151,7 +151,7 @@ mod tests {let result = df.collect().await?;- assert!(result.len() == 1);+ assert_eq!(result.len(), 1);assert!(!result[0].column(0).as_string::<i32>().is_null(0));let result = result[0].column(0).as_string::<i32>().value(0);assert_eq!(result, "AEST");diff --git a/datafusion/ffi/tests/ffi_udtf.rs b/datafusion/ffi/tests/ffi_udtf.rsindex 69e5de90e1..d1215b331b 100644--- a/datafusion/ffi/tests/ffi_udtf.rs+++ b/datafusion/ffi/tests/ffi_udtf.rs@@ -49,8 +49,8 @@ mod tests {.await?;let expected = create_array!(Int64, [0, 1, 2, 3, 4]) as ArrayRef;- assert!(result.len() == 1);- assert!(result[0].column(0) == &expected);+ assert_eq!(result.len(), 1);+ assert_eq!(result[0].column(0), &expected);Ok(())}diff --git a/datafusion/functions-aggregate-common/src/aggregate/groups_accumulator/accumulate.rs b/datafusion/functions-aggregate-common/src/aggregate/groups_accumulator/accumulate.rsindex a5ed75f346..f3e1661db1 100644--- a/datafusion/functions-aggregate-common/src/aggregate/groups_accumulator/accumulate.rs+++ b/datafusion/functions-aggregate-common/src/aggregate/groups_accumulator/accumulate.rs@@ -311,9 +311,11 @@ impl NullState {None}SeenValues::Some { .. } => {- let mut old_values = match std::mem::take(&mut self.seen_values) {- SeenValues::Some { values } => values,- _ => unreachable!(),+ let SeenValues::Some {+ values: mut old_values,+ } = std::mem::take(&mut self.seen_values)+ else {+ unreachable!()};let nulls = old_values.finish();let first_n_null = nulls.slice(0, n);@@ -565,14 +567,14 @@ pub fn accumulate_indices<F>(|(group_index_chunk, mask)| {// index_mask has value 1 << i in the looplet mut index_mask = 1;- group_index_chunk.iter().for_each(|&group_index| {+ for &group_index in group_index_chunk {// valid bit was set, real valelet is_valid = (mask & index_mask) != 0;if is_valid {index_fn(group_index);}index_mask <<= 1;- })+ }},);@@ -601,14 +603,14 @@ pub fn accumulate_indices<F>(|(group_index_chunk, mask)| {// index_mask has value 1 << i in the looplet mut index_mask = 1;- group_index_chunk.iter().for_each(|&group_index| {+ for &group_index in group_index_chunk {// valid bit was set, real valelet is_valid = (mask & index_mask) != 0;if is_valid {index_fn(group_index);}index_mask <<= 1;- })+ }},);@@ -642,14 +644,14 @@ pub fn accumulate_indices<F>(.for_each(|((group_index_chunk, valid_mask), filter_mask)| {// index_mask has value 1 << i in the looplet mut index_mask = 1;- group_index_chunk.iter().for_each(|&group_index| {+ for &group_index in group_index_chunk {// valid bit was set, real valelet is_valid = (valid_mask & filter_mask & index_mask) != 0;if is_valid {index_fn(group_index);}index_mask <<= 1;- })+ }});// handle any remaining bits (after the initial 64)diff --git a/datafusion/functions-aggregate/src/covariance.rs b/datafusion/functions-aggregate/src/covariance.rsindex bd7c8a0390..5d4992336c 100644--- a/datafusion/functions-aggregate/src/covariance.rs+++ b/datafusion/functions-aggregate/src/covariance.rs@@ -274,9 +274,8 @@ impl Accumulator for CovarianceAccumulator {let values2 = as_float64_array(&values[1])?;for (value1, value2) in values1.iter().zip(values2) {- let (value1, value2) = match (value1, value2) {- (Some(a), Some(b)) => (a, b),- _ => continue,+ let (Some(value1), Some(value2)) = (value1, value2) else {+ continue;};let new_count = self.count + 1;@@ -300,9 +299,8 @@ impl Accumulator for CovarianceAccumulator {let values2 = as_float64_array(&values[1])?;for (value1, value2) in values1.iter().zip(values2) {- let (value1, value2) = match (value1, value2) {- (Some(a), Some(b)) => (a, b),- _ => continue,+ let (Some(value1), Some(value2)) = (value1, value2) else {+ continue;};if self.count <= 1 {diff --git a/datafusion/functions-aggregate/src/first_last.rs b/datafusion/functions-aggregate/src/first_last.rsindex c56cd73dbe..fbabdbcbb2 100644--- a/datafusion/functions-aggregate/src/first_last.rs+++ b/datafusion/functions-aggregate/src/first_last.rs@@ -450,7 +450,7 @@ impl<S: ValueState> FirstLastGroupsAccumulator<S> {return Ok(true);}- debug_assert!(new_ordering_values.len() == self.ordering_req.len());+ debug_assert_eq!(new_ordering_values.len(), self.ordering_req.len());let current_ordering = &self.orderings[group_idx];compare_rows(current_ordering, new_ordering_values, &self.sort_options).map(|x| {if self.pick_first_in_group {@@ -509,7 +509,7 @@ impl<S: ValueState> FirstLastGroupsAccumulator<S> {self.state.update(group_idx, array, idx)?;self.is_sets.set_bit(group_idx, true);- debug_assert!(orderings.len() == self.ordering_req.len());+ debug_assert_eq!(orderings.len(), self.ordering_req.len());let old_size = ScalarValue::size_of_vec(&self.orderings[group_idx]);self.orderings[group_idx].clear();self.orderings[group_idx].extend_from_slice(orderings);@@ -681,7 +681,7 @@ impl<S: ValueState + 'static> GroupsAccumulator for FirstLastGroupsAccumulator<Sordering_cols.push(Vec::with_capacity(self.orderings.len()));}for row in orderings.into_iter() {- debug_assert!(row.len() == self.ordering_req.len());+ debug_assert_eq!(row.len(), self.ordering_req.len());for (col_idx, ordering) in row.into_iter().enumerate() {ordering_cols[col_idx].push(ordering);}@@ -708,9 +708,8 @@ impl<S: ValueState + 'static> GroupsAccumulator for FirstLastGroupsAccumulator<Slet mut ordering_buf = Vec::with_capacity(self.ordering_req.len());- let (is_set_arr, val_and_order_cols) = match values.split_last() {- Some(result) => result,- None => return internal_err!("Empty row in FIRST_VALUE"),+ let Some((is_set_arr, val_and_order_cols)) = values.split_last() else {+ return internal_err!("Empty row in FIRST_VALUE");};let is_set_arr = as_boolean_array(is_set_arr)?;diff --git a/datafusion/functions-aggregate/src/min_max.rs b/datafusion/functions-aggregate/src/min_max.rsindex 73a4b84fcf..89a1e8114f 100644--- a/datafusion/functions-aggregate/src/min_max.rs+++ b/datafusion/functions-aggregate/src/min_max.rs@@ -1254,7 +1254,7 @@ mod tests {let mut res = Vec::with_capacity(len);for i in 0..len {let start = i.saturating_sub(n_sliding_window);- expected.push(*data[start..i + 1].iter().min().unwrap());+ expected.push(*data[start..=i].iter().min().unwrap());moving_min.push(data[i]);if i > n_sliding_window {@@ -1273,7 +1273,7 @@ mod tests {let mut res = Vec::with_capacity(len);for i in 0..len {let start = i.saturating_sub(n_sliding_window);- expected.push(*data[start..i + 1].iter().max().unwrap());+ expected.push(*data[start..=i].iter().max().unwrap());moving_max.push(data[i]);if i > n_sliding_window {diff --git a/datafusion/functions-aggregate/src/min_max/min_max_struct.rs b/datafusion/functions-aggregate/src/min_max/min_max_struct.rsindex d1bac4e2f9..2c08a8e45d 100644--- a/datafusion/functions-aggregate/src/min_max/min_max_struct.rs+++ b/datafusion/functions-aggregate/src/min_max/min_max_struct.rs@@ -102,9 +102,8 @@ impl GroupsAccumulator for MinMaxStructAccumulator {fn evaluate(&mut self, emit_to: EmitTo) -> Result<ArrayRef> {let (_, min_maxes) = self.inner.emit_to(emit_to);- let fields = match &self.inner.data_type {- DataType::Struct(fields) => fields,- _ => return internal_err!("Data type is not a struct"),+ let DataType::Struct(fields) = &self.inner.data_type else {+ return internal_err!("Data type is not a struct");};let null_array = StructArray::new_null(fields.clone(), 1);let min_maxes_data: Vec<ArrayData> = min_maxesdiff --git a/datafusion/functions-aggregate/src/regr.rs b/datafusion/functions-aggregate/src/regr.rsindex 0065f1b876..5b5a144fd2 100644--- a/datafusion/functions-aggregate/src/regr.rs+++ b/datafusion/functions-aggregate/src/regr.rs@@ -599,10 +599,8 @@ impl Accumulator for RegrAccumulator {for (value_y, value_x) in values_y.iter().zip(values_x) {// skip either x or y is NULL- let (value_y, value_x) = match (value_y, value_x) {- (Some(y), Some(x)) => (y, x),- // skip either x or y is NULL- _ => continue,+ let (Some(value_y), Some(value_x)) = (value_y, value_x) else {+ continue;};// Update states for regr_slope(y,x) [using cov_pop(x,y)/var_pop(x)]@@ -631,10 +629,8 @@ impl Accumulator for RegrAccumulator {for (value_y, value_x) in values_y.iter().zip(values_x) {// skip either x or y is NULL- let (value_y, value_x) = match (value_y, value_x) {- (Some(y), Some(x)) => (y, x),- // skip either x or y is NULL- _ => continue,+ let (Some(value_y), Some(value_x)) = (value_y, value_x) else {+ continue;};// Update states for regr_slope(y,x) [using cov_pop(x,y)/var_pop(x)]diff --git a/datafusion/functions-aggregate/src/stddev.rs b/datafusion/functions-aggregate/src/stddev.rsindex 3485a50629..ad249969aa 100644--- a/datafusion/functions-aggregate/src/stddev.rs+++ b/datafusion/functions-aggregate/src/stddev.rs@@ -337,7 +337,9 @@ impl GroupsAccumulator for StddevGroupsAccumulator {fn evaluate(&mut self, emit_to: datafusion_expr::EmitTo) -> Result<ArrayRef> {let (mut variances, nulls) = self.variance.variance(emit_to);- variances.iter_mut().for_each(|v| *v = v.sqrt());+ for v in &mut variances {+ *v = v.sqrt();+ }Ok(Arc::new(Float64Array::new(variances.into(), Some(nulls))))}diff --git a/datafusion/functions-aggregate/src/string_agg.rs b/datafusion/functions-aggregate/src/string_agg.rsindex bfb07183d9..342afcb6ae 100644--- a/datafusion/functions-aggregate/src/string_agg.rs+++ b/datafusion/functions-aggregate/src/string_agg.rs@@ -748,7 +748,7 @@ mod tests {fn some_str_sorted(value: ScalarValue, sep: &str) -> String {let value = some_str(value);let mut parts: Vec<&str> = value.split(sep).collect();- parts.sort();+ parts.sort_unstable();parts.join(sep)}diff --git a/datafusion/functions-aggregate/src/sum.rs b/datafusion/functions-aggregate/src/sum.rsindex e2f9f1ec67..1999f68d4c 100644--- a/datafusion/functions-aggregate/src/sum.rs+++ b/datafusion/functions-aggregate/src/sum.rs@@ -772,7 +772,7 @@ mod tests {let initial_capacity = acc.counts.capacity();let additional_values: ArrayRef =- Arc::new(Int64Array::from_iter(4..4 + initial_capacity as i64 + 1));+ Arc::new(Int64Array::from_iter(4..=(4 + initial_capacity as i64)));acc.update_batch(&[Arc::clone(&additional_values)])?;let grown_size = expected_sliding_distinct_sum_size(&acc);diff --git a/datafusion/functions-aggregate/src/variance.rs b/datafusion/functions-aggregate/src/variance.rsindex a2ec830578..1ca258298d 100644--- a/datafusion/functions-aggregate/src/variance.rs+++ b/datafusion/functions-aggregate/src/variance.rs@@ -487,9 +487,9 @@ impl VarianceGroupsAccumulator {let m2s = emit_to.take_needed(&mut self.m2s);if self.stats_type == StatsType::Sample {- counts.iter_mut().for_each(|count| {+ for count in &mut counts {*count = count.saturating_sub(1);- });+ }}let nulls = NullBuffer::from_iter(counts.iter().map(|&count| count != 0));let variance = m2sdiff --git a/datafusion/functions-nested/src/distance.rs b/datafusion/functions-nested/src/distance.rsindex c9aec81667..d9182e871f 100644--- a/datafusion/functions-nested/src/distance.rs+++ b/datafusion/functions-nested/src/distance.rs@@ -174,14 +174,8 @@ fn compute_array_distance(arr1: Option<ArrayRef>,arr2: Option<ArrayRef>,) -> Result<Option<f64>> {- let value1 = match arr1 {- Some(arr) => arr,- None => return Ok(None),- };- let value2 = match arr2 {- Some(arr) => arr,- None => return Ok(None),- };+ let Some(value1) = arr1 else { return Ok(None) };+ let Some(value2) = arr2 else { return Ok(None) };// Check for NULL values inside the arraysif value1.null_count() != 0 || value2.null_count() != 0 {diff --git a/datafusion/functions-nested/src/lambda_utils.rs b/datafusion/functions-nested/src/lambda_utils.rsindex 4b01ae314e..89f2044213 100644--- a/datafusion/functions-nested/src/lambda_utils.rs+++ b/datafusion/functions-nested/src/lambda_utils.rs@@ -85,9 +85,8 @@ pub(crate) fn single_list_lambda_parameters() -> Result<LambdaParametersProgress> {let (list, _lambda) = value_lambda_pair(name, fields)?;- let field = match list.data_type() {- DataType::List(field) | DataType::LargeList(field) => field,- _ => return plan_err!("expected list, got {list}"),+ let (DataType::List(field) | DataType::LargeList(field)) = list.data_type() else {+ return plan_err!("expected list, got {list}");};Ok(LambdaParametersProgress::Complete(vec![vec![Arc::clone(diff --git a/datafusion/functions-nested/src/length.rs b/datafusion/functions-nested/src/length.rsindex 24c79c40d7..0f5055a5f9 100644--- a/datafusion/functions-nested/src/length.rs+++ b/datafusion/functions-nested/src/length.rs@@ -171,9 +171,8 @@ fn compute_array_length(dimension: Option<i64>,) -> Result<Option<u64>> {let mut current_dimension: i64 = 1;- let mut value = match arr {- Some(arr) => arr,- None => return Ok(None),+ let Some(mut value) = arr else {+ return Ok(None);};let dimension = match dimension {Some(value) => {diff --git a/datafusion/functions-nested/src/map.rs b/datafusion/functions-nested/src/map.rsindex 660442f8a3..264bbf2922 100644--- a/datafusion/functions-nested/src/map.rs+++ b/datafusion/functions-nested/src/map.rs@@ -745,9 +745,8 @@ mod tests {assert!(result.is_ok(), "Should handle NULL maps correctly");// Verify the result- let map_array = match result.unwrap() {- ColumnarValue::Array(arr) => arr,- _ => panic!("Expected Array result"),+ let ColumnarValue::Array(map_array) = result.unwrap() else {+ panic!("Expected Array result")};assert_eq!(map_array.len(), 3, "Should have 3 maps");@@ -851,9 +850,8 @@ mod tests {);// Verify the result- let map_array = match result.unwrap() {- ColumnarValue::Array(arr) => arr,- _ => panic!("Expected Array result"),+ let ColumnarValue::Array(map_array) = result.unwrap() else {+ panic!("Expected Array result")};assert_eq!(map_array.len(), 2, "Should have 2 maps");@@ -924,9 +922,8 @@ mod tests {);// Verify the result- let map_array = match result.unwrap() {- ColumnarValue::Array(arr) => arr,- _ => panic!("Expected Array result"),+ let ColumnarValue::Array(map_array) = result.unwrap() else {+ panic!("Expected Array result")};assert_eq!(map_array.len(), 3, "Should have 3 maps");diff --git a/datafusion/functions-nested/src/remove.rs b/datafusion/functions-nested/src/remove.rsindex 491e823c9a..b87f04cbfb 100644--- a/datafusion/functions-nested/src/remove.rs+++ b/datafusion/functions-nested/src/remove.rs@@ -454,14 +454,13 @@ fn general_remove<OffsetSize: OffsetSizeTrait>(element_array: &ArrayRef,arr_n: &[Option<i64>],) -> Result<ArrayRef> {- let list_field = match list_array.data_type() {- DataType::List(field) | DataType::LargeList(field) => field,- _ => {- return exec_err!(- "Expected List or LargeList data type, got {:?}",- list_array.data_type()- );- }+ let (DataType::List(list_field) | DataType::LargeList(list_field)) =+ list_array.data_type()+ else {+ return exec_err!(+ "Expected List or LargeList data type, got {:?}",+ list_array.data_type()+ );};let original_data = list_array.values().to_data();// Build up the offsets for the final output array@@ -567,14 +566,13 @@ fn general_remove_with_scalar<OffsetSize: OffsetSizeTrait>(return Ok(Arc::new(list_array.clone()));}- let list_field = match list_array.data_type() {- DataType::List(field) | DataType::LargeList(field) => field,- _ => {- return exec_err!(- "Expected List or LargeList data type, got {:?}",- list_array.data_type()- );- }+ let (DataType::List(list_field) | DataType::LargeList(list_field)) =+ list_array.data_type()+ else {+ return exec_err!(+ "Expected List or LargeList data type, got {:?}",+ list_array.data_type()+ );};let list_offsets = list_array.offsets();diff --git a/datafusion/functions-nested/src/utils.rs b/datafusion/functions-nested/src/utils.rsindex 9822b6121e..2906250ec6 100644--- a/datafusion/functions-nested/src/utils.rs+++ b/datafusion/functions-nested/src/utils.rs@@ -277,9 +277,8 @@ pub(crate) fn compare_element_to_list(pub(crate) fn compute_array_dims(arr: Option<ArrayRef>,) -> Result<Option<Vec<Option<u64>>>> {- let mut value = match arr {- Some(arr) => arr,- None => return Ok(None),+ let Some(mut value) = arr else {+ return Ok(None);};if value.is_empty() {return Ok(None);diff --git a/datafusion/functions-window/src/row_number.rs b/datafusion/functions-window/src/row_number.rsindex eb48a31753..0ef5349a9c 100644--- a/datafusion/functions-window/src/row_number.rs+++ b/datafusion/functions-window/src/row_number.rs@@ -143,7 +143,7 @@ impl PartitionEvaluator for NumRowsEvaluator {num_rows: usize,) -> Result<ArrayRef> {Ok(Arc::new(UInt64Array::from_iter_values(- 1..(num_rows as u64) + 1,+ 1..=(num_rows as u64),)))}diff --git a/datafusion/functions/src/core/arrow_metadata.rs b/datafusion/functions/src/core/arrow_metadata.rsindex a80f66f396..72983b47e2 100644--- a/datafusion/functions/src/core/arrow_metadata.rs+++ b/datafusion/functions/src/core/arrow_metadata.rs@@ -120,13 +120,11 @@ impl ScalarUDFImpl for ArrowMetadataFunc {let metadata = args.arg_fields[0].metadata();if args.args.len() == 2 {- let key = match &args.args[1] {- ColumnarValue::Scalar(ScalarValue::Utf8(Some(key))) => key,- _ => {- return exec_err!(- "Second argument to arrow_metadata must be a string literal key"- );- }+ let ColumnarValue::Scalar(ScalarValue::Utf8(Some(key))) = &args.args[1]+ else {+ return exec_err!(+ "Second argument to arrow_metadata must be a string literal key"+ );};let value = metadata.get(key).cloned();Ok(ColumnarValue::Scalar(ScalarValue::Utf8(value)))diff --git a/datafusion/functions/src/core/union_tag.rs b/datafusion/functions/src/core/union_tag.rsindex 7c36f6bf0b..1575ef5dc3 100644--- a/datafusion/functions/src/core/union_tag.rs+++ b/datafusion/functions/src/core/union_tag.rs@@ -89,9 +89,8 @@ impl ScalarUDFImpl for UnionTagFunc {let keys = Int8Array::try_new(union_array.type_ids().clone(), None)?;- let fields = match union_array.data_type() {- DataType::Union(fields, _) => fields,- _ => unreachable!(),+ let DataType::Union(fields, _) = union_array.data_type() else {+ unreachable!()};// Union fields type IDs only constraints are being unique and in the 0..128 range:diff --git a/datafusion/functions/src/datetime/current_time.rs b/datafusion/functions/src/datetime/current_time.rsindex b93fb07d2b..1e202ada1d 100644--- a/datafusion/functions/src/datetime/current_time.rs+++ b/datafusion/functions/src/datetime/current_time.rs@@ -186,20 +186,20 @@ mod tests {.unwrap();// Extract nanoseconds from results- let nanos_plus_5 = match result_plus_5 {- ExprSimplifyResult::Simplified(Expr::Literal(- ScalarValue::Time64Nanosecond(Some(n)),- _,- )) => n,- _ => panic!("Expected Time64Nanosecond literal"),+ let ExprSimplifyResult::Simplified(Expr::Literal(+ ScalarValue::Time64Nanosecond(Some(nanos_plus_5)),+ _,+ )) = result_plus_5+ else {+ panic!("Expected Time64Nanosecond literal")};- let nanos_minus_5 = match result_minus_5 {- ExprSimplifyResult::Simplified(Expr::Literal(- ScalarValue::Time64Nanosecond(Some(n)),- _,- )) => n,- _ => panic!("Expected Time64Nanosecond literal"),+ let ExprSimplifyResult::Simplified(Expr::Literal(+ ScalarValue::Time64Nanosecond(Some(nanos_minus_5)),+ _,+ )) = result_minus_5+ else {+ panic!("Expected Time64Nanosecond literal")};// Calculate the difference: UTC+05:00 should be 10 hours ahead of UTC-05:00diff --git a/datafusion/functions/src/datetime/date_bin.rs b/datafusion/functions/src/datetime/date_bin.rsindex 1338df3aa9..c973015843 100644--- a/datafusion/functions/src/datetime/date_bin.rs+++ b/datafusion/functions/src/datetime/date_bin.rs@@ -1153,49 +1153,47 @@ mod tests {),];- cases- .iter()- .for_each(|(original, tz_opt, origin, expected)| {- let input = original- .iter()- .map(|s| Some(string_to_timestamp_nanos(s).unwrap()))- .collect::<TimestampNanosecondArray>()- .with_timezone_opt(tz_opt.clone());- let right = expected- .iter()- .map(|s| Some(string_to_timestamp_nanos(s).unwrap()))- .collect::<TimestampNanosecondArray>()- .with_timezone_opt(tz_opt.clone());- let batch_len = input.len();- let args = vec![- ColumnarValue::Scalar(ScalarValue::new_interval_dt(1, 0)),- ColumnarValue::Array(Arc::new(input)),- ColumnarValue::Scalar(ScalarValue::TimestampNanosecond(- Some(string_to_timestamp_nanos(origin).unwrap()),- tz_opt.clone(),- )),- ];- let return_field = &Arc::new(Field::new(- "f",- DataType::Timestamp(TimeUnit::Nanosecond, tz_opt.clone()),- true,- ));- let result =- invoke_date_bin_with_args(args, batch_len, return_field).unwrap();-- if let ColumnarValue::Array(result) = result {- assert_eq!(- result.data_type(),- &DataType::Timestamp(TimeUnit::Nanosecond, tz_opt.clone())- );- let left = arrow::array::cast::as_primitive_array::<- TimestampNanosecondType,- >(&result);- assert_eq!(left, &right);- } else {- panic!("unexpected column type");- }- });+ for (original, tz_opt, origin, expected) in &cases {+ let input = original+ .iter()+ .map(|s| Some(string_to_timestamp_nanos(s).unwrap()))+ .collect::<TimestampNanosecondArray>()+ .with_timezone_opt(tz_opt.clone());+ let right = expected+ .iter()+ .map(|s| Some(string_to_timestamp_nanos(s).unwrap()))+ .collect::<TimestampNanosecondArray>()+ .with_timezone_opt(tz_opt.clone());+ let batch_len = input.len();+ let args = vec![+ ColumnarValue::Scalar(ScalarValue::new_interval_dt(1, 0)),+ ColumnarValue::Array(Arc::new(input)),+ ColumnarValue::Scalar(ScalarValue::TimestampNanosecond(+ Some(string_to_timestamp_nanos(origin).unwrap()),+ tz_opt.clone(),+ )),+ ];+ let return_field = &Arc::new(Field::new(+ "f",+ DataType::Timestamp(TimeUnit::Nanosecond, tz_opt.clone()),+ true,+ ));+ let result =+ invoke_date_bin_with_args(args, batch_len, return_field).unwrap();++ if let ColumnarValue::Array(result) = result {+ assert_eq!(+ result.data_type(),+ &DataType::Timestamp(TimeUnit::Nanosecond, tz_opt.clone())+ );+ let left = arrow::array::cast::as_primitive_array::<+ TimestampNanosecondType,+ >(&result);+ assert_eq!(left, &right);+ } else {+ panic!("unexpected column type");+ }+ }}#[test]@@ -1243,18 +1241,16 @@ mod tests {),];- cases- .iter()- .for_each(|((stride, source, origin), expected)| {- let stride = stride.unwrap();- let stride1 = stride.num_nanoseconds().unwrap();- let source1 = string_to_timestamp_nanos(source).unwrap();- let origin1 = string_to_timestamp_nanos(origin).unwrap();-- let expected1 = string_to_timestamp_nanos(expected).unwrap();- let result = date_bin_nanos_interval(stride1, source1, origin1).unwrap();- assert_eq!(result, expected1, "{source} = {expected}");- })+ for ((stride, source, origin), expected) in &cases {+ let stride = stride.unwrap();+ let stride1 = stride.num_nanoseconds().unwrap();+ let source1 = string_to_timestamp_nanos(source).unwrap();+ let origin1 = string_to_timestamp_nanos(origin).unwrap();++ let expected1 = string_to_timestamp_nanos(expected).unwrap();+ let result = date_bin_nanos_interval(stride1, source1, origin1).unwrap();+ assert_eq!(result, expected1, "{source} = {expected}");+ }}#[test]@@ -1274,7 +1270,7 @@ mod tests {),];- cases.iter().for_each(|((stride, source), expected)| {+ for ((stride, source), expected) in &cases {let stride = stride.unwrap();let stride1 = stride.num_nanoseconds().unwrap();let source1 = string_to_timestamp_nanos(source).unwrap();@@ -1282,7 +1278,7 @@ mod tests {let expected1 = string_to_timestamp_nanos(expected).unwrap();let result = date_bin_nanos_interval(stride1, source1, 0).unwrap();assert_eq!(result, expected1, "{source} = {expected}");- })+ }}#[test]diff --git a/datafusion/functions/src/datetime/date_trunc.rs b/datafusion/functions/src/datetime/date_trunc.rsindex 6dcd7a666d..b05f0f46e1 100644--- a/datafusion/functions/src/datetime/date_trunc.rs+++ b/datafusion/functions/src/datetime/date_trunc.rs@@ -979,13 +979,13 @@ mod tests {),];- cases.iter().for_each(|(original, granularity, expected)| {+ for (original, granularity, expected) in &cases {let left = string_to_timestamp_nanos(original).unwrap();let right = string_to_timestamp_nanos(expected).unwrap();let granularity_enum = DateTruncGranularity::from_str(granularity).unwrap();let result = date_trunc_coarse(granularity_enum, left, None).unwrap();assert_eq!(result, right, "{original} = {expected}");- });+ }}#[test]@@ -1129,7 +1129,7 @@ mod tests {),];- cases.iter().for_each(|(original, tz_opt, expected)| {+ for (original, tz_opt, expected) in &cases {let input = original.iter().map(|s| Some(string_to_timestamp_nanos(s).unwrap()))@@ -1171,7 +1171,7 @@ mod tests {} else {panic!("unexpected column type");}- });+ }}#[test]@@ -1317,7 +1317,7 @@ mod tests {),];- cases.iter().for_each(|(original, tz_opt, expected)| {+ for (original, tz_opt, expected) in &cases {let input = original.iter().map(|s| Some(string_to_timestamp_nanos(s).unwrap()))@@ -1359,7 +1359,7 @@ mod tests {} else {panic!("unexpected column type");}- });+ }}#[test]@@ -1483,54 +1483,52 @@ mod tests {),];- cases- .iter()- .for_each(|(original, tz_opt, granularity, expected)| {- let input = original- .iter()- .map(|s| Some(string_to_timestamp_nanos(s).unwrap()))- .collect::<TimestampNanosecondArray>()- .with_timezone_opt(tz_opt.clone());- let right = expected- .iter()- .map(|s| Some(string_to_timestamp_nanos(s).unwrap()))- .collect::<TimestampNanosecondArray>()- .with_timezone_opt(tz_opt.clone());- let batch_len = input.len();- let arg_fields = vec![- Field::new("a", DataType::Utf8, false).into(),- Field::new("b", input.data_type().clone(), false).into(),- ];- let args = ScalarFunctionArgs {- args: vec![- ColumnarValue::Scalar(ScalarValue::from(*granularity)),- ColumnarValue::Array(Arc::new(input)),- ],- arg_fields,- number_rows: batch_len,- return_field: Field::new(- "f",- DataType::Timestamp(TimeUnit::Nanosecond, tz_opt.clone()),- true,- )- .into(),- config_options: Arc::new(ConfigOptions::default()),- };- let result = DateTruncFunc::new().invoke_with_args(args).unwrap();- if let ColumnarValue::Array(result) = result {- assert_eq!(- result.data_type(),- &DataType::Timestamp(TimeUnit::Nanosecond, tz_opt.clone()),- "Failed for granularity: {granularity}, timezone: {tz_opt:?}"- );- let left = as_primitive_array::<TimestampNanosecondType>(&result);- assert_eq!(- left, &right,- "Failed for granularity: {granularity}, timezone: {tz_opt:?}"- );- } else {- panic!("unexpected column type");- }- });+ for (original, tz_opt, granularity, expected) in &cases {+ let input = original+ .iter()+ .map(|s| Some(string_to_timestamp_nanos(s).unwrap()))+ .collect::<TimestampNanosecondArray>()+ .with_timezone_opt(tz_opt.clone());+ let right = expected+ .iter()+ .map(|s| Some(string_to_timestamp_nanos(s).unwrap()))+ .collect::<TimestampNanosecondArray>()+ .with_timezone_opt(tz_opt.clone());+ let batch_len = input.len();+ let arg_fields = vec![+ Field::new("a", DataType::Utf8, false).into(),+ Field::new("b", input.data_type().clone(), false).into(),+ ];+ let args = ScalarFunctionArgs {+ args: vec![+ ColumnarValue::Scalar(ScalarValue::from(*granularity)),+ ColumnarValue::Array(Arc::new(input)),+ ],+ arg_fields,+ number_rows: batch_len,+ return_field: Field::new(+ "f",+ DataType::Timestamp(TimeUnit::Nanosecond, tz_opt.clone()),+ true,+ )+ .into(),+ config_options: Arc::new(ConfigOptions::default()),+ };+ let result = DateTruncFunc::new().invoke_with_args(args).unwrap();+ if let ColumnarValue::Array(result) = result {+ assert_eq!(+ result.data_type(),+ &DataType::Timestamp(TimeUnit::Nanosecond, tz_opt.clone()),+ "Failed for granularity: {granularity}, timezone: {tz_opt:?}"+ );+ let left = as_primitive_array::<TimestampNanosecondType>(&result);+ assert_eq!(+ left, &right,+ "Failed for granularity: {granularity}, timezone: {tz_opt:?}"+ );+ } else {+ panic!("unexpected column type");+ }+ }}}diff --git a/datafusion/functions/src/datetime/to_local_time.rs b/datafusion/functions/src/datetime/to_local_time.rsindex 5bd1978893..973afa549e 100644--- a/datafusion/functions/src/datetime/to_local_time.rs+++ b/datafusion/functions/src/datetime/to_local_time.rs@@ -550,7 +550,7 @@ mod tests {),];- cases.iter().for_each(|(source, _tz_opt, expected)| {+ for (source, _tz_opt, expected) in &cases {let input = source.iter().map(|s| Some(string_to_timestamp_nanos(s).unwrap()))@@ -586,6 +586,6 @@ mod tests {} else {panic!("unexpected column type");}- });+ }}}diff --git a/datafusion/functions/src/datetime/to_timestamp.rs b/datafusion/functions/src/datetime/to_timestamp.rsindex 1b45910f72..a858d8dad4 100644--- a/datafusion/functions/src/datetime/to_timestamp.rs+++ b/datafusion/functions/src/datetime/to_timestamp.rs@@ -1703,9 +1703,8 @@ mod tests {let res = udf.invoke_with_args(args).expect("that to_timestamp parsed values without error");- let array = match res {- ColumnarValue::Array(res) => res,- _ => panic!("Expected a columnar array"),+ let ColumnarValue::Array(array) = res else {+ panic!("Expected a columnar array")};let ty = array.data_type();assert!(matches!(ty, Timestamp(_, None)));@@ -1753,9 +1752,8 @@ mod tests {let res = udf.invoke_with_args(args).expect("that to_timestamp parsed values without error");- let array = match res {- ColumnarValue::Array(res) => res,- _ => panic!("Expected a columnar array"),+ let ColumnarValue::Array(array) = res else {+ panic!("Expected a columnar array")};let ty = array.data_type();assert!(matches!(ty, Timestamp(_, None)));diff --git a/datafusion/functions/src/utils.rs b/datafusion/functions/src/utils.rsindex b93bdb0b0d..52ce0bd72c 100644--- a/datafusion/functions/src/utils.rs+++ b/datafusion/functions/src/utils.rs@@ -22,6 +22,7 @@ use arrow::error::ArrowError;use datafusion_common::{DataFusionError, Result, ScalarValue};use datafusion_expr::ColumnarValue;use datafusion_expr::function::Hint;+use std::cmp::Ordering;use std::sync::Arc;/// Creates a function to identify the optimal return type of a string function given@@ -298,53 +299,47 @@ where/// Converts Decimal128 components (value and scale) to an unscaled i128pub fn decimal128_to_i128(value: i128, scale: i8) -> Result<i128, ArrowError> {- if scale < 0 {- Err(ArrowError::ComputeError(+ match scale.cmp(&0) {+ Ordering::Less => Err(ArrowError::ComputeError("Negative scale is not supported".into(),- ))- } else if scale == 0 {- Ok(value)- } else {- match i128::from(10).checked_pow(scale as u32) {+ )),+ Ordering::Equal => Ok(value),+ Ordering::Greater => match i128::from(10).checked_pow(scale as u32) {Some(divisor) => Ok(value / divisor),None => Err(ArrowError::ComputeError(format!("Cannot get a power of {scale}"))),- }+ },}}pub fn decimal32_to_i32(value: i32, scale: i8) -> Result<i32, ArrowError> {- if scale < 0 {- Err(ArrowError::ComputeError(+ match scale.cmp(&0) {+ Ordering::Less => Err(ArrowError::ComputeError("Negative scale is not supported".into(),- ))- } else if scale == 0 {- Ok(value)- } else {- match 10_i32.checked_pow(scale as u32) {+ )),+ Ordering::Equal => Ok(value),+ Ordering::Greater => match 10_i32.checked_pow(scale as u32) {Some(divisor) => Ok(value / divisor),None => Err(ArrowError::ComputeError(format!("Cannot get a power of {scale}"))),- }+ },}}pub fn decimal64_to_i64(value: i64, scale: i8) -> Result<i64, ArrowError> {- if scale < 0 {- Err(ArrowError::ComputeError(+ match scale.cmp(&0) {+ Ordering::Less => Err(ArrowError::ComputeError("Negative scale is not supported".into(),- ))- } else if scale == 0 {- Ok(value)- } else {- match i64::from(10).checked_pow(scale as u32) {+ )),+ Ordering::Equal => Ok(value),+ Ordering::Greater => match i64::from(10).checked_pow(scale as u32) {Some(divisor) => Ok(value / divisor),None => Err(ArrowError::ComputeError(format!("Cannot get a power of {scale}"))),- }+ },}}diff --git a/datafusion/optimizer/src/common_subexpr_eliminate.rs b/datafusion/optimizer/src/common_subexpr_eliminate.rsindex 41d09db7c2..94d61b7487 100644--- a/datafusion/optimizer/src/common_subexpr_eliminate.rs+++ b/datafusion/optimizer/src/common_subexpr_eliminate.rs@@ -1404,7 +1404,7 @@ mod test {fn test_extract_expressions_from_col() -> Result<()> {let mut result = Vec::with_capacity(1);extract_expressions(&col("a"), &mut result);- assert!(result.len() == 1);+ assert_eq!(result.len(), 1);Ok(())}diff --git a/datafusion/optimizer/src/extract_leaf_expressions.rs b/datafusion/optimizer/src/extract_leaf_expressions.rsindex 9eb1dfa7d5..2590b4769a 100644--- a/datafusion/optimizer/src/extract_leaf_expressions.rs+++ b/datafusion/optimizer/src/extract_leaf_expressions.rs@@ -1191,15 +1191,15 @@ fn try_push_into_inputs(input_schemas.iter().map(|s| schema_columns(s)).collect();// Route pairs and columns to the appropriate inputs- let per_input = match route_to_inputs(+ let Some(per_input) = route_to_inputs(pairs,columns_needed,node,&input_column_sets,&input_schemas,- )? {- Some(routed) => routed,- None => return Ok(None),+ )?+ else {+ return Ok(None);};let num_inputs = inputs.len();diff --git a/datafusion/optimizer/src/optimize_projections/mod.rs b/datafusion/optimizer/src/optimize_projections/mod.rsindex 80aceb8cad..413efd9558 100644--- a/datafusion/optimizer/src/optimize_projections/mod.rs+++ b/datafusion/optimizer/src/optimize_projections/mod.rs@@ -569,8 +569,9 @@ fn merge_consecutive_projections_one_level(// Count usages (referrals) of each projection expression in its input fields:let mut column_referral_map = HashMap::<&Column, usize>::new();- expr.iter()- .for_each(|expr| expr.add_column_ref_counts(&mut column_referral_map));+ for expr in &expr {+ expr.add_column_ref_counts(&mut column_referral_map);+ }// If an expression is non-trivial (KeepInPlace) and appears more than once, do not merge// them as consecutive projections will benefit from a compute-once approach.diff --git a/datafusion/optimizer/src/optimizer.rs b/datafusion/optimizer/src/optimizer.rsindex d784f29650..46c0118095 100644--- a/datafusion/optimizer/src/optimizer.rs+++ b/datafusion/optimizer/src/optimizer.rs@@ -1043,9 +1043,8 @@ mod tests {plan: LogicalPlan,_config: &dyn OptimizerConfig,) -> Result<Transformed<LogicalPlan>> {- let projection = match plan {- LogicalPlan::Projection(p) => p,- _ => return Ok(Transformed::no(plan)),+ let LogicalPlan::Projection(projection) = plan else {+ return Ok(Transformed::no(plan));};let expr = Expr::from(Column::from(projection.schema.qualified_field(0)));diff --git a/datafusion/physical-expr-adapter/src/schema_rewriter.rs b/datafusion/physical-expr-adapter/src/schema_rewriter.rsindex 5347b7ff60..d8cf664707 100644--- a/datafusion/physical-expr-adapter/src/schema_rewriter.rs+++ b/datafusion/physical-expr-adapter/src/schema_rewriter.rs@@ -465,46 +465,39 @@ impl DefaultPhysicalExprAdapterRewriter {&self,expr: &Arc<dyn PhysicalExpr>,) -> Result<Option<Arc<dyn PhysicalExpr>>> {- let get_field_expr =- match ScalarFunctionExpr::try_downcast_func::<GetFieldFunc>(expr.as_ref()) {- Some(expr) => expr,- None => return Ok(None),- };+ let Some(get_field_expr) =+ ScalarFunctionExpr::try_downcast_func::<GetFieldFunc>(expr.as_ref())+ else {+ return Ok(None);+ };- let source_expr = match get_field_expr.args().first() {- Some(expr) => expr,- None => return Ok(None),+ let Some(source_expr) = get_field_expr.args().first() else {+ return Ok(None);};- let field_name_expr = match get_field_expr.args().get(1) {- Some(expr) => expr,- None => return Ok(None),+ let Some(field_name_expr) = get_field_expr.args().get(1) else {+ return Ok(None);};- let lit = match field_name_expr.downcast_ref::<Literal>() {- Some(lit) => lit,- None => return Ok(None),+ let Some(lit) = field_name_expr.downcast_ref::<Literal>() else {+ return Ok(None);};- let field_name = match lit.value().try_as_str().flatten() {- Some(name) => name,- None => return Ok(None),+ let Some(field_name) = lit.value().try_as_str().flatten() else {+ return Ok(None);};- let column = match source_expr.downcast_ref::<Column>() {- Some(column) => column,- None => return Ok(None),+ let Some(column) = source_expr.downcast_ref::<Column>() else {+ return Ok(None);};- let physical_field =- match self.physical_file_schema.field_with_name(column.name()) {- Ok(field) => field,- Err(_) => return Ok(None),- };+ let Ok(physical_field) = self.physical_file_schema.field_with_name(column.name())+ else {+ return Ok(None);+ };- let physical_struct_fields = match physical_field.data_type() {- DataType::Struct(fields) => fields,- _ => return Ok(None),+ let DataType::Struct(physical_struct_fields) = physical_field.data_type() else {+ return Ok(None);};if physical_struct_fields@@ -514,23 +507,20 @@ impl DefaultPhysicalExprAdapterRewriter {return Ok(None);}- let logical_field = match self.logical_file_schema.field_with_name(column.name())- {- Ok(field) => field,- Err(_) => return Ok(None),+ let Ok(logical_field) = self.logical_file_schema.field_with_name(column.name())+ else {+ return Ok(None);};- let logical_struct_fields = match logical_field.data_type() {- DataType::Struct(fields) => fields,- _ => return Ok(None),+ let DataType::Struct(logical_struct_fields) = logical_field.data_type() else {+ return Ok(None);};- let logical_struct_field = match logical_struct_fields+ let Some(logical_struct_field) = logical_struct_fields.iter().find(|f| f.name() == field_name)- {- Some(field) => field,- None => return Ok(None),+ else {+ return Ok(None);};let null_value = ScalarValue::Null.cast_to(logical_struct_field.data_type())?;diff --git a/datafusion/physical-expr-common/src/binary_map.rs b/datafusion/physical-expr-common/src/binary_map.rsindex a95d13ee86..8815c5d434 100644--- a/datafusion/physical-expr-common/src/binary_map.rs+++ b/datafusion/physical-expr-common/src/binary_map.rs@@ -798,7 +798,7 @@ mod tests {}#[test]- #[should_panic]+ #[should_panic(expected = "byte array")]fn test_mismatched_sizes() {// inserting large strings into a set that expects small should paniclet values: ArrayRef = Arc::new(LargeBinaryArray::from_opt_vec(vec![Some(b"a")]));diff --git a/datafusion/physical-expr-common/src/metrics/value.rs b/datafusion/physical-expr-common/src/metrics/value.rsindex 232fefcc5f..37ab5194b2 100644--- a/datafusion/physical-expr-common/src/metrics/value.rs+++ b/datafusion/physical-expr-common/src/metrics/value.rs@@ -1186,13 +1186,13 @@ mod tests {let other_custom_val = new_custom_counter("Hello", 1);// Not equal since the name differs.- assert!(other_custom_val != custom_val);+ assert_ne!(other_custom_val, custom_val);// Should work even though the name differscustom_val.aggregate(&other_custom_val);let expected_val = new_custom_counter("Hi", 2);- assert!(expected_val == custom_val);+ assert_eq!(expected_val, custom_val);}#[test]@@ -1202,7 +1202,7 @@ mod tests {custom_val.aggregate(&other_custom_val);- assert!(custom_val != other_custom_val);+ assert_ne!(custom_val, other_custom_val);if let MetricValue::Custom { value, .. } = custom_val {let counter = valuediff --git a/datafusion/physical-expr/src/aggregate.rs b/datafusion/physical-expr/src/aggregate.rsindex 013779cf8c..5f045ca8c7 100644--- a/datafusion/physical-expr/src/aggregate.rs+++ b/datafusion/physical-expr/src/aggregate.rs@@ -287,13 +287,10 @@ impl AggregateExprBuilder {return_field = output_metadata.add_to_field_ref(return_field);}let is_nullable = fun.is_nullable();- let name = match alias {- None => {- return internal_err!(- "AggregateExprBuilder::alias must be provided prior to calling build"- );- }- Some(alias) => alias,+ let Some(name) = alias else {+ return internal_err!(+ "AggregateExprBuilder::alias must be provided prior to calling build"+ );};let human_display =diff --git a/datafusion/physical-expr/src/analysis.rs b/datafusion/physical-expr/src/analysis.rsindex a00fc19ae9..3905e4b7fc 100644--- a/datafusion/physical-expr/src/analysis.rs+++ b/datafusion/physical-expr/src/analysis.rs@@ -218,9 +218,9 @@ pub fn analyze(}PropagationResult::Infeasible => {// If the propagation result is infeasible, set intervals to None- target_boundaries- .iter_mut()- .for_each(|bound| bound.interval = None);+ for bound in &mut target_boundaries {+ bound.interval = None;+ }Ok(AnalysisContext::new(target_boundaries).with_selectivity(0.0))}PropagationResult::CannotPropagate => {@@ -240,7 +240,7 @@ fn shrink_boundaries(target_expr_and_indices: &[(Arc<dyn PhysicalExpr>, usize)],) -> Result<AnalysisContext> {let initial_boundaries = target_boundaries.clone();- target_expr_and_indices.iter().for_each(|(expr, i)| {+ for (expr, i) in target_expr_and_indices {if let Some(column) = expr.downcast_ref::<Column>()&& let Some(bound) = target_boundaries.iter_mut()@@ -248,7 +248,7 @@ fn shrink_boundaries({bound.interval = Some(graph.get_interval(*i));};- });+ }let selectivity = calculate_selectivity(&target_boundaries, &initial_boundaries)?;diff --git a/datafusion/physical-expr/src/expressions/binary/kernels.rs b/datafusion/physical-expr/src/expressions/binary/kernels.rsindex a123fba1f9..94612af9f6 100644--- a/datafusion/physical-expr/src/expressions/binary/kernels.rs+++ b/datafusion/physical-expr/src/expressions/binary/kernels.rs@@ -165,23 +165,17 @@ macro_rules! regexp_is_match_flag {// The analyzer coerces both operands to a common string type, but// expressions that bypass it may still reach here with mismatched// types, which must surface as an error rather than a panic.- let ll = match $LEFT.as_any().downcast_ref::<$ARRAYTYPE>() {- Some(ll) => ll,- None => {- return exec_err!(- "failed to downcast array to {} for operation 'regex_match_dyn'",- stringify!($ARRAYTYPE)- );- }+ let Some(ll) = $LEFT.as_any().downcast_ref::<$ARRAYTYPE>() else {+ return exec_err!(+ "failed to downcast array to {} for operation 'regex_match_dyn'",+ stringify!($ARRAYTYPE)+ );};- let rr = match $RIGHT.as_any().downcast_ref::<$ARRAYTYPE>() {- Some(rr) => rr,- None => {- return exec_err!(- "failed to downcast array to {} for operation 'regex_match_dyn'",- stringify!($ARRAYTYPE)- );- }+ let Some(rr) = $RIGHT.as_any().downcast_ref::<$ARRAYTYPE>() else {+ return exec_err!(+ "failed to downcast array to {} for operation 'regex_match_dyn'",+ stringify!($ARRAYTYPE)+ );};let flag = if $FLAG {@@ -223,14 +217,11 @@ pub(crate) fn regex_match_dyn(/// Invoke a compute kernel on a data array and a scalar value with flagmacro_rules! regexp_is_match_flag_scalar {($LEFT:expr, $RIGHT:expr, $ARRAYTYPE:ident, $NOT:expr, $FLAG:expr) => {{- let ll = match $LEFT.as_any().downcast_ref::<$ARRAYTYPE>() {- Some(ll) => ll,- None => {- return Some(exec_err!(- "failed to downcast array to {} for operation 'regex_match_dyn_scalar'",- stringify!($ARRAYTYPE)- ));- }+ let Some(ll) = $LEFT.as_any().downcast_ref::<$ARRAYTYPE>() else {+ return Some(exec_err!(+ "failed to downcast array to {} for operation 'regex_match_dyn_scalar'",+ stringify!($ARRAYTYPE)+ ));};if let Some(Some(string_value)) = $RIGHT.try_as_str() {diff --git a/datafusion/physical-expr/src/expressions/lambda.rs b/datafusion/physical-expr/src/expressions/lambda.rsindex 95bb5db0b3..be1539e208 100644--- a/datafusion/physical-expr/src/expressions/lambda.rs+++ b/datafusion/physical-expr/src/expressions/lambda.rs@@ -93,7 +93,7 @@ impl LambdaExpr {let mut projection = used_indices.into_iter().collect::<Vec<_>>();- projection.sort();+ projection.sort_unstable();let column_index_map = projection.iter()diff --git a/datafusion/physical-expr/src/simplifier/not.rs b/datafusion/physical-expr/src/simplifier/not.rsindex 7496eda6c4..f030ca1d75 100644--- a/datafusion/physical-expr/src/simplifier/not.rs+++ b/datafusion/physical-expr/src/simplifier/not.rs@@ -52,9 +52,8 @@ pub fn simplify_not_expr(schema: &Schema,) -> Result<Transformed<Arc<dyn PhysicalExpr>>> {// Check if this is a NOT expression- let not_expr = match expr.downcast_ref::<NotExpr>() {- Some(not_expr) => not_expr,- None => return Ok(Transformed::no(expr)),+ let Some(not_expr) = expr.downcast_ref::<NotExpr>() else {+ return Ok(Transformed::no(expr));};let inner_expr = not_expr.arg();diff --git a/datafusion/physical-expr/src/window/standard.rs b/datafusion/physical-expr/src/window/standard.rsindex 278b66c373..b70ad38e95 100644--- a/datafusion/physical-expr/src/window/standard.rs+++ b/datafusion/physical-expr/src/window/standard.rs@@ -179,9 +179,8 @@ impl WindowExpr for StandardWindowExpr {published: false,})};- let evaluator = match &mut window_state.window_fn {- WindowFn::Builtin(evaluator) => evaluator,- _ => unreachable!(),+ let WindowFn::Builtin(evaluator) = &mut window_state.window_fn else {+ unreachable!()};let state = &mut window_state.state;diff --git a/datafusion/physical-expr/src/window/window_expr.rs b/datafusion/physical-expr/src/window/window_expr.rsindex 7fe768cfbe..59edd5e865 100644--- a/datafusion/physical-expr/src/window/window_expr.rs+++ b/datafusion/physical-expr/src/window/window_expr.rs@@ -258,9 +258,8 @@ pub trait AggregateWindowExpr: WindowExpr {let window_state = window_agg_state.get_mut(partition_row).ok_or_else(|| exec_datafusion_err!("Cannot find state"))?;- let accumulator = match &mut window_state.window_fn {- WindowFn::Aggregate(accumulator) => accumulator,- _ => unreachable!(),+ let WindowFn::Aggregate(accumulator) = &mut window_state.window_fn else {+ unreachable!()};let state = &mut window_state.state;let record_batch = &partition_batch_state.record_batch;diff --git a/datafusion/physical-optimizer/src/ensure_requirements/enforce_sorting/mod.rs b/datafusion/physical-optimizer/src/ensure_requirements/enforce_sorting/mod.rsindex 90b19ca95b..42a1572573 100644--- a/datafusion/physical-optimizer/src/ensure_requirements/enforce_sorting/mod.rs+++ b/datafusion/physical-optimizer/src/ensure_requirements/enforce_sorting/mod.rs@@ -212,7 +212,7 @@ pub fn replace_with_partial_sort(let mut common_prefix_length = 0;while child_eq_properties- .ordering_satisfy(sort_exprs[0..common_prefix_length + 1].to_vec())?+ .ordering_satisfy(sort_exprs[0..=common_prefix_length].to_vec())?{common_prefix_length += 1;}diff --git a/datafusion/physical-plan/benches/sort_merge_join.rs b/datafusion/physical-plan/benches/sort_merge_join.rsindex 82610b2a54..26522136c2 100644--- a/datafusion/physical-plan/benches/sort_merge_join.rs+++ b/datafusion/physical-plan/benches/sort_merge_join.rs@@ -48,7 +48,7 @@ fn build_sorted_batches(let mut rows: Vec<(i64, i64)> = (0..num_rows).map(|i| ((i % key_mod) as i64, i as i64)).collect();- rows.sort();+ rows.sort_unstable();let keys: Vec<i64> = rows.iter().map(|(k, _)| *k).collect();let data: Vec<i64> = rows.iter().map(|(_, d)| *d).collect();diff --git a/datafusion/physical-plan/src/aggregates/group_values/multi_group_by/bytes_view.rs b/datafusion/physical-plan/src/aggregates/group_values/multi_group_by/bytes_view.rsindex 8625772e2c..37cbea2e9d 100644--- a/datafusion/physical-plan/src/aggregates/group_values/multi_group_by/bytes_view.rs+++ b/datafusion/physical-plan/src/aggregates/group_values/multi_group_by/bytes_view.rs@@ -475,7 +475,7 @@ impl<B: ByteViewType> ByteViewGroupValueBuilder<B> {self.flush_in_progress();}self.completed- .drain(0..last_remaining_buffer_index + 1)+ .drain(0..=last_remaining_buffer_index).collect()}diff --git a/datafusion/physical-plan/src/aggregates/group_values/multi_group_by/mod.rs b/datafusion/physical-plan/src/aggregates/group_values/multi_group_by/mod.rsindex 409e159216..257f13cbfa 100644--- a/datafusion/physical-plan/src/aggregates/group_values/multi_group_by/mod.rs+++ b/datafusion/physical-plan/src/aggregates/group_values/multi_group_by/mod.rs@@ -2100,7 +2100,7 @@ mod tests {num_remaining_rows -= num_emit;}- assert!(num_remaining_rows == 0);+ assert_eq!(num_remaining_rows, 0);let actual_batch = concat_batches(&schema, &actual_sub_batches).unwrap();check_result(&actual_batch, &data_set.expected_batch);diff --git a/datafusion/physical-plan/src/aggregates/mod.rs b/datafusion/physical-plan/src/aggregates/mod.rsindex 0f1b718a3c..e85ef5ce58 100644--- a/datafusion/physical-plan/src/aggregates/mod.rs+++ b/datafusion/physical-plan/src/aggregates/mod.rs@@ -1854,7 +1854,7 @@ impl AggregateExec {None}).collect();- debug_assert!(all_cols.len() == supported_accumulators_info.len());+ debug_assert_eq!(all_cols.len(), supported_accumulators_info.len());all_cols}diff --git a/datafusion/physical-plan/src/filter.rs b/datafusion/physical-plan/src/filter.rsindex 414e5a6d85..a1be69849b 100644--- a/datafusion/physical-plan/src/filter.rs+++ b/datafusion/physical-plan/src/filter.rs@@ -1370,7 +1370,7 @@ fn collect_columns_from_predicate_inner(let mut ne_predicate_columns = Vec::<PhysicalExprPairRef>::new();let predicates = split_conjunction(predicate);- predicates.into_iter().for_each(|p| {+ for p in predicates {if let Some(binary) = p.downcast_ref::<BinaryExpr>() {// Only extract pairs where at least one side is a Column reference.// Pairs like `complex_expr = literal` should not create equivalence@@ -1383,7 +1383,7 @@ fn collect_columns_from_predicate_inner(binary.left().downcast_ref::<Column>().is_some()|| binary.right().downcast_ref::<Column>().is_some();if !has_direct_column_operand {- return;+ continue;}match binary.op() {Operator::Eq => {@@ -1395,7 +1395,7 @@ fn collect_columns_from_predicate_inner(_ => {}}}- });+ }(eq_predicate_columns, ne_predicate_columns)}diff --git a/datafusion/physical-plan/src/joins/hash_join/partitioned_hash_eval.rs b/datafusion/physical-plan/src/joins/hash_join/partitioned_hash_eval.rsindex 1ff2587ae8..a106100c50 100644--- a/datafusion/physical-plan/src/joins/hash_join/partitioned_hash_eval.rs+++ b/datafusion/physical-plan/src/joins/hash_join/partitioned_hash_eval.rs@@ -250,9 +250,10 @@ impl HashExpr {ctx: &datafusion_physical_expr_common::physical_expr::proto_decode::PhysicalExprDecodeCtx<'_>,) -> Result<Arc<dyn PhysicalExpr>> {use datafusion_proto_models::protobuf;- let hash_expr = match &node.expr_type {- Some(protobuf::physical_expr_node::ExprType::HashExpr(h)) => h,- _ => return internal_err!("PhysicalExprNode is not a HashExpr"),+ let Some(protobuf::physical_expr_node::ExprType::HashExpr(hash_expr)) =+ &node.expr_type+ else {+ return internal_err!("PhysicalExprNode is not a HashExpr");};// Destructure exhaustively (no `..`) so that a newly added proto field// is a compile error here instead of being silently ignored.diff --git a/datafusion/physical-plan/src/joins/hash_join/stream.rs b/datafusion/physical-plan/src/joins/hash_join/stream.rsindex 3bb2d6d989..63a94e1987 100644--- a/datafusion/physical-plan/src/joins/hash_join/stream.rs+++ b/datafusion/physical-plan/src/joins/hash_join/stream.rs@@ -445,7 +445,7 @@ fn count_distinct_sorted_indices(indices: &UInt32Array) -> usize {return 0;}- debug_assert!(indices.null_count() == 0);+ debug_assert_eq!(indices.null_count(), 0);let values_buf = indices.values();let values = values_buf.as_ref();diff --git a/datafusion/physical-plan/src/joins/nested_loop_join.rs b/datafusion/physical-plan/src/joins/nested_loop_join.rsindex 7fc1ba45c6..548a0cf1db 100644--- a/datafusion/physical-plan/src/joins/nested_loop_join.rs+++ b/datafusion/physical-plan/src/joins/nested_loop_join.rs@@ -1652,19 +1652,14 @@ impl NestedLoopJoinStream {/// it to disk. Other partitions share the same spill file.fn initiate_fallback(&mut self) -> Result<()> {// Take ownership of Pending state- let (left_plan, context, left_spill_data) =- match std::mem::replace(&mut self.spill_state, SpillState::Disabled) {- SpillState::Pending {- left_plan,- task_context,- left_spill_data,- } => (left_plan, task_context, left_spill_data),- _ => {- return internal_err!(- "initiate_fallback called in non-Pending spill state"- );- }- };+ let SpillState::Pending {+ left_plan,+ task_context: context,+ left_spill_data,+ } = std::mem::replace(&mut self.spill_state, SpillState::Disabled)+ else {+ return internal_err!("initiate_fallback called in non-Pending spill state");+ };// Use OnceAsync to ensure only the first partition spills the left// side. Other partitions will get the same OnceFut that resolves@@ -2985,7 +2980,7 @@ fn build_row_join_batch(// in `col_indices`build_side: JoinSide,) -> Result<Option<RecordBatch>> {- debug_assert!(build_side != JoinSide::None);+ debug_assert_ne!(build_side, JoinSide::None);// TODO(perf): since the output might be projection of right batch, this// filtering step is more efficient to be done inside the column_index loop@@ -3242,7 +3237,7 @@ fn build_unmatched_batch(Vec::with_capacity(output_schema.fields().len());for column_index in col_indices {- debug_assert!(column_index.side == batch_side);+ debug_assert_eq!(column_index.side, batch_side);let col = batch.column(column_index.index);let filtered_col = filter(col, &bitmap)?;diff --git a/datafusion/physical-plan/src/joins/stream_join_utils.rs b/datafusion/physical-plan/src/joins/stream_join_utils.rsindex 05a56d2411..fa50ec6036 100644--- a/datafusion/physical-plan/src/joins/stream_join_utils.rs+++ b/datafusion/physical-plan/src/joins/stream_join_utils.rs@@ -235,12 +235,12 @@ impl PruningJoinHashMap {.collect::<Vec<_>>();// Remove the keys from the map.- removable_keys.into_iter().for_each(|hash_value| {+ for hash_value in removable_keys {self.map.find_entry(hash_value, |(hash, _)| hash_value == *hash).unwrap().remove();- });+ }// Shrink the map if necessary.self.shrink_if_necessary(shrink_factor);diff --git a/datafusion/physical-plan/src/joins/test_utils.rs b/datafusion/physical-plan/src/joins/test_utils.rsindex 0455fb2a1e..94dc9a6f29 100644--- a/datafusion/physical-plan/src/joins/test_utils.rs+++ b/datafusion/physical-plan/src/joins/test_utils.rs@@ -607,7 +607,7 @@ fn generate_ordered_array(size: i32, duplicate_ratio: f32) -> Arc<Int32Array> {}// Sort the values to ensure they are ordered- values.sort();+ values.sort_unstable();Arc::new(Int32Array::from_iter(values))}diff --git a/datafusion/physical-plan/src/joins/utils.rs b/datafusion/physical-plan/src/joins/utils.rsindex 62771af4c4..fe19123cb2 100644--- a/datafusion/physical-plan/src/joins/utils.rs+++ b/datafusion/physical-plan/src/joins/utils.rs@@ -1725,7 +1725,7 @@ fn append_probe_indices_in_order(// Set previous index as the start index for the initial loop:let mut prev_index = range.start as u32;// Zip the two iterators.- debug_assert!(build_indices.len() == probe_indices.len());+ debug_assert_eq!(build_indices.len(), probe_indices.len());for (build_index, probe_index) in build_indices.values().into_iter()diff --git a/datafusion/physical-plan/src/repartition/mod.rs b/datafusion/physical-plan/src/repartition/mod.rsindex 0334987994..11ddcec24d 100644--- a/datafusion/physical-plan/src/repartition/mod.rs+++ b/datafusion/physical-plan/src/repartition/mod.rs@@ -816,9 +816,10 @@ impl RangeExpr {ctx: &datafusion_physical_expr_common::physical_expr::proto_decode::PhysicalExprDecodeCtx<'_>,) -> Result<PhysicalExprRef> {// Decode the raw ordered children for the same reason as `try_to_proto`.- let range_expr = match &node.expr_type {- Some(protobuf::physical_expr_node::ExprType::RangeExpr(expr)) => expr,- _ => return internal_err!("PhysicalExprNode is not a RangeExpr"),+ let Some(protobuf::physical_expr_node::ExprType::RangeExpr(range_expr)) =+ &node.expr_type+ else {+ return internal_err!("PhysicalExprNode is not a RangeExpr");};let sort_exprs = sort_exprs_try_from_proto(&range_expr.sort_expr, ctx)?;let (on_columns, sort_options) = sort_exprs@@ -1128,7 +1129,9 @@ impl BatchPartitioner {hash_buffer,)?;- indices.iter_mut().for_each(|v| v.clear());+ for v in indices.iter_mut() {+ v.clear();+ }partition_reducer.partition_indices(hash_buffer, indices);@@ -1158,7 +1161,9 @@ impl BatchPartitioner {&batch,)?;- indices.iter_mut().for_each(|v| v.clear());+ for v in indices.iter_mut() {+ v.clear();+ }Self::partition_range_indices(&arrays,diff --git a/datafusion/physical-plan/src/sorts/sort_preserving_merge.rs b/datafusion/physical-plan/src/sorts/sort_preserving_merge.rsindex 09c1489002..e088d92d65 100644--- a/datafusion/physical-plan/src/sorts/sort_preserving_merge.rs+++ b/datafusion/physical-plan/src/sorts/sort_preserving_merge.rs@@ -528,13 +528,12 @@ impl SortPreservingMergeExec {.expr.iter().map(|e| {- let sort = match &e.expr_type {- Some(protobuf::physical_expr_node::ExprType::Sort(s)) => s,- _ => {- return internal_err!(- "SortPreservingMergeExec expression is not a sort expression"- );- }+ let Some(protobuf::physical_expr_node::ExprType::Sort(sort)) =+ &e.expr_type+ else {+ return internal_err!(+ "SortPreservingMergeExec expression is not a sort expression"+ );};let expr = ctx.decode_required_expr(sort.expr.as_deref(),diff --git a/datafusion/physical-plan/src/spill/spill_pool.rs b/datafusion/physical-plan/src/spill/spill_pool.rsindex 6e964d7a64..b787c62af3 100644--- a/datafusion/physical-plan/src/spill/spill_pool.rs+++ b/datafusion/physical-plan/src/spill/spill_pool.rs@@ -1305,7 +1305,7 @@ mod tests {let mut batch_order = reader_handle.await.unwrap();// When used with multiple writers, order is not guaranteed- batch_order.sort();+ batch_order.sort_unstable();assert_eq!(batch_order, (0i32..100i32).collect::<Vec<_>>());Ok(())diff --git a/datafusion/physical-plan/src/windows/mod.rs b/datafusion/physical-plan/src/windows/mod.rsindex b031476b35..18a877b0df 100644--- a/datafusion/physical-plan/src/windows/mod.rs+++ b/datafusion/physical-plan/src/windows/mod.rs@@ -605,14 +605,11 @@ pub fn get_best_fitting_window(// of the window_exprs are same.let partitionby_exprs = window_exprs[0].partition_by();let orderby_keys = window_exprs[0].order_by();- let (should_reverse, input_order_mode) =- if let Some((should_reverse, input_order_mode)) =- get_window_mode(partitionby_exprs, orderby_keys, input)?- {- (should_reverse, input_order_mode)- } else {- return Ok(None);- };+ let Some((should_reverse, input_order_mode)) =+ get_window_mode(partitionby_exprs, orderby_keys, input)?+ else {+ return Ok(None);+ };let is_unbounded = input.boundedness().is_unbounded();if !is_unbounded && input_order_mode != InputOrderMode::Sorted {// Executor has bounded input and `input_order_mode` is not `InputOrderMode::Sorted`diff --git a/datafusion/proto/tests/cases/mod.rs b/datafusion/proto/tests/cases/mod.rsindex 3f62fe223b..63dfebb38a 100644--- a/datafusion/proto/tests/cases/mod.rs+++ b/datafusion/proto/tests/cases/mod.rs@@ -214,9 +214,8 @@ impl HigherOrderUDFImpl for MyHigherOrderUDF {_step: usize,fields: &[ValueOrLambda<FieldRef, Option<FieldRef>>],) -> datafusion_common::Result<LambdaParametersProgress> {- let list = match fields.first() {- Some(ValueOrLambda::Value(field)) => field,- _ => return plan_err!("higher_order_udf expects a list as first argument"),+ let Some(ValueOrLambda::Value(list)) = fields.first() else {+ return plan_err!("higher_order_udf expects a list as first argument");};let element = match list.data_type() {DataType::List(field) | DataType::LargeList(field) => Arc::clone(field),diff --git a/datafusion/proto/tests/cases/serialize.rs b/datafusion/proto/tests/cases/serialize.rsindex 46ab8511f7..40548fb1cf 100644--- a/datafusion/proto/tests/cases/serialize.rs+++ b/datafusion/proto/tests/cases/serialize.rs@@ -285,13 +285,10 @@ fn roundtrip_deeply_nested() {let expr = (0..n).fold(expr_base.clone(), |expr, n| if n % 2 == 0 { expr.and(expr_base.clone()) } else { expr.or(expr_base.clone()) });// Convert it to an opaque form- let bytes = match expr.to_bytes() {- Ok(bytes) => bytes,- Err(_) => {+ let Ok(bytes) = expr.to_bytes() else {// found expression that is too deeply nestedreturn;- }- };+ };// Decode bytes from somewhere (over network, etc.let decoded_expr = Expr::from_bytes(&bytes).expect("serialization worked, so deserialization should work as well");diff --git a/datafusion/pruning/src/file_pruner.rs b/datafusion/pruning/src/file_pruner.rsindex 661832915c..3cc338faa3 100644--- a/datafusion/pruning/src/file_pruner.rs+++ b/datafusion/pruning/src/file_pruner.rs@@ -153,7 +153,7 @@ impl FilePruner {};match pruning_predicate.prune(&self.file_stats_pruning) {Ok(values) => {- assert!(values.len() == 1);+ assert_eq!(values.len(), 1);// We expect a single container -> if all containers are false skip this fileif values.into_iter().all(|v| !v) {return Ok(true);diff --git a/datafusion/pruning/src/pruning_predicate.rs b/datafusion/pruning/src/pruning_predicate.rsindex 6df5cbc5cc..dff18173ae 100644--- a/datafusion/pruning/src/pruning_predicate.rs+++ b/datafusion/pruning/src/pruning_predicate.rs@@ -1110,11 +1110,8 @@ impl<'a> PruningExpressionBuilder<'a> {scalar_expr,df_schema,)?;- let field = match schema.column_with_name(column.name()) {- Some((_, f)) => f,- _ => {- return plan_err!("Field not found in schema");- }+ let Some((_, field)) = schema.column_with_name(column.name()) else {+ return plan_err!("Field not found in schema");};Ok(Self {diff --git a/datafusion/spark/src/function/math/ceil.rs b/datafusion/spark/src/function/math/ceil.rsindex 5096914a1e..95717657ee 100644--- a/datafusion/spark/src/function/math/ceil.rs+++ b/datafusion/spark/src/function/math/ceil.rs@@ -187,9 +187,8 @@ mod tests {]);let args = vec![ColumnarValue::Array(Arc::new(input))];let result = spark_ceil(&args).unwrap();- let result = match result {- ColumnarValue::Array(arr) => arr,- _ => panic!("Expected array"),+ let ColumnarValue::Array(result) = result else {+ panic!("Expected array")};let result = result.as_primitive::<Int64Type>();assert_eq!(@@ -219,9 +218,8 @@ mod tests {]);let args = vec![ColumnarValue::Array(Arc::new(input))];let result = spark_ceil(&args).unwrap();- let result = match result {- ColumnarValue::Array(arr) => arr,- _ => panic!("Expected array"),+ let ColumnarValue::Array(result) = result else {+ panic!("Expected array")};let result = result.as_primitive::<Int64Type>();assert_eq!(@@ -243,9 +241,8 @@ mod tests {let input = Int64Array::from(vec![Some(1), Some(-1), None]);let args = vec![ColumnarValue::Array(Arc::new(input))];let result = spark_ceil(&args).unwrap();- let result = match result {- ColumnarValue::Array(arr) => arr,- _ => panic!("Expected array"),+ let ColumnarValue::Array(result) = result else {+ panic!("Expected array")};let result = result.as_primitive::<Int64Type>();assert_eq!(result, &Int64Array::from(vec![Some(1), Some(-1), None]));@@ -259,9 +256,8 @@ mod tests {.with_data_type(DataType::Decimal128(10, 2));let args = vec![ColumnarValue::Array(Arc::new(input))];let result = spark_ceil(&args).unwrap();- let result = match result {- ColumnarValue::Array(arr) => arr,- _ => panic!("Expected array"),+ let ColumnarValue::Array(result) = result else {+ panic!("Expected array")};let result = result.as_primitive::<Decimal128Type>();let expected = Decimal128Array::from(vec![Some(2), Some(-1), Some(1), None])@@ -273,9 +269,8 @@ mod tests {fn test_ceil_float64_scalar() {let input = ScalarValue::Float64(Some(-1.1));let args = vec![ColumnarValue::Scalar(input)];- let result = match spark_ceil(&args).unwrap() {- ColumnarValue::Scalar(v) => v,- _ => panic!("Expected scalar"),+ let ColumnarValue::Scalar(result) = spark_ceil(&args).unwrap() else {+ panic!("Expected scalar")};assert_eq!(result, ScalarValue::Int64(Some(-1)));}@@ -284,9 +279,8 @@ mod tests {fn test_ceil_float32_scalar() {let input = ScalarValue::Float32(Some(125.2345f32));let args = vec![ColumnarValue::Scalar(input)];- let result = match spark_ceil(&args).unwrap() {- ColumnarValue::Scalar(v) => v,- _ => panic!("Expected scalar"),+ let ColumnarValue::Scalar(result) = spark_ceil(&args).unwrap() else {+ panic!("Expected scalar")};assert_eq!(result, ScalarValue::Int64(Some(126)));}@@ -295,9 +289,8 @@ mod tests {fn test_ceil_int64_scalar() {let input = ScalarValue::Int64(Some(48));let args = vec![ColumnarValue::Scalar(input)];- let result = match spark_ceil(&args).unwrap() {- ColumnarValue::Scalar(v) => v,- _ => panic!("Expected scalar"),+ let ColumnarValue::Scalar(result) = spark_ceil(&args).unwrap() else {+ panic!("Expected scalar")};assert_eq!(result, ScalarValue::Int64(Some(48)));}diff --git a/datafusion/spark/src/function/math/factorial.rs b/datafusion/spark/src/function/math/factorial.rsindex c9405273e8..3c41479174 100644--- a/datafusion/spark/src/function/math/factorial.rs+++ b/datafusion/spark/src/function/math/factorial.rs@@ -151,9 +151,8 @@ mod test {let args = ColumnarValue::Array(Arc::new(input));let result = spark_factorial(&[args]).unwrap();- let result = match result {- ColumnarValue::Array(array) => array,- _ => panic!("Expected array"),+ let ColumnarValue::Array(result) = result else {+ panic!("Expected array")};let actual = as_int64_array(&result).unwrap();@@ -177,9 +176,8 @@ mod test {let args = ColumnarValue::Scalar(input);let result = spark_factorial(&[args]).unwrap();- let result = match result {- ColumnarValue::Scalar(ScalarValue::Int64(val)) => val,- _ => panic!("Expected scalar"),+ let ColumnarValue::Scalar(ScalarValue::Int64(result)) = result else {+ panic!("Expected scalar")};let actual = result.unwrap();let expected = 120_i64;diff --git a/datafusion/spark/src/function/math/hex.rs b/datafusion/spark/src/function/math/hex.rsindex aa32100dd4..c3f1cce2ab 100644--- a/datafusion/spark/src/function/math/hex.rs+++ b/datafusion/spark/src/function/math/hex.rs@@ -356,9 +356,8 @@ mod test {let columnar_value = ColumnarValue::Array(Arc::new(input));let result = super::spark_hex(&[columnar_value]).unwrap();- let result = match result {- ColumnarValue::Array(array) => array,- _ => panic!("Expected array"),+ let ColumnarValue::Array(result) = result else {+ panic!("Expected array")};let result = as_dictionary_array(&result).unwrap();@@ -385,9 +384,8 @@ mod test {let columnar_value = ColumnarValue::Array(Arc::new(input));let result = super::spark_hex(&[columnar_value]).unwrap();- let result = match result {- ColumnarValue::Array(array) => array,- _ => panic!("Expected array"),+ let ColumnarValue::Array(result) = result else {+ panic!("Expected array")};let result = as_dictionary_array(&result).unwrap();@@ -414,9 +412,8 @@ mod test {let columnar_value = ColumnarValue::Array(Arc::new(input));let result = super::spark_hex(&[columnar_value]).unwrap();- let result = match result {- ColumnarValue::Array(array) => array,- _ => panic!("Expected array"),+ let ColumnarValue::Array(result) = result else {+ panic!("Expected array")};let result = as_dictionary_array(&result).unwrap();@@ -473,9 +470,8 @@ mod test {let result =super::spark_hex(&[ColumnarValue::Array(Arc::new(bin_array))]).unwrap();- let array = match result {- ColumnarValue::Array(array) => array,- _ => panic!("Expected array"),+ let ColumnarValue::Array(array) = result else {+ panic!("Expected array")};let strings = as_string_array(&array);let mut expected = String::with_capacity(512);@@ -495,9 +491,8 @@ mod test {]);let result = super::spark_hex(&[ColumnarValue::Array(Arc::new(input))]).unwrap();- let array = match result {- ColumnarValue::Array(array) => array,- _ => panic!("Expected array"),+ let ColumnarValue::Array(array) = result else {+ panic!("Expected array")};let strings = as_string_array(&array);@@ -521,9 +516,8 @@ mod test {let input_nulls = input.nulls().unwrap().clone();let result = super::spark_hex(&[ColumnarValue::Array(Arc::new(input))]).unwrap();- let array = match result {- ColumnarValue::Array(array) => array,- _ => panic!("Expected array"),+ let ColumnarValue::Array(array) = result else {+ panic!("Expected array")};let strings = as_string_array(&array);let output_nulls = strings.nulls().unwrap();@@ -542,9 +536,8 @@ mod test {let columnar_value = ColumnarValue::Array(Arc::new(int_array));let result = super::spark_hex(&[columnar_value]).unwrap();- let result = match result {- ColumnarValue::Array(array) => array,- _ => panic!("Expected array"),+ let ColumnarValue::Array(result) = result else {+ panic!("Expected array")};let string_array = as_string_array(&result);@@ -568,9 +561,8 @@ mod test {let columnar_value = ColumnarValue::Array(Arc::new(dict));let result = super::spark_hex(&[columnar_value]).unwrap();- let result = match result {- ColumnarValue::Array(array) => array,- _ => panic!("Expected array"),+ let ColumnarValue::Array(result) = result else {+ panic!("Expected array")};let result = as_dictionary_array(&result).unwrap();@@ -590,9 +582,8 @@ mod test {let dict = DictionaryArray::new(keys, Arc::new(vals));let result = super::spark_hex(&[ColumnarValue::Array(Arc::new(dict))]).unwrap();- let result = match result {- ColumnarValue::Array(array) => array,- _ => panic!("Expected array"),+ let ColumnarValue::Array(result) = result else {+ panic!("Expected array")};let result = as_dictionary_array(&result).unwrap();diff --git a/datafusion/spark/src/function/math/round.rs b/datafusion/spark/src/function/math/round.rsindex 471d38d804..caa5a681a5 100644--- a/datafusion/spark/src/function/math/round.rs+++ b/datafusion/spark/src/function/math/round.rs@@ -423,14 +423,11 @@ fn spark_round(args: &[ColumnarValue], enable_ansi_mode: bool) -> Result<Columnareturn exec_err!("round requires 1 or 2 arguments, got {}", args.len());}- let scale = match get_scale(args)? {- Some(s) => s,- None => {- // NULL scale → return NULL with the same data type as the first argument- return Ok(ColumnarValue::Scalar(ScalarValue::try_from(- args[0].data_type(),- )?));- }+ let Some(scale) = get_scale(args)? else {+ // NULL scale → return NULL with the same data type as the first argument+ return Ok(ColumnarValue::Scalar(ScalarValue::try_from(+ args[0].data_type(),+ )?));};match &args[0] {diff --git a/datafusion/spark/src/function/math/width_bucket.rs b/datafusion/spark/src/function/math/width_bucket.rsindex 93be47a4ca..f387cc4e27 100644--- a/datafusion/spark/src/function/math/width_bucket.rs+++ b/datafusion/spark/src/function/math/width_bucket.rs@@ -225,12 +225,9 @@ macro_rules! width_bucket_kernel_impl {}}- let ord = match l.partial_cmp(&h) {- Some(o) => o,- None => {- b.append_null();- continue;- }+ let Some(ord) = l.partial_cmp(&h) else {+ b.append_null();+ continue;};if ord == std::cmp::Ordering::Equal {b.append_null();diff --git a/datafusion/sql/src/expr/mod.rs b/datafusion/sql/src/expr/mod.rsindex 22520d86bd..f1661028ed 100644--- a/datafusion/sql/src/expr/mod.rs+++ b/datafusion/sql/src/expr/mod.rs@@ -393,11 +393,8 @@ impl<S: ContextProvider> SqlToRel<'_, S> {value,uses_odbc_syntax: _,}) => {- let value = match value.into_string() {- Some(value) => value,- None => {- return plan_err!("Typed literal requires a string payload");- }+ let Some(value) = value.into_string() else {+ return plan_err!("Typed literal requires a string payload");};Ok(Expr::Cast(Cast::new_from_field(diff --git a/datafusion/sql/src/parser.rs b/datafusion/sql/src/parser.rsindex 86a00ca767..71493fb9c9 100644--- a/datafusion/sql/src/parser.rs+++ b/datafusion/sql/src/parser.rs@@ -1914,9 +1914,7 @@ mod tests {panic!("Expected statement, got {statement:?}");};- let query = if let SQLStatement::Query(query) = statement {- query- } else {+ let SQLStatement::Query(query) = statement else {panic!("Expected query, got {statement:?}");};diff --git a/datafusion/sql/src/statement.rs b/datafusion/sql/src/statement.rsindex fd5c34ff5d..33791227b3 100644--- a/datafusion/sql/src/statement.rs+++ b/datafusion/sql/src/statement.rs@@ -1897,9 +1897,7 @@ impl<S: ContextProvider> SqlToRel<'_, S> {.iter().map(|index_column| {let expr = &index_column.column.expr;- let ident = if let SQLExpr::Identifier(ident) = expr {- ident- } else {+ let SQLExpr::Identifier(ident) = expr else {return Err(plan_datafusion_err!("Column name for {constraint_name} must be an identifier: {expr}"));diff --git a/datafusion/sql/src/unparser/expr.rs b/datafusion/sql/src/unparser/expr.rsindex 9403e15406..898330018c 100644--- a/datafusion/sql/src/unparser/expr.rs+++ b/datafusion/sql/src/unparser/expr.rs@@ -443,10 +443,7 @@ impl Unparser<'_> {}Expr::ScalarSubquery(subq) => {let sub_statement = self.plan_to_sql(subq.subquery.as_ref())?;- let sub_query = if let ast::Statement::Query(inner_query) = sub_statement- {- inner_query- } else {+ let ast::Statement::Query(sub_query) = sub_statement else {return plan_err!("Subquery must be a Query, but found {sub_statement:?}");@@ -457,10 +454,7 @@ impl Unparser<'_> {let inexpr = Box::new(self.expr_to_sql_inner(insubq.expr.as_ref())?);let sub_statement =self.plan_to_sql(insubq.subquery.subquery.as_ref())?;- let sub_query = if let ast::Statement::Query(inner_query) = sub_statement- {- inner_query- } else {+ let ast::Statement::Query(sub_query) = sub_statement else {return plan_err!("Subquery must be a Query, but found {sub_statement:?}");@@ -475,10 +469,7 @@ impl Unparser<'_> {let left = Box::new(self.expr_to_sql_inner(set_cmp.expr.as_ref())?);let sub_statement =self.plan_to_sql(set_cmp.subquery.subquery.as_ref())?;- let sub_query = if let ast::Statement::Query(inner_query) = sub_statement- {- inner_query- } else {+ let ast::Statement::Query(sub_query) = sub_statement else {return plan_err!("Subquery must be a Query, but found {sub_statement:?}");@@ -500,10 +491,7 @@ impl Unparser<'_> {}Expr::Exists(Exists { subquery, negated }) => {let sub_statement = self.plan_to_sql(subquery.subquery.as_ref())?;- let sub_query = if let ast::Statement::Query(inner_query) = sub_statement- {- inner_query- } else {+ let ast::Statement::Query(sub_query) = sub_statement else {return plan_err!("Subquery must be a Query, but found {sub_statement:?}");@@ -1219,14 +1207,11 @@ impl Unparser<'_> {wherei64: From<T::Native>,{- let time_unit = match T::DATA_TYPE {- DataType::Timestamp(unit, _) => unit,- _ => {- return Err(internal_datafusion_err!(- "Expected Timestamp, got {:?}",- T::DATA_TYPE- ));- }+ let DataType::Timestamp(time_unit, _) = T::DATA_TYPE else {+ return Err(internal_datafusion_err!(+ "Expected Timestamp, got {:?}",+ T::DATA_TYPE+ ));};let ts = if let Some(tz) = tz {diff --git a/datafusion/sql/tests/sql_integration.rs b/datafusion/sql/tests/sql_integration.rsindex a255b940e6..00103bfd9f 100644--- a/datafusion/sql/tests/sql_integration.rs+++ b/datafusion/sql/tests/sql_integration.rs@@ -5759,9 +5759,8 @@ impl HigherOrderUDFImpl for MockArrayReduce {unreachable!()};- let list_field = match list.data_type() {- DataType::List(field) => field,- _ => unreachable!(),+ let DataType::List(list_field) = list.data_type() else {+ unreachable!()};Ok(match (step, merge) {diff --git a/datafusion/sqllogictest/bin/sqllogictests.rs b/datafusion/sqllogictest/bin/sqllogictests.rsindex ae0eee432a..81b0c41d6a 100644--- a/datafusion/sqllogictest/bin/sqllogictests.rs+++ b/datafusion/sqllogictest/bin/sqllogictests.rs@@ -593,20 +593,22 @@ fn get_record_count(path: &PathBuf, label: String) -> u64 {parse_file(path).unwrap();let mut count: u64 = 0;- records.iter().for_each(|rec| match rec {- Record::Query { conditions, .. } | Record::Statement { conditions, .. }- if conditions.is_empty()- || !conditions.contains(&Condition::SkipIf {- label: label.clone(),- })- || conditions.contains(&Condition::OnlyIf {- label: label.clone(),- }) =>- {- count += 1;+ for rec in &records {+ match rec {+ Record::Query { conditions, .. } | Record::Statement { conditions, .. }+ if conditions.is_empty()+ || !conditions.contains(&Condition::SkipIf {+ label: label.clone(),+ })+ || conditions.contains(&Condition::OnlyIf {+ label: label.clone(),+ }) =>+ {+ count += 1;+ }+ _ => {}}- _ => {}- });+ }count}diff --git a/datafusion/sqllogictest/src/engines/datafusion_engine/normalize.rs b/datafusion/sqllogictest/src/engines/datafusion_engine/normalize.rsindex fa566a6a3d..6172ffe350 100644--- a/datafusion/sqllogictest/src/engines/datafusion_engine/normalize.rs+++ b/datafusion/sqllogictest/src/engines/datafusion_engine/normalize.rs@@ -136,12 +136,12 @@ fn expand_row(mut row: Vec<String>) -> impl Iterator<Item = Vec<String>> {/// DataSourceExec: files={1 group: [[WORKSPACE_ROOT/testing/data/csv/aggregate_test_100.csv]]}, .../// ```fn normalize_paths(mut row: Vec<String>) -> Vec<String> {- row.iter_mut().for_each(|s| {+ for s in &mut row {let workspace_root: &str = WORKSPACE_ROOT.as_ref();if s.contains(workspace_root) {*s = s.replace(workspace_root, "WORKSPACE_ROOT");}- });+ }row}diff --git a/datafusion/substrait/src/logical_plan/consumer/expr/scalar_function.rs b/datafusion/substrait/src/logical_plan/consumer/expr/scalar_function.rsindex 47a944504c..13f86997f3 100644--- a/datafusion/substrait/src/logical_plan/consumer/expr/scalar_function.rs+++ b/datafusion/substrait/src/logical_plan/consumer/expr/scalar_function.rs@@ -232,9 +232,8 @@ impl BuiltinExprBuilder {}fn build_unary_expr(fn_name: &str, args: Vec<Expr>) -> Result<Expr> {- let [arg] = match args.try_into() {- Ok(args_arr) => args_arr,- Err(_) => return substrait_err!("Expected one argument for {fn_name} expr"),+ let Ok([arg]) = <[Expr; 1]>::try_from(args) else {+ return substrait_err!("Expected one argument for {fn_name} expr");};let arg = Box::new(arg);@@ -305,11 +304,8 @@ impl BuiltinExprBuilder {}fn build_binary_expr(fn_name: &str, args: Vec<Expr>) -> Result<Expr> {- let [a, b] = match args.try_into() {- Ok(args_arr) => args_arr,- Err(_) => {- return substrait_err!("Expected two arguments for `{fn_name}` expr");- }+ let Ok([a, b]) = <[Expr; 2]>::try_from(args) else {+ return substrait_err!("Expected two arguments for `{fn_name}` expr");};match fn_name {"and_not" => Ok(Self::build_and_not_expr(a, b)),@@ -329,11 +325,8 @@ impl BuiltinExprBuilder {}fn build_between_expr(fn_name: &str, args: Vec<Expr>) -> Result<Expr> {- let [expression, low, high] = match args.try_into() {- Ok(args_arr) => args_arr,- Err(_) => {- return substrait_err!("Expected three arguments for `{fn_name}` expr");- }+ let Ok([expression, low, high]) = <[Expr; 3]>::try_from(args) else {+ return substrait_err!("Expected three arguments for `{fn_name}` expr");};Ok(Expr::Between(Between {diff --git a/datafusion/substrait/tests/cases/consumer_integration.rs b/datafusion/substrait/tests/cases/consumer_integration.rsindex b06230f71d..adfbb4d719 100644--- a/datafusion/substrait/tests/cases/consumer_integration.rs+++ b/datafusion/substrait/tests/cases/consumer_integration.rs@@ -52,7 +52,7 @@ mod tests {let all_lines: Vec<&str> = pretty.trim().lines().collect();let header = &all_lines[..3];let mut data: Vec<&str> = all_lines[3..all_lines.len() - 1].to_vec();- data.sort();+ data.sort_unstable();let footer = &all_lines[all_lines.len() - 1..];header.iter()diff --git a/datafusion/substrait/tests/cases/roundtrip_logical_plan.rs b/datafusion/substrait/tests/cases/roundtrip_logical_plan.rsindex 1283295906..3ee40cd5c6 100644--- a/datafusion/substrait/tests/cases/roundtrip_logical_plan.rs+++ b/datafusion/substrait/tests/cases/roundtrip_logical_plan.rs@@ -611,7 +611,7 @@ async fn roundtrip_inlist_2() -> Result<()> {#[tokio::test]// Test with length > datafusion_optimizer::simplify_expressions::expr_simplifier::THRESHOLD_INLINE_INLISTasync fn roundtrip_inlist_3() -> Result<()> {- let inlist = (0..THRESHOLD_INLINE_INLIST + 1)+ let inlist = (0..=THRESHOLD_INLINE_INLIST).map(|i| format!("'{i}'")).collect::<Vec<_>>().join(", ");@@ -2323,9 +2323,8 @@ impl HigherOrderUDFImpl for ArrayTransform {unreachable!()};- let field = match list.data_type() {- DataType::List(field) => field,- _ => unreachable!(),+ let DataType::List(field) = list.data_type() else {+ unreachable!()};Ok(LambdaParametersProgress::Complete(vec![vec![