You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by je...@apache.org on 2026/08/17 02:39:07 UTC
(arrow-rs) branch main updated: Enable more clippy lints (#10673)
This is an automated email from the ASF dual-hosted git repository.
Jefffrey pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-rs.git
The following commit(s) were added to refs/heads/main by this push:
new 35fda7ccb9 Enable more clippy lints (#10673)
35fda7ccb9 is described below
commit 35fda7ccb903c4f9384c41d6604ebf7a6e35124c
Author: Emil Ernerfeldt <em...@gmail.com>
AuthorDate: Sun Aug 16 19:39:00 2026 -0700
Enable more clippy lints (#10673)
# Which issue does this PR close?
No issue in particular
- Follow-up to #10558
- Follow-up to #10552
- Follow-up to #10551
- Follow-up to #10533
# Rationale for this change
More lints hand-picked from [egui's
`Cargo.toml`](https://github.com/emilk/egui/blob/main/Cargo.toml), to
simplify the code, catch bugs, and write more efficient code.
## What changes are included in this PR?
One commit per new lint (maybe easiest to review commit by commit!),
except for ten lints with zero violations, which share one commit.
Let me know if you disagree with any of them.
I hope to add even more lints in later PRs.
## Are these changes tested?
Covered by existing tests plus the clippy CI job.
## Are there any user-facing changes?
Two additive ones: `IntoIterator` is now implemented for references to
`FixedSizeListArray`, `GenericListArray`, `GenericListViewArray`,
`MapArray`, `BitChunks`, `UnalignedBitChunk` and `VariantArray`, and the
`UnalignedBitChunkIterator` alias now names `Copied` instead of
`Cloned`.
---------
Co-authored-by: Jeffrey Vo <je...@gmail.com>
Co-authored-by: Claude Opus 5 (1M context) <no...@anthropic.com>
---
Cargo.toml | 25 ++++++
arrow-array/src/array/byte_view_array.rs | 9 ++-
arrow-array/src/array/dictionary_array.rs | 2 +-
arrow-array/src/array/fixed_size_list_array.rs | 9 +++
arrow-array/src/array/list_array.rs | 9 +++
arrow-array/src/array/list_view_array.rs | 9 +++
arrow-array/src/array/map_array.rs | 9 +++
arrow-array/src/array/struct_array.rs | 2 +-
.../src/builder/fixed_size_binary_builder.rs | 6 +-
arrow-array/src/builder/fixed_size_list_builder.rs | 9 +--
.../src/builder/generic_bytes_view_builder.rs | 2 +-
arrow-array/src/ffi.rs | 8 +-
arrow-array/src/ffi_stream.rs | 10 +--
arrow-array/src/trusted_len.rs | 2 +-
arrow-array/src/types.rs | 12 +--
arrow-avro/src/codec.rs | 6 +-
arrow-avro/src/reader/async_reader/mod.rs | 2 -
arrow-avro/src/reader/mod.rs | 8 +-
arrow-avro/src/reader/record.rs | 12 +--
arrow-avro/src/writer/encoder.rs | 78 +++++++++----------
arrow-buffer/benches/i256.rs | 4 +-
arrow-buffer/src/bigint/div.rs | 8 +-
arrow-buffer/src/buffer/boolean.rs | 6 +-
arrow-buffer/src/buffer/immutable.rs | 6 +-
arrow-buffer/src/buffer/mutable.rs | 6 +-
arrow-buffer/src/buffer/offset.rs | 2 +-
arrow-buffer/src/buffer/scalar.rs | 6 +-
arrow-buffer/src/builder/mod.rs | 4 +-
arrow-buffer/src/bytes.rs | 2 +-
arrow-buffer/src/native.rs | 4 +-
arrow-buffer/src/util/bit_chunk_iterator.rs | 28 +++++--
arrow-buffer/src/util/bit_mask.rs | 10 +--
arrow-buffer/src/util/bit_util.rs | 4 +-
arrow-cast/src/base64.rs | 4 +-
arrow-cast/src/cast/dictionary.rs | 6 +-
arrow-cast/src/cast/mod.rs | 91 +++++++++++++---------
arrow-cast/src/cast/string.rs | 8 +-
arrow-cast/src/display.rs | 4 +-
arrow-cast/src/parse.rs | 4 +-
arrow-cast/src/pretty.rs | 2 +-
arrow-cmp/src/lib.rs | 10 +--
arrow-csv/src/reader/mod.rs | 7 +-
arrow-csv/src/writer.rs | 2 +-
arrow-data/src/data.rs | 6 +-
arrow-data/src/equal/fixed_binary.rs | 9 +--
arrow-data/src/equal/list_view.rs | 36 ++-------
arrow-data/src/equal/primitive.rs | 9 +--
arrow-data/src/ffi.rs | 12 +--
arrow-data/src/transform/fixed_size_list.rs | 4 +-
arrow-data/src/transform/run.rs | 2 +-
arrow-data/src/transform/union.rs | 4 +-
arrow-flight/src/client.rs | 12 +--
arrow-flight/src/encode.rs | 12 +--
arrow-flight/src/sql/metadata/sql_info.rs | 2 +-
arrow-flight/src/utils.rs | 4 +-
arrow-integration-test/src/field.rs | 2 +-
arrow-integration-test/src/lib.rs | 2 +-
arrow-integration-test/src/schema.rs | 7 +-
arrow-ipc/src/convert.rs | 10 +--
arrow-ipc/src/gen/mod.rs | 12 +--
arrow-ipc/src/reader.rs | 8 +-
arrow-ipc/src/writer.rs | 2 +-
arrow-json/src/reader/mod.rs | 2 +-
arrow-json/src/reader/primitive_array.rs | 18 ++---
arrow-json/src/reader/schema.rs | 16 ++--
arrow-json/src/reader/struct_array.rs | 2 +-
arrow-json/src/writer/encoder.rs | 2 +-
arrow-json/src/writer/mod.rs | 2 +-
arrow-ord/src/comparison.rs | 4 +-
arrow-ord/src/sort.rs | 6 +-
arrow-row/src/lib.rs | 4 +-
arrow-schema/src/datatype_parse.rs | 3 +-
arrow-schema/src/ffi.rs | 17 ++--
arrow-schema/src/fields.rs | 2 +-
arrow-schema/src/schema.rs | 35 ++-------
arrow-select/src/coalesce.rs | 12 +--
arrow-select/src/coalesce/primitive.rs | 9 +--
arrow-select/src/concat.rs | 20 ++---
arrow-select/src/filter.rs | 16 ++--
arrow-select/src/interleave.rs | 4 +-
arrow-string/src/binary_like.rs | 2 +-
arrow-string/src/like.rs | 2 +-
arrow/benches/row_format.rs | 2 +-
arrow/tests/array_cast.rs | 2 +-
arrow/tests/array_validation.rs | 2 +-
arrow/tests/schema.rs | 4 +-
parquet-variant-compute/benches/variant_kernels.rs | 16 ++--
parquet-variant-compute/src/arrow_to_variant.rs | 2 +-
parquet-variant-compute/src/shred_variant.rs | 4 +-
parquet-variant-compute/src/unshred_variant.rs | 10 +--
parquet-variant-compute/src/variant_array.rs | 9 +++
parquet-variant-compute/src/variant_get.rs | 1 -
parquet-variant-compute/src/variant_to_arrow.rs | 2 +-
parquet-variant-json/src/from_json.rs | 2 +-
parquet-variant/src/builder/metadata.rs | 4 +-
parquet/benches/arrow_reader_row_filter.rs | 2 +-
parquet/benches/arrow_statistics.rs | 6 +-
parquet/benches/encoding.rs | 2 +-
parquet/benches/row_selection_cursor.rs | 2 +-
parquet/examples/write_parquet.rs | 2 +-
parquet/src/arrow/array_reader/byte_array.rs | 6 +-
.../arrow/array_reader/byte_array_dictionary.rs | 6 +-
parquet/src/arrow/array_reader/byte_view_array.rs | 9 +--
.../src/arrow/array_reader/cached_array_reader.rs | 2 +-
.../src/arrow/array_reader/fixed_len_byte_array.rs | 2 +-
parquet/src/arrow/array_reader/struct_array.rs | 4 +-
parquet/src/arrow/arrow_reader/mod.rs | 12 +--
parquet/src/arrow/arrow_reader/read_plan.rs | 2 +-
.../src/arrow/arrow_reader/selection/boolean.rs | 12 +--
parquet/src/arrow/arrow_reader/selection/mod.rs | 2 +-
parquet/src/arrow/arrow_reader/selection/ranges.rs | 8 +-
parquet/src/arrow/arrow_writer/mod.rs | 16 ++--
parquet/src/arrow/async_reader/mod.rs | 8 +-
parquet/src/arrow/async_reader/store.rs | 4 +-
parquet/src/arrow/buffer/bit_util.rs | 2 +-
parquet/src/arrow/buffer/dictionary_buffer.rs | 14 ++--
.../src/arrow/push_decoder/reader_builder/mod.rs | 2 +-
parquet/src/arrow/record_reader/mod.rs | 6 +-
parquet/src/arrow/schema/mod.rs | 5 +-
parquet/src/arrow/schema/primitive.rs | 2 +-
parquet/src/basic.rs | 16 ++--
parquet/src/bloom_filter/mod.rs | 4 +-
parquet/src/column/chunker/cdc.rs | 2 +-
parquet/src/column/page.rs | 2 +-
parquet/src/column/page_encryption.rs | 4 +-
parquet/src/column/page_encryption_disabled.rs | 7 ++
parquet/src/column/reader.rs | 5 +-
parquet/src/column/reader/decoder.rs | 2 +-
parquet/src/column/writer/encoder.rs | 2 -
parquet/src/column/writer/mod.rs | 20 +++--
parquet/src/compression.rs | 9 +--
parquet/src/data_type.rs | 14 ++--
parquet/src/encodings/decoding.rs | 4 +-
parquet/src/encodings/encoding/mod.rs | 3 +-
parquet/src/encodings/rle.rs | 16 ++--
parquet/src/encryption/decrypt.rs | 2 +-
parquet/src/encryption/encrypt.rs | 2 +-
parquet/src/file/metadata/mod.rs | 14 ++--
parquet/src/file/metadata/push_decoder.rs | 2 -
parquet/src/file/metadata/thrift/encryption.rs | 5 +-
parquet/src/file/metadata/thrift/mod.rs | 6 +-
parquet/src/file/page_index/column_index.rs | 2 +-
parquet/src/file/serialized_reader.rs | 23 ++----
parquet/src/file/statistics.rs | 19 +++--
parquet/src/file/writer.rs | 10 ++-
parquet/src/parquet_thrift.rs | 2 +-
parquet/src/record/reader.rs | 4 +-
parquet/src/schema/printer.rs | 2 +-
parquet/src/schema/types.rs | 32 ++++----
parquet/src/schema/visitor.rs | 2 +-
parquet/tests/arrow_reader/bad_data.rs | 2 +-
parquet/tests/arrow_reader/mod.rs | 4 +-
parquet/tests/arrow_writer/mod.rs | 2 +-
parquet/tests/encryption/encryption.rs | 12 +--
parquet/tests/encryption/encryption_async.rs | 2 +-
parquet/tests/encryption/encryption_util.rs | 2 +-
parquet_derive/src/parquet_field.rs | 2 +-
157 files changed, 645 insertions(+), 606 deletions(-)
diff --git a/Cargo.toml b/Cargo.toml
index 535caae8d9..5b2a9874f9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -157,22 +157,30 @@ missing_crate_level_docs = "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"
+cloned_instead_of_copied = "warn"
+coerce_container_to_any = "warn"
comparison_chain = "warn"
dbg_macro = "warn"
debug_assert_with_mut_call = "warn"
+decimal_bitwise_operands = "warn"
default_union_representation = "warn"
disallowed_script_idents = "warn"
+doc_broken_link = "warn"
doc_comment_double_space_linebreaks = "warn"
doc_include_without_cfg = "warn"
doc_link_with_quotes = "warn"
+duration_suboptimal_units = "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"
explicit_into_iter_loop = "warn"
+explicit_iter_loop = "warn"
filter_map_next = "warn"
flat_map_option = "warn"
float_cmp_const = "warn"
@@ -180,6 +188,7 @@ fn_params_excessive_bools = "warn"
fn_to_numeric_cast_any = "warn"
format_push_string = "warn"
ignored_unit_patterns = "warn"
+implicit_clone = "warn"
imprecise_flops = "warn"
inconsistent_struct_constructor = "warn"
index_refutable_slice = "warn"
@@ -187,11 +196,14 @@ 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_with_drain = "warn"
+iter_without_into_iter = "warn"
large_digit_groups = "warn"
large_futures = "warn"
large_include_file = "warn"
@@ -202,33 +214,44 @@ linkedlist = "warn"
literal_string_with_formatting_args = "warn"
lossy_float_literal = "warn"
macro_use_imports = "warn"
+manual_ilog2 = "warn"
manual_instant_elapsed = "warn"
manual_is_power_of_two = "warn"
manual_is_variant_and = "warn"
manual_midpoint = "warn"
manual_string_new = "warn"
match_wild_err_arm = "warn"
+match_wildcard_for_single_variants = "warn"
mismatching_type_param_order = "warn"
mut_mut = "warn"
mutex_integer = "warn"
+needless_continue = "warn"
+needless_pass_by_ref_mut = "warn"
needless_raw_string_hashes = "warn"
+needless_type_cast = "warn"
negative_feature_names = "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_as_ptr = "warn"
ptr_cast_constness = "warn"
ptr_offset_by_literal = "warn"
pub_without_shorthand = "warn"
rc_mutex = "warn"
+redundant_type_annotations = "warn"
+ref_as_ptr = "warn"
ref_binding_to_reference = "warn"
+ref_option = "warn"
ref_option_ref = "warn"
rest_pat_in_fully_bound_structs = "warn"
same_functions_in_if_condition = "warn"
same_length_and_capacity = "warn"
+self_only_used_in_recursion = "warn"
set_contains_or_insert = "warn"
should_panic_without_expect = "warn"
single_char_pattern = "warn"
@@ -243,12 +266,14 @@ trailing_empty_array = "warn"
trait_duplication_in_bounds = "warn"
transmute_ptr_to_ptr = "warn"
tuple_array_conversions = "warn"
+unchecked_time_subtraction = "warn"
uninhabited_references = "warn"
unnecessary_box_returns = "warn"
unnecessary_literal_bound = "warn"
unnecessary_safety_doc = "warn"
unnecessary_self_imports = "warn"
unnecessary_struct_initialization = "warn"
+unnecessary_trailing_comma = "warn"
unnested_or_patterns = "warn"
unused_async = "warn"
unused_peekable = "warn"
diff --git a/arrow-array/src/array/byte_view_array.rs b/arrow-array/src/array/byte_view_array.rs
index 964e7cbe34..f1ede087e5 100644
--- a/arrow-array/src/array/byte_view_array.rs
+++ b/arrow-array/src/array/byte_view_array.rs
@@ -357,7 +357,12 @@ impl<T: ByteViewType + ?Sized> GenericByteViewArray<T> {
pub unsafe fn inline_value(view: &u128, len: usize) -> &[u8] {
debug_assert!(len <= MAX_INLINE_VIEW_LEN as usize);
unsafe {
- std::slice::from_raw_parts((view as *const u128 as *const u8).wrapping_add(4), len)
+ std::slice::from_raw_parts(
+ std::ptr::from_ref::<u128>(view)
+ .cast::<u8>()
+ .wrapping_add(4),
+ len,
+ )
}
}
@@ -1513,7 +1518,7 @@ mod tests {
} else {
// random length between 0 and twice the inline limit
let len = rng.random_range(0..(MAX_INLINE_VIEW_LEN * 2));
- let s: String = "A".repeat(len as usize);
+ let s = "A".repeat(len as usize);
builder.append_option(Some(&s));
original.push(Some(s));
}
diff --git a/arrow-array/src/array/dictionary_array.rs b/arrow-array/src/array/dictionary_array.rs
index 0ee7710320..6bd3e64bef 100644
--- a/arrow-array/src/array/dictionary_array.rs
+++ b/arrow-array/src/array/dictionary_array.rs
@@ -1393,7 +1393,7 @@ mod tests {
#[should_panic(expected = "Invalid dictionary key -100 at index 0, expected 0 <= key < 2")]
fn test_try_new_index_too_small() {
let values: StringArray = [Some("foo"), Some("bar")].into_iter().collect();
- let keys: Int32Array = [Some(-100)].into_iter().collect();
+ let keys: Int32Array = std::iter::once(Some(-100)).collect();
DictionaryArray::new(keys, Arc::new(values));
}
diff --git a/arrow-array/src/array/fixed_size_list_array.rs b/arrow-array/src/array/fixed_size_list_array.rs
index 667546a852..414d35fac6 100644
--- a/arrow-array/src/array/fixed_size_list_array.rs
+++ b/arrow-array/src/array/fixed_size_list_array.rs
@@ -463,6 +463,15 @@ impl FixedSizeListArray {
}
}
+impl<'a> IntoIterator for &'a FixedSizeListArray {
+ type Item = Option<ArrayRef>;
+ type IntoIter = FixedSizeListIter<'a>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ FixedSizeListIter::new(self)
+ }
+}
+
impl From<ArrayData> for FixedSizeListArray {
fn from(data: ArrayData) -> Self {
let (data_type, len, nulls, offset, _buffers, child_data) = data.into_parts();
diff --git a/arrow-array/src/array/list_array.rs b/arrow-array/src/array/list_array.rs
index 33bf88e171..521bcbb84e 100644
--- a/arrow-array/src/array/list_array.rs
+++ b/arrow-array/src/array/list_array.rs
@@ -681,6 +681,15 @@ impl<OffsetSize: OffsetSizeTrait> super::ListLikeArray for GenericListArray<Offs
}
}
+impl<'a, OffsetSize: OffsetSizeTrait> IntoIterator for &'a GenericListArray<OffsetSize> {
+ type Item = Option<ArrayRef>;
+ type IntoIter = GenericListArrayIter<'a, OffsetSize>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ GenericListArrayIter::<'a, OffsetSize>::new(self)
+ }
+}
+
impl<OffsetSize: OffsetSizeTrait> ArrayAccessor for &GenericListArray<OffsetSize> {
type Item = ArrayRef;
diff --git a/arrow-array/src/array/list_view_array.rs b/arrow-array/src/array/list_view_array.rs
index 7dcd6755e7..2b92729b3b 100644
--- a/arrow-array/src/array/list_view_array.rs
+++ b/arrow-array/src/array/list_view_array.rs
@@ -449,6 +449,15 @@ impl<OffsetSize: OffsetSizeTrait> GenericListViewArray<OffsetSize> {
}
}
+impl<'a, OffsetSize: OffsetSizeTrait> IntoIterator for &'a GenericListViewArray<OffsetSize> {
+ type Item = Option<ArrayRef>;
+ type IntoIter = GenericListViewArrayIter<'a, OffsetSize>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ GenericListViewArrayIter::<'a, OffsetSize>::new(self)
+ }
+}
+
impl<OffsetSize: OffsetSizeTrait> ArrayAccessor for &GenericListViewArray<OffsetSize> {
type Item = ArrayRef;
diff --git a/arrow-array/src/array/map_array.rs b/arrow-array/src/array/map_array.rs
index 0e604dd0c7..2b3b69cd92 100644
--- a/arrow-array/src/array/map_array.rs
+++ b/arrow-array/src/array/map_array.rs
@@ -313,6 +313,15 @@ impl MapArray {
}
}
+impl<'a> IntoIterator for &'a MapArray {
+ type Item = Option<StructArray>;
+ type IntoIter = MapArrayIter<'a>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ MapArrayIter::new(self)
+ }
+}
+
impl From<ArrayData> for MapArray {
fn from(data: ArrayData) -> Self {
Self::try_new_from_array_data(data)
diff --git a/arrow-array/src/array/struct_array.rs b/arrow-array/src/array/struct_array.rs
index 95907d3246..0fbe361dc6 100644
--- a/arrow-array/src/array/struct_array.rs
+++ b/arrow-array/src/array/struct_array.rs
@@ -1029,7 +1029,7 @@ mod tests {
#[test]
fn test_struct_array_fmt_debug() {
- let arr: StructArray = StructArray::new(
+ let arr = StructArray::new(
vec![Arc::new(Field::new("c", DataType::Int32, true))].into(),
vec![Arc::new(Int32Array::from((0..30).collect::<Vec<_>>())) as ArrayRef],
Some(NullBuffer::new(BooleanBuffer::from(
diff --git a/arrow-array/src/builder/fixed_size_binary_builder.rs b/arrow-array/src/builder/fixed_size_binary_builder.rs
index 97fab0b55b..94d03324ba 100644
--- a/arrow-array/src/builder/fixed_size_binary_builder.rs
+++ b/arrow-array/src/builder/fixed_size_binary_builder.rs
@@ -205,7 +205,7 @@ mod tests {
builder.append_value(b"arrow").unwrap();
builder.append_nulls(2);
builder.append_value(b"world").unwrap();
- let array: FixedSizeBinaryArray = builder.finish();
+ let array = builder.finish();
assert_eq!(&DataType::FixedSizeBinary(5), array.data_type());
assert_eq!(6, array.len());
@@ -225,7 +225,7 @@ mod tests {
builder.append_value(b"hello").unwrap();
builder.append_null();
builder.append_value(b"arrow").unwrap();
- let mut array: FixedSizeBinaryArray = builder.finish_cloned();
+ let mut array = builder.finish_cloned();
assert_eq!(&DataType::FixedSizeBinary(5), array.data_type());
assert_eq!(3, array.len());
@@ -256,7 +256,7 @@ mod tests {
builder.append_value(b"").unwrap();
assert!(!builder.is_empty());
- let array: FixedSizeBinaryArray = builder.finish();
+ let array = builder.finish();
assert_eq!(&DataType::FixedSizeBinary(0), array.data_type());
assert_eq!(3, array.len());
assert_eq!(1, array.null_count());
diff --git a/arrow-array/src/builder/fixed_size_list_builder.rs b/arrow-array/src/builder/fixed_size_list_builder.rs
index 67608983bb..a297a5423d 100644
--- a/arrow-array/src/builder/fixed_size_list_builder.rs
+++ b/arrow-array/src/builder/fixed_size_list_builder.rs
@@ -289,17 +289,14 @@ mod tests {
builder.append(true);
}
+ builder.values().append_value(3);
if include_null_in_values {
- builder.values().append_value(3);
builder.values().append_null();
- builder.values().append_value(5);
- builder.append(true);
} else {
- builder.values().append_value(3);
builder.values().append_value(4);
- builder.values().append_value(5);
- builder.append(true);
}
+ builder.values().append_value(5);
+ builder.append(true);
builder
}
diff --git a/arrow-array/src/builder/generic_bytes_view_builder.rs b/arrow-array/src/builder/generic_bytes_view_builder.rs
index cb7ecf85eb..45a3b08814 100644
--- a/arrow-array/src/builder/generic_bytes_view_builder.rs
+++ b/arrow-array/src/builder/generic_bytes_view_builder.rs
@@ -991,7 +991,7 @@ mod tests {
// All views should be identical
let first_view = array.views()[0];
- for view in array.views().iter() {
+ for view in array.views() {
assert_eq!(*view, first_view);
}
}
diff --git a/arrow-array/src/ffi.rs b/arrow-array/src/ffi.rs
index 8227034a9e..7aaf1f2248 100644
--- a/arrow-array/src/ffi.rs
+++ b/arrow-array/src/ffi.rs
@@ -481,7 +481,7 @@ impl ImportedArrowArray<'_> {
// first buffer is the null buffer => add(1)
// we assume that pointer is aligned for `i32`, as Utf8 uses `i32` offsets.
#[expect(clippy::cast_ptr_alignment)]
- let offset_buffer = self.array.buffer(1) as *const i32;
+ let offset_buffer = self.array.buffer(1).cast::<i32>();
// get last offset
(unsafe { *offset_buffer.add(len / size_of::<i32>() - 1) }) as usize
}
@@ -495,7 +495,7 @@ impl ImportedArrowArray<'_> {
// first buffer is the null buffer => add(1)
// we assume that pointer is aligned for `i64`, as Large uses `i64` offsets.
#[expect(clippy::cast_ptr_alignment)]
- let offset_buffer = self.array.buffer(1) as *const i64;
+ let offset_buffer = self.array.buffer(1).cast::<i64>();
// get last offset
(unsafe { *offset_buffer.add(len / size_of::<i64>() - 1) }) as usize
}
@@ -589,8 +589,8 @@ mod tests_to_then_from_ffi {
let schema = Box::new(ManuallyDrop::new(schema));
let array = Box::new(ManuallyDrop::new(array));
- let schema_ptr = &**schema as *const _;
- let array_ptr = &**array as *const _;
+ let schema_ptr = std::ptr::from_ref(&**schema);
+ let array_ptr = std::ptr::from_ref(&**array);
// We can read them back to memory
// SAFETY:
diff --git a/arrow-array/src/ffi_stream.rs b/arrow-array/src/ffi_stream.rs
index ac79e10eb2..79f15afdde 100644
--- a/arrow-array/src/ffi_stream.rs
+++ b/arrow-array/src/ffi_stream.rs
@@ -123,7 +123,7 @@ unsafe extern "C" fn release_stream(stream: *mut FFI_ArrowArrayStream) {
stream.get_next = None;
stream.get_last_error = None;
- let private_data = unsafe { Box::from_raw(stream.private_data as *mut StreamPrivateData) };
+ let private_data = unsafe { Box::from_raw(stream.private_data.cast::<StreamPrivateData>()) };
drop(private_data);
stream.release = None;
@@ -183,7 +183,7 @@ impl FFI_ArrowArrayStream {
get_next: Some(get_next),
get_last_error: Some(get_last_error),
release: Some(release_stream),
- private_data: Box::into_raw(private_data) as *mut c_void,
+ private_data: Box::into_raw(private_data).cast::<c_void>(),
}
}
@@ -260,7 +260,7 @@ struct ExportedArrayStream {
impl ExportedArrayStream {
fn get_private_data(&mut self) -> &mut StreamPrivateData {
- unsafe { &mut *((*self.stream).private_data as *mut StreamPrivateData) }
+ unsafe { &mut *(*self.stream).private_data.cast::<StreamPrivateData>() }
}
pub fn get_schema(&mut self, out: *mut FFI_ArrowSchema) -> i32 {
@@ -619,7 +619,7 @@ mod tests {
unsafe extern "C" fn wrapping_release(stream: *mut FFI_ArrowArrayStream) {
use std::sync::atomic::Ordering;
let stream = unsafe { &mut *stream };
- let data = unsafe { Box::from_raw(stream.private_data() as *mut StreamWrapperData) };
+ let data = unsafe { Box::from_raw(stream.private_data().cast::<StreamWrapperData>()) };
STREAM_WRAPPER_RAN.store(true, Ordering::SeqCst);
unsafe { stream.set_release(data.original_release) };
unsafe { stream.set_private_data(data.original_private_data) };
@@ -643,7 +643,7 @@ mod tests {
original_private_data: stream.private_data(),
});
unsafe { stream.set_release(Some(wrapping_release)) };
- unsafe { stream.set_private_data(Box::into_raw(data) as *mut c_void) };
+ unsafe { stream.set_private_data(Box::into_raw(data).cast::<c_void>()) };
drop(stream); // runs wrapping_release, which chains to the original
assert!(STREAM_WRAPPER_RAN.load(Ordering::SeqCst));
diff --git a/arrow-array/src/trusted_len.rs b/arrow-array/src/trusted_len.rs
index 8a3c3edec0..6ce2da8806 100644
--- a/arrow-array/src/trusted_len.rs
+++ b/arrow-array/src/trusted_len.rs
@@ -37,7 +37,7 @@ where
let mut buffer = MutableBuffer::new(len);
let dst_null = null.as_mut_ptr();
- let mut dst = buffer.as_mut_ptr() as *mut T;
+ let mut dst = buffer.as_mut_ptr().cast::<T>();
for (i, item) in iterator.enumerate() {
let item = item.borrow();
if let Some(item) = item {
diff --git a/arrow-array/src/types.rs b/arrow-array/src/types.rs
index 8988491314..729ebd6e33 100644
--- a/arrow-array/src/types.rs
+++ b/arrow-array/src/types.rs
@@ -952,7 +952,7 @@ impl Date32Type {
#[deprecated(since = "58.0.0", note = "Use to_naive_date_opt instead.")]
pub fn to_naive_date(i: <Date32Type as ArrowPrimitiveType>::Native) -> NaiveDate {
Self::to_naive_date_opt(i)
- .unwrap_or_else(|| panic!("Date32Type::to_naive_date overflowed for date: {i}",))
+ .unwrap_or_else(|| panic!("Date32Type::to_naive_date overflowed for date: {i}"))
}
/// Converts an arrow Date32Type into a chrono::NaiveDate
@@ -996,7 +996,7 @@ impl Date32Type {
delta: <IntervalYearMonthType as ArrowPrimitiveType>::Native,
) -> <Date32Type as ArrowPrimitiveType>::Native {
Self::add_year_months_opt(date, delta).unwrap_or_else(|| {
- panic!("Date32Type::add_year_months overflowed for date: {date}, delta: {delta}",)
+ panic!("Date32Type::add_year_months overflowed for date: {date}, delta: {delta}")
})
}
@@ -1037,7 +1037,7 @@ impl Date32Type {
delta: <IntervalDayTimeType as ArrowPrimitiveType>::Native,
) -> <Date32Type as ArrowPrimitiveType>::Native {
Self::add_day_time_opt(date, delta).unwrap_or_else(|| {
- panic!("Date32Type::add_day_time overflowed for date: {date}, delta: {delta:?}",)
+ panic!("Date32Type::add_day_time overflowed for date: {date}, delta: {delta:?}")
})
}
@@ -1079,7 +1079,7 @@ impl Date32Type {
delta: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
) -> <Date32Type as ArrowPrimitiveType>::Native {
Self::add_month_day_nano_opt(date, delta).unwrap_or_else(|| {
- panic!("Date32Type::add_month_day_nano overflowed for date: {date}, delta: {delta:?}",)
+ panic!("Date32Type::add_month_day_nano overflowed for date: {date}, delta: {delta:?}")
})
}
@@ -1122,7 +1122,7 @@ impl Date32Type {
delta: <IntervalYearMonthType as ArrowPrimitiveType>::Native,
) -> <Date32Type as ArrowPrimitiveType>::Native {
Self::subtract_year_months_opt(date, delta).unwrap_or_else(|| {
- panic!("Date32Type::subtract_year_months overflowed for date: {date}, delta: {delta}",)
+ panic!("Date32Type::subtract_year_months overflowed for date: {date}, delta: {delta}")
})
}
@@ -1163,7 +1163,7 @@ impl Date32Type {
delta: <IntervalDayTimeType as ArrowPrimitiveType>::Native,
) -> <Date32Type as ArrowPrimitiveType>::Native {
Self::subtract_day_time_opt(date, delta).unwrap_or_else(|| {
- panic!("Date32Type::subtract_day_time overflowed for date: {date}, delta: {delta:?}",)
+ panic!("Date32Type::subtract_day_time overflowed for date: {date}, delta: {delta:?}")
})
}
diff --git a/arrow-avro/src/codec.rs b/arrow-avro/src/codec.rs
index ec6224ed1e..76f642942b 100644
--- a/arrow-avro/src/codec.rs
+++ b/arrow-avro/src/codec.rs
@@ -1200,12 +1200,12 @@ fn union_branch_name(dt: &AvroDataType) -> String {
if let Some(name) = dt.metadata.get(AVRO_NAME_METADATA_KEY) {
if name.contains('.') {
// Full name
- return name.to_string();
+ return name.clone();
}
if let Some(ns) = dt.metadata.get(AVRO_NAMESPACE_METADATA_KEY) {
return format!("{ns}.{name}");
}
- return name.to_string();
+ return name.clone();
}
dt.codec.union_field_name()
}
@@ -2243,7 +2243,7 @@ impl<'a> Maker<'a> {
Entry::Vacant(e) => {
e.insert(idx);
}
- _ => {}
+ Entry::Occupied(_) => {}
}
}
}
diff --git a/arrow-avro/src/reader/async_reader/mod.rs b/arrow-avro/src/reader/async_reader/mod.rs
index b98792e1a9..9a48d7e243 100644
--- a/arrow-avro/src/reader/async_reader/mod.rs
+++ b/arrow-avro/src/reader/async_reader/mod.rs
@@ -363,7 +363,6 @@ impl<R: AsyncFileReader + Unpin + 'static> AsyncAvroFileReader<R> {
future,
next_behaviour: FetchNextBehaviour::ContinueDecoding,
};
- continue;
}
FetchNextBehaviour::ContinueDecoding => {
self.reader_state = ReaderState::DecodingBlock {
@@ -482,7 +481,6 @@ impl<R: AsyncFileReader + Unpin + 'static> AsyncAvroFileReader<R> {
future,
next_behaviour: FetchNextBehaviour::ContinueDecoding,
};
- continue;
}
ReaderState::ReadingBatches {
reader,
diff --git a/arrow-avro/src/reader/mod.rs b/arrow-avro/src/reader/mod.rs
index d024904844..a8d7d7d214 100644
--- a/arrow-avro/src/reader/mod.rs
+++ b/arrow-avro/src/reader/mod.rs
@@ -4454,7 +4454,7 @@ mod test {
let offs = vec![0, 0, 0, 1];
let arr = mk_dense_union(&uf, tids, offs, |f| match f.data_type() {
DataType::FixedSizeBinary(8) => {
- let it = [Some(fx8_a)].into_iter();
+ let it = std::iter::once(Some(fx8_a));
Some(Arc::new(
FixedSizeBinaryArray::try_from_sparse_iter_with_size(it, 8).unwrap(),
) as ArrayRef)
@@ -5397,7 +5397,7 @@ mod test {
.to_string_lossy()
.into_owned()
};
- let pow10: i128 = 10i128.pow(scale_u32);
+ let pow10 = 10i128.pow(scale_u32);
let values_i128: Vec<i128> = (1..=24).map(|n| (n as i128) * pow10).collect();
let build_expected = |dt: &DataType, values: &[i128]| -> ArrayRef {
match *dt {
@@ -6587,7 +6587,7 @@ mod test {
.expect("id column should be an Int64Array");
let expected_ids = [1, 2, 3, 4, 5, 6, 7];
for (i, &expected_id) in expected_ids.iter().enumerate() {
- assert_eq!(id_array.value(i), expected_id, "Mismatch in id at row {i}",);
+ assert_eq!(id_array.value(i), expected_id, "Mismatch in id at row {i}");
}
let int_array = batch
.column(1)
@@ -7945,7 +7945,7 @@ mod test {
let mut tid_array: Option<i8> = None;
let mut tid_map: Option<i8> = None;
let mut map_entry_field: Option<FieldRef> = None;
- let mut map_sorted: bool = false;
+ let mut map_sorted = false;
for (tid, f) in uf.iter() {
match f.data_type() {
DataType::Dictionary(_, _) => tid_enum = Some(tid),
diff --git a/arrow-avro/src/reader/record.rs b/arrow-avro/src/reader/record.rs
index 9f97a800a0..9689e3df20 100644
--- a/arrow-avro/src/reader/record.rs
+++ b/arrow-avro/src/reader/record.rs
@@ -50,7 +50,7 @@ const DEFAULT_CAPACITY: usize = 1024;
/// Macro to decode a decimal payload for a given width and integer type.
macro_rules! decode_decimal {
($size:expr, $buf:expr, $builder:expr, $N:expr, $Int:ty) => {{
- let bytes = read_decimal_bytes_be::<{ $N }>($buf, $size)?;
+ let bytes = read_decimal_bytes_be::<{ $N }>($buf, *$size)?;
$builder.append_value(<$Int>::from_be_bytes(bytes));
}};
}
@@ -2364,17 +2364,17 @@ fn flush_primitive<T: ArrowPrimitiveType>(
#[inline]
fn read_decimal_bytes_be<const N: usize>(
buf: &mut AvroCursor<'_>,
- size: &Option<usize>,
+ size: Option<usize>,
) -> Result<[u8; N], AvroError> {
match size {
- Some(n) if *n == N => {
+ Some(n) if n == N => {
let raw = buf.get_fixed(N)?;
let mut arr = [0u8; N];
arr.copy_from_slice(raw);
Ok(arr)
}
Some(n) => {
- let raw = buf.get_fixed(*n)?;
+ let raw = buf.get_fixed(n)?;
sign_cast_to::<N>(raw)
}
None => {
@@ -2513,7 +2513,7 @@ impl Projector {
buf: &mut AvroCursor<'_>,
encodings: &mut [Decoder],
) -> Result<(), AvroError> {
- for field_proj in self.writer_projections.iter() {
+ for field_proj in &self.writer_projections {
match field_proj {
FieldProjection::ToReader(index) => encodings[*index].decode(buf)?,
FieldProjection::Skip(skipper) => skipper.skip(buf)?,
@@ -2716,7 +2716,7 @@ impl Skipper {
Ok(())
}
Self::Struct(fields) => {
- for f in fields.iter() {
+ for f in fields {
f.skip(buf)?
}
Ok(())
diff --git a/arrow-avro/src/writer/encoder.rs b/arrow-avro/src/writer/encoder.rs
index 4d1140677c..6da54467b7 100644
--- a/arrow-avro/src/writer/encoder.rs
+++ b/arrow-avro/src/writer/encoder.rs
@@ -891,7 +891,7 @@ impl RecordEncoder {
) -> Result<Vec<FieldEncoder<'a>>, AvroError> {
let arrays = batch.columns();
let mut out = Vec::with_capacity(self.columns.len());
- for col_plan in self.columns.iter() {
+ for col_plan in &self.columns {
let arrow_index = col_plan.arrow_index;
let array = arrays.get(arrow_index).ok_or_else(|| {
AvroError::SchemaError(format!("Column index {arrow_index} out of range"))
@@ -924,7 +924,7 @@ impl RecordEncoder {
let n = batch.num_rows();
let prefix = self.prefix.as_ref().map(|p| p.as_slice());
for_rows_with_prefix!(n, prefix, out, |row| {
- for enc in column_encoders.iter_mut() {
+ for enc in &mut column_encoders {
enc.encode(out, row)?;
}
});
@@ -983,7 +983,7 @@ impl RecordEncoder {
});
} else {
for_rows_with_prefix!(n, prefix_bytes, w, |row| {
- for enc in column_encoders.iter_mut() {
+ for enc in &mut column_encoders {
enc.encode(&mut w, row)?;
}
offsets.push(w.get_ref().len());
@@ -1464,7 +1464,7 @@ impl<'a> Encoder<'a> {
struct BooleanEncoder<'a>(&'a arrow_array::BooleanArray);
impl BooleanEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
write_bool(out, self.0.value(idx))
}
}
@@ -1472,7 +1472,7 @@ impl BooleanEncoder<'_> {
/// Generic Avro `int` encoder for primitive arrays with `i32` native values.
struct IntEncoder<'a, P: ArrowPrimitiveType<Native = i32>>(&'a PrimitiveArray<P>);
impl<'a, P: ArrowPrimitiveType<Native = i32>> IntEncoder<'a, P> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
write_int(out, self.0.value(idx))
}
}
@@ -1480,7 +1480,7 @@ impl<'a, P: ArrowPrimitiveType<Native = i32>> IntEncoder<'a, P> {
/// Generic Avro `long` encoder for primitive arrays with `i64` native values.
struct LongEncoder<'a, P: ArrowPrimitiveType<Native = i64>>(&'a PrimitiveArray<P>);
impl<'a, P: ArrowPrimitiveType<Native = i64>> LongEncoder<'a, P> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
write_long(out, self.0.value(idx))
}
}
@@ -1489,7 +1489,7 @@ impl<'a, P: ArrowPrimitiveType<Native = i64>> LongEncoder<'a, P> {
struct Time32SecondsToMillisEncoder<'a>(&'a PrimitiveArray<Time32SecondType>);
impl<'a> Time32SecondsToMillisEncoder<'a> {
#[inline]
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
let secs = self.0.value(idx);
let millis = secs
.checked_mul(1000)
@@ -1504,7 +1504,7 @@ struct TimestampSecondsToMillisEncoder<'a>(&'a PrimitiveArray<TimestampSecondTyp
#[cfg(not(feature = "avro_custom_types"))]
impl<'a> TimestampSecondsToMillisEncoder<'a> {
#[inline]
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
let secs = self.0.value(idx);
let millis = secs.checked_mul(1000).ok_or_else(|| {
AvroError::InvalidArgument("timestamp(secs) * 1000 overflowed".into())
@@ -1518,7 +1518,7 @@ impl<'a> TimestampSecondsToMillisEncoder<'a> {
struct Int8Encoder<'a>(&'a PrimitiveArray<Int8Type>);
#[cfg(feature = "avro_custom_types")]
impl Int8Encoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
write_int(out, self.0.value(idx) as i32)
}
}
@@ -1528,7 +1528,7 @@ impl Int8Encoder<'_> {
struct Int16Encoder<'a>(&'a PrimitiveArray<Int16Type>);
#[cfg(feature = "avro_custom_types")]
impl Int16Encoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
write_int(out, self.0.value(idx) as i32)
}
}
@@ -1538,7 +1538,7 @@ impl Int16Encoder<'_> {
struct UInt8Encoder<'a>(&'a PrimitiveArray<UInt8Type>);
#[cfg(feature = "avro_custom_types")]
impl UInt8Encoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
write_int(out, self.0.value(idx) as i32)
}
}
@@ -1548,7 +1548,7 @@ impl UInt8Encoder<'_> {
struct UInt16Encoder<'a>(&'a PrimitiveArray<UInt16Type>);
#[cfg(feature = "avro_custom_types")]
impl UInt16Encoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
write_int(out, self.0.value(idx) as i32)
}
}
@@ -1558,7 +1558,7 @@ impl UInt16Encoder<'_> {
struct UInt32Encoder<'a>(&'a PrimitiveArray<UInt32Type>);
#[cfg(feature = "avro_custom_types")]
impl UInt32Encoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
write_long(out, self.0.value(idx) as i64)
}
}
@@ -1568,7 +1568,7 @@ impl UInt32Encoder<'_> {
struct UInt64FixedEncoder<'a>(&'a PrimitiveArray<UInt64Type>);
#[cfg(feature = "avro_custom_types")]
impl UInt64FixedEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
let v = self.0.value(idx);
out.write_all(&v.to_le_bytes())?;
Ok(())
@@ -1580,7 +1580,7 @@ impl UInt64FixedEncoder<'_> {
struct Float16FixedEncoder<'a>(&'a Float16Array);
#[cfg(feature = "avro_custom_types")]
impl Float16FixedEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
let v = self.0.value(idx);
out.write_all(&v.to_le_bytes())?;
Ok(())
@@ -1598,7 +1598,7 @@ impl Float16FixedEncoder<'_> {
struct IntervalMonthDayNanoFixedEncoder<'a>(&'a PrimitiveArray<IntervalMonthDayNanoType>);
#[cfg(feature = "avro_custom_types")]
impl IntervalMonthDayNanoFixedEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
let v = self.0.value(idx);
let (months, days, nanos) = IntervalMonthDayNanoType::to_parts(v);
out.write_all(&months.to_le_bytes())?;
@@ -1613,7 +1613,7 @@ impl IntervalMonthDayNanoFixedEncoder<'_> {
struct IntervalYearMonthFixedEncoder<'a>(&'a PrimitiveArray<IntervalYearMonthType>);
#[cfg(feature = "avro_custom_types")]
impl IntervalYearMonthFixedEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
let months = self.0.value(idx);
out.write_all(&months.to_le_bytes())?;
Ok(())
@@ -1625,7 +1625,7 @@ impl IntervalYearMonthFixedEncoder<'_> {
struct IntervalDayTimeFixedEncoder<'a>(&'a PrimitiveArray<IntervalDayTimeType>);
#[cfg(feature = "avro_custom_types")]
impl IntervalDayTimeFixedEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
let dt = self.0.value(idx);
out.write_all(&dt.days.to_le_bytes())?;
out.write_all(&dt.milliseconds.to_le_bytes())?;
@@ -1638,7 +1638,7 @@ impl IntervalDayTimeFixedEncoder<'_> {
struct Int8ToIntEncoder<'a>(&'a PrimitiveArray<Int8Type>);
#[cfg(not(feature = "avro_custom_types"))]
impl Int8ToIntEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
write_int(out, self.0.value(idx) as i32)
}
}
@@ -1648,7 +1648,7 @@ impl Int8ToIntEncoder<'_> {
struct Int16ToIntEncoder<'a>(&'a PrimitiveArray<Int16Type>);
#[cfg(not(feature = "avro_custom_types"))]
impl Int16ToIntEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
write_int(out, self.0.value(idx) as i32)
}
}
@@ -1658,7 +1658,7 @@ impl Int16ToIntEncoder<'_> {
struct UInt8ToIntEncoder<'a>(&'a PrimitiveArray<UInt8Type>);
#[cfg(not(feature = "avro_custom_types"))]
impl UInt8ToIntEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
write_int(out, self.0.value(idx) as i32)
}
}
@@ -1668,7 +1668,7 @@ impl UInt8ToIntEncoder<'_> {
struct UInt16ToIntEncoder<'a>(&'a PrimitiveArray<UInt16Type>);
#[cfg(not(feature = "avro_custom_types"))]
impl UInt16ToIntEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
write_int(out, self.0.value(idx) as i32)
}
}
@@ -1678,7 +1678,7 @@ impl UInt16ToIntEncoder<'_> {
struct UInt32ToLongEncoder<'a>(&'a PrimitiveArray<UInt32Type>);
#[cfg(not(feature = "avro_custom_types"))]
impl UInt32ToLongEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
write_long(out, self.0.value(idx) as i64)
}
}
@@ -1688,7 +1688,7 @@ impl UInt32ToLongEncoder<'_> {
struct UInt64ToLongEncoder<'a>(&'a PrimitiveArray<UInt64Type>);
#[cfg(not(feature = "avro_custom_types"))]
impl UInt64ToLongEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
let v = self.0.value(idx);
if v > i64::MAX as u64 {
return Err(AvroError::InvalidArgument(format!(
@@ -1704,7 +1704,7 @@ impl UInt64ToLongEncoder<'_> {
struct Float16ToFloatEncoder<'a>(&'a Float16Array);
#[cfg(not(feature = "avro_custom_types"))]
impl Float16ToFloatEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
out.write_all(&self.0.value(idx).to_f32().to_bits().to_le_bytes())?;
Ok(())
}
@@ -1715,7 +1715,7 @@ impl Float16ToFloatEncoder<'_> {
struct Date64ToLongEncoder<'a>(&'a PrimitiveArray<Date64Type>);
#[cfg(not(feature = "avro_custom_types"))]
impl Date64ToLongEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
write_long(out, self.0.value(idx))
}
}
@@ -1725,7 +1725,7 @@ impl Date64ToLongEncoder<'_> {
struct Time64NanosToMicrosEncoder<'a>(&'a PrimitiveArray<Time64NanosecondType>);
#[cfg(not(feature = "avro_custom_types"))]
impl Time64NanosToMicrosEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
let nanos = self.0.value(idx);
let micros = nanos / 1000;
write_long(out, micros)
@@ -1735,7 +1735,7 @@ impl Time64NanosToMicrosEncoder<'_> {
/// Unified binary encoder generic over offset size (i32/i64).
struct BinaryEncoder<'a, O: OffsetSizeTrait>(&'a GenericBinaryArray<O>);
impl<'a, O: OffsetSizeTrait> BinaryEncoder<'a, O> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
write_len_prefixed(out, self.0.value(idx))
}
}
@@ -1743,7 +1743,7 @@ impl<'a, O: OffsetSizeTrait> BinaryEncoder<'a, O> {
/// BinaryView (byte view) encoder.
struct BinaryViewEncoder<'a>(&'a BinaryViewArray);
impl BinaryViewEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
write_len_prefixed(out, self.0.value(idx))
}
}
@@ -1751,14 +1751,14 @@ impl BinaryViewEncoder<'_> {
/// StringView encoder.
struct Utf8ViewEncoder<'a>(&'a StringViewArray);
impl Utf8ViewEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
write_len_prefixed(out, self.0.value(idx).as_bytes())
}
}
struct F32Encoder<'a>(&'a arrow_array::Float32Array);
impl F32Encoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
// Avro float: 4 bytes, IEEE-754 little-endian
out.write_all(&self.0.value(idx).to_bits().to_le_bytes())?;
Ok(())
@@ -1767,7 +1767,7 @@ impl F32Encoder<'_> {
struct F64Encoder<'a>(&'a arrow_array::Float64Array);
impl F64Encoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
// Avro double: 8 bytes, IEEE-754 little-endian
out.write_all(&self.0.value(idx).to_bits().to_le_bytes())
.map_err(Into::into)
@@ -1777,7 +1777,7 @@ impl F64Encoder<'_> {
struct Utf8GenericEncoder<'a, O: OffsetSizeTrait>(&'a GenericStringArray<O>);
impl<'a, O: OffsetSizeTrait> Utf8GenericEncoder<'a, O> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
write_len_prefixed(out, self.0.value(idx).as_bytes())
}
}
@@ -1885,7 +1885,7 @@ struct EnumEncoder<'a> {
keys: &'a PrimitiveArray<Int32Type>,
}
impl EnumEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, row: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, row: usize) -> Result<(), AvroError> {
write_int(out, self.keys.value(row))
}
}
@@ -1972,7 +1972,7 @@ impl<'a> StructEncoder<'a> {
}
fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
- for encoder in self.encoders.iter_mut() {
+ for encoder in &mut self.encoders {
encoder.encode(out, idx)?;
}
Ok(())
@@ -2140,7 +2140,7 @@ impl<'a> FixedSizeListEncoder<'a> {
/// Spec: a fixed is encoded as exactly `size` bytes, with no length prefix.
struct FixedEncoder<'a>(&'a FixedSizeBinaryArray);
impl FixedEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
let v = self.0.value(idx); // &[u8] of fixed width
out.write_all(v)?;
Ok(())
@@ -2151,7 +2151,7 @@ impl FixedEncoder<'_> {
/// Spec: uuid is a logical type over string (RFC‑4122). We output hyphenated form.
struct UuidEncoder<'a>(&'a FixedSizeBinaryArray);
impl UuidEncoder<'_> {
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
let mut buf = [0u8; 1 + uuid::fmt::Hyphenated::LENGTH];
buf[0] = 0x48;
let v = self.0.value(idx);
@@ -2235,7 +2235,7 @@ impl IntervalToDurationParts for IntervalDayTimeType {
struct DurationEncoder<'a, P: ArrowPrimitiveType + IntervalToDurationParts>(&'a PrimitiveArray<P>);
impl<'a, P: ArrowPrimitiveType + IntervalToDurationParts> DurationEncoder<'a, P> {
#[inline(always)]
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
let parts = P::duration_parts(self.0.value(idx))?;
let months = parts.months.to_le_bytes();
let days = parts.days.to_le_bytes();
@@ -2308,7 +2308,7 @@ impl<'a, const N: usize, A: DecimalBeBytes<N>> DecimalEncoder<'a, N, A> {
Self { arr, fixed_size }
}
- fn encode<W: Write + ?Sized>(&mut self, out: &mut W, idx: usize) -> Result<(), AvroError> {
+ fn encode<W: Write + ?Sized>(&self, out: &mut W, idx: usize) -> Result<(), AvroError> {
let be = self.arr.value_be_bytes(idx);
match self.fixed_size {
Some(n) => write_sign_extended(out, &be, n),
diff --git a/arrow-buffer/benches/i256.rs b/arrow-buffer/benches/i256.rs
index 2e1d63d2e3..435f43c71e 100644
--- a/arrow-buffer/benches/i256.rs
+++ b/arrow-buffer/benches/i256.rs
@@ -37,14 +37,14 @@ fn criterion_benchmark(c: &mut Criterion) {
i256::MAX,
];
- for number in numbers.iter() {
+ for number in &numbers {
let t = hint::black_box(number.to_string());
c.bench_function(&format!("i256_parse({t})"), |b| {
b.iter(|| i256::from_str(&t).unwrap());
});
}
- for number in numbers.iter() {
+ for number in &numbers {
c.bench_function(&format!("i256_to_f64({number})"), |b| {
b.iter(|| (*number).to_f64().unwrap())
});
diff --git a/arrow-buffer/src/bigint/div.rs b/arrow-buffer/src/bigint/div.rs
index f094f662cc..fbed732e71 100644
--- a/arrow-buffer/src/bigint/div.rs
+++ b/arrow-buffer/src/bigint/div.rs
@@ -289,14 +289,14 @@ impl<T, const N: usize> std::ops::Deref for ArrayPlusOne<T, N> {
#[inline]
fn deref(&self) -> &Self::Target {
- let x = self as *const Self;
- unsafe { std::slice::from_raw_parts(x as *const T, N + 1) }
+ let x = std::ptr::from_ref::<Self>(self);
+ unsafe { std::slice::from_raw_parts(x.cast::<T>(), N + 1) }
}
}
impl<T, const N: usize> std::ops::DerefMut for ArrayPlusOne<T, N> {
fn deref_mut(&mut self) -> &mut Self::Target {
- let x = self as *mut Self;
- unsafe { std::slice::from_raw_parts_mut(x as *mut T, N + 1) }
+ let x = std::ptr::from_mut::<Self>(self);
+ unsafe { std::slice::from_raw_parts_mut(x.cast::<T>(), N + 1) }
}
}
diff --git a/arrow-buffer/src/buffer/boolean.rs b/arrow-buffer/src/buffer/boolean.rs
index 4943447c22..81a9ea1d93 100644
--- a/arrow-buffer/src/buffer/boolean.rs
+++ b/arrow-buffer/src/buffer/boolean.rs
@@ -255,7 +255,7 @@ impl BooleanBuffer {
let suffix = read_u64(suffix);
let result_u64s: Vec<u64> = aligned_u64s
.iter()
- .cloned()
+ .copied()
.chain(std::iter::once(suffix))
.map(&mut op)
.collect();
@@ -375,11 +375,11 @@ impl BooleanBuffer {
([], left_suf, [], right_suf) => {
let left_iter = left_u64s
.iter()
- .cloned()
+ .copied()
.chain((!left_suf.is_empty()).then(|| read_u64(left_suf)));
let right_iter = right_u64s
.iter()
- .cloned()
+ .copied()
.chain((!right_suf.is_empty()).then(|| read_u64(right_suf)));
let result_u64s: Vec<u64> =
left_iter.zip(right_iter).map(|(l, r)| op(l, r)).collect();
diff --git a/arrow-buffer/src/buffer/immutable.rs b/arrow-buffer/src/buffer/immutable.rs
index 2b3b698278..12d873ba2c 100644
--- a/arrow-buffer/src/buffer/immutable.rs
+++ b/arrow-buffer/src/buffer/immutable.rs
@@ -438,7 +438,7 @@ impl Buffer {
pub fn into_vec<T: ArrowNativeType>(self) -> Result<Vec<T>, Self> {
let layout = match self.data.deallocation() {
Deallocation::Standard(l) => l,
- _ => return Err(self), // Custom allocation
+ Deallocation::Custom(..) => return Err(self),
};
if self.ptr != self.data.as_ptr() {
@@ -457,7 +457,7 @@ impl Buffer {
Arc::try_unwrap(self.data)
.map(|bytes| unsafe {
- let ptr = bytes.ptr().as_ptr() as _;
+ let ptr = bytes.ptr().as_ptr().cast();
std::mem::forget(bytes);
// Safety
// Verified that bytes layout matches that of Vec
@@ -906,7 +906,7 @@ mod tests {
let mut vector = vec![1_i32, 2, 3, 4, 5];
let buffer = unsafe {
Buffer::from_custom_allocation(
- NonNull::new_unchecked(vector.as_mut_ptr() as *mut u8),
+ NonNull::new_unchecked(vector.as_mut_ptr().cast::<u8>()),
vector.len() * std::mem::size_of::<i32>(),
Arc::new(vector),
)
diff --git a/arrow-buffer/src/buffer/mutable.rs b/arrow-buffer/src/buffer/mutable.rs
index e83b0c4708..1b0d9b2865 100644
--- a/arrow-buffer/src/buffer/mutable.rs
+++ b/arrow-buffer/src/buffer/mutable.rs
@@ -232,7 +232,7 @@ impl MutableBuffer {
pub(crate) fn from_bytes(bytes: Bytes) -> Result<Self, Bytes> {
let layout = match bytes.deallocation() {
Deallocation::Standard(layout) => *layout,
- _ => return Err(bytes),
+ Deallocation::Custom(..) => return Err(bytes),
};
let len = bytes.len();
@@ -657,7 +657,7 @@ impl MutableBuffer {
// this assumes that `[ToByteSlice]` can be copied directly
// without calling `to_byte_slice` for each element,
// which is correct for all ArrowNativeType implementations.
- let src = items.as_ptr() as *const u8;
+ let src = items.as_ptr().cast::<u8>();
let dst = self.data.as_ptr().add(self.len);
std::ptr::copy_nonoverlapping(src, dst, additional);
}
@@ -1182,7 +1182,7 @@ impl Drop for MutableBuffer {
fn drop(&mut self) {
if self.layout.size() != 0 {
// Safety: data was allocated with standard allocator with given layout
- unsafe { std::alloc::dealloc(self.data.as_ptr() as _, self.layout) };
+ unsafe { std::alloc::dealloc(self.data.as_ptr().cast(), self.layout) };
}
}
}
diff --git a/arrow-buffer/src/buffer/offset.rs b/arrow-buffer/src/buffer/offset.rs
index f4c059a912..f1dcdfd5aa 100644
--- a/arrow-buffer/src/buffer/offset.rs
+++ b/arrow-buffer/src/buffer/offset.rs
@@ -381,7 +381,7 @@ impl<O: ArrowNativeType> OffsetBuffer<O> {
let shifted_offsets: Vec<O> = match self.into_inner().into_inner().into_vec() {
// If we can reuse the buffer, update in place
Ok(mut v) => {
- for offset in v.iter_mut() {
+ for offset in &mut v {
*offset = *offset - rhs;
}
v
diff --git a/arrow-buffer/src/buffer/scalar.rs b/arrow-buffer/src/buffer/scalar.rs
index eeadfb13f7..fde87680e2 100644
--- a/arrow-buffer/src/buffer/scalar.rs
+++ b/arrow-buffer/src/buffer/scalar.rs
@@ -165,7 +165,7 @@ impl<T: ArrowNativeType> Deref for ScalarBuffer<T> {
// SAFETY: Verified alignment in From<Buffer>
unsafe {
std::slice::from_raw_parts(
- self.buffer.as_ptr() as *const T,
+ self.buffer.as_ptr().cast::<T>(),
self.buffer.len() / std::mem::size_of::<T>(),
)
}
@@ -291,7 +291,7 @@ mod tests {
#[test]
fn test_basic() {
let expected = [0_i32, 1, 2];
- let buffer = Buffer::from_iter(expected.iter().cloned());
+ let buffer = Buffer::from_iter(expected.iter().copied());
let typed = ScalarBuffer::<i32>::new(buffer.clone(), 0, 3);
assert_eq!(*typed, expected);
@@ -315,7 +315,7 @@ mod tests {
#[should_panic(expected = "Memory pointer is not aligned with the specified scalar type")]
fn test_unaligned() {
let expected = [0_i32, 1, 2];
- let buffer = Buffer::from_iter(expected.iter().cloned());
+ let buffer = Buffer::from_iter(expected.iter().copied());
let buffer = buffer.slice(1);
ScalarBuffer::<i32>::new(buffer, 0, 2);
}
diff --git a/arrow-buffer/src/builder/mod.rs b/arrow-buffer/src/builder/mod.rs
index 053813c715..289374359a 100644
--- a/arrow-buffer/src/builder/mod.rs
+++ b/arrow-buffer/src/builder/mod.rs
@@ -266,7 +266,7 @@ impl<T: ArrowNativeType> BufferBuilder<T> {
// - MutableBuffer is aligned and initialized for len elements of T
// - MutableBuffer corresponds to a single allocation
// - MutableBuffer does not support modification whilst active immutable borrows
- unsafe { std::slice::from_raw_parts(self.buffer.as_ptr() as _, self.len()) }
+ unsafe { std::slice::from_raw_parts(self.buffer.as_ptr().cast(), self.len()) }
}
/// View the contents of this buffer as a mutable slice
@@ -290,7 +290,7 @@ impl<T: ArrowNativeType> BufferBuilder<T> {
// - MutableBuffer is aligned and initialized for len elements of T
// - MutableBuffer corresponds to a single allocation
// - MutableBuffer does not support modification whilst active immutable borrows
- unsafe { std::slice::from_raw_parts_mut(self.buffer.as_mut_ptr() as _, self.len()) }
+ unsafe { std::slice::from_raw_parts_mut(self.buffer.as_mut_ptr().cast(), self.len()) }
}
/// Shorten this BufferBuilder to `len` items
diff --git a/arrow-buffer/src/bytes.rs b/arrow-buffer/src/bytes.rs
index d473f13dac..07b08da43d 100644
--- a/arrow-buffer/src/bytes.rs
+++ b/arrow-buffer/src/bytes.rs
@@ -218,7 +218,7 @@ impl PartialEq for Bytes {
impl Debug for Bytes {
fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
- write!(f, "Bytes {{ ptr: {:?}, len: {}, data: ", self.ptr, self.len,)?;
+ write!(f, "Bytes {{ ptr: {:?}, len: {}, data: ", self.ptr, self.len)?;
f.debug_list().entries(self.iter()).finish()?;
diff --git a/arrow-buffer/src/native.rs b/arrow-buffer/src/native.rs
index 7939cb0ca6..6b55323896 100644
--- a/arrow-buffer/src/native.rs
+++ b/arrow-buffer/src/native.rs
@@ -276,7 +276,7 @@ pub trait ToByteSlice: private::Sealed {
impl<T: ArrowNativeType> ToByteSlice for [T] {
#[inline]
fn to_byte_slice(&self) -> &[u8] {
- let raw_ptr = self.as_ptr() as *const u8;
+ let raw_ptr = self.as_ptr().cast::<u8>();
unsafe { std::slice::from_raw_parts(raw_ptr, std::mem::size_of_val(self)) }
}
}
@@ -284,7 +284,7 @@ impl<T: ArrowNativeType> ToByteSlice for [T] {
impl<T: ArrowNativeType> ToByteSlice for T {
#[inline]
fn to_byte_slice(&self) -> &[u8] {
- let raw_ptr = self as *const T as *const u8;
+ let raw_ptr = std::ptr::from_ref::<T>(self).cast::<u8>();
unsafe { std::slice::from_raw_parts(raw_ptr, std::mem::size_of::<T>()) }
}
}
diff --git a/arrow-buffer/src/util/bit_chunk_iterator.rs b/arrow-buffer/src/util/bit_chunk_iterator.rs
index 95ef82bd60..2c4e684917 100644
--- a/arrow-buffer/src/util/bit_chunk_iterator.rs
+++ b/arrow-buffer/src/util/bit_chunk_iterator.rs
@@ -160,7 +160,7 @@ impl<'a> UnalignedBitChunk<'a> {
pub fn iter(&self) -> UnalignedBitChunkIterator<'a> {
self.prefix
.into_iter()
- .chain(self.chunks.iter().cloned())
+ .chain(self.chunks.iter().copied())
.chain(self.suffix)
}
@@ -170,9 +170,18 @@ impl<'a> UnalignedBitChunk<'a> {
}
}
+impl<'a> IntoIterator for &UnalignedBitChunk<'a> {
+ type Item = u64;
+ type IntoIter = UnalignedBitChunkIterator<'a>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.iter()
+ }
+}
+
/// Iterator over an [`UnalignedBitChunk`]
pub type UnalignedBitChunkIterator<'a> = std::iter::Chain<
- std::iter::Chain<std::option::IntoIter<u64>, std::iter::Cloned<std::slice::Iter<'a, u64>>>,
+ std::iter::Chain<std::option::IntoIter<u64>, std::iter::Copied<std::slice::Iter<'a, u64>>>,
std::option::IntoIter<u64>,
>;
@@ -338,6 +347,15 @@ impl<'a> IntoIterator for BitChunks<'a> {
}
}
+impl<'a> IntoIterator for &BitChunks<'a> {
+ type Item = u64;
+ type IntoIter = BitChunkIterator<'a>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.iter()
+ }
+}
+
impl Iterator for BitChunkIterator<'_> {
type Item = u64;
@@ -350,7 +368,7 @@ impl Iterator for BitChunkIterator<'_> {
// cast to *const u64 should be fine since we are using read_unaligned below
#[expect(clippy::cast_ptr_alignment)]
- let raw_data = self.buffer.as_ptr() as *const u64;
+ let raw_data = self.buffer.as_ptr().cast::<u64>();
// bit-packed buffers are stored starting with the least-significant byte first
// so when reading as u64 on a big-endian machine, the bytes need to be swapped
@@ -364,7 +382,7 @@ impl Iterator for BitChunkIterator<'_> {
// the constructor ensures that bit_offset is in 0..8
// that means we need to read at most one additional byte to fill in the high bits
let next =
- unsafe { std::ptr::read_unaligned(raw_data.add(index + 1) as *const u8) as u64 };
+ unsafe { std::ptr::read_unaligned(raw_data.add(index + 1).cast::<u8>()) as u64 };
(current >> bit_offset) | (next << (64 - bit_offset))
};
@@ -714,7 +732,7 @@ mod tests {
.take(mask_len)
.collect();
- let buffer = Buffer::from_iter(bools.iter().cloned());
+ let buffer = Buffer::from_iter(bools.iter().copied());
let max_offset = 64.min(mask_len);
let offset = uusize.sample(&mut rng).checked_rem(max_offset).unwrap_or(0);
diff --git a/arrow-buffer/src/util/bit_mask.rs b/arrow-buffer/src/util/bit_mask.rs
index daec6c9a47..b1f25eb014 100644
--- a/arrow-buffer/src/util/bit_mask.rs
+++ b/arrow-buffer/src/util/bit_mask.rs
@@ -90,7 +90,7 @@ unsafe fn set_upto_64bits(
let write_shift = offset_write % 8;
if len >= 64 {
- let chunk = unsafe { (data.as_ptr().add(read_byte) as *const u64).read_unaligned() };
+ let chunk = unsafe { data.as_ptr().add(read_byte).cast::<u64>().read_unaligned() };
if read_shift == 0 {
if write_shift == 0 {
// no shifting necessary
@@ -148,7 +148,7 @@ unsafe fn read_bytes_to_u64(data: &[u8], offset: usize, count: usize) -> u64 {
debug_assert!(count <= 8);
let mut tmp: u64 = 0;
let src = unsafe { data.as_ptr().add(offset) };
- unsafe { std::ptr::copy_nonoverlapping(src, &mut tmp as *mut _ as *mut u8, count) };
+ unsafe { std::ptr::copy_nonoverlapping(src, std::ptr::from_mut(&mut tmp).cast::<u8>(), count) };
tmp
}
@@ -156,7 +156,7 @@ unsafe fn read_bytes_to_u64(data: &[u8], offset: usize, count: usize) -> u64 {
/// The caller must ensure `data` has `offset..(offset + 8)` range
#[inline]
unsafe fn write_u64_bytes(data: &mut [u8], offset: usize, chunk: u64) {
- let ptr = unsafe { data.as_mut_ptr().add(offset) } as *mut u64;
+ let ptr = unsafe { data.as_mut_ptr().add(offset) }.cast::<u64>();
unsafe { ptr.write_unaligned(chunk) };
}
@@ -169,7 +169,7 @@ unsafe fn write_u64_bytes(data: &mut [u8], offset: usize, chunk: u64) {
unsafe fn or_write_u64_bytes(data: &mut [u8], offset: usize, chunk: u64) {
let ptr = unsafe { data.as_mut_ptr().add(offset) };
let chunk = chunk | (unsafe { *ptr }) as u64;
- unsafe { (ptr as *mut u64).write_unaligned(chunk) };
+ unsafe { ptr.cast::<u64>().write_unaligned(chunk) };
}
#[cfg(test)]
@@ -393,7 +393,7 @@ mod tests {
/// call set_bits with the given parameters and compare with the expected output
fn verify(&self) {
// call set_bits and compare
- let mut actual = self.write_data.to_vec();
+ let mut actual = self.write_data.clone();
let null_count = set_bits(
&mut actual,
&self.data,
diff --git a/arrow-buffer/src/util/bit_util.rs b/arrow-buffer/src/util/bit_util.rs
index 4ba42f761a..ec0c7b9524 100644
--- a/arrow-buffer/src/util/bit_util.rs
+++ b/arrow-buffer/src/util/bit_util.rs
@@ -259,7 +259,7 @@ pub fn apply_bitwise_binary_op<F>(
let right_byte_offset = right_offset_in_bits / 8;
// Read the same amount of bits from the right buffer
- let right_first_byte: u8 = crate::util::bit_util::read_up_to_byte_from_offset(
+ let right_first_byte = crate::util::bit_util::read_up_to_byte_from_offset(
&right.as_ref()[right_byte_offset..],
bits_to_next_byte,
// Right bit offset
@@ -574,7 +574,7 @@ impl<'a> U64UnalignedSlice<'a> {
assert!(u64_len_in_bytes <= left_buffer_mut.len());
let (bytes_for_u64, remainder) = left_buffer_mut.split_at_mut(u64_len_in_bytes);
- let ptr = bytes_for_u64.as_mut_ptr() as *mut u64;
+ let ptr = bytes_for_u64.as_mut_ptr().cast::<u64>();
let this = Self {
ptr,
diff --git a/arrow-cast/src/base64.rs b/arrow-cast/src/base64.rs
index bd5474982a..b444f8d1a8 100644
--- a/arrow-cast/src/base64.rs
+++ b/arrow-cast/src/base64.rs
@@ -72,7 +72,7 @@ pub fn b64_decode<E: Engine, O: OffsetSizeTrait>(
offsets.push(O::usize_as(0));
let mut offset = 0;
- for v in array.iter() {
+ for v in array {
if let Some(v) = v {
let len = engine.decode_slice(v, &mut buffer[offset..]).unwrap();
// This cannot overflow as `len` is less than `v.len()` and `a` is valid
@@ -152,7 +152,7 @@ mod tests {
output_buf: &mut [u8],
) -> Result<usize, base64::EncodeSliceError> {
let len = BASE64_STANDARD.encode_slice(input, output_buf)?;
- for b in output_buf[..len].iter_mut() {
+ for b in &mut output_buf[..len] {
*b = 0xFF; // invalid UTF-8, but correct length
}
Ok(len)
diff --git a/arrow-cast/src/cast/dictionary.rs b/arrow-cast/src/cast/dictionary.rs
index 0a9751dfa8..367084cbdc 100644
--- a/arrow-cast/src/cast/dictionary.rs
+++ b/arrow-cast/src/cast/dictionary.rs
@@ -136,7 +136,7 @@ fn view_from_dict_values<K: ArrowDictionaryKeyType, V: ByteArrayType, T: ByteVie
let values_have_nulls = values.null_count() != 0;
let mut builder = GenericByteViewBuilder::<T>::with_capacity(keys.len());
builder.append_block(value_buffer.clone());
- for i in keys.iter() {
+ for i in keys {
match i {
Some(v) => {
let idx = v.to_usize().ok_or_else(|| {
@@ -456,7 +456,7 @@ where
.ok_or_else(|| {
ArrowError::ComputeError("Internal Error: Cannot cast to StringViewArray".to_string())
})?;
- for v in string_view.iter() {
+ for v in string_view {
match v {
Some(v) => {
b.append(v)?;
@@ -487,7 +487,7 @@ where
.ok_or_else(|| {
ArrowError::ComputeError("Internal Error: Cannot cast to BinaryViewArray".to_string())
})?;
- for v in binary_view.iter() {
+ for v in binary_view {
match v {
Some(v) => {
b.append(v)?;
diff --git a/arrow-cast/src/cast/mod.rs b/arrow-cast/src/cast/mod.rs
index 942e393ebd..e698293dd4 100644
--- a/arrow-cast/src/cast/mod.rs
+++ b/arrow-cast/src/cast/mod.rs
@@ -1277,20 +1277,28 @@ pub fn cast_with_options(
Time64(TimeUnit::Nanosecond) => {
parse_string::<Time64NanosecondType, i32>(array, cast_options)
}
- Timestamp(TimeUnit::Second, to_tz) => {
- cast_string_to_timestamp::<i32, TimestampSecondType>(array, to_tz, cast_options)
- }
+ Timestamp(TimeUnit::Second, to_tz) => cast_string_to_timestamp::<
+ i32,
+ TimestampSecondType,
+ >(array, to_tz.as_ref(), cast_options),
Timestamp(TimeUnit::Millisecond, to_tz) => cast_string_to_timestamp::<
i32,
TimestampMillisecondType,
- >(array, to_tz, cast_options),
+ >(
+ array, to_tz.as_ref(), cast_options
+ ),
Timestamp(TimeUnit::Microsecond, to_tz) => cast_string_to_timestamp::<
i32,
TimestampMicrosecondType,
- >(array, to_tz, cast_options),
- Timestamp(TimeUnit::Nanosecond, to_tz) => {
- cast_string_to_timestamp::<i32, TimestampNanosecondType>(array, to_tz, cast_options)
- }
+ >(
+ array, to_tz.as_ref(), cast_options
+ ),
+ Timestamp(TimeUnit::Nanosecond, to_tz) => cast_string_to_timestamp::<
+ i32,
+ TimestampNanosecondType,
+ >(
+ array, to_tz.as_ref(), cast_options
+ ),
Interval(IntervalUnit::YearMonth) => {
cast_string_to_year_month_interval::<i32>(array, cast_options)
}
@@ -1334,17 +1342,23 @@ pub fn cast_with_options(
parse_string_view::<Time64NanosecondType>(array, cast_options)
}
Timestamp(TimeUnit::Second, to_tz) => {
- cast_view_to_timestamp::<TimestampSecondType>(array, to_tz, cast_options)
- }
- Timestamp(TimeUnit::Millisecond, to_tz) => {
- cast_view_to_timestamp::<TimestampMillisecondType>(array, to_tz, cast_options)
- }
- Timestamp(TimeUnit::Microsecond, to_tz) => {
- cast_view_to_timestamp::<TimestampMicrosecondType>(array, to_tz, cast_options)
- }
- Timestamp(TimeUnit::Nanosecond, to_tz) => {
- cast_view_to_timestamp::<TimestampNanosecondType>(array, to_tz, cast_options)
+ cast_view_to_timestamp::<TimestampSecondType>(array, to_tz.as_ref(), cast_options)
}
+ Timestamp(TimeUnit::Millisecond, to_tz) => cast_view_to_timestamp::<
+ TimestampMillisecondType,
+ >(
+ array, to_tz.as_ref(), cast_options
+ ),
+ Timestamp(TimeUnit::Microsecond, to_tz) => cast_view_to_timestamp::<
+ TimestampMicrosecondType,
+ >(
+ array, to_tz.as_ref(), cast_options
+ ),
+ Timestamp(TimeUnit::Nanosecond, to_tz) => cast_view_to_timestamp::<
+ TimestampNanosecondType,
+ >(
+ array, to_tz.as_ref(), cast_options
+ ),
Interval(IntervalUnit::YearMonth) => {
cast_view_to_year_month_interval(array, cast_options)
}
@@ -1396,20 +1410,28 @@ pub fn cast_with_options(
Time64(TimeUnit::Nanosecond) => {
parse_string::<Time64NanosecondType, i64>(array, cast_options)
}
- Timestamp(TimeUnit::Second, to_tz) => {
- cast_string_to_timestamp::<i64, TimestampSecondType>(array, to_tz, cast_options)
- }
+ Timestamp(TimeUnit::Second, to_tz) => cast_string_to_timestamp::<
+ i64,
+ TimestampSecondType,
+ >(array, to_tz.as_ref(), cast_options),
Timestamp(TimeUnit::Millisecond, to_tz) => cast_string_to_timestamp::<
i64,
TimestampMillisecondType,
- >(array, to_tz, cast_options),
+ >(
+ array, to_tz.as_ref(), cast_options
+ ),
Timestamp(TimeUnit::Microsecond, to_tz) => cast_string_to_timestamp::<
i64,
TimestampMicrosecondType,
- >(array, to_tz, cast_options),
- Timestamp(TimeUnit::Nanosecond, to_tz) => {
- cast_string_to_timestamp::<i64, TimestampNanosecondType>(array, to_tz, cast_options)
- }
+ >(
+ array, to_tz.as_ref(), cast_options
+ ),
+ Timestamp(TimeUnit::Nanosecond, to_tz) => cast_string_to_timestamp::<
+ i64,
+ TimestampNanosecondType,
+ >(
+ array, to_tz.as_ref(), cast_options
+ ),
Interval(IntervalUnit::YearMonth) => {
cast_string_to_year_month_interval::<i64>(array, cast_options)
}
@@ -2834,7 +2856,7 @@ where
let mut byte_array_builder = GenericByteBuilder::<TO>::with_capacity(len, bytes);
- for val in view_array.iter() {
+ for val in &view_array {
byte_array_builder.append_option(val);
}
@@ -7715,7 +7737,7 @@ mod tests {
{
let string_view_array = {
let mut builder = StringViewBuilder::new().with_fixed_block_size(8); // multiple buffers.
- for s in VIEW_TEST_DATA.iter() {
+ for s in &VIEW_TEST_DATA {
builder.append_option(*s);
}
builder.finish()
@@ -7750,7 +7772,7 @@ mod tests {
{
let view_array = {
let mut builder = BinaryViewBuilder::new().with_fixed_block_size(8); // multiple buffers.
- for s in VIEW_TEST_DATA.iter() {
+ for s in &VIEW_TEST_DATA {
builder.append_option(*s);
}
builder.finish()
@@ -9828,7 +9850,7 @@ mod tests {
3,
)) as ArrayRef;
- for (values, lengths) in cases.iter() {
+ for (values, lengths) in &cases {
let array = Arc::new(ListArray::new(
field.clone(),
OffsetBuffer::from_lengths(lengths.clone()),
@@ -9903,7 +9925,7 @@ mod tests {
3,
)) as ArrayRef;
- for (values, offsets, lengths) in cases.iter() {
+ for (values, offsets, lengths) in &cases {
let array = Arc::new(ListViewArray::new(
field.clone(),
offsets.clone().into(),
@@ -11502,11 +11524,8 @@ mod tests {
format_options: FormatOptions::default(),
};
- let result = cast_string_to_timestamp::<i32, TimestampNanosecondType>(
- &array,
- &None::<Arc<str>>,
- &cast_options,
- );
+ let result =
+ cast_string_to_timestamp::<i32, TimestampNanosecondType>(&array, None, &cast_options);
let err = result.unwrap_err();
assert_eq!(
diff --git a/arrow-cast/src/cast/string.rs b/arrow-cast/src/cast/string.rs
index 3c19335196..b8039e6529 100644
--- a/arrow-cast/src/cast/string.rs
+++ b/arrow-cast/src/cast/string.rs
@@ -123,7 +123,7 @@ fn parse_string_iter<
/// Casts generic string arrays to an ArrowTimestampType (TimeStampNanosecondArray, etc.)
pub(crate) fn cast_string_to_timestamp<O: OffsetSizeTrait, T: ArrowTimestampType>(
array: &dyn Array,
- to_tz: &Option<Arc<str>>,
+ to_tz: Option<&Arc<str>>,
cast_options: &CastOptions,
) -> Result<ArrayRef, ArrowError> {
let array = array.as_string::<O>();
@@ -134,13 +134,13 @@ pub(crate) fn cast_string_to_timestamp<O: OffsetSizeTrait, T: ArrowTimestampType
}
None => cast_string_to_timestamp_impl(array.iter(), &Utc, cast_options)?,
};
- Ok(Arc::new(out.with_timezone_opt(to_tz.clone())))
+ Ok(Arc::new(out.with_timezone_opt(to_tz.cloned())))
}
/// Casts string view arrays to an ArrowTimestampType (TimeStampNanosecondArray, etc.)
pub(crate) fn cast_view_to_timestamp<T: ArrowTimestampType>(
array: &dyn Array,
- to_tz: &Option<Arc<str>>,
+ to_tz: Option<&Arc<str>>,
cast_options: &CastOptions,
) -> Result<ArrayRef, ArrowError> {
let array = array.as_string_view();
@@ -151,7 +151,7 @@ pub(crate) fn cast_view_to_timestamp<T: ArrowTimestampType>(
}
None => cast_string_to_timestamp_impl(array.iter(), &Utc, cast_options)?,
};
- Ok(Arc::new(out.with_timezone_opt(to_tz.clone())))
+ Ok(Arc::new(out.with_timezone_opt(to_tz.cloned())))
}
fn cast_string_to_timestamp_impl<
diff --git a/arrow-cast/src/display.rs b/arrow-cast/src/display.rs
index 64ba6b7d81..68775ace75 100644
--- a/arrow-cast/src/display.rs
+++ b/arrow-cast/src/display.rs
@@ -147,7 +147,7 @@ impl Hash for FormatOptions<'_> {
self.types_info.hash(state);
self.quoted_strings.hash(state);
self.formatter_factory
- .map(|f| f as *const dyn ArrayFormatterFactory)
+ .map(std::ptr::from_ref::<dyn ArrayFormatterFactory>)
.hash(state);
}
}
@@ -971,7 +971,7 @@ impl DisplayIndex for &PrimitiveArray<IntervalYearMonthType> {
let years = (interval / 12_f64).floor();
let month = interval - (years * 12_f64);
- write!(f, "{years} years {month} mons",)?;
+ write!(f, "{years} years {month} mons")?;
Ok(())
}
}
diff --git a/arrow-cast/src/parse.rs b/arrow-cast/src/parse.rs
index 2db047359a..a5599d9ef8 100644
--- a/arrow-cast/src/parse.rs
+++ b/arrow-cast/src/parse.rs
@@ -809,7 +809,7 @@ fn parse_e_notation<T: DecimalType>(
let base = T::Native::usize_as(10);
// e has a plus sign
- let mut pos_shift_direction: bool = true;
+ let mut pos_shift_direction = true;
// skip to the exponent index directly or just after any processed fractionals
let mut bs = s.as_bytes().iter().skip(index + fractionals as usize);
@@ -1840,7 +1840,7 @@ mod tests {
for case in cases {
let v = date32_to_datetime(Date32Type::parse(case).unwrap()).unwrap();
let expected = NaiveDate::parse_from_str(case, "%Y-%m-%d")
- .or(NaiveDate::parse_from_str(case, "%Y-%m-%d %H:%M:%S"))
+ .or_else(|_| NaiveDate::parse_from_str(case, "%Y-%m-%d %H:%M:%S"))
.unwrap();
assert_eq!(v.date(), expected);
}
diff --git a/arrow-cast/src/pretty.rs b/arrow-cast/src/pretty.rs
index fc0a7259c0..98dd605d7e 100644
--- a/arrow-cast/src/pretty.rs
+++ b/arrow-cast/src/pretty.rs
@@ -206,7 +206,7 @@ fn create_table(
}
for batch in results {
- let schema = schema_opt.as_ref().unwrap_or(batch.schema_ref());
+ let schema = schema_opt.as_ref().unwrap_or_else(|| batch.schema_ref());
// Could be a custom schema that was provided.
if batch.columns().len() != schema.fields().len() {
diff --git a/arrow-cmp/src/lib.rs b/arrow-cmp/src/lib.rs
index 5620ba710e..368ef9921c 100644
--- a/arrow-cmp/src/lib.rs
+++ b/arrow-cmp/src/lib.rs
@@ -250,7 +250,7 @@ fn compare_list<O: OffsetSizeTrait>(
for (i, j) in (l_start..l_end).zip(r_start..r_end) {
match cmp(i, j) {
- Ordering::Equal => continue,
+ Ordering::Equal => {}
r => return r,
}
}
@@ -281,7 +281,7 @@ fn compare_fixed_list(
let r_end = r_start + r_size;
for (i, j) in (l_start..l_end).zip(r_start..r_end) {
match cmp(i, j) {
- Ordering::Equal => continue,
+ Ordering::Equal => {}
r => return r,
}
}
@@ -317,7 +317,7 @@ fn compare_list_view<O: OffsetSizeTrait>(
for (i, j) in (l_start..l_end).zip(r_start..r_end) {
match cmp(i, j) {
- Ordering::Equal => continue,
+ Ordering::Equal => {}
r => return r,
}
}
@@ -348,7 +348,7 @@ fn compare_map(
for (i, j) in (l_start..l_end).zip(r_start..r_end) {
match cmp(i, j) {
- Ordering::Equal => continue,
+ Ordering::Equal => {}
r => return r,
}
}
@@ -380,7 +380,7 @@ fn compare_struct(
let f = compare(left, right, opts, move |i, j| {
for cmp in &comparators {
match cmp(i, j) {
- Ordering::Equal => continue,
+ Ordering::Equal => {}
r => return r,
}
}
diff --git a/arrow-csv/src/reader/mod.rs b/arrow-csv/src/reader/mod.rs
index fc06aaffa5..7cb8dd5913 100644
--- a/arrow-csv/src/reader/mod.rs
+++ b/arrow-csv/src/reader/mod.rs
@@ -472,7 +472,7 @@ pub fn infer_schema_from_files(
..Default::default()
};
- for fname in files.iter() {
+ for fname in files {
let f = File::open(fname)?;
let (schema, records_read) = format.infer_schema(f, Some(records_to_read))?;
if records_read == 0 {
@@ -2678,7 +2678,7 @@ mod tests {
let batches = reader.collect::<Result<Vec<_>, _>>();
assert!(match batches {
- Err(ArrowError::CsvError(e)) => e.to_string().contains("incorrect number of fields"),
+ Err(ArrowError::CsvError(e)) => e.contains("incorrect number of fields"),
_ => false,
});
}
@@ -2907,8 +2907,7 @@ mod tests {
let batches = reader.collect::<Result<Vec<_>, _>>();
assert!(match batches {
- Err(ArrowError::InvalidArgumentError(e)) =>
- e.to_string().contains("contains null values"),
+ Err(ArrowError::InvalidArgumentError(e)) => e.contains("contains null values"),
_ => false,
});
}
diff --git a/arrow-csv/src/writer.rs b/arrow-csv/src/writer.rs
index af413c889d..dd63a683e2 100644
--- a/arrow-csv/src/writer.rs
+++ b/arrow-csv/src/writer.rs
@@ -247,7 +247,7 @@ impl<W: Write> Writer<W> {
.schema()
.fields()
.iter()
- .for_each(|field| headers.push(field.name().to_string()));
+ .for_each(|field| headers.push(field.name().clone()));
self.writer
.write_record(&headers[..])
.map_err(map_csv_error)?;
diff --git a/arrow-data/src/data.rs b/arrow-data/src/data.rs
index 7407873c23..fa995f7095 100644
--- a/arrow-data/src/data.rs
+++ b/arrow-data/src/data.rs
@@ -529,7 +529,7 @@ impl ArrayData {
let mut result: usize = 0;
let layout = layout(&self.data_type);
- for spec in layout.buffers.iter() {
+ for spec in &layout.buffers {
match spec {
BufferSpec::FixedWidth { byte_width, .. } => {
// Offset buffers contain len+1 elements: one boundary per element
@@ -863,7 +863,7 @@ impl ArrayData {
}
}
// align children data recursively
- for data in self.child_data.iter_mut() {
+ for data in &mut self.child_data {
data.align_buffers()
}
}
@@ -1695,7 +1695,7 @@ impl ArrayData {
T: ArrowNativeType + TryInto<i64> + num_traits::Num + std::fmt::Display,
{
let values = self.typed_buffer::<T>(0, self.len)?;
- let mut prev_value: i64 = 0_i64;
+ let mut prev_value = 0_i64;
values.iter().enumerate().try_for_each(|(ix, &inp_value)| {
let value: i64 = inp_value.try_into().map_err(|_| {
ArrowError::InvalidArgumentError(format!(
diff --git a/arrow-data/src/equal/fixed_binary.rs b/arrow-data/src/equal/fixed_binary.rs
index 8d29a2684d..497e138d8a 100644
--- a/arrow-data/src/equal/fixed_binary.rs
+++ b/arrow-data/src/equal/fixed_binary.rs
@@ -47,10 +47,11 @@ pub(super) fn fixed_binary_equal(
} else {
let selectivity_frac = lhs.null_count() as f64 / lhs.len() as f64;
+ // get a ref of the null buffer bytes, to use in testing for nullness
+ let lhs_nulls = lhs.nulls().unwrap();
+ let rhs_nulls = rhs.nulls().unwrap();
+
if selectivity_frac >= NULL_SLICES_SELECTIVITY_THRESHOLD {
- // get a ref of the null buffer bytes, to use in testing for nullness
- let lhs_nulls = lhs.nulls().unwrap();
- let rhs_nulls = rhs.nulls().unwrap();
// with nulls, we need to compare item by item whenever it is not null
(0..len).all(|i| {
let lhs_pos = lhs_start + i;
@@ -70,10 +71,8 @@ pub(super) fn fixed_binary_equal(
)
})
} else {
- let lhs_nulls = lhs.nulls().unwrap();
let lhs_slices_iter =
BitSliceIterator::new(lhs_nulls.validity(), lhs_start + lhs_nulls.offset(), len);
- let rhs_nulls = rhs.nulls().unwrap();
let rhs_slices_iter =
BitSliceIterator::new(rhs_nulls.validity(), rhs_start + rhs_nulls.offset(), len);
diff --git a/arrow-data/src/equal/list_view.rs b/arrow-data/src/equal/list_view.rs
index c7cb31db90..f431e84589 100644
--- a/arrow-data/src/equal/list_view.rs
+++ b/arrow-data/src/equal/list_view.rs
@@ -44,27 +44,19 @@ pub(super) fn list_view_equal<T: ArrowNativeType + Integer>(
return false;
}
+ // All four slices are `len` long
+ let lhs_range_sizes = &lhs_sizes[lhs_start..lhs_start + len];
+ let rhs_range_sizes = &rhs_sizes[rhs_start..rhs_start + len];
+ let lhs_range_offsets = &lhs_offsets[lhs_start..lhs_start + len];
+ let rhs_range_offsets = &rhs_offsets[rhs_start..rhs_start + len];
+
if lhs_null_count == 0 {
// non-null pathway: all sizes must be equal, and all values must be equal
- let lhs_range_sizes = &lhs_sizes[lhs_start..lhs_start + len];
- let rhs_range_sizes = &rhs_sizes[rhs_start..rhs_start + len];
-
- if lhs_range_sizes.len() != rhs_range_sizes.len() {
- return false;
- }
-
if lhs_range_sizes != rhs_range_sizes {
return false;
}
// Check values for equality
- let lhs_range_offsets = &lhs_offsets[lhs_start..lhs_start + len];
- let rhs_range_offsets = &rhs_offsets[rhs_start..rhs_start + len];
-
- if lhs_range_offsets.len() != rhs_range_offsets.len() {
- return false;
- }
-
for ((&lhs_offset, &rhs_offset), &size) in lhs_range_offsets
.iter()
.zip(rhs_range_offsets)
@@ -81,26 +73,10 @@ pub(super) fn list_view_equal<T: ArrowNativeType + Integer>(
}
} else {
// Need to integrate validity check in the inner loop.
- // non-null pathway: all sizes must be equal, and all values must be equal
- let lhs_range_sizes = &lhs_sizes[lhs_start..lhs_start + len];
- let rhs_range_sizes = &rhs_sizes[rhs_start..rhs_start + len];
-
let lhs_nulls = lhs.nulls().unwrap().slice(lhs_start, len);
let rhs_nulls = rhs.nulls().unwrap().slice(rhs_start, len);
- // Sizes can differ if values are null
- if lhs_range_sizes.len() != rhs_range_sizes.len() {
- return false;
- }
-
// Check values for equality, with null checking
- let lhs_range_offsets = &lhs_offsets[lhs_start..lhs_start + len];
- let rhs_range_offsets = &rhs_offsets[rhs_start..rhs_start + len];
-
- if lhs_range_offsets.len() != rhs_range_offsets.len() {
- return false;
- }
-
for (index, ((&lhs_offset, &rhs_offset), &size)) in lhs_range_offsets
.iter()
.zip(rhs_range_offsets)
diff --git a/arrow-data/src/equal/primitive.rs b/arrow-data/src/equal/primitive.rs
index e92fdd2ba2..bd7e57eaa9 100644
--- a/arrow-data/src/equal/primitive.rs
+++ b/arrow-data/src/equal/primitive.rs
@@ -50,10 +50,11 @@ pub(super) fn primitive_equal<T>(
} else {
let selectivity_frac = lhs.null_count() as f64 / lhs.len() as f64;
+ // get a ref of the null buffer bytes, to use in testing for nullness
+ let lhs_nulls = lhs.nulls().unwrap();
+ let rhs_nulls = rhs.nulls().unwrap();
+
if selectivity_frac >= NULL_SLICES_SELECTIVITY_THRESHOLD {
- // get a ref of the null buffer bytes, to use in testing for nullness
- let lhs_nulls = lhs.nulls().unwrap();
- let rhs_nulls = rhs.nulls().unwrap();
// with nulls, we need to compare item by item whenever it is not null
(0..len).all(|i| {
let lhs_pos = lhs_start + i;
@@ -72,10 +73,8 @@ pub(super) fn primitive_equal<T>(
)
})
} else {
- let lhs_nulls = lhs.nulls().unwrap();
let lhs_slices_iter =
BitSliceIterator::new(lhs_nulls.validity(), lhs_start + lhs_nulls.offset(), len);
- let rhs_nulls = rhs.nulls().unwrap();
let rhs_slices_iter =
BitSliceIterator::new(rhs_nulls.validity(), rhs_start + rhs_nulls.offset(), len);
diff --git a/arrow-data/src/ffi.rs b/arrow-data/src/ffi.rs
index 8506a8844d..dff57e41c8 100644
--- a/arrow-data/src/ffi.rs
+++ b/arrow-data/src/ffi.rs
@@ -86,8 +86,8 @@ unsafe extern "C" fn release_array(array: *mut FFI_ArrowArray) {
let array = unsafe { &mut *array };
// take ownership of `private_data`, therefore dropping it`
- let private = unsafe { Box::from_raw(array.private_data as *mut ArrayPrivateData) };
- for child in private.children.iter() {
+ let private = unsafe { Box::from_raw(array.private_data.cast::<ArrayPrivateData>()) };
+ for child in &private.children {
let _ = unsafe { Box::from_raw(*child) };
}
if !private.dictionary.is_null() {
@@ -169,7 +169,7 @@ impl FFI_ArrowArray {
let buffers_ptr = buffers
.iter()
.filter_map(|maybe_buffer| match maybe_buffer {
- Some(b) => Some(b.as_ptr() as *const c_void),
+ Some(b) => Some(b.as_ptr().cast::<c_void>()),
// This is for null buffer. We only put a null pointer for
// null buffer if by spec it can contain null mask.
None if data_layout.can_contain_null_mask => Some(std::ptr::null()),
@@ -217,7 +217,7 @@ impl FFI_ArrowArray {
children: private_data.children.as_mut_ptr(),
dictionary,
release: Some(release_array),
- private_data: Box::into_raw(private_data) as *mut c_void,
+ private_data: Box::into_raw(private_data).cast::<c_void>(),
}
}
@@ -347,7 +347,7 @@ impl FFI_ArrowArray {
assert!(index < self.num_buffers());
// SAFETY:
// If buffers is not null must be valid for reads up to num_buffers
- unsafe { std::ptr::read_unaligned((self.buffers as *mut *const u8).add(index)) }
+ unsafe { std::ptr::read_unaligned(self.buffers.cast::<*const u8>().add(index)) }
}
/// Returns the number of buffers
@@ -398,7 +398,7 @@ mod tests {
assert_eq!(0, ffi_array.n_buffers);
let private_data =
- unsafe { Box::from_raw(ffi_array.private_data as *mut ArrayPrivateData) };
+ unsafe { Box::from_raw(ffi_array.private_data.cast::<ArrayPrivateData>()) };
assert_eq!(0, private_data.buffers_ptr.len());
diff --git a/arrow-data/src/transform/fixed_size_list.rs b/arrow-data/src/transform/fixed_size_list.rs
index 139ee45e51..de791884b9 100644
--- a/arrow-data/src/transform/fixed_size_list.rs
+++ b/arrow-data/src/transform/fixed_size_list.rs
@@ -28,7 +28,7 @@ pub(super) fn build_extend(array: &ArrayData) -> Extend<'_> {
Box::new(
move |mutable: &mut _MutableArrayData, index: usize, start: usize, len: usize| {
- for child in mutable.child_data.iter_mut() {
+ for child in &mut mutable.child_data {
child.try_extend(index, start * size, (start + len) * size)?;
}
Ok(())
@@ -42,7 +42,7 @@ pub(super) fn extend_nulls(mutable: &mut _MutableArrayData, len: usize) -> Resul
_ => unreachable!(),
};
- for child in mutable.child_data.iter_mut() {
+ for child in &mut mutable.child_data {
child.try_extend_nulls(len * size)?;
}
Ok(())
diff --git a/arrow-data/src/transform/run.rs b/arrow-data/src/transform/run.rs
index 2167790cc1..db3edd0597 100644
--- a/arrow-data/src/transform/run.rs
+++ b/arrow-data/src/transform/run.rs
@@ -252,7 +252,7 @@ pub fn build_extend(array: &ArrayData) -> Extend<'_> {
DataType::Int16 => build_and_process_impl!(i16),
DataType::Int32 => build_and_process_impl!(i32),
DataType::Int64 => build_and_process_impl!(i64),
- _ => panic!("Invalid run end type for RunEndEncoded array: {dest_run_end_type}",),
+ _ => panic!("Invalid run end type for RunEndEncoded array: {dest_run_end_type}"),
}
Ok(())
},
diff --git a/arrow-data/src/transform/union.rs b/arrow-data/src/transform/union.rs
index 5c4d1b9313..ce2c55c391 100644
--- a/arrow-data/src/transform/union.rs
+++ b/arrow-data/src/transform/union.rs
@@ -29,7 +29,7 @@ pub(super) fn build_extend_sparse(array: &ArrayData) -> Extend<'_> {
.buffer1
.extend_from_slice(&type_ids[start..start + len]);
- for child in mutable.child_data.iter_mut() {
+ for child in &mut mutable.child_data {
child.try_extend(index, start, start + len)?;
}
Ok(())
@@ -117,7 +117,7 @@ pub(super) fn extend_nulls_sparse(
.map_err(|e| ArrowError::MemoryError(e.to_string()))?;
// Sparse: extend nulls in ALL children
- for child in mutable.child_data.iter_mut() {
+ for child in &mut mutable.child_data {
child.try_extend_nulls(len)?;
}
Ok(())
diff --git a/arrow-flight/src/client.rs b/arrow-flight/src/client.rs
index b2059a81d0..cd5a34730a 100644
--- a/arrow-flight/src/client.rs
+++ b/arrow-flight/src/client.rs
@@ -625,9 +625,9 @@ where
) -> Result<CancelFlightInfoResult> {
let action = Action::new("CancelFlightInfo", request.encode_to_vec());
let response = self.do_action(action).await?.try_next().await?;
- let response = response.ok_or(FlightError::protocol(
- "Received no response for cancel_flight_info call",
- ))?;
+ let response = response.ok_or_else(|| {
+ FlightError::protocol("Received no response for cancel_flight_info call")
+ })?;
CancelFlightInfoResult::decode(response)
.map_err(|e| FlightError::DecodeError(e.to_string()))
}
@@ -664,9 +664,9 @@ where
) -> Result<FlightEndpoint> {
let action = Action::new("RenewFlightEndpoint", request.encode_to_vec());
let response = self.do_action(action).await?.try_next().await?;
- let response = response.ok_or(FlightError::protocol(
- "Received no response for renew_flight_endpoint call",
- ))?;
+ let response = response.ok_or_else(|| {
+ FlightError::protocol("Received no response for renew_flight_endpoint call")
+ })?;
FlightEndpoint::decode(response).map_err(|e| FlightError::DecodeError(e.to_string()))
}
diff --git a/arrow-flight/src/encode.rs b/arrow-flight/src/encode.rs
index 29d3eb105c..a34edf35e3 100644
--- a/arrow-flight/src/encode.rs
+++ b/arrow-flight/src/encode.rs
@@ -1235,7 +1235,7 @@ mod tests {
let arr1 = builder.finish();
- let type_id_buffer = [0].into_iter().collect::<ScalarBuffer<i8>>();
+ let type_id_buffer = std::iter::once(0).collect::<ScalarBuffer<i8>>();
let arr1 = UnionArray::try_new(
union_fields.clone(),
type_id_buffer,
@@ -1253,7 +1253,7 @@ mod tests {
let arr2 = Arc::new(builder.finish());
let arr2 = StructArray::new(struct_fields.clone().into(), vec![arr2], None);
- let type_id_buffer = [1].into_iter().collect::<ScalarBuffer<i8>>();
+ let type_id_buffer = std::iter::once(1).collect::<ScalarBuffer<i8>>();
let arr2 = UnionArray::try_new(
union_fields.clone(),
type_id_buffer,
@@ -1266,7 +1266,7 @@ mod tests {
)
.unwrap();
- let type_id_buffer = [2].into_iter().collect::<ScalarBuffer<i8>>();
+ let type_id_buffer = std::iter::once(2).collect::<ScalarBuffer<i8>>();
let arr3 = UnionArray::try_new(
union_fields.clone(),
type_id_buffer,
@@ -1409,7 +1409,7 @@ mod tests {
let arr1 = builder.finish();
- let type_id_buffer = [0].into_iter().collect::<ScalarBuffer<i8>>();
+ let type_id_buffer = std::iter::once(0).collect::<ScalarBuffer<i8>>();
let arr1 = UnionArray::try_new(
union_fields.clone(),
type_id_buffer,
@@ -1427,7 +1427,7 @@ mod tests {
let arr2 = Arc::new(builder.finish());
let arr2 = StructArray::new(struct_fields.clone().into(), vec![arr2], None);
- let type_id_buffer = [1].into_iter().collect::<ScalarBuffer<i8>>();
+ let type_id_buffer = std::iter::once(1).collect::<ScalarBuffer<i8>>();
let arr2 = UnionArray::try_new(
union_fields.clone(),
type_id_buffer,
@@ -1440,7 +1440,7 @@ mod tests {
)
.unwrap();
- let type_id_buffer = [2].into_iter().collect::<ScalarBuffer<i8>>();
+ let type_id_buffer = std::iter::once(2).collect::<ScalarBuffer<i8>>();
let arr3 = UnionArray::try_new(
union_fields.clone(),
type_id_buffer,
diff --git a/arrow-flight/src/sql/metadata/sql_info.rs b/arrow-flight/src/sql/metadata/sql_info.rs
index 885d15dd6f..ec4f901b84 100644
--- a/arrow-flight/src/sql/metadata/sql_info.rs
+++ b/arrow-flight/src/sql/metadata/sql_info.rs
@@ -356,7 +356,7 @@ impl SqlInfoDataBuilder {
let mut name_builder = UInt32Builder::new();
let mut value_builder = SqlInfoUnionBuilder::new();
- let mut names: Vec<_> = self.infos.keys().cloned().collect();
+ let mut names: Vec<_> = self.infos.keys().copied().collect();
names.sort_unstable();
for key in names {
diff --git a/arrow-flight/src/utils.rs b/arrow-flight/src/utils.rs
index 0cc55ee75d..192ebcf0d5 100644
--- a/arrow-flight/src/utils.rs
+++ b/arrow-flight/src/utils.rs
@@ -44,7 +44,7 @@ pub fn flight_data_to_batches(flight_data: &[FlightData]) -> Result<Vec<RecordBa
let mut batches = vec![];
let dictionaries_by_id = HashMap::new();
- for datum in flight_data[1..].iter() {
+ for datum in &flight_data[1..] {
let batch = flight_data_to_arrow_batch(datum, schema.clone(), &dictionaries_by_id)?;
batches.push(batch);
}
@@ -94,7 +94,7 @@ pub fn batches_to_flight_data(
let mut dictionary_tracker = writer::DictionaryTracker::new(false);
let mut ipc_write_context = IpcWriteContext::default();
- for batch in batches.iter() {
+ for batch in &batches {
let (encoded_dictionaries, encoded_batch) = data_gen.encode(
batch,
&mut dictionary_tracker,
diff --git a/arrow-integration-test/src/field.rs b/arrow-integration-test/src/field.rs
index b7d14acd60..997c509890 100644
--- a/arrow-integration-test/src/field.rs
+++ b/arrow-integration-test/src/field.rs
@@ -27,7 +27,7 @@ pub fn field_from_json(json: &serde_json::Value) -> Result<Field> {
match *json {
Value::Object(ref map) => {
let name = match map.get("name") {
- Some(Value::String(name)) => name.to_string(),
+ Some(Value::String(name)) => name.clone(),
_ => {
return Err(ArrowError::ParseError(
"Field missing 'name' attribute".to_string(),
diff --git a/arrow-integration-test/src/lib.rs b/arrow-integration-test/src/lib.rs
index 2b51318f1b..e294aced03 100644
--- a/arrow-integration-test/src/lib.rs
+++ b/arrow-integration-test/src/lib.rs
@@ -132,7 +132,7 @@ impl From<&Field> for ArrowJsonField {
};
Self {
- name: field.name().to_string(),
+ name: field.name().clone(),
field_type: data_type_to_json(field.data_type()),
nullable: field.is_nullable(),
children: vec![],
diff --git a/arrow-integration-test/src/schema.rs b/arrow-integration-test/src/schema.rs
index 092a07a955..c43c8bb126 100644
--- a/arrow-integration-test/src/schema.rs
+++ b/arrow-integration-test/src/schema.rs
@@ -83,7 +83,7 @@ fn from_metadata(json: &serde_json::Value) -> Result<HashMap<String, String>> {
.iter()
.map(|(k, v)| {
if let Value::String(v) = v {
- Ok((k.to_string(), v.to_string()))
+ Ok((k.clone(), v.clone()))
} else {
Err(ArrowError::ParseError(
"metadata `value` field must be a string".to_string(),
@@ -113,10 +113,7 @@ mod tests {
#[test]
fn schema_json() {
// Add some custom metadata
- let metadata: HashMap<String, String> = [("Key".to_string(), "Value".to_string())]
- .iter()
- .cloned()
- .collect();
+ let metadata = HashMap::from([("Key".to_string(), "Value".to_string())]);
let schema = Schema::new_with_metadata(
vec![
diff --git a/arrow-ipc/src/convert.rs b/arrow-ipc/src/convert.rs
index d422704ec8..86e61a65ee 100644
--- a/arrow-ipc/src/convert.rs
+++ b/arrow-ipc/src/convert.rs
@@ -1166,14 +1166,8 @@ mod tests {
#[test]
fn convert_schema_round_trip() {
- let md: HashMap<String, String> = [("Key".to_string(), "value".to_string())]
- .iter()
- .cloned()
- .collect();
- let field_md: HashMap<String, String> = [("k".to_string(), "v".to_string())]
- .iter()
- .cloned()
- .collect();
+ let md = HashMap::from([("Key".to_string(), "value".to_string())]);
+ let field_md = HashMap::from([("k".to_string(), "v".to_string())]);
let schema = Schema::new_with_metadata(
vec![
Field::new("uint8", DataType::UInt8, false).with_metadata(field_md),
diff --git a/arrow-ipc/src/gen/mod.rs b/arrow-ipc/src/gen/mod.rs
index 37192354ed..ef7274eb08 100644
--- a/arrow-ipc/src/gen/mod.rs
+++ b/arrow-ipc/src/gen/mod.rs
@@ -21,6 +21,8 @@
// The flatbuffers compiler emits redundant `T: 'a` bounds, and lifetime parameters
// that some of the generated types never use. This file is not regenerated by
// `regen.sh`, so these attributes survive regeneration of the modules below.
+// The generated modules are exempt from `clippy::pedantic` for the same reason:
+// we cannot fix what we do not write.
#![expect(
explicit_outlives_requirements,
reason = "the flatbuffers compiler emits redundant `T: 'a` bounds"
@@ -30,13 +32,13 @@
reason = "the flatbuffers compiler emits lifetime parameters that some generated types never use"
)]
-#[allow(clippy::all)]
+#[allow(clippy::all, clippy::pedantic)]
pub mod File;
-#[allow(clippy::all)]
+#[allow(clippy::all, clippy::pedantic)]
pub mod Message;
-#[allow(clippy::all)]
+#[allow(clippy::all, clippy::pedantic)]
pub mod Schema;
-#[allow(clippy::all)]
+#[allow(clippy::all, clippy::pedantic)]
pub mod SparseTensor;
-#[allow(clippy::all)]
+#[allow(clippy::all, clippy::pedantic)]
pub mod Tensor;
diff --git a/arrow-ipc/src/reader.rs b/arrow-ipc/src/reader.rs
index f501e4c344..d06415175e 100644
--- a/arrow-ipc/src/reader.rs
+++ b/arrow-ipc/src/reader.rs
@@ -870,7 +870,7 @@ fn get_dictionary_values(
buf: &Buffer,
batch: crate::DictionaryBatch,
schema: &Schema,
- dictionaries_by_id: &mut HashMap<i64, ArrayRef>,
+ dictionaries_by_id: &HashMap<i64, ArrayRef>,
metadata: &MetadataVersion,
require_alignment: bool,
skip_validation: UnsafeFlag,
@@ -1664,9 +1664,7 @@ impl<R: Read> StreamReader<R> {
IpcMessage::RecordBatch(record_batch) => {
return Ok(Some(record_batch));
}
- IpcMessage::DictionaryBatch { .. } => {
- continue;
- }
+ IpcMessage::DictionaryBatch { .. } => {}
};
}
}
@@ -1725,7 +1723,7 @@ impl<R: Read> StreamReader<R> {
&body.into(),
dict,
&self.schema,
- &mut self.dictionaries_by_id,
+ &self.dictionaries_by_id,
&version,
false,
self.skip_validation.clone(),
diff --git a/arrow-ipc/src/writer.rs b/arrow-ipc/src/writer.rs
index 6e32d0b157..6490f10c1b 100644
--- a/arrow-ipc/src/writer.rs
+++ b/arrow-ipc/src/writer.rs
@@ -3209,7 +3209,7 @@ mod tests {
// Dict field with id 2
#[expect(deprecated)]
let dctfield = Field::new_dict("dict", array.data_type().clone(), false, 0, false);
- let union_fields = [(0, Arc::new(dctfield))].into_iter().collect();
+ let union_fields = std::iter::once((0, Arc::new(dctfield))).collect();
let types = [0, 0, 0].into_iter().collect::<ScalarBuffer<i8>>();
let offsets = [0, 1, 2].into_iter().collect::<ScalarBuffer<i32>>();
diff --git a/arrow-json/src/reader/mod.rs b/arrow-json/src/reader/mod.rs
index 83864b1a4f..1a2ca7631d 100644
--- a/arrow-json/src/reader/mod.rs
+++ b/arrow-json/src/reader/mod.rs
@@ -3295,7 +3295,7 @@ mod tests {
.iter()
.chain(json_values[..i].iter())
.zip(&schema.fields)
- .map(|(v, f)| (f.name().to_string(), v.clone()))
+ .map(|(v, f)| (f.name().clone(), v.clone()))
.collect();
serde_json::Value::Object(pairs)
})
diff --git a/arrow-json/src/reader/primitive_array.rs b/arrow-json/src/reader/primitive_array.rs
index b086954297..dc9c0a8b1a 100644
--- a/arrow-json/src/reader/primitive_array.rs
+++ b/arrow-json/src/reader/primitive_array.rs
@@ -109,28 +109,26 @@ where
TapeElement::String(idx) => {
let s = tape.get_string(idx);
P::parse(s).ok_or_else(|| {
- ArrowError::JsonError(format!("failed to parse \"{s}\" as {d}",))
+ ArrowError::JsonError(format!("failed to parse \"{s}\" as {d}"))
})
}
TapeElement::Number(idx) => {
let s = tape.get_string(idx);
- ParseJsonNumber::parse(s.as_bytes()).ok_or_else(|| {
- ArrowError::JsonError(format!("failed to parse {s} as {d}",))
- })
+ ParseJsonNumber::parse(s.as_bytes())
+ .ok_or_else(|| ArrowError::JsonError(format!("failed to parse {s} as {d}")))
}
TapeElement::F32(v) => {
let v = f32::from_bits(v);
- NumCast::from(v).ok_or_else(|| {
- ArrowError::JsonError(format!("failed to parse {v} as {d}",))
- })
+ NumCast::from(v)
+ .ok_or_else(|| ArrowError::JsonError(format!("failed to parse {v} as {d}")))
}
TapeElement::I32(v) => NumCast::from(v)
- .ok_or_else(|| ArrowError::JsonError(format!("failed to parse {v} as {d}",))),
+ .ok_or_else(|| ArrowError::JsonError(format!("failed to parse {v} as {d}"))),
TapeElement::F64(high) => match tape.get(p + 1) {
TapeElement::F32(low) => {
let v = f64::from_bits(((high as u64) << 32) | low as u64);
NumCast::from(v).ok_or_else(|| {
- ArrowError::JsonError(format!("failed to parse {v} as {d}",))
+ ArrowError::JsonError(format!("failed to parse {v} as {d}"))
})
}
_ => unreachable!(),
@@ -139,7 +137,7 @@ where
TapeElement::I32(low) => {
let v = ((high as i64) << 32) | (low as u32) as i64;
NumCast::from(v).ok_or_else(|| {
- ArrowError::JsonError(format!("failed to parse {v} as {d}",))
+ ArrowError::JsonError(format!("failed to parse {v} as {d}"))
})
}
_ => unreachable!(),
diff --git a/arrow-json/src/reader/schema.rs b/arrow-json/src/reader/schema.rs
index f9f70da1f0..674375f629 100644
--- a/arrow-json/src/reader/schema.rs
+++ b/arrow-json/src/reader/schema.rs
@@ -328,13 +328,13 @@ fn collect_field_types_from_object(
match ele_type {
InferredType::Scalar(_) => {
field_types.insert(
- k.to_string(),
+ k.clone(),
InferredType::Array(Box::new(InferredType::Scalar(HashSet::new()))),
);
}
InferredType::Object(_) => {
field_types.insert(
- k.to_string(),
+ k.clone(),
InferredType::Array(Box::new(InferredType::Object(HashMap::new()))),
);
}
@@ -342,7 +342,7 @@ fn collect_field_types_from_object(
// set inner type to any for nested array as well
// so it can be updated properly from subsequent type merges
field_types.insert(
- k.to_string(),
+ k.clone(),
InferredType::Array(Box::new(InferredType::Any)),
);
}
@@ -373,7 +373,7 @@ fn collect_field_types_from_object(
// we treat json as nullable by default when inferring, so just
// mark existence of a field if it wasn't known before
if !field_types.contains_key(k) {
- field_types.insert(k.to_string(), InferredType::Any);
+ field_types.insert(k.clone(), InferredType::Any);
}
}
Value::Number(n) => {
@@ -391,7 +391,7 @@ fn collect_field_types_from_object(
field_types.get(k).unwrap_or(&InferredType::Any),
InferredType::Any
) {
- field_types.insert(k.to_string(), InferredType::Object(HashMap::new()));
+ field_types.insert(k.clone(), InferredType::Object(HashMap::new()));
}
match field_types.get_mut(k).unwrap() {
InferredType::Object(inner_field_types) => {
@@ -664,11 +664,7 @@ mod tests {
infer_json_schema_from_seekable(Cursor::new(data), None).expect("infer");
let schema = Schema::new(vec![Field::new(
"obj",
- DataType::Struct(
- [Field::new("foo", DataType::Int64, true)]
- .into_iter()
- .collect(),
- ),
+ DataType::Struct(std::iter::once(Field::new("foo", DataType::Int64, true)).collect()),
true,
)]);
assert_eq!(inferred_schema, schema);
diff --git a/arrow-json/src/reader/struct_array.rs b/arrow-json/src/reader/struct_array.rs
index 75bb02781b..6de81a6c8d 100644
--- a/arrow-json/src/reader/struct_array.rs
+++ b/arrow-json/src/reader/struct_array.rs
@@ -284,7 +284,7 @@ fn build_field_index(fields: &Fields) -> Option<HashMap<String, usize>> {
for (idx, field) in fields.iter().enumerate() {
let name = field.name();
if !map.contains_key(name) {
- map.insert(name.to_string(), idx);
+ map.insert(name.clone(), idx);
}
}
Some(map)
diff --git a/arrow-json/src/writer/encoder.rs b/arrow-json/src/writer/encoder.rs
index a3db1ce053..76a1ca440d 100644
--- a/arrow-json/src/writer/encoder.rs
+++ b/arrow-json/src/writer/encoder.rs
@@ -512,7 +512,7 @@ impl Encoder for StructArrayEncoder<'_> {
// Nulls can only be dropped in explicit mode
let drop_nulls = (self.struct_mode == StructMode::ObjectOnly) && !self.explicit_nulls;
- for field_encoder in self.encoders.iter_mut() {
+ for field_encoder in &mut self.encoders {
let is_null = field_encoder.is_null(idx);
if is_null && drop_nulls {
continue;
diff --git a/arrow-json/src/writer/mod.rs b/arrow-json/src/writer/mod.rs
index 3596d41883..35202bf962 100644
--- a/arrow-json/src/writer/mod.rs
+++ b/arrow-json/src/writer/mod.rs
@@ -2317,7 +2317,7 @@ mod tests {
};
// check that the fields are supported
let fields = fields.iter().map(|(_, f)| f).collect::<Vec<_>>();
- for f in fields.iter() {
+ for f in &fields {
match f.data_type() {
DataType::Null => {}
DataType::Int32 => {}
diff --git a/arrow-ord/src/comparison.rs b/arrow-ord/src/comparison.rs
index 823be32207..5fbd11c124 100644
--- a/arrow-ord/src/comparison.rs
+++ b/arrow-ord/src/comparison.rs
@@ -61,7 +61,7 @@ where
for j in 0..list.len() {
if list.is_valid(j) && (left.value(i) == list.value(j)) {
bit_util::set_bit(bool_slice, i);
- continue;
+ break;
}
}
}
@@ -102,7 +102,7 @@ where
for j in 0..list.len() {
if list.is_valid(j) && (left.value(i) == list.value(j)) {
bit_util::set_bit(bool_slice, i);
- continue;
+ break;
}
}
}
diff --git a/arrow-ord/src/sort.rs b/arrow-ord/src/sort.rs
index f6139ad902..1bdb3e986b 100644
--- a/arrow-ord/src/sort.rs
+++ b/arrow-ord/src/sort.rs
@@ -373,7 +373,7 @@ fn sort_bytes<T: ByteArrayType>(
let len = slice.len() as u64;
// Compute the 4‑byte prefix in BE order, or left‑pad if shorter
let prefix = if slice.len() >= 4 {
- let raw = std::ptr::read_unaligned(slice.as_ptr() as *const u32);
+ let raw = std::ptr::read_unaligned(slice.as_ptr().cast::<u32>());
u32::from_be(raw)
} else if slice.is_empty() {
// Handle empty slice case to avoid shift overflow
@@ -1132,7 +1132,7 @@ impl LexicographicalComparator {
pub fn compare(&self, a_idx: usize, b_idx: usize) -> Ordering {
for comparator in &self.compare_items {
match comparator(a_idx, b_idx) {
- Ordering::Equal => continue,
+ Ordering::Equal => {}
r => return r,
}
}
@@ -1168,7 +1168,7 @@ impl<const N: usize> FixedLexicographicalComparator<N> {
pub fn compare(&self, a_idx: usize, b_idx: usize) -> Ordering {
for comparator in &self.compare_items {
match comparator(a_idx, b_idx) {
- Ordering::Equal => continue,
+ Ordering::Equal => {}
r => return r,
}
}
diff --git a/arrow-row/src/lib.rs b/arrow-row/src/lib.rs
index c38a2849ee..8e6f70c84b 100644
--- a/arrow-row/src/lib.rs
+++ b/arrow-row/src/lib.rs
@@ -2391,7 +2391,7 @@ unsafe fn decode_column(
unsafe { converter.convert_raw(&mut sparse_data, validate_utf8) }?;
// advance row slices by the bytes consumed for rows that belong to this field
- for (row_idx, child_row) in field_rows.iter() {
+ for (row_idx, child_row) in field_rows {
let remaining_len = sparse_data[*row_idx].len();
let consumed_length = 1 + child_row.len() - remaining_len;
rows[*row_idx] = &rows[*row_idx][consumed_length..];
@@ -5399,7 +5399,7 @@ mod tests {
let second = Int32Array::from(vec![Some(2), None, Some(4)]);
let arrays = [Arc::new(first) as ArrayRef, Arc::new(second) as ArrayRef];
- for array in arrays.iter() {
+ for array in &arrays {
rows.clear();
converter
.append(&mut rows, std::slice::from_ref(array))
diff --git a/arrow-schema/src/datatype_parse.rs b/arrow-schema/src/datatype_parse.rs
index 9439d8ea21..c2c607c22f 100644
--- a/arrow-schema/src/datatype_parse.rs
+++ b/arrow-schema/src/datatype_parse.rs
@@ -512,7 +512,7 @@ impl<'a> Parser<'a> {
let field = self.parse_field()?;
fields.push(Arc::new(field));
match self.next_token()? {
- Token::Comma => continue,
+ Token::Comma => {}
Token::RParen => break,
tok => {
return Err(make_error(
@@ -863,7 +863,6 @@ impl Iterator for Tokenizer<'_> {
' ' => {
// skip whitespace
self.next_char();
- continue;
}
'"' => {
return Some(self.parse_quoted_string(QuoteType::Double));
diff --git a/arrow-schema/src/ffi.rs b/arrow-schema/src/ffi.rs
index 557313ab85..a37f0443b5 100644
--- a/arrow-schema/src/ffi.rs
+++ b/arrow-schema/src/ffi.rs
@@ -116,8 +116,9 @@ unsafe extern "C" fn release_schema(schema: *mut FFI_ArrowSchema) {
drop(unsafe { CString::from_raw(schema.name.cast_mut()) });
}
if !schema.private_data.is_null() {
- let private_data = unsafe { Box::from_raw(schema.private_data as *mut SchemaPrivateData) };
- for child in private_data.children.iter() {
+ let private_data =
+ unsafe { Box::from_raw(schema.private_data.cast::<SchemaPrivateData>()) };
+ for child in &private_data.children {
drop(unsafe { Box::from_raw(*child) })
}
if !private_data.dictionary.is_null() {
@@ -169,7 +170,7 @@ impl FFI_ArrowSchema {
this.dictionary = dictionary_ptr;
- this.private_data = Box::into_raw(private_data) as *mut c_void;
+ this.private_data = Box::into_raw(private_data).cast::<c_void>();
Ok(this)
}
@@ -234,7 +235,7 @@ impl FFI_ArrowSchema {
metadata_serialized.extend_from_slice(value.as_ref().as_bytes());
}
- self.metadata = metadata_serialized.as_ptr() as *const c_char;
+ self.metadata = metadata_serialized.as_ptr().cast::<c_char>();
Some(metadata_serialized)
} else {
self.metadata = std::ptr::null_mut();
@@ -242,9 +243,9 @@ impl FFI_ArrowSchema {
};
unsafe {
- let mut private_data = Box::from_raw(self.private_data as *mut SchemaPrivateData);
+ let mut private_data = Box::from_raw(self.private_data.cast::<SchemaPrivateData>());
private_data.metadata = new_metadata;
- self.private_data = Box::into_raw(private_data) as *mut c_void;
+ self.private_data = Box::into_raw(private_data).cast::<c_void>();
}
Ok(self)
@@ -1097,7 +1098,7 @@ mod tests {
unsafe extern "C" fn wrapping_release(schema: *mut FFI_ArrowSchema) {
let schema = unsafe { &mut *schema };
- let data = unsafe { Box::from_raw(schema.private_data() as *mut WrapperData) };
+ let data = unsafe { Box::from_raw(schema.private_data().cast::<WrapperData>()) };
WRAPPER_RAN.store(true, Ordering::SeqCst);
// restore the originals, then let the original callback free everything
unsafe { schema.set_release(data.original_release) };
@@ -1116,7 +1117,7 @@ mod tests {
original_private_data: schema.private_data(),
});
unsafe { schema.set_release(Some(wrapping_release)) };
- unsafe { schema.set_private_data(Box::into_raw(data) as *mut c_void) };
+ unsafe { schema.set_private_data(Box::into_raw(data).cast::<c_void>()) };
drop(schema); // runs wrapping_release, which chains to the original
assert!(WRAPPER_RAN.load(Ordering::SeqCst));
diff --git a/arrow-schema/src/fields.rs b/arrow-schema/src/fields.rs
index 7f6bc21172..2e6242f950 100644
--- a/arrow-schema/src/fields.rs
+++ b/arrow-schema/src/fields.rs
@@ -593,7 +593,7 @@ impl UnionFields {
let mut output: Vec<_> = self.iter().map(|(id, f)| (id, f.clone())).collect();
for (field_type_id, from_field) in other.iter() {
let mut is_new_field = true;
- for (self_type_id, self_field) in output.iter_mut() {
+ for (self_type_id, self_field) in &mut output {
if from_field == self_field {
// If the nested fields in two unions are the same, they must have same
// type id.
diff --git a/arrow-schema/src/schema.rs b/arrow-schema/src/schema.rs
index ca7d3dadb4..47d031deab 100644
--- a/arrow-schema/src/schema.rs
+++ b/arrow-schema/src/schema.rs
@@ -1221,26 +1221,17 @@ mod tests {
#[test]
fn test_try_merge_field_with_metadata() {
// 1. Different values for the same key should cause error.
- let metadata1: HashMap<String, String> = [("foo".to_string(), "bar".to_string())]
- .iter()
- .cloned()
- .collect();
+ let metadata1 = HashMap::from([("foo".to_string(), "bar".to_string())]);
let f1 = Field::new("first_name", DataType::Utf8, false).with_metadata(metadata1);
- let metadata2: HashMap<String, String> = [("foo".to_string(), "baz".to_string())]
- .iter()
- .cloned()
- .collect();
+ let metadata2 = HashMap::from([("foo".to_string(), "baz".to_string())]);
let f2 = Field::new("first_name", DataType::Utf8, false).with_metadata(metadata2);
assert!(Schema::try_merge(vec![Schema::new(vec![f1]), Schema::new(vec![f2])]).is_err());
// 2. None + Some
let mut f1 = Field::new("first_name", DataType::Utf8, false);
- let metadata2: HashMap<String, String> = [("missing".to_string(), "value".to_string())]
- .iter()
- .cloned()
- .collect();
+ let metadata2 = HashMap::from([("missing".to_string(), "value".to_string())]);
let f2 = Field::new("first_name", DataType::Utf8, false).with_metadata(metadata2);
assert!(f1.try_merge(&f2).is_ok());
@@ -1303,10 +1294,7 @@ mod tests {
// new field
Field::new("number", DataType::Utf8, true),
],
- [("foo".to_string(), "bar".to_string())]
- .iter()
- .cloned()
- .collect::<HashMap<String, String>>(),
+ HashMap::from([("foo".to_string(), "bar".to_string())]),
),
])
.unwrap();
@@ -1327,10 +1315,7 @@ mod tests {
),
Field::new("number", DataType::Utf8, true),
],
- [("foo".to_string(), "bar".to_string())]
- .iter()
- .cloned()
- .collect::<HashMap<String, String>>()
+ HashMap::from([("foo".to_string(), "bar".to_string())])
)
);
@@ -1385,17 +1370,11 @@ mod tests {
let res = Schema::try_merge(vec![
Schema::new_with_metadata(
vec![Field::new("first_name", DataType::Utf8, false)],
- [("foo".to_string(), "bar".to_string())]
- .iter()
- .cloned()
- .collect::<HashMap<String, String>>(),
+ HashMap::from([("foo".to_string(), "bar".to_string())]),
),
Schema::new_with_metadata(
vec![Field::new("last_name", DataType::Utf8, false)],
- [("foo".to_string(), "baz".to_string())]
- .iter()
- .cloned()
- .collect::<HashMap<String, String>>(),
+ HashMap::from([("foo".to_string(), "baz".to_string())]),
),
])
.unwrap_err();
diff --git a/arrow-select/src/coalesce.rs b/arrow-select/src/coalesce.rs
index 1889a0360e..49d198c98f 100644
--- a/arrow-select/src/coalesce.rs
+++ b/arrow-select/src/coalesce.rs
@@ -500,7 +500,7 @@ impl BatchCoalescer {
debug_assert!(remaining_rows > 0);
// Copy remaining_rows from each array
- for in_progress in self.in_progress_arrays.iter_mut() {
+ for in_progress in &mut self.in_progress_arrays {
in_progress.copy_rows(offset, remaining_rows)?;
}
@@ -514,7 +514,7 @@ impl BatchCoalescer {
// Add any the remaining rows to the buffer
self.buffered_rows += num_rows;
if num_rows > 0 {
- for in_progress in self.in_progress_arrays.iter_mut() {
+ for in_progress in &mut self.in_progress_arrays {
in_progress.copy_rows(offset, num_rows)?;
}
}
@@ -525,7 +525,7 @@ impl BatchCoalescer {
}
// clear in progress sources (to allow the memory to be freed)
- for in_progress in self.in_progress_arrays.iter_mut() {
+ for in_progress in &mut self.in_progress_arrays {
in_progress.set_source(None);
}
@@ -2069,7 +2069,7 @@ mod tests {
let values: Vec<_> = values.into_iter().collect();
let values_iter = std::iter::repeat(values.iter())
.flatten()
- .cloned()
+ .copied()
.take(num_rows);
let mut builder = StringViewBuilder::with_capacity(100).with_fixed_block_size(8192);
@@ -2180,12 +2180,12 @@ mod tests {
// Only need to normalize StringViews (as == also tests for memory layout)
let (schema, mut columns, row_count) = batch.into_parts();
- for column in columns.iter_mut() {
+ for column in &mut columns {
if let Some(string_view) = column.as_string_view_opt() {
// Re-create the StringViewArray to ensure memory layout is
// consistent
let mut builder = StringViewBuilder::new();
- for s in string_view.iter() {
+ for s in string_view {
builder.append_option(s);
}
*column = Arc::new(builder.finish());
diff --git a/arrow-select/src/coalesce/primitive.rs b/arrow-select/src/coalesce/primitive.rs
index 3fa070d627..98df820236 100644
--- a/arrow-select/src/coalesce/primitive.rs
+++ b/arrow-select/src/coalesce/primitive.rs
@@ -121,10 +121,9 @@ impl<T: ArrowPrimitiveType> InProgressPrimitiveArray<T> {
#[inline]
fn primitive_source<T: ArrowPrimitiveType>(
- source: &Option<ArrayRef>,
+ source: Option<&ArrayRef>,
) -> Result<&PrimitiveArray<T>, ArrowError> {
Ok(source
- .as_ref()
.ok_or_else(|| {
ArrowError::InvalidArgumentError(
"Internal Error: InProgressPrimitiveArray: source not set".to_string(),
@@ -153,7 +152,7 @@ impl<T: ArrowPrimitiveType + Debug> InProgressArray for InProgressPrimitiveArray
fn copy_rows(&mut self, offset: usize, len: usize) -> Result<(), ArrowError> {
self.ensure_capacity();
- let s = primitive_source::<T>(&self.source)?;
+ let s = primitive_source::<T>(self.source.as_ref())?;
// add nulls if necessary
if let Some(nulls) = s.nulls().as_ref() {
@@ -176,7 +175,7 @@ impl<T: ArrowPrimitiveType + Debug> InProgressArray for InProgressPrimitiveArray
match filter.selection() {
FilterSelection::Indices(indices) => {
self.ensure_capacity();
- let s = primitive_source::<T>(&self.source)?;
+ let s = primitive_source::<T>(self.source.as_ref())?;
append_filtered_nulls(&mut self.nulls, s.nulls(), filter);
self.current.reserve(filter.count());
@@ -190,7 +189,7 @@ impl<T: ArrowPrimitiveType + Debug> InProgressArray for InProgressPrimitiveArray
}
FilterSelection::Slices(slices) => {
self.ensure_capacity();
- let s = primitive_source::<T>(&self.source)?;
+ let s = primitive_source::<T>(self.source.as_ref())?;
append_filtered_nulls(&mut self.nulls, s.nulls(), filter);
self.current.reserve(filter.count());
diff --git a/arrow-select/src/concat.rs b/arrow-select/src/concat.rs
index 46f3095565..921d286452 100644
--- a/arrow-select/src/concat.rs
+++ b/arrow-select/src/concat.rs
@@ -91,7 +91,7 @@ fn fixed_size_list_capacity(arrays: &[&dyn Array], data_type: &DataType) -> Capa
fn concat_byte_view<B: ByteViewType>(arrays: &[&dyn Array]) -> Result<ArrayRef, ArrowError> {
let mut builder =
GenericByteViewBuilder::<B>::with_capacity(arrays.iter().map(|a| a.len()).sum());
- for &array in arrays.iter() {
+ for &array in arrays {
builder.append_array(array.as_byte_view());
}
Ok(Arc::new(builder.finish()))
@@ -309,7 +309,7 @@ fn concat_list_view<OffsetSize: OffsetSizeTrait>(
let mut offsets = MutableBuffer::with_capacity(lists.iter().map(|l| l.offsets().len()).sum());
let mut global_offset = OffsetSize::zero();
- for l in lists.iter() {
+ for l in &lists {
for &offset in l.offsets() {
offsets.push(offset + global_offset);
}
@@ -1084,7 +1084,7 @@ mod tests {
Some(vec![Some(10), Some(20)]),
];
let mut list1_array = ListViewBuilder::new(Int64Builder::new());
- for v in list1.iter() {
+ for v in &list1 {
list1_array.append_option(v.clone());
}
let list1_array = list1_array.finish();
@@ -1095,14 +1095,14 @@ mod tests {
Some(vec![Some(102), Some(103)]),
];
let mut list2_array = ListViewBuilder::new(Int64Builder::new());
- for v in list2.iter() {
+ for v in &list2 {
list2_array.append_option(v.clone());
}
let list2_array = list2_array.finish();
let list3 = [Some(vec![Some(1000), Some(1001)])];
let mut list3_array = ListViewBuilder::new(Int64Builder::new());
- for v in list3.iter() {
+ for v in &list3 {
list3_array.append_option(v.clone());
}
let list3_array = list3_array.finish();
@@ -1111,7 +1111,7 @@ mod tests {
let expected: Vec<_> = list1.into_iter().chain(list2).chain(list3).collect();
let mut array_expected = ListViewBuilder::new(Int64Builder::new());
- for v in expected.iter() {
+ for v in &expected {
array_expected.append_option(v.clone());
}
let array_expected = array_expected.finish();
@@ -1127,7 +1127,7 @@ mod tests {
Some(vec![Some(10), Some(20)]),
];
let mut list1_array = ListViewBuilder::new(Int64Builder::new());
- for v in list1.iter() {
+ for v in &list1 {
list1_array.append_option(v.clone());
}
let list1_array = list1_array.finish();
@@ -1138,14 +1138,14 @@ mod tests {
Some(vec![Some(102), Some(103)]),
];
let mut list2_array = ListViewBuilder::new(Int64Builder::new());
- for v in list2.iter() {
+ for v in &list2 {
list2_array.append_option(v.clone());
}
let list2_array = list2_array.finish();
let list3 = [Some(vec![Some(1000), Some(1001)])];
let mut list3_array = ListViewBuilder::new(Int64Builder::new());
- for v in list3.iter() {
+ for v in &list3 {
list3_array.append_option(v.clone());
}
let list3_array = list3_array.finish();
@@ -1167,7 +1167,7 @@ mod tests {
Some(vec![Some(1000), Some(1001)]),
];
let mut array_expected = ListViewBuilder::new(Int64Builder::new());
- for v in expected.iter() {
+ for v in &expected {
array_expected.append_option(v.clone());
}
let array_expected = array_expected.finish();
diff --git a/arrow-select/src/filter.rs b/arrow-select/src/filter.rs
index 1c49826fe3..be2fb18918 100644
--- a/arrow-select/src/filter.rs
+++ b/arrow-select/src/filter.rs
@@ -902,16 +902,16 @@ where
filter.extend_slices(SlicesIterator::new(&predicate.filter))
}
IterationStrategy::Slices(slices) => {
- filter.extend_offsets_slices(slices.iter().cloned(), predicate.count);
- filter.extend_slices(slices.iter().cloned())
+ filter.extend_offsets_slices(slices.iter().copied(), predicate.count);
+ filter.extend_slices(slices.iter().copied())
}
IterationStrategy::IndexIterator => {
filter.extend_offsets_idx(IndexIterator::new(&predicate.filter, predicate.count));
filter.extend_idx(IndexIterator::new(&predicate.filter, predicate.count))
}
IterationStrategy::Indices(indices) => {
- filter.extend_offsets_idx(indices.iter().cloned());
- filter.extend_idx(indices.iter().cloned())
+ filter.extend_offsets_idx(indices.iter().copied());
+ filter.extend_idx(indices.iter().copied())
}
IterationStrategy::All | IterationStrategy::None => unreachable!(),
}
@@ -1788,7 +1788,7 @@ mod tests {
.take(mask_len)
.collect();
- let buffer = Buffer::from_iter(bools.iter().cloned());
+ let buffer = Buffer::from_iter(bools.iter().copied());
let truncated_length = mask_len - offset - truncate;
@@ -1909,7 +1909,7 @@ mod tests {
.take(array_len + filter_offset - filter_truncate)
.collect();
- let predicate = BooleanArray::from_iter(bools.iter().cloned().map(Some));
+ let predicate = BooleanArray::from_iter(bools.iter().copied().map(Some));
// Offset predicate
let predicate = predicate.slice(filter_offset, array_len - filter_truncate);
@@ -1918,7 +1918,7 @@ mod tests {
// Test i32
let values = gen_primitive(array_len + array_offset, valid_percent);
- let src = Int32Array::from_iter(values.iter().cloned());
+ let src = Int32Array::from_iter(values.iter().copied());
let src = src.slice(array_offset, array_len);
let src = src.as_any().downcast_ref::<Int32Array>().unwrap();
@@ -1928,7 +1928,7 @@ mod tests {
let array = filtered.as_any().downcast_ref::<Int32Array>().unwrap();
let actual: Vec<_> = array.iter().collect();
- assert_eq!(actual, filter_rust(values.iter().cloned(), bools));
+ assert_eq!(actual, filter_rust(values.iter().copied(), bools));
// Test string
let strings = gen_strings(array_len + array_offset, valid_percent, 0..20);
diff --git a/arrow-select/src/interleave.rs b/arrow-select/src/interleave.rs
index d843709479..f56864ac65 100644
--- a/arrow-select/src/interleave.rs
+++ b/arrow-select/src/interleave.rs
@@ -310,7 +310,7 @@ fn interleave_views<T: ByteViewType>(
let mut offsets = Vec::with_capacity(interleaved.arrays.len() + 1);
offsets.push(0);
let mut total_buffers = 0;
- for a in interleaved.arrays.iter() {
+ for a in &interleaved.arrays {
total_buffers += a.data_buffers().len();
offsets.push(total_buffers);
}
@@ -1956,7 +1956,7 @@ mod tests {
#[test]
fn test_interleave_run_end_encoded_empty_runs() {
let mut builder = PrimitiveRunBuilder::<Int32Type, Int32Type>::new();
- builder.extend([1].into_iter().map(Some));
+ builder.extend(std::iter::once(Some(1)));
let a = builder.finish();
let mut builder = PrimitiveRunBuilder::<Int32Type, Int32Type>::new();
diff --git a/arrow-string/src/binary_like.rs b/arrow-string/src/binary_like.rs
index 3759ff8573..1e67a03a85 100644
--- a/arrow-string/src/binary_like.rs
+++ b/arrow-string/src/binary_like.rs
@@ -65,7 +65,7 @@ pub(crate) fn binary_apply<'a, T: BinaryArrayType<'a> + 'a>(
r_s: bool,
r_v: Option<&'a dyn AnyDictionaryArray>,
) -> Result<BooleanArray, ArrowError> {
- let l_len = l_v.map(|l| l.len()).unwrap_or(l.len());
+ let l_len = l_v.map_or_else(|| l.len(), |l| l.len());
if r_s {
let idx = match r_v {
Some(dict) if dict.null_count() != 0 => return Ok(BooleanArray::new_null(l_len)),
diff --git a/arrow-string/src/like.rs b/arrow-string/src/like.rs
index 5fc75d81c9..4c2ef88d40 100644
--- a/arrow-string/src/like.rs
+++ b/arrow-string/src/like.rs
@@ -304,7 +304,7 @@ fn string_apply<'a, T: StringArrayType<'a> + 'a>(
r_s: bool,
r_v: Option<&'a dyn AnyDictionaryArray>,
) -> Result<BooleanArray, ArrowError> {
- let l_len = l_v.map(|l| l.len()).unwrap_or(l.len());
+ let l_len = l_v.map_or_else(|| l.len(), |l| l.len());
if r_s {
let idx = match r_v {
Some(dict) if dict.null_count() != 0 => return Ok(BooleanArray::new_null(l_len)),
diff --git a/arrow/benches/row_format.rs b/arrow/benches/row_format.rs
index caa06dc07e..09d3800fae 100644
--- a/arrow/benches/row_format.rs
+++ b/arrow/benches/row_format.rs
@@ -103,7 +103,7 @@ fn bench_iter(c: &mut Criterion) {
c.bench_function("iterate rows", |b| {
b.iter(|| {
- for r in rows.iter() {
+ for r in &rows {
hint::black_box(r.as_ref());
}
})
diff --git a/arrow/tests/array_cast.rs b/arrow/tests/array_cast.rs
index b5a8c43cc4..a6e2bbd512 100644
--- a/arrow/tests/array_cast.rs
+++ b/arrow/tests/array_cast.rs
@@ -366,7 +366,7 @@ fn make_fixed_size_list_array() -> FixedSizeListArray {
}
fn make_fixed_size_binary_array() -> FixedSizeBinaryArray {
- let values: &[u8; 15] = b"hellotherearrow";
+ let values = b"hellotherearrow";
let array_data = ArrayData::builder(DataType::FixedSizeBinary(5))
.len(3)
diff --git a/arrow/tests/array_validation.rs b/arrow/tests/array_validation.rs
index d34032b7cb..b92ccae3c9 100644
--- a/arrow/tests/array_validation.rs
+++ b/arrow/tests/array_validation.rs
@@ -1027,7 +1027,7 @@ fn test_string_data_from_foreign() {
};
let offsets_buffer = unsafe {
Buffer::from_custom_allocation(
- NonNull::new_unchecked(offsets.as_mut_ptr() as *mut u8),
+ NonNull::new_unchecked(offsets.as_mut_ptr().cast::<u8>()),
offsets.len() * std::mem::size_of::<i32>(),
Arc::new(offsets),
)
diff --git a/arrow/tests/schema.rs b/arrow/tests/schema.rs
index f252d77ca6..4894508fd7 100644
--- a/arrow/tests/schema.rs
+++ b/arrow/tests/schema.rs
@@ -22,9 +22,7 @@ use std::collections::HashMap;
#[test]
fn schema_destructure() {
- let meta = [("foo".to_string(), "baz".to_string())]
- .into_iter()
- .collect::<HashMap<String, String>>();
+ let meta = HashMap::from([("foo".to_string(), "baz".to_string())]);
let field = Field::new("c1", DataType::Utf8, false);
let schema = Schema::new(vec![field]).with_metadata(meta);
diff --git a/parquet-variant-compute/benches/variant_kernels.rs b/parquet-variant-compute/benches/variant_kernels.rs
index 8ecf5bf44e..800633b571 100644
--- a/parquet-variant-compute/benches/variant_kernels.rs
+++ b/parquet-variant-compute/benches/variant_kernels.rs
@@ -462,7 +462,7 @@ impl RandomJsonGenerator {
let random_string: String = (0..length)
.map(|_| rng.sample(Alphanumeric) as char)
.collect();
- write!(output_buffer, "\"{random_string}\"",).unwrap();
+ write!(output_buffer, "\"{random_string}\"").unwrap();
} else {
random_value -= *string_weight;
@@ -471,11 +471,11 @@ impl RandomJsonGenerator {
if rng.random_bool(0.5) {
// Generate a random integer
let random_integer: i64 = rng.random_range(-1000..1000);
- write!(output_buffer, "{random_integer}",).unwrap();
+ write!(output_buffer, "{random_integer}").unwrap();
} else {
// Generate a random float
let random_float: f64 = rng.random_range(-1000.0..1000.0);
- write!(output_buffer, "{random_float}",).unwrap();
+ write!(output_buffer, "{random_float}").unwrap();
}
} else {
random_value -= *number_weight;
@@ -483,7 +483,7 @@ impl RandomJsonGenerator {
if random_value <= *boolean_weight {
// Generate a random boolean
let random_boolean: bool = rng.random();
- write!(output_buffer, "{random_boolean}",).unwrap();
+ write!(output_buffer, "{random_boolean}").unwrap();
}
}
}
@@ -539,7 +539,7 @@ impl RandomJsonGenerator {
let random_string: String = (0..length)
.map(|_| rng.sample(Alphanumeric) as char)
.collect();
- write!(output_buffer, "\"{random_string}\"",).unwrap();
+ write!(output_buffer, "\"{random_string}\"").unwrap();
return;
}
random_value -= *string_weight;
@@ -549,11 +549,11 @@ impl RandomJsonGenerator {
if rng.random_bool(0.5) {
// Generate a random integer
let random_integer: i64 = rng.random_range(-1000..1000);
- write!(output_buffer, "{random_integer}",).unwrap();
+ write!(output_buffer, "{random_integer}").unwrap();
} else {
// Generate a random float
let random_float: f64 = rng.random_range(-1000.0..1000.0);
- write!(output_buffer, "{random_float}",).unwrap();
+ write!(output_buffer, "{random_float}").unwrap();
}
return;
}
@@ -562,7 +562,7 @@ impl RandomJsonGenerator {
if random_value <= *boolean_weight {
// Generate a random boolean
let random_boolean: bool = rng.random();
- write!(output_buffer, "{random_boolean}",).unwrap();
+ write!(output_buffer, "{random_boolean}").unwrap();
return;
}
random_value -= *boolean_weight;
diff --git a/parquet-variant-compute/src/arrow_to_variant.rs b/parquet-variant-compute/src/arrow_to_variant.rs
index a4b06cbbe9..5b6299b84f 100644
--- a/parquet-variant-compute/src/arrow_to_variant.rs
+++ b/parquet-variant-compute/src/arrow_to_variant.rs
@@ -501,7 +501,7 @@ pub(crate) struct NullArrowToVariantBuilder;
impl NullArrowToVariantBuilder {
fn append_row(
- &mut self,
+ &self,
builder: &mut impl VariantBuilderExt,
_index: usize,
) -> Result<(), ArrowError> {
diff --git a/parquet-variant-compute/src/shred_variant.rs b/parquet-variant-compute/src/shred_variant.rs
index 03efb7c177..ae3ee4f0a3 100644
--- a/parquet-variant-compute/src/shred_variant.rs
+++ b/parquet-variant-compute/src/shred_variant.rs
@@ -639,11 +639,11 @@ impl VariantSchemaNode {
// Ensure this node is a Struct node
let children = match self {
Self::Struct(children) => children,
- _ => {
+ Self::Leaf(_) => {
*self = Self::Struct(BTreeMap::new());
match self {
Self::Struct(children) => children,
- _ => unreachable!(),
+ Self::Leaf(_) => unreachable!(),
}
}
};
diff --git a/parquet-variant-compute/src/unshred_variant.rs b/parquet-variant-compute/src/unshred_variant.rs
index 18cc8a8d75..14afb8db12 100644
--- a/parquet-variant-compute/src/unshred_variant.rs
+++ b/parquet-variant-compute/src/unshred_variant.rs
@@ -361,7 +361,7 @@ struct NullUnshredVariantBuilder;
impl NullUnshredVariantBuilder {
fn append_row(
- &mut self,
+ &self,
builder: &mut impl VariantBuilderExt,
_metadata: &VariantMetadata,
_index: usize,
@@ -382,7 +382,7 @@ impl<'a> ValueOnlyUnshredVariantBuilder<'a> {
}
fn append_row(
- &mut self,
+ &self,
builder: &mut impl VariantBuilderExt,
metadata: &VariantMetadata,
index: usize,
@@ -462,7 +462,7 @@ impl<'a, T: AppendToVariantBuilder> UnshredPrimitiveRowBuilder<'a, T> {
}
fn append_row(
- &mut self,
+ &self,
builder: &mut impl VariantBuilderExt,
metadata: &VariantMetadata,
index: usize,
@@ -570,7 +570,7 @@ impl<'a, T: TimestampType> TimestampUnshredRowBuilder<'a, T> {
}
fn append_row(
- &mut self,
+ &self,
builder: &mut impl VariantBuilderExt,
metadata: &VariantMetadata,
index: usize,
@@ -614,7 +614,7 @@ where
}
fn append_row(
- &mut self,
+ &self,
builder: &mut impl VariantBuilderExt,
metadata: &VariantMetadata,
index: usize,
diff --git a/parquet-variant-compute/src/variant_array.rs b/parquet-variant-compute/src/variant_array.rs
index 961544fa6a..3549dacd3b 100644
--- a/parquet-variant-compute/src/variant_array.rs
+++ b/parquet-variant-compute/src/variant_array.rs
@@ -539,6 +539,15 @@ impl VariantArray {
}
}
+impl<'a> IntoIterator for &'a VariantArray {
+ type Item = Option<Variant<'a, 'a>>;
+ type IntoIter = VariantArrayIter<'a>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ VariantArrayIter::new(self)
+ }
+}
+
impl PartialEq for VariantArray {
fn eq(&self, other: &Self) -> bool {
self.inner == other.inner
diff --git a/parquet-variant-compute/src/variant_get.rs b/parquet-variant-compute/src/variant_get.rs
index dd662cb7fd..9eb1931b76 100644
--- a/parquet-variant-compute/src/variant_get.rs
+++ b/parquet-variant-compute/src/variant_get.rs
@@ -283,7 +283,6 @@ fn shredded_get_path(
}
shredding_state = state;
path_index += 1;
- continue;
}
ShreddedPathStep::Missing => {
let num_rows = input.len();
diff --git a/parquet-variant-compute/src/variant_to_arrow.rs b/parquet-variant-compute/src/variant_to_arrow.rs
index 87f4f8512d..d88813fa36 100644
--- a/parquet-variant-compute/src/variant_to_arrow.rs
+++ b/parquet-variant-compute/src/variant_to_arrow.rs
@@ -650,7 +650,7 @@ impl<'a> StructVariantToArrowRowBuilder<'a> {
capacity: usize,
) -> Result<Self> {
let mut field_builders = Vec::with_capacity(fields.len());
- for field in fields.iter() {
+ for field in fields {
field_builders.push(make_typed_variant_to_arrow_row_builder(
field.data_type(),
cast_options,
diff --git a/parquet-variant-json/src/from_json.rs b/parquet-variant-json/src/from_json.rs
index 4c22785ef1..57068f41cf 100644
--- a/parquet-variant-json/src/from_json.rs
+++ b/parquet-variant-json/src/from_json.rs
@@ -119,7 +119,7 @@ pub fn append_json(json: &Value, builder: &mut impl VariantBuilderExt) -> Result
}
Value::Object(obj) => {
let mut obj_builder = builder.try_new_object()?;
- for (key, value) in obj.iter() {
+ for (key, value) in obj {
let mut field_builder = ObjectFieldBuilder::new(key, &mut obj_builder);
append_json(value, &mut field_builder)?;
}
diff --git a/parquet-variant/src/builder/metadata.rs b/parquet-variant/src/builder/metadata.rs
index 003407847a..70b5d92167 100644
--- a/parquet-variant/src/builder/metadata.rs
+++ b/parquet-variant/src/builder/metadata.rs
@@ -198,7 +198,7 @@ impl WritableMetadataBuilder {
let nkeys = self.num_field_names();
// Calculate metadata size
- let total_dict_size: usize = self.metadata_size();
+ let total_dict_size = self.metadata_size();
let metadata_buffer = &mut self.metadata_buffer;
let is_sorted = std::mem::take(&mut self.is_sorted);
@@ -222,7 +222,7 @@ impl WritableMetadataBuilder {
// Write offsets
let mut cur_offset = 0;
- for key in field_names.iter() {
+ for key in &field_names {
write_offset(metadata_buffer, cur_offset, offset_size);
cur_offset += key.len();
}
diff --git a/parquet/benches/arrow_reader_row_filter.rs b/parquet/benches/arrow_reader_row_filter.rs
index 85e75e5a7c..d34d2eb3d9 100644
--- a/parquet/benches/arrow_reader_row_filter.rs
+++ b/parquet/benches/arrow_reader_row_filter.rs
@@ -468,7 +468,7 @@ fn benchmark_filters_and_projections(c: &mut Criterion) {
let projection_mask = ProjectionMask::roots(schema_descr, output_projection.clone());
let pred_mask = ProjectionMask::roots(schema_descr, filter_col.clone());
- let benchmark_name = format!("{filter_type}/{proj_case}",);
+ let benchmark_name = format!("{filter_type}/{proj_case}");
// run the benchmark for the async reader
let bench_id = BenchmarkId::new(benchmark_name.clone(), "async");
diff --git a/parquet/benches/arrow_statistics.rs b/parquet/benches/arrow_statistics.rs
index 6da816bde9..8dd064e86a 100644
--- a/parquet/benches/arrow_statistics.rs
+++ b/parquet/benches/arrow_statistics.rs
@@ -61,7 +61,7 @@ impl fmt::Display for TestTypes {
fn create_parquet_file(
dtype: TestTypes,
row_groups: usize,
- data_page_row_count_limit: &Option<usize>,
+ data_page_row_count_limit: Option<usize>,
) -> NamedTempFile {
let schema = match dtype {
TestTypes::UInt64 => Arc::new(Schema::new(vec![Field::new("col", DataType::UInt64, true)])),
@@ -82,7 +82,7 @@ fn create_parquet_file(
let mut props = WriterProperties::builder().set_max_row_group_row_count(Some(row_groups));
if let Some(limit) = data_page_row_count_limit {
props = props
- .set_data_page_row_count_limit(*limit)
+ .set_data_page_row_count_limit(limit)
.set_statistics_enabled(EnabledStatistics::Page);
};
let props = props.build();
@@ -196,7 +196,7 @@ fn criterion_benchmark(c: &mut Criterion) {
for dtype in types {
for data_page_row_count_limit in &data_page_row_count_limits {
- let file = create_parquet_file(dtype.clone(), row_groups, data_page_row_count_limit);
+ let file = create_parquet_file(dtype.clone(), row_groups, *data_page_row_count_limit);
let file = file.reopen().unwrap();
let options =
ArrowReaderOptions::new().with_page_index_policy(PageIndexPolicy::from(true));
diff --git a/parquet/benches/encoding.rs b/parquet/benches/encoding.rs
index 65c2ec3d37..880e169cff 100644
--- a/parquet/benches/encoding.rs
+++ b/parquet/benches/encoding.rs
@@ -63,7 +63,7 @@ fn bench_typed<T: DataType>(
let mut encoder = get_encoder::<T>(encoding, &column_desc_ptr).unwrap();
encoder.put(values).unwrap();
let encoded = encoder.flush_buffer().unwrap();
- println!("{} encoded as {} bytes", name, encoded.len(),);
+ println!("{} encoded as {} bytes", name, encoded.len());
let mut buffer = vec![T::T::default(); values.len()];
c.bench_function(&format!("decoding: {name}"), |b| {
diff --git a/parquet/benches/row_selection_cursor.rs b/parquet/benches/row_selection_cursor.rs
index 8b96f0363d..87b0e101f3 100644
--- a/parquet/benches/row_selection_cursor.rs
+++ b/parquet/benches/row_selection_cursor.rs
@@ -316,7 +316,7 @@ fn build_utf8view_batch(total_rows: usize) -> RecordBatch {
fn build_utf8view_batch_with_len(total_rows: usize, len: usize) -> RecordBatch {
let mut builder = StringViewBuilder::new();
- let value: String = "a".repeat(len);
+ let value = "a".repeat(len);
for _ in 0..total_rows {
builder.append_value(&value);
}
diff --git a/parquet/examples/write_parquet.rs b/parquet/examples/write_parquet.rs
index 803f29da38..8b704c2e02 100644
--- a/parquet/examples/write_parquet.rs
+++ b/parquet/examples/write_parquet.rs
@@ -76,7 +76,7 @@ fn mem(system: &mut System) -> String {
system
.process(pid)
.map(|proc| format!("{}MB", proc.memory() / 1_000_000))
- .unwrap_or("N/A".to_string())
+ .unwrap_or_else(|| "N/A".to_string())
}
fn main() -> Result<()> {
diff --git a/parquet/src/arrow/array_reader/byte_array.rs b/parquet/src/arrow/array_reader/byte_array.rs
index 4fc32dd803..309abc3dba 100644
--- a/parquet/src/arrow/array_reader/byte_array.rs
+++ b/parquet/src/arrow/array_reader/byte_array.rs
@@ -461,7 +461,7 @@ impl ByteArrayDecoderDeltaLength {
let mut total_bytes = 0;
- for l in lengths.iter() {
+ for l in &lengths {
if *l < 0 {
return Err(ParquetError::General(
"negative delta length byte array length".to_string(),
@@ -658,7 +658,7 @@ mod tests {
assert_eq!(decoder.read(&mut output, 4).unwrap(), 0);
let valid = [false, false, true, true, false, true, true, false, false];
- let valid_buffer = Buffer::from_iter(valid.iter().cloned());
+ let valid_buffer = Buffer::from_iter(valid.iter().copied());
output
.pad_nulls(0, 4, valid.len(), valid_buffer.as_slice())
@@ -714,7 +714,7 @@ mod tests {
assert_eq!(decoder.read(&mut output, 4).unwrap(), 0);
let valid = [false, false, true, true, false, false];
- let valid_buffer = Buffer::from_iter(valid.iter().cloned());
+ let valid_buffer = Buffer::from_iter(valid.iter().copied());
output
.pad_nulls(0, 2, valid.len(), valid_buffer.as_slice())
diff --git a/parquet/src/arrow/array_reader/byte_array_dictionary.rs b/parquet/src/arrow/array_reader/byte_array_dictionary.rs
index 65f2d9cb0a..14a2bd1241 100644
--- a/parquet/src/arrow/array_reader/byte_array_dictionary.rs
+++ b/parquet/src/arrow/array_reader/byte_array_dictionary.rs
@@ -437,7 +437,7 @@ mod tests {
assert_eq!(decoder.read(&mut output, 3).unwrap(), 3);
let mut valid = vec![false, false, true, true, false, true];
- let valid_buffer = Buffer::from_iter(valid.iter().cloned());
+ let valid_buffer = Buffer::from_iter(valid.iter().copied());
output
.pad_nulls(0, 3, valid.len(), valid_buffer.as_slice())
.unwrap();
@@ -447,7 +447,7 @@ mod tests {
assert_eq!(decoder.read(&mut output, 4).unwrap(), 4);
valid.extend_from_slice(&[false, false, true, true, false, true, true, false]);
- let valid_buffer = Buffer::from_iter(valid.iter().cloned());
+ let valid_buffer = Buffer::from_iter(valid.iter().copied());
output.pad_nulls(6, 4, 8, valid_buffer.as_slice()).unwrap();
assert!(matches!(output, DictionaryBuffer::Dict { .. }));
@@ -518,7 +518,7 @@ mod tests {
assert_eq!(decoder.skip_values(4).unwrap(), 0);
let valid = [true, true, true, true, true];
- let valid_buffer = Buffer::from_iter(valid.iter().cloned());
+ let valid_buffer = Buffer::from_iter(valid.iter().copied());
output.pad_nulls(0, 5, 5, valid_buffer.as_slice()).unwrap();
assert!(matches!(output, DictionaryBuffer::Dict { .. }));
diff --git a/parquet/src/arrow/array_reader/byte_view_array.rs b/parquet/src/arrow/array_reader/byte_view_array.rs
index cc1abf7ff6..6647e51db9 100644
--- a/parquet/src/arrow/array_reader/byte_view_array.rs
+++ b/parquet/src/arrow/array_reader/byte_view_array.rs
@@ -501,7 +501,7 @@ impl ByteViewArrayDecoderDictionary {
};
if need_to_create_new_buffer {
- for b in dict.buffers.iter() {
+ for b in &dict.buffers {
output.buffers.push(b.clone());
}
}
@@ -529,7 +529,6 @@ impl ByteViewArrayDecoderDictionary {
0
}
}));
- Ok(())
} else {
output
.views
@@ -551,8 +550,8 @@ impl ByteViewArrayDecoderDictionary {
0
}
}));
- Ok(())
}
+ Ok(())
})?;
if let Some(e) = error {
return Err(e);
@@ -588,7 +587,7 @@ impl ByteViewArrayDecoderDeltaLength {
let mut total_bytes = 0;
- for l in lengths.iter() {
+ for l in &lengths {
if *l < 0 {
return Err(ParquetError::General(
"negative delta length byte array length".to_string(),
@@ -802,7 +801,7 @@ mod tests {
assert_eq!(output.views.len(), 4);
let valid = [false, false, true, true, false, true, true, false, false];
- let valid_buffer = Buffer::from_iter(valid.iter().cloned());
+ let valid_buffer = Buffer::from_iter(valid.iter().copied());
output
.pad_nulls(0, 4, valid.len(), valid_buffer.as_slice())
diff --git a/parquet/src/arrow/array_reader/cached_array_reader.rs b/parquet/src/arrow/array_reader/cached_array_reader.rs
index 73f3ba6c8f..5e4d91ce30 100644
--- a/parquet/src/arrow/array_reader/cached_array_reader.rs
+++ b/parquet/src/arrow/array_reader/cached_array_reader.rs
@@ -165,7 +165,7 @@ impl CachedArrayReader {
/// Remove batches from cache that have been completely consumed
/// This is only called for Consumer role readers
- fn cleanup_consumed_batches(&mut self) {
+ fn cleanup_consumed_batches(&self) {
let current_batch_id = self.get_batch_id_from_position(self.outer_position);
// Remove batches that are at least one batch behind the current position
diff --git a/parquet/src/arrow/array_reader/fixed_len_byte_array.rs b/parquet/src/arrow/array_reader/fixed_len_byte_array.rs
index 91e5076f45..436e1db343 100644
--- a/parquet/src/arrow/array_reader/fixed_len_byte_array.rs
+++ b/parquet/src/arrow/array_reader/fixed_len_byte_array.rs
@@ -558,7 +558,7 @@ impl ColumnValueDecoder for ValueDecoder {
// `offset`. Values will be appended to `dst`.
fn read_byte_stream_split(
dst: &mut Vec<u8>,
- src: &mut Bytes,
+ src: &Bytes,
offset: usize,
num_values: usize,
data_width: usize,
diff --git a/parquet/src/arrow/array_reader/struct_array.rs b/parquet/src/arrow/array_reader/struct_array.rs
index 2032768976..4faba7d6aa 100644
--- a/parquet/src/arrow/array_reader/struct_array.rs
+++ b/parquet/src/arrow/array_reader/struct_array.rs
@@ -71,7 +71,7 @@ impl ArrayReader for StructArrayReader {
fn read_records(&mut self, batch_size: usize) -> Result<usize> {
let mut read = None;
- for child in self.children.iter_mut() {
+ for child in &mut self.children {
let child_read = child.read_records(batch_size)?;
match read {
Some(expected) => {
@@ -157,7 +157,7 @@ impl ArrayReader for StructArrayReader {
fn skip_records(&mut self, num_records: usize) -> Result<usize> {
let mut skipped = None;
- for child in self.children.iter_mut() {
+ for child in &mut self.children {
let child_skipped = child.skip_records(num_records)?;
match skipped {
Some(expected) => {
diff --git a/parquet/src/arrow/arrow_reader/mod.rs b/parquet/src/arrow/arrow_reader/mod.rs
index 7ab219086f..113faeb3f5 100644
--- a/parquet/src/arrow/arrow_reader/mod.rs
+++ b/parquet/src/arrow/arrow_reader/mod.rs
@@ -1228,7 +1228,7 @@ impl<T: ChunkReader + 'static> ParquetRecordBatchReaderBuilder<T> {
// Update selection based on any filters
if let Some(filter) = filter.as_mut() {
- for predicate in filter.predicates.iter_mut() {
+ for predicate in &mut filter.predicates {
// break early if we have ruled out all rows
if !plan_builder.selects_any() {
break;
@@ -1310,7 +1310,7 @@ struct ReaderPageIterator<T: ChunkReader> {
impl<T: ChunkReader + 'static> ReaderPageIterator<T> {
/// Return the next SerializedPageReader
- fn next_page_reader(&mut self, rg_idx: usize) -> Result<SerializedPageReader<T>> {
+ fn next_page_reader(&self, rg_idx: usize) -> Result<SerializedPageReader<T>> {
let rg = self.metadata.row_group(rg_idx);
let column_chunk_metadata = rg.column(self.column_idx);
let offset_index = self.metadata.offset_index();
@@ -1939,14 +1939,14 @@ pub(crate) mod tests {
2,
ConvertedType::NONE,
None,
- |vals| Arc::new(BooleanArray::from_iter(vals.iter().cloned())),
+ |vals| Arc::new(BooleanArray::from_iter(vals.iter().copied())),
&[Encoding::PLAIN, Encoding::RLE, Encoding::RLE_DICTIONARY],
);
run_single_column_reader_tests::<Int32Type, _, Int32Type>(
2,
ConvertedType::NONE,
None,
- |vals| Arc::new(Int32Array::from_iter(vals.iter().cloned())),
+ |vals| Arc::new(Int32Array::from_iter(vals.iter().copied())),
&[
Encoding::PLAIN,
Encoding::RLE_DICTIONARY,
@@ -1958,7 +1958,7 @@ pub(crate) mod tests {
2,
ConvertedType::NONE,
None,
- |vals| Arc::new(Int64Array::from_iter(vals.iter().cloned())),
+ |vals| Arc::new(Int64Array::from_iter(vals.iter().copied())),
&[
Encoding::PLAIN,
Encoding::RLE_DICTIONARY,
@@ -1970,7 +1970,7 @@ pub(crate) mod tests {
2,
ConvertedType::NONE,
None,
- |vals| Arc::new(Float32Array::from_iter(vals.iter().cloned())),
+ |vals| Arc::new(Float32Array::from_iter(vals.iter().copied())),
&[Encoding::PLAIN, Encoding::BYTE_STREAM_SPLIT],
);
}
diff --git a/parquet/src/arrow/arrow_reader/read_plan.rs b/parquet/src/arrow/arrow_reader/read_plan.rs
index a05024dac0..63e1b1ce35 100644
--- a/parquet/src/arrow/arrow_reader/read_plan.rs
+++ b/parquet/src/arrow/arrow_reader/read_plan.rs
@@ -308,7 +308,7 @@ impl ReadPlanBuilder {
let row_selection_cursor = selection
.map(|s| build_cursor(s.trim(), selection_strategy, loaded_row_ranges))
- .unwrap_or(RowSelectionCursor::new_all());
+ .unwrap_or_else(RowSelectionCursor::new_all);
ReadPlan {
batch_size,
diff --git a/parquet/src/arrow/arrow_reader/selection/boolean.rs b/parquet/src/arrow/arrow_reader/selection/boolean.rs
index 990fc1b2ab..1196fac219 100644
--- a/parquet/src/arrow/arrow_reader/selection/boolean.rs
+++ b/parquet/src/arrow/arrow_reader/selection/boolean.rs
@@ -386,13 +386,13 @@ mod tests {
let _ = selection.iter().count();
match &selection.inner {
RowSelectionInner::Mask(m) => assert!(m.selectors.get().is_some()),
- _ => unreachable!(),
+ RowSelectionInner::Selectors(_) => unreachable!(),
}
let cloned = selection.clone();
match &cloned.inner {
RowSelectionInner::Mask(m) => assert!(m.selectors.get().is_none()),
- _ => unreachable!(),
+ RowSelectionInner::Selectors(_) => unreachable!(),
}
let round_tripped: Vec<RowSelector> = cloned.iter().copied().collect();
@@ -417,7 +417,7 @@ mod tests {
fn cached_selectors_ptr(selection: &RowSelection) -> Option<*const RowSelector> {
match &selection.inner {
RowSelectionInner::Mask(m) => m.selectors.get().map(|s| s.as_ptr()),
- _ => unreachable!(),
+ RowSelectionInner::Selectors(_) => unreachable!(),
}
}
@@ -454,7 +454,7 @@ mod tests {
let selection = RowSelection::from_boolean_buffer(interleaved_mask());
let mask = match &selection.inner {
RowSelectionInner::Mask(m) => m,
- _ => unreachable!(),
+ RowSelectionInner::Selectors(_) => unreachable!(),
};
// Uncached: converts into a temporary, leaving the cache empty.
@@ -464,7 +464,7 @@ mod tests {
let expected: Vec<RowSelector> = selection.iter().copied().collect();
let mask = match &selection.inner {
RowSelectionInner::Mask(m) => m,
- _ => unreachable!(),
+ RowSelectionInner::Selectors(_) => unreachable!(),
};
match mask.borrowed_selectors() {
Cow::Borrowed(selectors) => assert_eq!(selectors, expected.as_slice()),
@@ -475,7 +475,7 @@ mod tests {
#[test]
fn test_set_algebra_agrees_whether_or_not_the_cache_is_populated() {
let bits: Vec<bool> = (0..256).map(|i| i % 3 == 0).collect();
- let other: RowSelection = RowSelection::from_filters(&[BooleanArray::from(
+ let other = RowSelection::from_filters(&[BooleanArray::from(
(0..256).map(|i| i % 5 != 0).collect::<Vec<bool>>(),
)]);
diff --git a/parquet/src/arrow/arrow_reader/selection/mod.rs b/parquet/src/arrow/arrow_reader/selection/mod.rs
index c01da6b905..7eacf2e525 100644
--- a/parquet/src/arrow/arrow_reader/selection/mod.rs
+++ b/parquet/src/arrow/arrow_reader/selection/mod.rs
@@ -229,7 +229,7 @@ impl RowSelection {
pub fn as_mask(&self) -> Option<&BooleanBuffer> {
match &self.inner {
RowSelectionInner::Mask(m) => Some(m.mask()),
- _ => None,
+ RowSelectionInner::Selectors(_) => None,
}
}
diff --git a/parquet/src/arrow/arrow_reader/selection/ranges.rs b/parquet/src/arrow/arrow_reader/selection/ranges.rs
index 4c7860d095..ac9ee17d9c 100644
--- a/parquet/src/arrow/arrow_reader/selection/ranges.rs
+++ b/parquet/src/arrow/arrow_reader/selection/ranges.rs
@@ -62,8 +62,6 @@ where
row_offset += remaining_in_page;
current_page = pages.next();
current_page_included = false;
-
- continue;
} else {
if row_offset + selector.row_count == next_page.first_row_index as usize {
current_page = pages.next();
@@ -100,9 +98,7 @@ where
let mut row_offset = 0;
for selector in selectors {
- if selector.skip {
- row_offset += selector.row_count;
- } else {
+ if !selector.skip {
let start = row_offset;
let end = row_offset + selector.row_count;
@@ -113,8 +109,8 @@ where
let expanded_end = expanded_end.min(total_rows);
expanded_ranges.push(expanded_start..expanded_end);
- row_offset += selector.row_count;
}
+ row_offset += selector.row_count;
}
// Sort ranges by start position
diff --git a/parquet/src/arrow/arrow_writer/mod.rs b/parquet/src/arrow/arrow_writer/mod.rs
index 4ffdb17c96..71d122b935 100644
--- a/parquet/src/arrow/arrow_writer/mod.rs
+++ b/parquet/src/arrow/arrow_writer/mod.rs
@@ -818,7 +818,13 @@ impl ArrowPageWriter {
self.page_encryptor.as_mut()
}
+ // Mirrors the signature of the encryption-enabled version above, so that the
+ // callers do not need a `cfg` of their own.
#[cfg(not(feature = "encryption"))]
+ #[expect(
+ clippy::needless_pass_by_ref_mut,
+ reason = "mirrors the encryption-enabled signature"
+ )]
fn page_encryptor_mut(&mut self) -> Option<&mut PageEncryptor> {
None
}
@@ -1368,7 +1374,7 @@ impl ArrowColumnWriterFactory {
) -> Result<Box<ArrowPageWriter>> {
let column_path = column_descriptor.path().string();
let page_encryptor = PageEncryptor::create_if_column_encrypted(
- &self.file_encryptor,
+ self.file_encryptor.as_ref(),
self.row_group_index,
column_index,
&column_path,
@@ -1691,7 +1697,7 @@ fn write_leaf(
let array = column.as_primitive::<IntervalDayTimeType>();
get_interval_dt_array_slice(array, indices.iter().copied())
}
- _ => {
+ IntervalUnit::MonthDayNano => {
return Err(ParquetError::NYI(format!(
"Attempting to write an Arrow interval type {interval_unit:?} to parquet that is not yet implemented"
)));
@@ -4445,7 +4451,7 @@ mod tests {
u32::MAX - 1,
u32::MAX,
];
- let values = Arc::new(UInt32Array::from_iter_values(src.iter().cloned()));
+ let values = Arc::new(UInt32Array::from_iter_values(src.iter().copied()));
let files = RoundTripTest::new(values).with_nullable(false).run();
for file in files {
@@ -4491,7 +4497,7 @@ mod tests {
u64::MAX - 1,
u64::MAX,
];
- let values = Arc::new(UInt64Array::from_iter_values(src.iter().cloned()));
+ let values = Arc::new(UInt64Array::from_iter_values(src.iter().copied()));
let files = RoundTripTest::new(values).with_nullable(false).run();
for file in files {
@@ -4694,7 +4700,7 @@ mod tests {
.unwrap()
.values()
.iter()
- .cloned()
+ .copied()
})
.collect();
diff --git a/parquet/src/arrow/async_reader/mod.rs b/parquet/src/arrow/async_reader/mod.rs
index 903a3952d0..d386bec48d 100644
--- a/parquet/src/arrow/async_reader/mod.rs
+++ b/parquet/src/arrow/async_reader/mod.rs
@@ -835,7 +835,7 @@ where
match self.decoder.try_next_reader()? {
DecodeResult::NeedsData(ranges) => {
self.request_state = RequestState::begin_request(input, ranges);
- continue; // poll again (as the input might be ready immediately)
+ // Will loop again: the input might be ready immediately.
}
DecodeResult::Data(reader) => {
self.request_state = RequestState::None { input };
@@ -849,7 +849,7 @@ where
// Push the requested data to the decoder and try again
self.decoder.push_ranges(ranges, data)?;
self.request_state = RequestState::None { input };
- continue; // try and decode on next iteration
+ // Will try and decode on the next iteration.
}
RequestState::Done => {
self.request_state = RequestState::Done;
@@ -897,7 +897,7 @@ where
match self.decoder.try_decode()? {
DecodeResult::NeedsData(ranges) => {
self.request_state = RequestState::begin_request(input, ranges);
- continue; // poll again (as the input might be ready immediately)
+ // Will loop again: the input might be ready immediately.
}
DecodeResult::Data(batch) => {
self.request_state = RequestState::None { input };
@@ -916,7 +916,7 @@ where
// Push the requested data to the decoder
self.decoder.push_ranges(ranges, data)?;
self.request_state = RequestState::None { input };
- continue; // next iteration will try to decode the next batch
+ // The next iteration will try to decode the next batch.
}
Poll::Pending => {
self.request_state = RequestState::Outstanding { ranges, future };
diff --git a/parquet/src/arrow/async_reader/store.rs b/parquet/src/arrow/async_reader/store.rs
index 0b1efc492b..8d572fe99b 100644
--- a/parquet/src/arrow/async_reader/store.rs
+++ b/parquet/src/arrow/async_reader/store.rs
@@ -342,7 +342,7 @@ mod tests {
Ok(_) => panic!("expected failure"),
Err(e) => {
let err = e.to_string();
- assert!(err.contains("I don't exist.parquet not found:"), "{err}",);
+ assert!(err.contains("I don't exist.parquet not found:"), "{err}");
}
}
}
@@ -427,7 +427,7 @@ mod tests {
let err = reader.get_bytes(0..1).await.unwrap_err().to_string();
- assert!(err.to_string().contains("was cancelled"));
+ assert!(err.contains("was cancelled"));
}
#[tokio::test]
diff --git a/parquet/src/arrow/buffer/bit_util.rs b/parquet/src/arrow/buffer/bit_util.rs
index 985943b851..3a288bf7d1 100644
--- a/parquet/src/arrow/buffer/bit_util.rs
+++ b/parquet/src/arrow/buffer/bit_util.rs
@@ -33,7 +33,7 @@ pub fn iter_set_bits_rev(bytes: &[u8]) -> impl Iterator<Item = usize> + '_ {
let iter = unaligned
.prefix()
.into_iter()
- .chain(unaligned.chunks().iter().cloned())
+ .chain(unaligned.chunks().iter().copied())
.chain(unaligned.suffix());
iter.rev().flat_map(move |chunk| {
diff --git a/parquet/src/arrow/buffer/dictionary_buffer.rs b/parquet/src/arrow/buffer/dictionary_buffer.rs
index 1450bc16b0..2cfb9b26b8 100644
--- a/parquet/src/arrow/buffer/dictionary_buffer.rs
+++ b/parquet/src/arrow/buffer/dictionary_buffer.rs
@@ -62,8 +62,8 @@ impl<K: ArrowNativeType + Ord, V: OffsetSizeTrait> DictionaryBuffer<K, V> {
// Need to discard fat pointer for equality check
// - https://stackoverflow.com/a/67114787
// - https://github.com/rust-lang/rust/issues/46139
- let values_ptr = values.as_ref() as *const _ as *const ();
- let dict_ptr = dictionary.as_ref() as *const _ as *const ();
+ let values_ptr = std::ptr::from_ref(values.as_ref()).cast::<()>();
+ let dict_ptr = std::ptr::from_ref(dictionary.as_ref()).cast::<()>();
if values_ptr == dict_ptr {
Some(keys)
} else if keys.is_empty() {
@@ -80,10 +80,10 @@ impl<K: ArrowNativeType + Ord, V: OffsetSizeTrait> DictionaryBuffer<K, V> {
};
match self {
Self::Dict { keys, .. } => Some(keys),
- _ => unreachable!(),
+ Self::Values { .. } => unreachable!(),
}
}
- _ => None,
+ Self::Values { .. } => None,
}
}
@@ -116,7 +116,7 @@ impl<K: ArrowNativeType + Ord, V: OffsetSizeTrait> DictionaryBuffer<K, V> {
*self = Self::Values { values: spilled };
match self {
Self::Values { values } => Ok(values),
- _ => unreachable!(),
+ Self::Dict { .. } => unreachable!(),
}
}
}
@@ -300,7 +300,7 @@ mod tests {
buffer.as_keys(&d1).unwrap().extend_from_slice(values);
let mut valid = vec![false, false, true, true, false, true, true, true];
- let valid_buffer = Buffer::from_iter(valid.iter().cloned());
+ let valid_buffer = Buffer::from_iter(valid.iter().copied());
buffer
.pad_nulls(0, values.len(), valid.len(), valid_buffer.as_slice())
.unwrap();
@@ -313,7 +313,7 @@ mod tests {
values.try_push("bongo".as_bytes(), false).unwrap();
valid.extend_from_slice(&[false, false, true, false, true]);
- let null_buffer = Buffer::from_iter(valid.iter().cloned());
+ let null_buffer = Buffer::from_iter(valid.iter().copied());
buffer
.pad_nulls(read_offset, 2, 5, null_buffer.as_slice())
.unwrap();
diff --git a/parquet/src/arrow/push_decoder/reader_builder/mod.rs b/parquet/src/arrow/push_decoder/reader_builder/mod.rs
index ffc1038244..9444161b8c 100644
--- a/parquet/src/arrow/push_decoder/reader_builder/mod.rs
+++ b/parquet/src/arrow/push_decoder/reader_builder/mod.rs
@@ -836,7 +836,7 @@ impl RowGroupReaderBuilder {
return None;
}
let mut cache_projection = filter.predicates.first()?.projection().clone();
- for predicate in filter.predicates.iter() {
+ for predicate in &filter.predicates {
cache_projection.union(predicate.projection());
}
cache_projection.intersect(&self.projection);
diff --git a/parquet/src/arrow/record_reader/mod.rs b/parquet/src/arrow/record_reader/mod.rs
index ba3c525b4a..d4b2f5cefd 100644
--- a/parquet/src/arrow/record_reader/mod.rs
+++ b/parquet/src/arrow/record_reader/mod.rs
@@ -605,7 +605,7 @@ mod tests {
// Verify bitmap
let expected_valid = &[false, true, false, true, true, false, true];
- let expected_buffer = Buffer::from_iter(expected_valid.iter().cloned());
+ let expected_buffer = Buffer::from_iter(expected_valid.iter().copied());
assert_eq!(Some(expected_buffer), record_reader.consume_bitmap());
// Verify result record data
@@ -711,7 +711,7 @@ mod tests {
// Verify bitmap
let expected_valid = &[true, false, false, true, true, true, true, true, true];
- let expected_buffer = Buffer::from_iter(expected_valid.iter().cloned());
+ let expected_buffer = Buffer::from_iter(expected_valid.iter().copied());
assert_eq!(Some(expected_buffer), record_reader.consume_bitmap());
// Verify result record data
@@ -1063,7 +1063,7 @@ mod tests {
// Verify bitmap
let expected_valid = &[false, true, true];
- let expected_buffer = Buffer::from_iter(expected_valid.iter().cloned());
+ let expected_buffer = Buffer::from_iter(expected_valid.iter().copied());
assert_eq!(Some(expected_buffer), record_reader.consume_bitmap());
// Verify result record data
diff --git a/parquet/src/arrow/schema/mod.rs b/parquet/src/arrow/schema/mod.rs
index be5577b2c4..05a6952529 100644
--- a/parquet/src/arrow/schema/mod.rs
+++ b/parquet/src/arrow/schema/mod.rs
@@ -2272,10 +2272,7 @@ mod tests {
#[test]
fn test_arrow_schema_roundtrip_lists() -> Result<()> {
- let metadata: HashMap<String, String> = [("Key".to_string(), "Value".to_string())]
- .iter()
- .cloned()
- .collect();
+ let metadata = HashMap::from([("Key".to_string(), "Value".to_string())]);
let schema = Schema::new_with_metadata(
vec![
diff --git a/parquet/src/arrow/schema/primitive.rs b/parquet/src/arrow/schema/primitive.rs
index 2ca9b9b35e..ea35f68031 100644
--- a/parquet/src/arrow/schema/primitive.rs
+++ b/parquet/src/arrow/schema/primitive.rs
@@ -370,7 +370,7 @@ mod tests {
precision,
scale,
},
- _ => unreachable!(),
+ Type::GroupType { .. } => unreachable!(),
}
}
diff --git a/parquet/src/basic.rs b/parquet/src/basic.rs
index ab99f7b682..c92b5286ff 100644
--- a/parquet/src/basic.rs
+++ b/parquet/src/basic.rs
@@ -249,7 +249,7 @@ impl GeographyType {
///
/// [specification]: https://github.com/apache/parquet-format/blob/master/LogicalTypes.md#geography
pub fn algorithm(&self) -> Option<EdgeInterpolationAlgorithm> {
- self.algorithm.or(Some(Default::default()))
+ Some(self.algorithm.unwrap_or_default())
}
}
@@ -724,7 +724,7 @@ fn split_compression_string(str_setting: &str) -> Result<(&str, Option<i32>), Pa
}
}
-fn check_level_is_none(level: &Option<i32>) -> Result<(), ParquetError> {
+fn check_level_is_none(level: Option<i32>) -> Result<(), ParquetError> {
if level.is_some() {
return Err(ParquetError::General(
"compression level is not supported".to_string(),
@@ -748,11 +748,11 @@ impl FromStr for Compression {
let c = match codec {
"UNCOMPRESSED" | "uncompressed" => {
- check_level_is_none(&level)?;
+ check_level_is_none(level)?;
Compression::UNCOMPRESSED
}
"SNAPPY" | "snappy" => {
- check_level_is_none(&level)?;
+ check_level_is_none(level)?;
Compression::SNAPPY
}
"GZIP" | "gzip" => {
@@ -760,7 +760,7 @@ impl FromStr for Compression {
Compression::GZIP(GzipLevel::try_new(level.try_into()?)?)
}
"LZO" | "lzo" => {
- check_level_is_none(&level)?;
+ check_level_is_none(level)?;
Compression::LZO
}
"BROTLI" | "brotli" => {
@@ -768,7 +768,7 @@ impl FromStr for Compression {
Compression::BROTLI(BrotliLevel::try_new(level.try_into()?)?)
}
"LZ4" | "lz4" => {
- check_level_is_none(&level)?;
+ check_level_is_none(level)?;
Compression::LZ4
}
"ZSTD" | "zstd" => {
@@ -776,7 +776,7 @@ impl FromStr for Compression {
Compression::ZSTD(ZstdLevel::try_new(level)?)
}
"LZ4_RAW" | "lz4_raw" => {
- check_level_is_none(&level)?;
+ check_level_is_none(level)?;
Compression::LZ4_RAW
}
_ => {
@@ -856,7 +856,7 @@ impl EdgeInterpolationAlgorithm {
Self::THOMAS => Ok(parquet_geospatial::WkbEdges::Thomas),
Self::ANDOYER => Ok(parquet_geospatial::WkbEdges::Andoyer),
Self::KARNEY => Ok(parquet_geospatial::WkbEdges::Karney),
- unknown => Err(general_err!(
+ unknown @ Self::_Unknown(_) => Err(general_err!(
"Unknown edge interpolation algorithm: {}",
unknown
)),
diff --git a/parquet/src/bloom_filter/mod.rs b/parquet/src/bloom_filter/mod.rs
index 8e89ba406b..15197c79c4 100644
--- a/parquet/src/bloom_filter/mod.rs
+++ b/parquet/src/bloom_filter/mod.rs
@@ -446,7 +446,7 @@ impl Sbbf {
// Safety: Block is repr(transparent) and [u32; 8] can be reinterpreted as [u8; 32].
let slice = unsafe {
std::slice::from_raw_parts(
- self.0.as_ptr() as *const u8,
+ self.0.as_ptr().cast::<u8>(),
self.0.len() * size_of::<Block>(),
)
};
@@ -1050,7 +1050,7 @@ mod tests {
}
// --- Per-hash verification of the two lemmas ---
- for &h in hashes.iter() {
+ for &h in &hashes {
// mask(h as u32) gives the 8-bit pattern that this hash sets
// inside whichever block it lands in. It uses only the lower
// 32 bits of h, so it's the same regardless of filter size.
diff --git a/parquet/src/column/chunker/cdc.rs b/parquet/src/column/chunker/cdc.rs
index ca59913701..28a8bb3c06 100644
--- a/parquet/src/column/chunker/cdc.rs
+++ b/parquet/src/column/chunker/cdc.rs
@@ -1024,7 +1024,7 @@ mod arrow_tests {
crate::basic::PageType::DICTIONARY_PAGE => {
info.has_dictionary_page = true;
}
- _ => {}
+ crate::basic::PageType::INDEX_PAGE => {}
}
}
result.push(info);
diff --git a/parquet/src/column/page.rs b/parquet/src/column/page.rs
index ed80e279a0..b0e60b9f0d 100644
--- a/parquet/src/column/page.rs
+++ b/parquet/src/column/page.rs
@@ -382,7 +382,7 @@ impl TryFrom<&crate::file::metadata::thrift::PageHeader> for PageMetadata {
is_dict: false,
})
}
- other => Err(ParquetError::General(format!(
+ other @ PageType::INDEX_PAGE => Err(ParquetError::General(format!(
"page type {other:?} cannot be converted to PageMetadata"
))),
}
diff --git a/parquet/src/column/page_encryption.rs b/parquet/src/column/page_encryption.rs
index 26df75900c..e9729a8b7a 100644
--- a/parquet/src/column/page_encryption.rs
+++ b/parquet/src/column/page_encryption.rs
@@ -40,7 +40,7 @@ pub(crate) struct PageEncryptor {
impl PageEncryptor {
/// Create a [`PageEncryptor`] for a column if it should be encrypted
pub fn create_if_column_encrypted(
- file_encryptor: &Option<Arc<FileEncryptor>>,
+ file_encryptor: Option<&Arc<FileEncryptor>>,
row_group_index: usize,
column_index: usize,
column_path: &str,
@@ -99,7 +99,7 @@ impl PageEncryptor {
PageType::DATA_PAGE => ModuleType::DataPageHeader,
PageType::DATA_PAGE_V2 => ModuleType::DataPageHeader,
PageType::DICTIONARY_PAGE => ModuleType::DictionaryPageHeader,
- _ => {
+ PageType::INDEX_PAGE => {
return Err(general_err!(
"Unsupported page type for page header encryption: {:?}",
page_header.r#type
diff --git a/parquet/src/column/page_encryption_disabled.rs b/parquet/src/column/page_encryption_disabled.rs
index 71f25862cc..e2f227ff5c 100644
--- a/parquet/src/column/page_encryption_disabled.rs
+++ b/parquet/src/column/page_encryption_disabled.rs
@@ -15,6 +15,13 @@
// specific language governing permissions and limitations
// under the License.
+// The methods below mirror the signatures of the real `PageEncryptor`, so that the
+// callers do not need a `cfg` of their own.
+#![expect(
+ clippy::needless_pass_by_ref_mut,
+ reason = "mirrors the encryption-enabled `PageEncryptor`"
+)]
+
use crate::column::page::CompressedPage;
use crate::errors::Result;
use crate::file::metadata::thrift::PageHeader;
diff --git a/parquet/src/column/reader.rs b/parquet/src/column/reader.rs
index 61c8c766ed..498f73a4a9 100644
--- a/parquet/src/column/reader.rs
+++ b/parquet/src/column/reader.rs
@@ -444,7 +444,6 @@ where
} => {
self.values_decoder
.set_dict(buf, num_values, encoding, is_sorted)?;
- continue;
}
// 2. Data page v1
Page::DataPage {
@@ -1339,7 +1338,7 @@ mod tests {
let max_def_level = desc.max_def_level();
let max_rep_level = desc.max_rep_level();
let page_reader = InMemoryPageReader::new(pages);
- let column_reader: ColumnReader = get_column_reader(desc, Box::new(page_reader));
+ let column_reader = get_column_reader(desc, Box::new(page_reader));
let mut typed_column_reader = get_typed_column_reader::<T>(column_reader);
let mut values = Vec::new();
@@ -1472,7 +1471,7 @@ mod tests {
// 5 records total: [10,20], [30,40], [50,60], [70,80], [90,100]
let pages = VecDeque::from(vec![page1, page2, page3]);
let page_reader = InMemoryPageReader::new(pages);
- let column_reader: ColumnReader = get_column_reader(desc, Box::new(page_reader));
+ let column_reader = get_column_reader(desc, Box::new(page_reader));
let mut typed_reader = get_typed_column_reader::<Int32Type>(column_reader);
// Step 1 — skip 1 record:
diff --git a/parquet/src/column/reader/decoder.rs b/parquet/src/column/reader/decoder.rs
index 053db813ce..4e579f8f0d 100644
--- a/parquet/src/column/reader/decoder.rs
+++ b/parquet/src/column/reader/decoder.rs
@@ -392,7 +392,7 @@ impl RepetitionLevelDecoderImpl {
/// and returns the number of "complete" records along with the corresponding number of values
///
/// A "complete" record is one where the buffer contains a subsequent repetition level of 0
- fn count_records(&mut self, records_to_read: usize, num_levels: usize) -> (bool, usize, usize) {
+ fn count_records(&self, records_to_read: usize, num_levels: usize) -> (bool, usize, usize) {
let mut records_read = 0;
let levels = num_levels.min(self.buffer_len - self.buffer_offset);
diff --git a/parquet/src/column/writer/encoder.rs b/parquet/src/column/writer/encoder.rs
index 9420aa40f7..e7b548f0dc 100644
--- a/parquet/src/column/writer/encoder.rs
+++ b/parquet/src/column/writer/encoder.rs
@@ -423,14 +423,12 @@ where
// skip NaNs if we've encounter non-NaN
(false, true) => {
nan_count += 1;
- continue;
}
// if min/max are NaN, check for non-NaN and reset
(true, false) => {
min = val;
max = val;
min_max_nan = false;
- continue;
}
// both are NaN or non-NaN, so do the comparison
(_, val_is_nan) => {
diff --git a/parquet/src/column/writer/mod.rs b/parquet/src/column/writer/mod.rs
index 5aa3c40482..850bcc425b 100644
--- a/parquet/src/column/writer/mod.rs
+++ b/parquet/src/column/writer/mod.rs
@@ -233,7 +233,7 @@ impl ColumnCloseResult {
.build()?;
if let Some(offset_index) = self.offset_index.as_mut() {
let mut offset = dictionary_len as i64;
- for location in offset_index.page_locations.iter_mut() {
+ for location in &mut offset_index.page_locations {
location.offset = offset;
offset += location.compressed_page_size as i64;
}
@@ -327,7 +327,7 @@ impl<T: Default> ColumnMetrics<T> {
/// Sum `page_histogram` into `chunk_histogram`
fn update_histogram(
chunk_histogram: &mut Option<LevelHistogram>,
- page_histogram: &Option<LevelHistogram>,
+ page_histogram: Option<&LevelHistogram>,
) {
if let (Some(page_hist), Some(chunk_hist)) = (page_histogram, chunk_histogram) {
chunk_hist.add(page_hist);
@@ -339,11 +339,11 @@ impl<T: Default> ColumnMetrics<T> {
fn update_from_page_metrics(&mut self, page_metrics: &PageMetrics) {
ColumnMetrics::<T>::update_histogram(
&mut self.definition_level_histogram,
- &page_metrics.definition_level_histogram,
+ page_metrics.definition_level_histogram.as_ref(),
);
ColumnMetrics::<T>::update_histogram(
&mut self.repetition_level_histogram,
- &page_metrics.repetition_level_histogram,
+ page_metrics.repetition_level_histogram.as_ref(),
);
}
@@ -572,7 +572,7 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
let num_levels = if num_levels > 0 {
num_levels
} else {
- value_indices.map_or(values.len(), |i| i.len())
+ value_indices.map_or_else(|| values.len(), |i| i.len())
};
if let Some(min) = min {
@@ -1652,7 +1652,7 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
);
self.column_metrics.dictionary_page_offset = Some(page_spec.offset);
}
- _ => {}
+ PageType::INDEX_PAGE => {}
}
}
@@ -3562,8 +3562,7 @@ mod tests {
#[test]
fn test_float16_statistics_zero_only() {
- let input = [f16::ZERO]
- .into_iter()
+ let input = std::iter::once(f16::ZERO)
.map(|s| ByteArray::from(s).into())
.collect::<Vec<_>>();
@@ -3575,8 +3574,7 @@ mod tests {
#[test]
fn test_float16_statistics_neg_zero_only() {
- let input = [f16::NEG_ZERO]
- .into_iter()
+ let input = std::iter::once(f16::NEG_ZERO)
.map(|s| ByteArray::from(s).into())
.collect::<Vec<_>>();
@@ -5052,7 +5050,7 @@ mod tests {
PageType::DICTIONARY_PAGE => {
collected.dict_page_size = collected.dict_page_size.max(page.buffer().len());
}
- _ => {}
+ PageType::INDEX_PAGE => {}
}
}
collected
diff --git a/parquet/src/compression.rs b/parquet/src/compression.rs
index 55783de1c3..8d25891e90 100644
--- a/parquet/src/compression.rs
+++ b/parquet/src/compression.rs
@@ -194,7 +194,7 @@ pub fn create_codec(codec: CodecType, _options: &CodecOptions) -> Result<Option<
))
}
CodecType::UNCOMPRESSED => Ok(None),
- _ => Err(nyi_err!("The codec type {} is not supported yet", codec)),
+ CodecType::LZO => Err(nyi_err!("The codec type {} is not supported yet", codec)),
}
}
@@ -546,7 +546,7 @@ mod zstd_codec {
.flatten()
.map(|size| size as usize)
})
- .unwrap_or(input_buf.len().saturating_mul(4));
+ .unwrap_or_else(|| input_buf.len().saturating_mul(4));
output_buf.reserve(len);
let mut cursor = Cursor::new(output_buf);
@@ -936,9 +936,8 @@ mod tests {
#[test]
fn test_codec_zstd() {
// since ZstdLevel::MINIMUM_LEVEL is a large negative number, we test a smaller range
- for level in [ZstdLevel::MINIMUM_LEVEL]
- .into_iter()
- .chain(-100..=ZstdLevel::MAXIMUM_LEVEL)
+ for level in
+ std::iter::once(ZstdLevel::MINIMUM_LEVEL).chain(-100..=ZstdLevel::MAXIMUM_LEVEL)
{
let level = ZstdLevel::try_new(level).unwrap();
test_codec_with_size(CodecType::ZSTD(level));
diff --git a/parquet/src/data_type.rs b/parquet/src/data_type.rs
index 8895280110..063caa0dfd 100644
--- a/parquet/src/data_type.rs
+++ b/parquet/src/data_type.rs
@@ -570,7 +570,7 @@ macro_rules! gen_as_bytes {
// resulting slice always refers to initialized memory.
unsafe {
std::slice::from_raw_parts(
- self as *const $source_ty as *const u8,
+ std::ptr::from_ref::<$source_ty>(self).cast::<u8>(),
std::mem::size_of::<$source_ty>(),
)
}
@@ -585,7 +585,7 @@ macro_rules! gen_as_bytes {
// resulting slice always refers to initialized memory.
unsafe {
std::slice::from_raw_parts(
- self_.as_ptr() as *const u8,
+ self_.as_ptr().cast::<u8>(),
std::mem::size_of_val(self_),
)
}
@@ -599,7 +599,7 @@ macro_rules! gen_as_bytes {
// invalid bit patterns, so all writes to the resulting slice will be valid.
unsafe {
std::slice::from_raw_parts_mut(
- self_.as_mut_ptr() as *mut u8,
+ self_.as_mut_ptr().cast::<u8>(),
std::mem::size_of_val(self_),
)
}
@@ -643,14 +643,16 @@ impl AsBytes for bool {
fn as_bytes(&self) -> &[u8] {
// SAFETY: a bool is guaranteed to be either 0x00 or 0x01 in memory, so the memory is
// valid.
- unsafe { std::slice::from_raw_parts(self as *const bool as *const u8, 1) }
+ unsafe { std::slice::from_raw_parts(std::ptr::from_ref::<bool>(self).cast::<u8>(), 1) }
}
}
impl AsBytes for Int96 {
fn as_bytes(&self) -> &[u8] {
// SAFETY: Int96::data is a &[u32; 3].
- unsafe { std::slice::from_raw_parts(self.data() as *const [u32] as *const u8, 12) }
+ unsafe {
+ std::slice::from_raw_parts(std::ptr::from_ref::<[u32]>(self.data()).cast::<u8>(), 12)
+ }
}
}
@@ -845,7 +847,7 @@ pub(crate) mod private {
// SAFETY: Self is one of i32, i64, f32, f64, which have no padding.
let raw = unsafe {
std::slice::from_raw_parts(
- values.as_ptr() as *const u8,
+ values.as_ptr().cast::<u8>(),
std::mem::size_of_val(values),
)
};
diff --git a/parquet/src/encodings/decoding.rs b/parquet/src/encodings/decoding.rs
index 1e117799ad..4d902a96e6 100644
--- a/parquet/src/encodings/decoding.rs
+++ b/parquet/src/encodings/decoding.rs
@@ -2266,14 +2266,14 @@ mod tests {
let mut decoder = get_decoder::<T>(col_descr, encoding).expect("get decoder");
decoder.set_data(bytes, data.len()).expect("ok to set data");
+ let skipped = decoder.skip(skip).expect("ok to skip");
+
if skip >= data.len() {
- let skipped = decoder.skip(skip).expect("ok to skip");
assert_eq!(skipped, data.len());
let skipped_again = decoder.skip(skip).expect("ok to skip again");
assert_eq!(skipped_again, 0);
} else {
- let skipped = decoder.skip(skip).expect("ok to skip");
assert_eq!(skipped, skip);
let remaining = data.len() - skip;
diff --git a/parquet/src/encodings/encoding/mod.rs b/parquet/src/encodings/encoding/mod.rs
index 06ad3ac10e..b5fd5c78f7 100644
--- a/parquet/src/encodings/encoding/mod.rs
+++ b/parquet/src/encodings/encoding/mod.rs
@@ -102,7 +102,8 @@ pub fn get_encoder<T: DataType>(
)),
_ => Box::new(ByteStreamSplitEncoder::new()),
},
- e => return Err(nyi_err!("Encoding {} is not supported", e)),
+ #[expect(deprecated, reason = "BIT_PACKED is the encoding we reject here")]
+ e @ Encoding::BIT_PACKED => return Err(nyi_err!("Encoding {} is not supported", e)),
};
Ok(encoder)
}
diff --git a/parquet/src/encodings/rle.rs b/parquet/src/encodings/rle.rs
index f4dfebe81d..e9f013a69c 100644
--- a/parquet/src/encodings/rle.rs
+++ b/parquet/src/encodings/rle.rs
@@ -652,7 +652,7 @@ mod tests {
// Test data: 0-7 with bit width 3
// 00000011 10001000 11000110 11111010
let data = vec![0x03, 0x88, 0xC6, 0xFA];
- let mut decoder: RleDecoder = RleDecoder::new(3);
+ let mut decoder = RleDecoder::new(3);
decoder.set_data(data.into()).unwrap();
let mut buffer = vec![0; BIT_PACK_GROUP_SIZE];
let expected = vec![0, 1, 2, 3, 4, 5, 6, 7];
@@ -666,7 +666,7 @@ mod tests {
// Test data: 0-7 with bit width 3
// 00000011 10001000 11000110 11111010
let data = vec![0x03, 0x88, 0xC6, 0xFA];
- let mut decoder: RleDecoder = RleDecoder::new(3);
+ let mut decoder = RleDecoder::new(3);
decoder.set_data(data.into()).unwrap();
let expected = vec![2, 3, 4, 5, 6, 7];
let skipped = decoder.skip(2).expect("skipping values");
@@ -707,7 +707,7 @@ mod tests {
0x1B, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x0A,
];
- let mut decoder: RleDecoder = RleDecoder::new(1);
+ let mut decoder = RleDecoder::new(1);
decoder.set_data(data1.into()).unwrap();
let mut buffer = vec![false; 100];
let mut expected = vec![];
@@ -750,7 +750,7 @@ mod tests {
0x1B, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x0A,
];
- let mut decoder: RleDecoder = RleDecoder::new(1);
+ let mut decoder = RleDecoder::new(1);
decoder.set_data(data1.into()).unwrap();
let mut buffer = vec![true; 50];
let expected = vec![false; 50];
@@ -788,7 +788,7 @@ mod tests {
// 00000110 00000000 00001000 00000001 00001010 00000010
let dict = vec![10, 20, 30];
let data = vec![0x06, 0x00, 0x08, 0x01, 0x0A, 0x02];
- let mut decoder: RleDecoder = RleDecoder::new(3);
+ let mut decoder = RleDecoder::new(3);
decoder.set_data(data.into()).unwrap();
let mut buffer = vec![0; 12];
let expected = vec![10, 10, 10, 20, 20, 20, 20, 30, 30, 30, 30, 30];
@@ -801,7 +801,7 @@ mod tests {
// 00000011 01100011 11000111 10001110 00000011 01100101 00001011
let dict = vec!["aaa", "bbb", "ccc", "ddd", "eee", "fff"];
let data = vec![0x03, 0x63, 0xC7, 0x8E, 0x03, 0x65, 0x0B];
- let mut decoder: RleDecoder = RleDecoder::new(3);
+ let mut decoder = RleDecoder::new(3);
decoder.set_data(data.into()).unwrap();
let mut buffer = vec![""; 12];
let expected = vec![
@@ -819,7 +819,7 @@ mod tests {
// 00000110 00000000 00001000 00000001 00001010 00000010
let dict = vec![10, 20, 30];
let data = vec![0x06, 0x00, 0x08, 0x01, 0x0A, 0x02];
- let mut decoder: RleDecoder = RleDecoder::new(3);
+ let mut decoder = RleDecoder::new(3);
decoder.set_data(data.into()).unwrap();
let mut buffer = vec![0; 10];
let expected = vec![10, 20, 20, 20, 20, 30, 30, 30, 30, 30];
@@ -836,7 +836,7 @@ mod tests {
// 00000011 01100011 11000111 10001110 00000011 01100101 00001011
let dict = vec!["aaa", "bbb", "ccc", "ddd", "eee", "fff"];
let data = vec![0x03, 0x63, 0xC7, 0x8E, 0x03, 0x65, 0x0B];
- let mut decoder: RleDecoder = RleDecoder::new(3);
+ let mut decoder = RleDecoder::new(3);
decoder.set_data(data.into()).unwrap();
let mut buffer = vec![""; BIT_PACK_GROUP_SIZE];
let expected = vec!["eee", "fff", "ddd", "eee", "fff", "eee", "fff", "fff"];
diff --git a/parquet/src/encryption/decrypt.rs b/parquet/src/encryption/decrypt.rs
index 3e42664d58..409ec3c4b8 100644
--- a/parquet/src/encryption/decrypt.rs
+++ b/parquet/src/encryption/decrypt.rs
@@ -425,7 +425,7 @@ impl FileDecryptionProperties {
let mut column_names: Vec<String> = Vec::new();
let mut column_keys: Vec<Vec<u8>> = Vec::new();
if let DecryptionKeys::Explicit(keys) = &self.keys {
- for (key, value) in keys.column_keys.iter() {
+ for (key, value) in &keys.column_keys {
column_names.push(key.clone());
column_keys.push(value.clone());
}
diff --git a/parquet/src/encryption/encrypt.rs b/parquet/src/encryption/encrypt.rs
index d69e3c0250..eb0cd09e83 100644
--- a/parquet/src/encryption/encrypt.rs
+++ b/parquet/src/encryption/encrypt.rs
@@ -124,7 +124,7 @@ impl FileEncryptionProperties {
let mut column_names: Vec<String> = Vec::with_capacity(self.column_keys.len());
let mut keys: Vec<Vec<u8>> = Vec::with_capacity(self.column_keys.len());
let mut meta: Vec<Vec<u8>> = Vec::with_capacity(self.column_keys.len());
- for (key, value) in self.column_keys.iter() {
+ for (key, value) in &self.column_keys {
column_names.push(key.clone());
keys.push(value.key.clone());
if let Some(metadata) = value.key_metadata.as_ref() {
diff --git a/parquet/src/file/metadata/mod.rs b/parquet/src/file/metadata/mod.rs
index 8c8be1994e..54eee48063 100644
--- a/parquet/src/file/metadata/mod.rs
+++ b/parquet/src/file/metadata/mod.rs
@@ -911,7 +911,7 @@ impl LevelHistogram {
/// Sets the values of all histogram levels to 0.
pub fn reset(&mut self) {
- for value in self.inner.iter_mut() {
+ for value in &mut self.inner {
*value = 0;
}
}
@@ -1785,7 +1785,7 @@ mod tests {
let mut writer = ThriftCompactOutputProtocol::new(&mut buf);
row_group_meta.write_thrift(&mut writer).unwrap();
- let row_group_res = read_row_group(&mut buf, schema_descr).unwrap();
+ let row_group_res = read_row_group(&buf, schema_descr).unwrap();
assert_eq!(row_group_res, row_group_meta);
}
@@ -1867,7 +1867,7 @@ mod tests {
let mut writer = ThriftCompactOutputProtocol::new(&mut buf);
row_group_meta_2cols.write_thrift(&mut writer).unwrap();
- let err = read_row_group(&mut buf, schema_descr_3cols)
+ let err = read_row_group(&buf, schema_descr_3cols)
.unwrap_err()
.to_string();
assert_eq!(
@@ -1917,7 +1917,7 @@ mod tests {
let mut buf = Vec::new();
let mut writer = ThriftCompactOutputProtocol::new(&mut buf);
col_metadata.write_thrift(&mut writer).unwrap();
- let col_chunk_res = read_column_chunk(&mut buf, column_descr.clone()).unwrap();
+ let col_chunk_res = read_column_chunk(&buf, column_descr.clone()).unwrap();
let expected_metadata = ColumnChunkMetaData::builder(column_descr)
.set_encodings_mask(EncodingMask::new_from_encodings(
@@ -1982,7 +1982,7 @@ mod tests {
let options = ParquetMetaDataOptions::new().with_encoding_stats_as_mask(false);
let col_chunk_res =
- read_column_chunk_with_options(&mut buf, column_descr, Some(&options)).unwrap();
+ read_column_chunk_with_options(&buf, column_descr, Some(&options)).unwrap();
assert_eq!(col_chunk_res, col_metadata);
}
@@ -1998,7 +1998,7 @@ mod tests {
let mut buf = Vec::new();
let mut writer = ThriftCompactOutputProtocol::new(&mut buf);
col_metadata.write_thrift(&mut writer).unwrap();
- let col_chunk_res = read_column_chunk(&mut buf, column_descr).unwrap();
+ let col_chunk_res = read_column_chunk(&buf, column_descr).unwrap();
assert_eq!(col_chunk_res, col_metadata);
}
@@ -2022,7 +2022,7 @@ mod tests {
.build()
.unwrap();
- let compressed_size_res: i64 = row_group_meta.compressed_size();
+ let compressed_size_res = row_group_meta.compressed_size();
let compressed_size_exp: i64 = 1000;
assert_eq!(compressed_size_res, compressed_size_exp);
diff --git a/parquet/src/file/metadata/push_decoder.rs b/parquet/src/file/metadata/push_decoder.rs
index 42545f1565..e70cea23e8 100644
--- a/parquet/src/file/metadata/push_decoder.rs
+++ b/parquet/src/file/metadata/push_decoder.rs
@@ -383,7 +383,6 @@ impl ParquetMetaDataPushDecoder {
let footer_tail = FooterTail::try_from(footer_bytes.as_ref())?;
self.state = DecodeState::ReadingMetadata(footer_tail);
- continue;
}
DecodeState::ReadingMetadata(footer_tail) => {
@@ -404,7 +403,6 @@ impl ParquetMetaDataPushDecoder {
// Note: ReadingPageIndex first checks if page indexes are needed
// and is a no-op if not
self.state = DecodeState::ReadingPageIndex(Box::new(metadata));
- continue;
}
DecodeState::ReadingPageIndex(mut metadata) => {
diff --git a/parquet/src/file/metadata/thrift/encryption.rs b/parquet/src/file/metadata/thrift/encryption.rs
index 00258d2981..4e40acbf81 100644
--- a/parquet/src/file/metadata/thrift/encryption.rs
+++ b/parquet/src/file/metadata/thrift/encryption.rs
@@ -258,7 +258,7 @@ pub(crate) fn parquet_metadata_with_encryption(
.map_err(|e| general_err!("Could not parse crypto metadata: {}", e))?;
let supply_aad_prefix = match &t_file_crypto_metadata.encryption_algorithm {
EncryptionAlgorithm::AES_GCM_V1(algo) => algo.supply_aad_prefix,
- _ => Some(false),
+ EncryptionAlgorithm::AES_GCM_CTR_V1(_) => Some(false),
}
.unwrap_or(false);
if supply_aad_prefix && file_decryption_properties.aad_prefix().is_none() {
@@ -350,9 +350,8 @@ fn get_file_decryptor(
let aad_prefix = if let Some(aad_prefix) = file_decryption_properties.aad_prefix() {
aad_prefix.clone()
} else {
- algo.aad_prefix.map(|v| v.to_vec()).unwrap_or_default()
+ algo.aad_prefix.unwrap_or_default()
};
- let aad_file_unique = aad_file_unique.to_vec();
FileDecryptor::new(
file_decryption_properties,
diff --git a/parquet/src/file/metadata/thrift/mod.rs b/parquet/src/file/metadata/thrift/mod.rs
index f8d50e07dc..3915e96a80 100644
--- a/parquet/src/file/metadata/thrift/mod.rs
+++ b/parquet/src/file/metadata/thrift/mod.rs
@@ -1754,7 +1754,7 @@ pub(crate) mod tests {
// for testing. decode thrift encoded RowGroup
pub(crate) fn read_row_group(
- buf: &mut [u8],
+ buf: &[u8],
schema_descr: Arc<SchemaDescriptor>,
) -> Result<RowGroupMetaData> {
let mut reader = ThriftSliceInputProtocol::new(buf);
@@ -1762,14 +1762,14 @@ pub(crate) mod tests {
}
pub(crate) fn read_column_chunk(
- buf: &mut [u8],
+ buf: &[u8],
column_descr: Arc<ColumnDescriptor>,
) -> Result<ColumnChunkMetaData> {
read_column_chunk_with_options(buf, column_descr, None)
}
pub(crate) fn read_column_chunk_with_options(
- buf: &mut [u8],
+ buf: &[u8],
column_descr: Arc<ColumnDescriptor>,
options: Option<&ParquetMetaDataOptions>,
) -> Result<ColumnChunkMetaData> {
diff --git a/parquet/src/file/page_index/column_index.rs b/parquet/src/file/page_index/column_index.rs
index 665b4bc454..b7a77fdc0d 100644
--- a/parquet/src/file/page_index/column_index.rs
+++ b/parquet/src/file/page_index/column_index.rs
@@ -752,7 +752,7 @@ impl WriteThrift for ColumnIndexMetaData {
ColumnIndexMetaData::DOUBLE(index) => index.write_thrift(writer),
ColumnIndexMetaData::BYTE_ARRAY(index) => index.write_thrift(writer),
ColumnIndexMetaData::FIXED_LEN_BYTE_ARRAY(index) => index.write_thrift(writer),
- _ => Err(general_err!("Cannot serialize NONE index")),
+ ColumnIndexMetaData::NONE => Err(general_err!("Cannot serialize NONE index")),
}
}
}
diff --git a/parquet/src/file/serialized_reader.rs b/parquet/src/file/serialized_reader.rs
index e0a8d079e7..661976c560 100644
--- a/parquet/src/file/serialized_reader.rs
+++ b/parquet/src/file/serialized_reader.rs
@@ -516,7 +516,7 @@ pub(crate) fn decode_page(
statistics: statistics::from_thrift_page_stats(physical_type, header.statistics)?,
}
}
- _ => {
+ PageType::INDEX_PAGE => {
// For unknown page type (e.g., INDEX_PAGE), skip and read next.
return Err(general_err!(
"Page type {:?} is not supported",
@@ -1445,7 +1445,7 @@ mod tests {
assert!(statistics.is_none());
true
}
- _ => false,
+ Page::DataPageV2 { .. } => false,
};
assert!(is_expected_page);
page_count += 1;
@@ -1472,10 +1472,7 @@ mod tests {
"parquet-mr version 1.8.1 (build 4aba4dae7bb0d4edbcf7923ae1339f28fd3f7fcf)"
);
assert!(file_metadata.key_value_metadata().is_some());
- assert_eq!(
- file_metadata.key_value_metadata().to_owned().unwrap().len(),
- 1
- );
+ assert_eq!(file_metadata.key_value_metadata().unwrap().len(), 1);
assert_eq!(file_metadata.num_rows(), 5);
assert_eq!(file_metadata.version(), 1);
@@ -1543,7 +1540,7 @@ mod tests {
assert!(statistics.is_none()); // page stats are no longer read
true
}
- _ => false,
+ Page::DataPage { .. } => false,
};
assert!(is_expected_page);
page_count += 1;
@@ -1571,10 +1568,7 @@ mod tests {
"parquet-cpp-arrow version 14.0.2"
);
assert!(file_metadata.key_value_metadata().is_some());
- assert_eq!(
- file_metadata.key_value_metadata().to_owned().unwrap().len(),
- 1
- );
+ assert_eq!(file_metadata.key_value_metadata().unwrap().len(), 1);
assert_eq!(file_metadata.num_rows(), 10);
assert_eq!(file_metadata.version(), 2);
@@ -1645,7 +1639,7 @@ mod tests {
assert!(statistics.is_none()); // page stats are no longer read
true
}
- _ => false,
+ Page::DataPage { .. } => false,
};
assert!(is_expected_page);
page_count += 1;
@@ -1673,10 +1667,7 @@ mod tests {
"parquet-mr version 1.13.1 (build db4183109d5b734ec5930d870cdae161e408ddba)"
);
assert!(file_metadata.key_value_metadata().is_some());
- assert_eq!(
- file_metadata.key_value_metadata().to_owned().unwrap().len(),
- 2
- );
+ assert_eq!(file_metadata.key_value_metadata().unwrap().len(), 2);
assert_eq!(file_metadata.num_rows(), 1);
assert_eq!(file_metadata.version(), 1);
diff --git a/parquet/src/file/statistics.rs b/parquet/src/file/statistics.rs
index 21932fc303..1da2abe5cd 100644
--- a/parquet/src/file/statistics.rs
+++ b/parquet/src/file/statistics.rs
@@ -166,7 +166,7 @@ pub(crate) fn from_thrift_page_stats(
stats.max_value
};
- fn check_len(min: &Option<Vec<u8>>, max: &Option<Vec<u8>>, len: usize) -> Result<()> {
+ fn check_len(min: Option<&[u8]>, max: Option<&[u8]>, len: usize) -> Result<()> {
if let Some(min) = min
&& min.len() < len
{
@@ -184,13 +184,16 @@ pub(crate) fn from_thrift_page_stats(
Ok(())
}
- match physical_type {
- Type::BOOLEAN => check_len(&min, &max, 1),
- Type::INT32 | Type::FLOAT => check_len(&min, &max, 4),
- Type::INT64 | Type::DOUBLE => check_len(&min, &max, 8),
- Type::INT96 => check_len(&min, &max, 12),
- _ => Ok(()),
- }?;
+ {
+ let (min, max) = (min.as_deref(), max.as_deref());
+ match physical_type {
+ Type::BOOLEAN => check_len(min, max, 1),
+ Type::INT32 | Type::FLOAT => check_len(min, max, 4),
+ Type::INT64 | Type::DOUBLE => check_len(min, max, 8),
+ Type::INT96 => check_len(min, max, 12),
+ _ => Ok(()),
+ }?;
+ }
// Values are encoded using PLAIN encoding definition, except that
// variable-length byte arrays do not include a length prefix.
diff --git a/parquet/src/file/writer.rs b/parquet/src/file/writer.rs
index cc2e36b50f..a4611bfce5 100644
--- a/parquet/src/file/writer.rs
+++ b/parquet/src/file/writer.rs
@@ -926,7 +926,7 @@ impl<'a, W: Write + Send> SerializedRowGroupWriter<'a, W> {
page_writer: SerializedPageWriter<'b, W>,
) -> Result<SerializedPageWriter<'b, W>> {
let page_encryptor = PageEncryptor::create_if_column_encrypted(
- &context.file_encryptor,
+ context.file_encryptor.as_ref(),
context.row_group_index,
context.column_index,
&column.path().string(),
@@ -1072,7 +1072,13 @@ impl<'a, W: Write> SerializedPageWriter<'a, W> {
}
}
+// These mirror the signatures of the encryption-enabled versions above, so that the
+// callers do not need a `cfg` of their own.
#[cfg(not(feature = "encryption"))]
+#[expect(
+ clippy::needless_pass_by_ref_mut,
+ reason = "mirrors the encryption-enabled signatures"
+)]
impl<'a, W: Write> SerializedPageWriter<'a, W> {
fn page_encryptor_mut(&mut self) -> Option<&mut PageEncryptor> {
None
@@ -1388,7 +1394,6 @@ mod tests {
.metadata()
.file_metadata()
.key_value_metadata()
- .to_owned()
.unwrap()
.len(),
1
@@ -1431,7 +1436,6 @@ mod tests {
.metadata()
.file_metadata()
.key_value_metadata()
- .to_owned()
.unwrap()
.len(),
1
diff --git a/parquet/src/parquet_thrift.rs b/parquet/src/parquet_thrift.rs
index a3da857411..50a1235ce3 100644
--- a/parquet/src/parquet_thrift.rs
+++ b/parquet/src/parquet_thrift.rs
@@ -542,7 +542,7 @@ pub(crate) trait ThriftCompactInputProtocol<'a> {
}
// see https://github.com/apache/thrift/blob/master/doc/specs/thrift-compact-protocol.md#universal-unique-identifier-encoding
FieldType::Uuid => self.skip_bytes(16),
- _ => Err(ThriftProtocolError::SkipUnsupportedType(field_type)),
+ FieldType::Stop => Err(ThriftProtocolError::SkipUnsupportedType(field_type)),
}
}
}
diff --git a/parquet/src/record/reader.rs b/parquet/src/record/reader.rs
index f1a262250c..caad06ab5d 100644
--- a/parquet/src/record/reader.rs
+++ b/parquet/src/record/reader.rs
@@ -123,12 +123,12 @@ impl TreeBuilder {
curr_def_level += 1;
curr_rep_level += 1;
}
- _ => {}
+ Repetition::REQUIRED => {}
}
path.push(String::from(field.name()));
let reader = if field.is_primitive() {
- let col_path = ColumnPath::new(path.to_vec());
+ let col_path = ColumnPath::new(path.clone());
let orig_index = *paths
.get(&col_path)
.ok_or(general_err!("Path {:?} not found", col_path))?;
diff --git a/parquet/src/schema/printer.rs b/parquet/src/schema/printer.rs
index 67d8861aaf..ddb51b20a1 100644
--- a/parquet/src/schema/printer.rs
+++ b/parquet/src/schema/printer.rs
@@ -78,7 +78,7 @@ pub fn print_file_metadata(out: &mut dyn io::Write, file_metadata: &FileMetaData
}
if let Some(metadata) = file_metadata.key_value_metadata() {
writeln!(out, "metadata:");
- for kv in metadata.iter() {
+ for kv in metadata {
writeln!(
out,
" {}: {}",
diff --git a/parquet/src/schema/types.rs b/parquet/src/schema/types.rs
index 186c2744e5..5c906b171d 100644
--- a/parquet/src/schema/types.rs
+++ b/parquet/src/schema/types.rs
@@ -114,7 +114,7 @@ impl Type {
pub fn get_fields(&self) -> &[TypePtr] {
match *self {
Type::GroupType { ref fields, .. } => &fields[..],
- _ => panic!("Cannot call get_fields() on a non-group type"),
+ Type::PrimitiveType { .. } => panic!("Cannot call get_fields() on a non-group type"),
}
}
@@ -130,7 +130,9 @@ impl Type {
physical_type,
..
} => physical_type,
- _ => panic!("Cannot call get_physical_type() on a non-primitive type"),
+ Type::GroupType { .. } => {
+ panic!("Cannot call get_physical_type() on a non-primitive type")
+ }
}
}
@@ -142,7 +144,7 @@ impl Type {
pub fn get_precision(&self) -> i32 {
match *self {
Type::PrimitiveType { precision, .. } => precision,
- _ => panic!("Cannot call get_precision() on non-primitive type"),
+ Type::GroupType { .. } => panic!("Cannot call get_precision() on non-primitive type"),
}
}
@@ -154,7 +156,7 @@ impl Type {
pub fn get_scale(&self) -> i32 {
match *self {
Type::PrimitiveType { scale, .. } => scale,
- _ => panic!("Cannot call get_scale() on non-primitive type"),
+ Type::GroupType { .. } => panic!("Cannot call get_scale() on non-primitive type"),
}
}
@@ -209,7 +211,7 @@ impl Type {
pub fn is_schema(&self) -> bool {
match *self {
Type::GroupType { ref basic_info, .. } => !basic_info.has_repetition(),
- _ => false,
+ Type::PrimitiveType { .. } => false,
}
}
@@ -977,7 +979,7 @@ impl ColumnDescriptor {
pub fn physical_type(&self) -> PhysicalType {
match self.primitive_type.as_ref() {
Type::PrimitiveType { physical_type, .. } => *physical_type,
- _ => panic!("Expected primitive type!"),
+ Type::GroupType { .. } => panic!("Expected primitive type!"),
}
}
@@ -989,7 +991,7 @@ impl ColumnDescriptor {
pub fn type_length(&self) -> i32 {
match self.primitive_type.as_ref() {
Type::PrimitiveType { type_length, .. } => *type_length,
- _ => panic!("Expected primitive type!"),
+ Type::GroupType { .. } => panic!("Expected primitive type!"),
}
}
@@ -1001,7 +1003,7 @@ impl ColumnDescriptor {
pub fn type_precision(&self) -> i32 {
match self.primitive_type.as_ref() {
Type::PrimitiveType { precision, .. } => *precision,
- _ => panic!("Expected primitive type!"),
+ Type::GroupType { .. } => panic!("Expected primitive type!"),
}
}
@@ -1013,7 +1015,7 @@ impl ColumnDescriptor {
pub fn type_scale(&self) -> i32 {
match self.primitive_type.as_ref() {
Type::PrimitiveType { scale, .. } => *scale,
- _ => panic!("Expected primitive type!"),
+ Type::GroupType { .. } => panic!("Expected primitive type!"),
}
}
@@ -1215,7 +1217,7 @@ pub(crate) fn num_nodes(tp: &TypePtr) -> Result<usize> {
return Err(general_err!("Root schema must be Group type"));
}
let mut n_nodes = 1usize; // count root
- for f in tp.get_fields().iter() {
+ for f in tp.get_fields() {
count_nodes(f, &mut n_nodes);
}
Ok(n_nodes)
@@ -1236,7 +1238,7 @@ fn num_leaves(tp: &TypePtr) -> Result<usize> {
return Err(general_err!("Root schema must be Group type"));
}
let mut n_leaves = 0usize;
- for f in tp.get_fields().iter() {
+ for f in tp.get_fields() {
count_leaves(f, &mut n_leaves);
}
Ok(n_leaves)
@@ -1276,7 +1278,7 @@ fn build_tree<'a>(
max_rep_level += 1;
repeated_ancestor_def_level = max_def_level;
}
- _ => {}
+ Repetition::REQUIRED => {}
}
match tp.as_ref() {
@@ -1312,7 +1314,7 @@ fn build_tree<'a>(
}
/// Checks if the logical type is valid.
-fn check_logical_type(logical_type: &Option<LogicalType>) -> Result<()> {
+fn check_logical_type(logical_type: Option<&LogicalType>) -> Result<()> {
if let Some(LogicalType::Integer(IntType { bit_width, .. })) = logical_type
&& *bit_width != 8
&& *bit_width != 16
@@ -1385,7 +1387,7 @@ fn schema_from_array_helper<'a>(
// LogicalType is prefered to ConvertedType, but both may be present.
let logical_type = element.logical_type;
- check_logical_type(&logical_type)?;
+ check_logical_type(logical_type.as_ref())?;
let field_id = element.field_id;
match element.num_children {
@@ -1505,7 +1507,7 @@ mod tests {
Type::PrimitiveType { physical_type, .. } => {
assert_eq!(physical_type, PhysicalType::INT32);
}
- _ => panic!(),
+ Type::GroupType { .. } => panic!(),
}
}
diff --git a/parquet/src/schema/visitor.rs b/parquet/src/schema/visitor.rs
index 7a10d3a5ff..2ce8ced668 100644
--- a/parquet/src/schema/visitor.rs
+++ b/parquet/src/schema/visitor.rs
@@ -88,7 +88,7 @@ pub trait TypeVisitor<R, C> {
}
}
}
- _ => Err(General(
+ Type::GroupType { .. } => Err(General(
"Group element type of list can only contain one field.".to_string(),
)),
}
diff --git a/parquet/tests/arrow_reader/bad_data.rs b/parquet/tests/arrow_reader/bad_data.rs
index b3173138fb..b43e553179 100644
--- a/parquet/tests/arrow_reader/bad_data.rs
+++ b/parquet/tests/arrow_reader/bad_data.rs
@@ -50,7 +50,7 @@ fn bad_data_dir() -> PathBuf {
#[test]
// Ensure that if we add a new test the files are added to the tests.
fn test_invalid_files() {
- let known_files: HashSet<_> = KNOWN_FILES.iter().cloned().collect();
+ let known_files: HashSet<_> = KNOWN_FILES.iter().copied().collect();
let mut seen_files = HashSet::new();
let files = std::fs::read_dir(bad_data_dir()).unwrap();
diff --git a/parquet/tests/arrow_reader/mod.rs b/parquet/tests/arrow_reader/mod.rs
index c4c15d77a2..c7c77e0a44 100644
--- a/parquet/tests/arrow_reader/mod.rs
+++ b/parquet/tests/arrow_reader/mod.rs
@@ -675,8 +675,8 @@ fn make_dict_batch() -> RecordBatch {
Some("fffff"),
Some("aaa"),
];
- let dict_i8_array = DictionaryArray::<Int8Type>::from_iter(values.iter().cloned());
- let dict_i32_array = DictionaryArray::<Int32Type>::from_iter(values.iter().cloned());
+ let dict_i8_array = DictionaryArray::<Int8Type>::from_iter(values.iter().copied());
+ let dict_i32_array = DictionaryArray::<Int32Type>::from_iter(values.iter().copied());
// Dictionary array of integers
let int64_values = Int64Array::from(vec![0, -100, 100]);
diff --git a/parquet/tests/arrow_writer/mod.rs b/parquet/tests/arrow_writer/mod.rs
index b0bf3bcb5a..2ab386f982 100644
--- a/parquet/tests/arrow_writer/mod.rs
+++ b/parquet/tests/arrow_writer/mod.rs
@@ -178,7 +178,7 @@ fn make_batch(schema: &SchemaRef, batch_index: usize) -> RecordBatch {
let mut fat: Vec<u8> = vec![0u8; FAT_VALUE_LEN * ROWS_PER_BATCH];
// A cheap xorshift fill keyed by the batch index → distinct, incompressible.
let mut state = (batch_index as u64).wrapping_mul(0x9E37_79B9_7F4A_7C15) | 1;
- for byte in fat.iter_mut() {
+ for byte in &mut fat {
state ^= state << 13;
state ^= state >> 7;
state ^= state << 17;
diff --git a/parquet/tests/encryption/encryption.rs b/parquet/tests/encryption/encryption.rs
index 2b4a438b61..123bb30ad8 100644
--- a/parquet/tests/encryption/encryption.rs
+++ b/parquet/tests/encryption/encryption.rs
@@ -631,7 +631,7 @@ fn uniform_encryption_roundtrip(
.unwrap()
.values()
.iter()
- .cloned()
+ .copied()
})
.collect();
@@ -644,7 +644,7 @@ fn uniform_encryption_roundtrip(
.unwrap()
.values()
.iter()
- .cloned()
+ .copied()
})
.collect();
@@ -743,7 +743,7 @@ fn uniform_encryption_page_skipping(page_index: bool) -> parquet::errors::Result
.unwrap()
.values()
.iter()
- .cloned()
+ .copied()
})
.collect();
@@ -756,7 +756,7 @@ fn uniform_encryption_page_skipping(page_index: bool) -> parquet::errors::Result
.unwrap()
.values()
.iter()
- .cloned()
+ .copied()
})
.collect();
@@ -783,7 +783,7 @@ fn test_write_non_uniform_encryption() {
let file = File::open(path).unwrap();
let decryption_properties = FileDecryptionProperties::builder(footer_key.to_vec())
- .with_column_keys(column_names.to_vec(), column_keys.clone())
+ .with_column_keys(column_names.clone(), column_keys.clone())
.unwrap()
.build()
.unwrap();
@@ -1089,7 +1089,7 @@ fn write_and_read_stats(
// Check column statistics produced at write time are available in full
let row_group = metadata.row_group(0);
- for column in row_group.columns().iter() {
+ for column in row_group.columns() {
check_column_stats(column, true);
}
diff --git a/parquet/tests/encryption/encryption_async.rs b/parquet/tests/encryption/encryption_async.rs
index 35fb98a9eb..7d73601643 100644
--- a/parquet/tests/encryption/encryption_async.rs
+++ b/parquet/tests/encryption/encryption_async.rs
@@ -380,7 +380,7 @@ async fn test_write_non_uniform_encryption() {
);
let decryption_properties = FileDecryptionProperties::builder(footer_key.to_vec())
- .with_column_keys(column_names.to_vec(), column_keys.clone())
+ .with_column_keys(column_names.clone(), column_keys.clone())
.unwrap()
.build()
.unwrap();
diff --git a/parquet/tests/encryption/encryption_util.rs b/parquet/tests/encryption/encryption_util.rs
index daf7e07b7b..62762ac01c 100644
--- a/parquet/tests/encryption/encryption_util.rs
+++ b/parquet/tests/encryption/encryption_util.rs
@@ -153,7 +153,7 @@ pub(crate) fn verify_encryption_test_data(
((row_index(i) * 2 + 1) * 1000000000000) as i64
);
}
- for x in timestamp_col.iter() {
+ for x in timestamp_col {
assert!(x.is_some());
}
for (i, x) in f32_col.iter().enumerate() {
diff --git a/parquet_derive/src/parquet_field.rs b/parquet_derive/src/parquet_field.rs
index 07a04a2a24..b5171c23c5 100644
--- a/parquet_derive/src/parquet_field.rs
+++ b/parquet_derive/src/parquet_field.rs
@@ -193,7 +193,7 @@ impl Field {
},
_ => unimplemented!("Unsupported definition encountered"),
},
- _ => unimplemented!("Unsupported definition encountered"),
+ Type::Option(_) => unimplemented!("Unsupported definition encountered"),
}
}
},