Skip to content

Apache DataFusion SQL Query Engine

Enable more clippy lints (#24466)

Emil Ernerfeldtf75c5032af76
diff --git a/Cargo.toml b/Cargo.toml
index 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/18881
allow_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 overflows
large_stack_frames = "warn"
-large_types_passed_by_value = "warn"
-linkedlist = "warn"
# Catches `"{foo}"` where the string is never actually formatted
literal_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 twice
set_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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 strings
let 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 list
for name in names {
diff --git a/datafusion/core/src/execution/session_state.rs b/datafusion/core/src/execution/session_state.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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<Record
let 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.rs
index 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 output
let 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 Arguments
if 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());
}
}
- });
+ }
}
// Arguments
if 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 UDFs
if 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.html
let 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 loop
let mut index_mask = 1;
- group_index_chunk.iter().for_each(|&group_index| {
+ for &group_index in group_index_chunk {
// valid bit was set, real vale
let 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 loop
let mut index_mask = 1;
- group_index_chunk.iter().for_each(|&group_index| {
+ for &group_index in group_index_chunk {
// valid bit was set, real vale
let 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 loop
let mut index_mask = 1;
- group_index_chunk.iter().for_each(|&group_index| {
+ for &group_index in group_index_chunk {
// valid bit was set, real vale
let 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.rs
index 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.rs
index 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<S
ordering_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<S
let 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.rs
index 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.rs
index 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_maxes
diff --git a/datafusion/functions-aggregate/src/regr.rs b/datafusion/functions-aggregate/src/regr.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 = m2s
diff --git a/datafusion/functions-nested/src/distance.rs b/datafusion/functions-nested/src/distance.rs
index 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 arrays
if 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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:00
diff --git a/datafusion/functions/src/datetime/date_bin.rs b/datafusion/functions/src/datetime/date_bin.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 i128
pub 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 panic
let 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.rs
index 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 differs
custom_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 = value
diff --git a/datafusion/physical-expr/src/aggregate.rs b/datafusion/physical-expr/src/aggregate.rs
index 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.rs
index 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.rs
index 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 flag
macro_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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 nested
return;
- }
- };
+ };
// 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.rs
index 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 file
if values.into_iter().all(|v| !v) {
return Ok(true);
diff --git a/datafusion/pruning/src/pruning_predicate.rs b/datafusion/pruning/src/pruning_predicate.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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<Columna
return 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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<'_> {
where
i64: 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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_INLIST
async 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![