You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@datafusion.apache.org by gi...@apache.org on 2026/08/21 09:00:08 UTC
(datafusion) branch gh-readonly-queue/main/pr-24466-9213bb596472fddd02539a56439a701919b499db created (now f75c5032af)
This is an automated email from the ASF dual-hosted git repository.
github-merge-queue[bot] pushed a change to branch gh-readonly-queue/main/pr-24466-9213bb596472fddd02539a56439a701919b499db
in repository https://gitbox.apache.org/repos/asf/datafusion.git
at f75c5032af Enable more clippy lints (#24466)
This branch includes the following new commits:
new f75c5032af Enable more clippy lints (#24466)
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datafusion.apache.org
For additional commands, e-mail: commits-help@datafusion.apache.org
(datafusion) 01/01: Enable more clippy lints (#24466)
Posted by gi...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
github-merge-queue[bot] pushed a commit to branch gh-readonly-queue/main/pr-24466-9213bb596472fddd02539a56439a701919b499db
in repository https://gitbox.apache.org/repos/asf/datafusion.git
commit f75c5032af7693cc92583502e57f2afddf140325
Author: Emil Ernerfeldt <em...@gmail.com>
AuthorDate: Fri Aug 21 08:59:43 2026 +0000
Enable more clippy lints (#24466)
## Which issue does this PR close?
- Part of #18467.
## Rationale for this change
Turn on all `clippy::pedantic` lints, and do opt-out instead of opt-in.
Then enable these lints (remove their opt-outs):
## What changes are included in this PR?
One commit per lint, each removing its `"allow"` line from `Cargo.toml`
and fixing every site. Review one commit at a time!
Let me know if you disagree with any and I'll revert it
| Lint | Sites | Fix |
|
----------------------------------------------------------------------------------------------------------
| ----: | ------------------------------------------------------- |
|
[`collapsible_else_if`](https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_else_if)
| 1 | flatten `else { if .. }` into `else if` |
|
[`range_plus_one`](https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one)
| 12 | `a..=b` instead of `a..b + 1` |
|
[`stable_sort_primitive`](https://rust-lang.github.io/rust-clippy/master/index.html#stable_sort_primitive)
| 14 | `sort_unstable` where stability cannot be observed |
|
[`comparison_chain`](https://rust-lang.github.io/rust-clippy/master/index.html#comparison_chain)
| 3 | `match Ord::cmp` instead of an `if`/`else if` chain |
|
[`should_panic_without_expect`](https://rust-lang.github.io/rust-clippy/master/index.html#should_panic_without_expect)
| 1 | name the expected panic message |
|
[`manual_assert_eq`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_assert_eq)
| 25 | `assert_eq!`/`assert_ne!` so failures print both values |
|
[`needless_for_each`](https://rust-lang.github.io/rust-clippy/master/index.html#needless_for_each)
| 47 | `for` loops instead of `for_each` |
|
[`manual_let_else`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else)
| 106 | `let .. else` instead of a diverging `match` |
## Are these changes tested?
`cargo clippy --workspace --all-targets --all-features` reports no
warnings, and the extended test suite passes. The changes are mechanical
and behavior-preserving, so no new tests.
## Are there any user-facing changes?
No.
---------
Co-authored-by: Claude Opus 5 (1M context) <no...@anthropic.com>
Co-authored-by: Daniël Heres <da...@gmail.com>
---
Cargo.toml | 139 +++++++++++----------
benchmarks/src/sort_pushdown.rs | 2 +-
benchmarks/src/sql_benchmark_runner.rs | 6 +-
datafusion-cli/src/helper.rs | 13 +-
.../examples/data_io/json_shredding.rs | 11 +-
.../examples/data_io/parquet_exec_visitor.rs | 5 +-
datafusion/common/src/dfschema.rs | 5 +-
datafusion/common/src/functional_dependencies.rs | 4 +-
datafusion/common/src/hash_utils.rs | 8 +-
datafusion/common/src/hash_utils/build_hasher.rs | 4 +-
datafusion/common/src/scalar/mod.rs | 2 +-
datafusion/common/src/utils/mod.rs | 2 +-
datafusion/core/src/bin/print_functions_docs.rs | 4 +-
datafusion/core/src/execution/session_state.rs | 8 +-
.../core/src/execution/session_state_defaults.rs | 15 +--
datafusion/core/src/physical_planner.rs | 17 ++-
datafusion/core/tests/fuzz_cases/aggregate_fuzz.rs | 10 +-
datafusion/core/tests/fuzz_cases/join_fuzz.rs | 24 ++--
.../fuzz_cases/sort_preserving_repartition_fuzz.rs | 6 +-
datafusion/core/tests/fuzz_cases/window_fuzz.rs | 10 +-
.../tests/physical_optimizer/pushdown_utils.rs | 2 +-
datafusion/core/tests/sql/path_partition.rs | 11 +-
.../user_defined/user_defined_scalar_functions.rs | 2 +-
datafusion/datasource-arrow/src/source.rs | 13 +-
datafusion/datasource-avro/src/source.rs | 13 +-
datafusion/datasource-csv/src/source.rs | 11 +-
datafusion/datasource-json/src/source.rs | 13 +-
.../datasource-parquet/src/projection_read_plan.rs | 11 +-
datafusion/datasource-parquet/src/source.rs | 15 +--
datafusion/datasource/src/boundary_stream.rs | 8 +-
.../datasource/src/file_stream/scan_state.rs | 5 +-
datafusion/datasource/src/statistics.rs | 30 ++---
datafusion/doc/src/lib.rs | 23 ++--
datafusion/expr/src/expr_rewriter/order_by.rs | 4 +-
datafusion/expr/src/higher_order_function.rs | 5 +-
datafusion/expr/src/logical_plan/plan.rs | 11 +-
datafusion/expr/src/utils.rs | 12 +-
datafusion/ffi/src/table_provider.rs | 13 +-
datafusion/ffi/src/util.rs | 10 +-
datafusion/ffi/tests/ffi_udf.rs | 8 +-
datafusion/ffi/tests/ffi_udtf.rs | 4 +-
.../src/aggregate/groups_accumulator/accumulate.rs | 20 +--
datafusion/functions-aggregate/src/covariance.rs | 10 +-
datafusion/functions-aggregate/src/first_last.rs | 11 +-
datafusion/functions-aggregate/src/min_max.rs | 4 +-
.../src/min_max/min_max_struct.rs | 5 +-
datafusion/functions-aggregate/src/regr.rs | 12 +-
datafusion/functions-aggregate/src/stddev.rs | 4 +-
datafusion/functions-aggregate/src/string_agg.rs | 2 +-
datafusion/functions-aggregate/src/sum.rs | 2 +-
datafusion/functions-aggregate/src/variance.rs | 4 +-
datafusion/functions-nested/src/distance.rs | 10 +-
datafusion/functions-nested/src/lambda_utils.rs | 5 +-
datafusion/functions-nested/src/length.rs | 5 +-
datafusion/functions-nested/src/map.rs | 15 +--
datafusion/functions-nested/src/remove.rs | 30 +++--
datafusion/functions-nested/src/utils.rs | 5 +-
datafusion/functions-window/src/row_number.rs | 2 +-
datafusion/functions/src/core/arrow_metadata.rs | 12 +-
datafusion/functions/src/core/union_tag.rs | 5 +-
datafusion/functions/src/datetime/current_time.rs | 24 ++--
datafusion/functions/src/datetime/date_bin.rs | 110 ++++++++--------
datafusion/functions/src/datetime/date_trunc.rs | 108 ++++++++--------
datafusion/functions/src/datetime/to_local_time.rs | 4 +-
datafusion/functions/src/datetime/to_timestamp.rs | 10 +-
datafusion/functions/src/utils.rs | 43 +++----
.../optimizer/src/common_subexpr_eliminate.rs | 2 +-
.../optimizer/src/extract_leaf_expressions.rs | 8 +-
.../optimizer/src/optimize_projections/mod.rs | 5 +-
datafusion/optimizer/src/optimizer.rs | 5 +-
.../physical-expr-adapter/src/schema_rewriter.rs | 68 +++++-----
datafusion/physical-expr-common/src/binary_map.rs | 2 +-
.../physical-expr-common/src/metrics/value.rs | 6 +-
datafusion/physical-expr/src/aggregate.rs | 11 +-
datafusion/physical-expr/src/analysis.rs | 10 +-
.../src/expressions/binary/kernels.rs | 39 +++---
datafusion/physical-expr/src/expressions/lambda.rs | 2 +-
datafusion/physical-expr/src/simplifier/not.rs | 5 +-
datafusion/physical-expr/src/window/standard.rs | 5 +-
datafusion/physical-expr/src/window/window_expr.rs | 5 +-
.../src/ensure_requirements/enforce_sorting/mod.rs | 2 +-
.../physical-plan/benches/sort_merge_join.rs | 2 +-
.../group_values/multi_group_by/bytes_view.rs | 2 +-
.../aggregates/group_values/multi_group_by/mod.rs | 2 +-
datafusion/physical-plan/src/aggregates/mod.rs | 2 +-
datafusion/physical-plan/src/filter.rs | 6 +-
.../src/joins/hash_join/partitioned_hash_eval.rs | 7 +-
.../physical-plan/src/joins/hash_join/stream.rs | 2 +-
.../physical-plan/src/joins/nested_loop_join.rs | 25 ++--
.../physical-plan/src/joins/stream_join_utils.rs | 4 +-
datafusion/physical-plan/src/joins/test_utils.rs | 2 +-
datafusion/physical-plan/src/joins/utils.rs | 2 +-
datafusion/physical-plan/src/repartition/mod.rs | 15 ++-
.../src/sorts/sort_preserving_merge.rs | 13 +-
datafusion/physical-plan/src/spill/spill_pool.rs | 2 +-
datafusion/physical-plan/src/windows/mod.rs | 13 +-
datafusion/proto/tests/cases/mod.rs | 5 +-
datafusion/proto/tests/cases/serialize.rs | 7 +-
datafusion/pruning/src/file_pruner.rs | 2 +-
datafusion/pruning/src/pruning_predicate.rs | 7 +-
datafusion/spark/src/function/math/ceil.rs | 35 +++---
datafusion/spark/src/function/math/factorial.rs | 10 +-
datafusion/spark/src/function/math/hex.rs | 45 +++----
datafusion/spark/src/function/math/round.rs | 13 +-
datafusion/spark/src/function/math/width_bucket.rs | 9 +-
datafusion/sql/src/expr/mod.rs | 7 +-
datafusion/sql/src/parser.rs | 4 +-
datafusion/sql/src/statement.rs | 4 +-
datafusion/sql/src/unparser/expr.rs | 33 ++---
datafusion/sql/tests/sql_integration.rs | 5 +-
datafusion/sqllogictest/bin/sqllogictests.rs | 28 +++--
.../src/engines/datafusion_engine/normalize.rs | 4 +-
.../logical_plan/consumer/expr/scalar_function.rs | 19 +--
.../substrait/tests/cases/consumer_integration.rs | 2 +-
.../tests/cases/roundtrip_logical_plan.rs | 7 +-
115 files changed, 676 insertions(+), 825 deletions(-)
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![
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datafusion.apache.org
For additional commands, e-mail: commits-help@datafusion.apache.org