This is an automated email from the ASF dual-hosted git repository.
tustvold pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/arrow-rs.git
The following commit(s) were added to refs/heads/master by this push:
new dfb1ea2469 Fix new clippy lints (#4734)
dfb1ea2469 is described below
commit dfb1ea2469c9edf399e944821c6f00130cdf8016
Author: Raphael Taylor-Davies <[email protected]>
AuthorDate: Thu Aug 24 19:54:13 2023 +0100
Fix new clippy lints (#4734)
* Fix new clippy lints
* More clippy
* Even more clippy
* Clippy
---
arrow-array/src/array/dictionary_array.rs | 5 +-
arrow-array/src/array/primitive_array.rs | 9 +-
arrow-array/src/array/run_array.rs | 7 +-
arrow-array/src/array/string_array.rs | 4 +-
arrow-array/src/record_batch.rs | 2 +-
arrow-array/src/run_iterator.rs | 4 +-
arrow-array/src/trusted_len.rs | 2 +-
arrow-buffer/src/native.rs | 2 +-
arrow-buffer/src/util/bit_chunk_iterator.rs | 2 +-
arrow-cast/src/cast.rs | 47 +----
arrow-cast/src/parse.rs | 14 +-
arrow-cast/src/pretty.rs | 2 +-
arrow-flight/src/utils.rs | 4 +-
arrow-integration-testing/tests/ipc_reader.rs | 8 +-
arrow-integration-testing/tests/ipc_writer.rs | 28 +--
arrow-ipc/src/convert.rs | 2 +-
arrow-ipc/src/reader.rs | 4 +-
arrow-ipc/src/writer.rs | 2 +-
arrow-json/src/writer.rs | 10 +-
arrow-ord/src/comparison.rs | 222 ++++++---------------
arrow-ord/src/partition.rs | 6 +-
arrow-ord/src/sort.rs | 159 +++++----------
arrow-row/src/interner.rs | 2 +-
arrow-select/src/concat.rs | 5 +-
arrow-select/src/filter.rs | 2 +-
arrow-string/src/length.rs | 1 +
arrow-string/src/like.rs | 50 +----
arrow-string/src/regexp.rs | 10 +-
arrow/tests/array_equal.rs | 6 +-
object_store/src/memory.rs | 2 +-
object_store/src/util.rs | 2 +-
parquet/src/arrow/array_reader/byte_array.rs | 4 +-
.../arrow/array_reader/byte_array_dictionary.rs | 2 +-
parquet/src/arrow/arrow_writer/mod.rs | 6 +-
parquet/src/arrow/buffer/bit_util.rs | 2 +-
parquet/src/arrow/buffer/offset_buffer.rs | 4 +-
parquet/src/column/writer/mod.rs | 13 +-
parquet/src/encodings/decoding.rs | 50 ++---
parquet/src/file/serialized_reader.rs | 37 +---
parquet/src/record/reader.rs | 39 ++--
parquet/src/schema/types.rs | 4 +-
41 files changed, 271 insertions(+), 515 deletions(-)
diff --git a/arrow-array/src/array/dictionary_array.rs
b/arrow-array/src/array/dictionary_array.rs
index ed043754da..5896cf02df 100644
--- a/arrow-array/src/array/dictionary_array.rs
+++ b/arrow-array/src/array/dictionary_array.rs
@@ -800,10 +800,7 @@ pub struct TypedDictionaryArray<'a, K:
ArrowDictionaryKeyType, V> {
// Manually implement `Clone` to avoid `V: Clone` type constraint
impl<'a, K: ArrowDictionaryKeyType, V> Clone for TypedDictionaryArray<'a, K,
V> {
fn clone(&self) -> Self {
- Self {
- dictionary: self.dictionary,
- values: self.values,
- }
+ *self
}
}
diff --git a/arrow-array/src/array/primitive_array.rs
b/arrow-array/src/array/primitive_array.rs
index 0c32279640..4c07e81468 100644
--- a/arrow-array/src/array/primitive_array.rs
+++ b/arrow-array/src/array/primitive_array.rs
@@ -1580,7 +1580,7 @@ mod tests {
assert_eq!(3, arr.len());
assert_eq!(0, arr.offset());
assert_eq!(0, arr.null_count());
- let formatted = vec!["00:00:00.001", "10:30:00.005", "23:59:59.210"];
+ let formatted = ["00:00:00.001", "10:30:00.005", "23:59:59.210"];
for (i, formatted) in formatted.iter().enumerate().take(3) {
// check that we can't create dates or datetimes from time
instances
assert_eq!(None, arr.value_as_datetime(i));
@@ -1604,7 +1604,7 @@ mod tests {
assert_eq!(3, arr.len());
assert_eq!(0, arr.offset());
assert_eq!(0, arr.null_count());
- let formatted = vec!["00:00:00.001", "10:30:00.005", "23:59:59.210"];
+ let formatted = ["00:00:00.001", "10:30:00.005", "23:59:59.210"];
for (i, item) in formatted.iter().enumerate().take(3) {
// check that we can't create dates or datetimes from time
instances
assert_eq!(None, arr.value_as_datetime(i));
@@ -2219,7 +2219,7 @@ mod tests {
#[test]
fn test_decimal_from_iter_values() {
- let array = Decimal128Array::from_iter_values(vec![-100, 0,
101].into_iter());
+ let array = Decimal128Array::from_iter_values(vec![-100, 0, 101]);
assert_eq!(array.len(), 3);
assert_eq!(array.data_type(), &DataType::Decimal128(38, 10));
assert_eq!(-100_i128, array.value(0));
@@ -2419,8 +2419,7 @@ mod tests {
expected = "Trying to access an element at index 4 from a
PrimitiveArray of length 3"
)]
fn test_fixed_size_binary_array_get_value_index_out_of_bound() {
- let array = Decimal128Array::from_iter_values(vec![-100, 0,
101].into_iter());
-
+ let array = Decimal128Array::from(vec![-100, 0, 101]);
array.value(4);
}
diff --git a/arrow-array/src/array/run_array.rs
b/arrow-array/src/array/run_array.rs
index 30cefaeb4d..ba6986c284 100644
--- a/arrow-array/src/array/run_array.rs
+++ b/arrow-array/src/array/run_array.rs
@@ -537,10 +537,7 @@ pub struct TypedRunArray<'a, R: RunEndIndexType, V> {
// Manually implement `Clone` to avoid `V: Clone` type constraint
impl<'a, R: RunEndIndexType, V> Clone for TypedRunArray<'a, R, V> {
fn clone(&self) -> Self {
- Self {
- run_array: self.run_array,
- values: self.values,
- }
+ *self
}
}
@@ -1093,7 +1090,7 @@ mod tests {
let values = Int32Array::from(vec![Some(0), None, Some(1), None]);
let array = RunArray::try_new(&run, &values).unwrap();
- let expected = vec![
+ let expected = [
true, true, true, false, false, false, true, true, true, false,
false, false,
];
diff --git a/arrow-array/src/array/string_array.rs
b/arrow-array/src/array/string_array.rs
index 9694cd2d4e..cac4651f44 100644
--- a/arrow-array/src/array/string_array.rs
+++ b/arrow-array/src/array/string_array.rs
@@ -324,14 +324,14 @@ mod tests {
#[test]
fn test_string_array_from_iter_values() {
- let data = vec!["hello", "hello2"];
+ let data = ["hello", "hello2"];
let array1 = StringArray::from_iter_values(data.iter());
assert_eq!(array1.value(0), "hello");
assert_eq!(array1.value(1), "hello2");
// Also works with String types.
- let data2: Vec<String> = vec!["goodbye".into(), "goodbye2".into()];
+ let data2 = ["goodbye".to_string(), "goodbye2".to_string()];
let array2 = StringArray::from_iter_values(data2.iter());
assert_eq!(array2.value(0), "goodbye");
diff --git a/arrow-array/src/record_batch.rs b/arrow-array/src/record_batch.rs
index 886d00e0c2..27804447fb 100644
--- a/arrow-array/src/record_batch.rs
+++ b/arrow-array/src/record_batch.rs
@@ -757,7 +757,7 @@ mod tests {
))))
.add_child_data(a2_child.into_data())
.len(2)
- .add_buffer(Buffer::from(vec![0i32, 3, 4].to_byte_slice()))
+ .add_buffer(Buffer::from([0i32, 3, 4].to_byte_slice()))
.build()
.unwrap();
let a2: ArrayRef = Arc::new(ListArray::from(a2));
diff --git a/arrow-array/src/run_iterator.rs b/arrow-array/src/run_iterator.rs
index 60022113c3..489aabf475 100644
--- a/arrow-array/src/run_iterator.rs
+++ b/arrow-array/src/run_iterator.rs
@@ -237,7 +237,7 @@ mod tests {
Some(72),
];
let mut builder = PrimitiveRunBuilder::<Int32Type, Int32Type>::new();
- builder.extend(input_vec.clone().into_iter());
+ builder.extend(input_vec.iter().copied());
let ree_array = builder.finish();
let ree_array = ree_array.downcast::<Int32Array>().unwrap();
@@ -261,7 +261,7 @@ mod tests {
Some(72),
];
let mut builder = PrimitiveRunBuilder::<Int32Type, Int32Type>::new();
- builder.extend(input_vec.into_iter());
+ builder.extend(input_vec);
let ree_array = builder.finish();
let ree_array = ree_array.downcast::<Int32Array>().unwrap();
diff --git a/arrow-array/src/trusted_len.rs b/arrow-array/src/trusted_len.rs
index fdec18b787..781cad38f7 100644
--- a/arrow-array/src/trusted_len.rs
+++ b/arrow-array/src/trusted_len.rs
@@ -63,7 +63,7 @@ mod tests {
#[test]
fn trusted_len_unzip_good() {
- let vec = vec![Some(1u32), None];
+ let vec = [Some(1u32), None];
let (null, buffer) = unsafe { trusted_len_unzip(vec.iter()) };
assert_eq!(null.as_slice(), &[0b00000001]);
assert_eq!(buffer.as_slice(), &[1u8, 0, 0, 0, 0, 0, 0, 0]);
diff --git a/arrow-buffer/src/native.rs b/arrow-buffer/src/native.rs
index 8fe6cf2b78..38074a8dc2 100644
--- a/arrow-buffer/src/native.rs
+++ b/arrow-buffer/src/native.rs
@@ -222,7 +222,7 @@ pub trait ToByteSlice {
impl<T: ArrowNativeType> ToByteSlice for [T] {
#[inline]
fn to_byte_slice(&self) -> &[u8] {
- let raw_ptr = self.as_ptr() as *const T as *const u8;
+ let raw_ptr = self.as_ptr() as *const u8;
unsafe { std::slice::from_raw_parts(raw_ptr,
std::mem::size_of_val(self)) }
}
}
diff --git a/arrow-buffer/src/util/bit_chunk_iterator.rs
b/arrow-buffer/src/util/bit_chunk_iterator.rs
index 3d9632e732..6830acae94 100644
--- a/arrow-buffer/src/util/bit_chunk_iterator.rs
+++ b/arrow-buffer/src/util/bit_chunk_iterator.rs
@@ -157,7 +157,7 @@ impl<'a> UnalignedBitChunk<'a> {
self.prefix
.into_iter()
.chain(self.chunks.iter().cloned())
- .chain(self.suffix.into_iter())
+ .chain(self.suffix)
}
/// Counts the number of ones
diff --git a/arrow-cast/src/cast.rs b/arrow-cast/src/cast.rs
index 23b7a4b5a0..7b8e6144bb 100644
--- a/arrow-cast/src/cast.rs
+++ b/arrow-cast/src/cast.rs
@@ -3428,50 +3428,24 @@ mod tests {
macro_rules! generate_cast_test_case {
($INPUT_ARRAY: expr, $OUTPUT_TYPE_ARRAY: ident, $OUTPUT_TYPE: expr,
$OUTPUT_VALUES: expr) => {
+ let output = $OUTPUT_TYPE_ARRAY::from($OUTPUT_VALUES)
+ .with_data_type($OUTPUT_TYPE.clone());
+
// assert cast type
let input_array_type = $INPUT_ARRAY.data_type();
assert!(can_cast_types(input_array_type, $OUTPUT_TYPE));
- let casted_array = cast($INPUT_ARRAY, $OUTPUT_TYPE).unwrap();
- let result_array = casted_array
- .as_any()
- .downcast_ref::<$OUTPUT_TYPE_ARRAY>()
- .unwrap();
- assert_eq!($OUTPUT_TYPE, result_array.data_type());
- assert_eq!(result_array.len(), $OUTPUT_VALUES.len());
- for (i, x) in $OUTPUT_VALUES.iter().enumerate() {
- match x {
- Some(x) => {
- assert!(!result_array.is_null(i));
- assert_eq!(result_array.value(i), *x);
- }
- None => {
- assert!(result_array.is_null(i));
- }
- }
- }
+ let result = cast($INPUT_ARRAY, $OUTPUT_TYPE).unwrap();
+ assert_eq!($OUTPUT_TYPE, result.data_type());
+ assert_eq!(result.as_ref(), &output);
let cast_option = CastOptions {
safe: false,
format_options: FormatOptions::default(),
};
- let casted_array_with_option =
+ let result =
cast_with_options($INPUT_ARRAY, $OUTPUT_TYPE,
&cast_option).unwrap();
- let result_array = casted_array_with_option
- .as_any()
- .downcast_ref::<$OUTPUT_TYPE_ARRAY>()
- .unwrap();
- assert_eq!($OUTPUT_TYPE, result_array.data_type());
- assert_eq!(result_array.len(), $OUTPUT_VALUES.len());
- for (i, x) in $OUTPUT_VALUES.iter().enumerate() {
- match x {
- Some(x) => {
- assert_eq!(result_array.value(i), *x);
- }
- None => {
- assert!(result_array.is_null(i));
- }
- }
- }
+ assert_eq!($OUTPUT_TYPE, result.data_type());
+ assert_eq!(result.as_ref(), &output);
};
}
@@ -5997,7 +5971,7 @@ mod tests {
#[test]
fn test_str_to_str_casts() {
- for data in vec![
+ for data in [
vec![Some("foo"), Some("bar"), Some("ham")],
vec![Some("foo"), None, Some("bar")],
] {
@@ -8934,6 +8908,7 @@ mod tests {
};
#[test]
+ #[allow(clippy::assertions_on_constants)]
fn test_const_options() {
assert!(CAST_OPTIONS.safe)
}
diff --git a/arrow-cast/src/parse.rs b/arrow-cast/src/parse.rs
index 50bfca0f84..8483c44f97 100644
--- a/arrow-cast/src/parse.rs
+++ b/arrow-cast/src/parse.rs
@@ -1003,15 +1003,11 @@ impl Interval {
fn parse(value: &str, config: &IntervalParseConfig) -> Result<Self,
ArrowError> {
let components = parse_interval_components(value, config)?;
- let result = components.into_iter().fold(
- Ok(Self::default()),
- |result, (amount, unit)| match result {
- Ok(result) => result.add(amount, unit),
- Err(e) => Err(e),
- },
- )?;
-
- Ok(result)
+ components
+ .into_iter()
+ .try_fold(Self::default(), |result, (amount, unit)| {
+ result.add(amount, unit)
+ })
}
/// Interval addition following Postgres behavior. Fractional units will
be spilled into smaller units.
diff --git a/arrow-cast/src/pretty.rs b/arrow-cast/src/pretty.rs
index 13d1df6a11..59a9f9d605 100644
--- a/arrow-cast/src/pretty.rs
+++ b/arrow-cast/src/pretty.rs
@@ -848,7 +848,7 @@ mod tests {
let mut buf = String::new();
write!(&mut buf, "{}",
pretty_format_batches(&[batch]).unwrap()).unwrap();
- let s = vec![
+ let s = [
"+---+-----+",
"| a | b |",
"+---+-----+",
diff --git a/arrow-flight/src/utils.rs b/arrow-flight/src/utils.rs
index 8baf5ed723..145626b660 100644
--- a/arrow-flight/src/utils.rs
+++ b/arrow-flight/src/utils.rs
@@ -166,8 +166,8 @@ pub fn batches_to_flight_data(
flight_data.push(encoded_batch.into());
}
let mut stream = vec![schema_flight_data];
- stream.extend(dictionaries.into_iter());
- stream.extend(flight_data.into_iter());
+ stream.extend(dictionaries);
+ stream.extend(flight_data);
let flight_data: Vec<_> = stream.into_iter().collect();
Ok(flight_data)
}
diff --git a/arrow-integration-testing/tests/ipc_reader.rs
b/arrow-integration-testing/tests/ipc_reader.rs
index 9205f43183..696ab6e605 100644
--- a/arrow-integration-testing/tests/ipc_reader.rs
+++ b/arrow-integration-testing/tests/ipc_reader.rs
@@ -27,7 +27,7 @@ use std::fs::File;
fn read_0_1_4() {
let testdata = arrow_test_data();
let version = "0.14.1";
- let paths = vec![
+ let paths = [
"generated_interval",
"generated_datetime",
"generated_dictionary",
@@ -48,7 +48,7 @@ fn read_0_1_4() {
fn read_0_1_7() {
let testdata = arrow_test_data();
let version = "0.17.1";
- let paths = vec!["generated_union"];
+ let paths = ["generated_union"];
paths.iter().for_each(|path| {
verify_arrow_file(&testdata, version, path);
verify_arrow_stream(&testdata, version, path);
@@ -76,7 +76,7 @@ fn read_1_0_0_bigendian_dictionary_should_panic() {
#[test]
fn read_1_0_0_bigendian() {
let testdata = arrow_test_data();
- let paths = vec![
+ let paths = [
"generated_interval",
"generated_datetime",
"generated_map",
@@ -145,7 +145,7 @@ fn read_2_0_0_compression() {
let version = "2.0.0-compression";
// the test is repetitive, thus we can read all supported files at once
- let paths = vec!["generated_lz4", "generated_zstd"];
+ let paths = ["generated_lz4", "generated_zstd"];
paths.iter().for_each(|path| {
verify_arrow_file(&testdata, version, path);
verify_arrow_stream(&testdata, version, path);
diff --git a/arrow-integration-testing/tests/ipc_writer.rs
b/arrow-integration-testing/tests/ipc_writer.rs
index 40f356b1d4..11707d9355 100644
--- a/arrow-integration-testing/tests/ipc_writer.rs
+++ b/arrow-integration-testing/tests/ipc_writer.rs
@@ -27,7 +27,7 @@ use std::io::Seek;
fn write_0_1_4() {
let testdata = arrow_test_data();
let version = "0.14.1";
- let paths = vec![
+ let paths = [
"generated_interval",
"generated_datetime",
"generated_dictionary",
@@ -48,7 +48,7 @@ fn write_0_1_4() {
fn write_0_1_7() {
let testdata = arrow_test_data();
let version = "0.17.1";
- let paths = vec!["generated_union"];
+ let paths = ["generated_union"];
paths.iter().for_each(|path| {
roundtrip_arrow_file(&testdata, version, path);
roundtrip_arrow_stream(&testdata, version, path);
@@ -59,7 +59,7 @@ fn write_0_1_7() {
fn write_1_0_0_littleendian() {
let testdata = arrow_test_data();
let version = "1.0.0-littleendian";
- let paths = vec![
+ let paths = [
"generated_datetime",
"generated_custom_metadata",
"generated_decimal",
@@ -94,10 +94,10 @@ fn write_1_0_0_littleendian() {
fn write_2_0_0_compression() {
let testdata = arrow_test_data();
let version = "2.0.0-compression";
- let paths = vec!["generated_lz4", "generated_zstd"];
+ let paths = ["generated_lz4", "generated_zstd"];
// writer options for each compression type
- let all_options = vec![
+ let all_options = [
IpcWriteOptions::try_new(8, false, ipc::MetadataVersion::V5)
.unwrap()
.try_with_compression(Some(ipc::CompressionType::LZ4_FRAME))
@@ -187,11 +187,12 @@ fn roundtrip_arrow_file_with_options(
let rewrite_reader = FileReader::try_new(&tempfile, None).unwrap();
// Compare to original reader
- reader.into_iter().zip(rewrite_reader.into_iter()).for_each(
- |(batch1, batch2)| {
+ reader
+ .into_iter()
+ .zip(rewrite_reader)
+ .for_each(|(batch1, batch2)| {
assert_eq!(batch1.unwrap(), batch2.unwrap());
- },
- );
+ });
}
}
@@ -264,10 +265,11 @@ fn roundtrip_arrow_stream_with_options(
let rewrite_reader = StreamReader::try_new(&tempfile, None).unwrap();
// Compare to original reader
- reader.into_iter().zip(rewrite_reader.into_iter()).for_each(
- |(batch1, batch2)| {
+ reader
+ .into_iter()
+ .zip(rewrite_reader)
+ .for_each(|(batch1, batch2)| {
assert_eq!(batch1.unwrap(), batch2.unwrap());
- },
- );
+ });
}
}
diff --git a/arrow-ipc/src/convert.rs b/arrow-ipc/src/convert.rs
index 3569562af2..a78ccde6e1 100644
--- a/arrow-ipc/src/convert.rs
+++ b/arrow-ipc/src/convert.rs
@@ -717,7 +717,7 @@ pub(crate) fn get_fb_field_type<'a>(
RunEndEncoded(run_ends, values) => {
let run_ends_field = build_field(fbb, run_ends);
let values_field = build_field(fbb, values);
- let children = vec![run_ends_field, values_field];
+ let children = [run_ends_field, values_field];
FBFieldType {
type_type: crate::Type::RunEndEncoded,
type_: crate::RunEndEncodedBuilder::new(fbb)
diff --git a/arrow-ipc/src/reader.rs b/arrow-ipc/src/reader.rs
index 962b17c39d..96cb4393ba 100644
--- a/arrow-ipc/src/reader.rs
+++ b/arrow-ipc/src/reader.rs
@@ -1156,7 +1156,7 @@ mod tests {
let array10_input = vec![Some(1_i32), None, None];
let mut array10_builder = PrimitiveRunBuilder::<Int16Type,
Int32Type>::new();
- array10_builder.extend(array10_input.into_iter());
+ array10_builder.extend(array10_input);
let array10 = array10_builder.finish();
let array11 = BooleanArray::from(vec![false, false, true]);
@@ -1411,7 +1411,7 @@ mod tests {
let run_array_2_inupt = vec![Some(1_i32), None, None, Some(2),
Some(2)];
let mut run_array_2_builder = PrimitiveRunBuilder::<Int16Type,
Int32Type>::new();
- run_array_2_builder.extend(run_array_2_inupt.into_iter());
+ run_array_2_builder.extend(run_array_2_inupt);
let run_array_2 = run_array_2_builder.finish();
let schema = Arc::new(Schema::new(vec![
diff --git a/arrow-ipc/src/writer.rs b/arrow-ipc/src/writer.rs
index 9c418d76e4..0e01e51231 100644
--- a/arrow-ipc/src/writer.rs
+++ b/arrow-ipc/src/writer.rs
@@ -2138,7 +2138,7 @@ mod tests {
let u32 = UInt32Builder::new();
let mut ls = ListBuilder::new(u32);
- for list in vec![vec![1u32, 2, 3], vec![4, 5, 6], vec![7, 8, 9,
10]] {
+ for list in [vec![1u32, 2, 3], vec![4, 5, 6], vec![7, 8, 9, 10]] {
for value in list {
ls.values().append_value(value);
}
diff --git a/arrow-json/src/writer.rs b/arrow-json/src/writer.rs
index 571e95a1a4..a918f44b54 100644
--- a/arrow-json/src/writer.rs
+++ b/arrow-json/src/writer.rs
@@ -320,11 +320,9 @@ fn set_column_for_json_rows(
}
DataType::Struct(_) => {
let inner_objs = struct_array_to_jsonmap_array(array.as_struct())?;
- rows.iter_mut()
- .zip(inner_objs.into_iter())
- .for_each(|(row, obj)| {
- row.insert(col_name.to_string(), Value::Object(obj));
- });
+ rows.iter_mut().zip(inner_objs).for_each(|(row, obj)| {
+ row.insert(col_name.to_string(), Value::Object(obj));
+ });
}
DataType::List(_) => {
let listarr = as_list_array(array);
@@ -374,7 +372,7 @@ fn set_column_for_json_rows(
let keys = keys.as_string::<i32>();
let values = array_to_json_array(values)?;
- let mut kv = keys.iter().zip(values.into_iter());
+ let mut kv = keys.iter().zip(values);
for (i, row) in rows.iter_mut().enumerate() {
if maparr.is_null(i) {
diff --git a/arrow-ord/src/comparison.rs b/arrow-ord/src/comparison.rs
index 1a6e564283..4e475d8fd5 100644
--- a/arrow-ord/src/comparison.rs
+++ b/arrow-ord/src/comparison.rs
@@ -2187,25 +2187,17 @@ mod tests {
($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr)
=> {
#[test]
fn $test_name() {
+ let expected = BooleanArray::from($expected);
+
let left = BinaryArray::from_vec($left);
let right = BinaryArray::from_vec($right);
let res = $op(&left, &right).unwrap();
- let expected = $expected;
- assert_eq!(expected.len(), res.len());
- for i in 0..res.len() {
- let v = res.value(i);
- assert_eq!(v, expected[i]);
- }
+ assert_eq!(res, expected);
let left = LargeBinaryArray::from_vec($left);
let right = LargeBinaryArray::from_vec($right);
let res = $op(&left, &right).unwrap();
- let expected = $expected;
- assert_eq!(expected.len(), res.len());
- for i in 0..res.len() {
- let v = res.value(i);
- assert_eq!(v, expected[i]);
- }
+ assert_eq!(res, expected);
}
};
}
@@ -2228,37 +2220,15 @@ mod tests {
($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr)
=> {
#[test]
fn $test_name() {
+ let expected = BooleanArray::from($expected);
+
let left = BinaryArray::from_vec($left);
let res = $op(&left, $right).unwrap();
- let expected = $expected;
- assert_eq!(expected.len(), res.len());
- for i in 0..res.len() {
- let v = res.value(i);
- assert_eq!(
- v,
- expected[i],
- "unexpected result when comparing {:?} at position {}
to {:?} ",
- left.value(i),
- i,
- $right
- );
- }
+ assert_eq!(res, expected);
let left = LargeBinaryArray::from_vec($left);
let res = $op(&left, $right).unwrap();
- let expected = $expected;
- assert_eq!(expected.len(), res.len());
- for i in 0..res.len() {
- let v = res.value(i);
- assert_eq!(
- v,
- expected[i],
- "unexpected result when comparing {:?} at position {}
to {:?} ",
- left.value(i),
- i,
- $right
- );
- }
+ assert_eq!(res, expected);
}
};
}
@@ -2492,14 +2462,14 @@ mod tests {
vec!["arrow", "arrow", "arrow", "arrow"],
vec!["arrow", "parquet", "datafusion", "flight"],
eq_utf8,
- vec![true, false, false, false]
+ [true, false, false, false]
);
test_utf8_scalar!(
test_utf8_array_eq_scalar,
vec!["arrow", "parquet", "datafusion", "flight"],
"arrow",
eq_utf8_scalar,
- vec![true, false, false, false]
+ [true, false, false, false]
);
test_utf8!(
@@ -2507,14 +2477,14 @@ mod tests {
vec!["arrow", "arrow", "arrow", "arrow"],
vec!["arrow", "parquet", "datafusion", "flight"],
neq_utf8,
- vec![false, true, true, true]
+ [false, true, true, true]
);
test_utf8_scalar!(
test_utf8_array_neq_scalar,
vec!["arrow", "parquet", "datafusion", "flight"],
"arrow",
neq_utf8_scalar,
- vec![false, true, true, true]
+ [false, true, true, true]
);
test_utf8!(
@@ -2522,14 +2492,14 @@ mod tests {
vec!["arrow", "datafusion", "flight", "parquet"],
vec!["flight", "flight", "flight", "flight"],
lt_utf8,
- vec![true, true, false, false]
+ [true, true, false, false]
);
test_utf8_scalar!(
test_utf8_array_lt_scalar,
vec!["arrow", "datafusion", "flight", "parquet"],
"flight",
lt_utf8_scalar,
- vec![true, true, false, false]
+ [true, true, false, false]
);
test_utf8!(
@@ -2537,14 +2507,14 @@ mod tests {
vec!["arrow", "datafusion", "flight", "parquet"],
vec!["flight", "flight", "flight", "flight"],
lt_eq_utf8,
- vec![true, true, true, false]
+ [true, true, true, false]
);
test_utf8_scalar!(
test_utf8_array_lt_eq_scalar,
vec!["arrow", "datafusion", "flight", "parquet"],
"flight",
lt_eq_utf8_scalar,
- vec![true, true, true, false]
+ [true, true, true, false]
);
test_utf8!(
@@ -2552,14 +2522,14 @@ mod tests {
vec!["arrow", "datafusion", "flight", "parquet"],
vec!["flight", "flight", "flight", "flight"],
gt_utf8,
- vec![false, false, false, true]
+ [false, false, false, true]
);
test_utf8_scalar!(
test_utf8_array_gt_scalar,
vec!["arrow", "datafusion", "flight", "parquet"],
"flight",
gt_utf8_scalar,
- vec![false, false, false, true]
+ [false, false, false, true]
);
test_utf8!(
@@ -2567,14 +2537,14 @@ mod tests {
vec!["arrow", "datafusion", "flight", "parquet"],
vec!["flight", "flight", "flight", "flight"],
gt_eq_utf8,
- vec![false, false, true, true]
+ [false, false, true, true]
);
test_utf8_scalar!(
test_utf8_array_gt_eq_scalar,
vec!["arrow", "datafusion", "flight", "parquet"],
"flight",
gt_eq_utf8_scalar,
- vec![false, false, true, true]
+ [false, false, true, true]
);
#[test]
@@ -3365,8 +3335,8 @@ mod tests {
#[test]
fn test_eq_dyn_neq_dyn_dictionary_utf8_array() {
- let test1 = vec!["a", "a", "b", "c"];
- let test2 = vec!["a", "b", "b", "c"];
+ let test1 = ["a", "a", "b", "c"];
+ let test2 = ["a", "b", "b", "c"];
let dict_array1: DictionaryArray<Int8Type> = test1
.iter()
@@ -3535,7 +3505,7 @@ mod tests {
#[test]
fn test_unary_cmp() {
let a = Int32Array::from(vec![Some(1), None, Some(2), Some(3)]);
- let values = vec![1_i32, 3];
+ let values = [1_i32, 3];
let a_eq = unary_cmp(&a, |a| values.contains(&a)).unwrap();
assert_eq!(
@@ -3638,14 +3608,8 @@ mod tests {
#[test]
fn test_eq_dyn_neq_dyn_float_nan() {
- let array1: Float16Array = vec![f16::NAN, f16::from_f32(7.0),
f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(10.0)]
- .into_iter()
- .map(Some)
- .collect();
- let array2: Float16Array = vec![f16::NAN, f16::NAN,
f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(10.0)]
- .into_iter()
- .map(Some)
- .collect();
+ let array1 = Float16Array::from(vec![f16::NAN, f16::from_f32(7.0),
f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(10.0)]);
+ let array2 = Float16Array::from(vec![f16::NAN, f16::NAN,
f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(10.0)]);
let expected = BooleanArray::from(
vec![Some(true), Some(false), Some(true), Some(true), Some(true)],
);
@@ -3660,14 +3624,8 @@ mod tests {
assert_eq!(neq(&array1, &array2).unwrap(), expected);
- let array1: Float32Array = vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]
- .into_iter()
- .map(Some)
- .collect();
- let array2: Float32Array = vec![f32::NAN, f32::NAN, 8.0, 8.0, 10.0]
- .into_iter()
- .map(Some)
- .collect();
+ let array1 = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]);
+ let array2 = Float32Array::from(vec![f32::NAN, f32::NAN, 8.0, 8.0,
10.0]);
let expected = BooleanArray::from(
vec![Some(true), Some(false), Some(true), Some(true), Some(true)],
);
@@ -3682,14 +3640,8 @@ mod tests {
assert_eq!(neq(&array1, &array2).unwrap(), expected);
- let array1: Float64Array = vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]
- .into_iter()
- .map(Some)
- .collect();
- let array2: Float64Array = vec![f64::NAN, f64::NAN, 8.0, 8.0, 10.0]
- .into_iter()
- .map(Some)
- .collect();
+ let array1 = Float64Array::from(vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]);
+ let array2 = Float64Array::from(vec![f64::NAN, f64::NAN, 8.0, 8.0,
10.0]);
let expected = BooleanArray::from(
vec![Some(true), Some(false), Some(true), Some(true), Some(true)],
@@ -3708,14 +3660,8 @@ mod tests {
#[test]
fn test_lt_dyn_lt_eq_dyn_float_nan() {
- let array1: Float16Array = vec![f16::NAN, f16::from_f32(7.0),
f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(11.0), f16::NAN]
- .into_iter()
- .map(Some)
- .collect();
- let array2: Float16Array = vec![f16::NAN, f16::NAN,
f16::from_f32(8.0), f16::from_f32(9.0), f16::from_f32(10.0), f16::from_f32(1.0)]
- .into_iter()
- .map(Some)
- .collect();
+ let array1 = Float16Array::from(vec![f16::NAN, f16::from_f32(7.0),
f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(11.0), f16::NAN]);
+ let array2 = Float16Array::from(vec![f16::NAN, f16::NAN,
f16::from_f32(8.0), f16::from_f32(9.0), f16::from_f32(10.0),
f16::from_f32(1.0)]);
let expected = BooleanArray::from(
vec![Some(false), Some(true), Some(false), Some(true),
Some(false), Some(false)],
@@ -3731,14 +3677,8 @@ mod tests {
assert_eq!(lt_eq(&array1, &array2).unwrap(), expected);
- let array1: Float32Array = vec![f32::NAN, 7.0, 8.0, 8.0, 11.0,
f32::NAN]
- .into_iter()
- .map(Some)
- .collect();
- let array2: Float32Array = vec![f32::NAN, f32::NAN, 8.0, 9.0, 10.0,
1.0]
- .into_iter()
- .map(Some)
- .collect();
+ let array1 = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 11.0,
f32::NAN]);
+ let array2 = Float32Array::from(vec![f32::NAN, f32::NAN, 8.0, 9.0,
10.0, 1.0]);
let expected = BooleanArray::from(
vec![Some(false), Some(true), Some(false), Some(true),
Some(false), Some(false)],
@@ -3780,14 +3720,8 @@ mod tests {
#[test]
fn test_gt_dyn_gt_eq_dyn_float_nan() {
- let array1: Float16Array = vec![f16::NAN, f16::from_f32(7.0),
f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(11.0), f16::NAN]
- .into_iter()
- .map(Some)
- .collect();
- let array2: Float16Array = vec![f16::NAN, f16::NAN,
f16::from_f32(8.0), f16::from_f32(9.0), f16::from_f32(10.0), f16::from_f32(1.0)]
- .into_iter()
- .map(Some)
- .collect();
+ let array1 = Float16Array::from(vec![f16::NAN, f16::from_f32(7.0),
f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(11.0), f16::NAN]);
+ let array2 = Float16Array::from(vec![f16::NAN, f16::NAN,
f16::from_f32(8.0), f16::from_f32(9.0), f16::from_f32(10.0),
f16::from_f32(1.0)]);
let expected = BooleanArray::from(
vec![Some(false), Some(false), Some(false), Some(false),
Some(true), Some(true)],
@@ -3803,14 +3737,8 @@ mod tests {
assert_eq!(gt_eq(&array1, &array2).unwrap(), expected);
- let array1: Float32Array = vec![f32::NAN, 7.0, 8.0, 8.0, 11.0,
f32::NAN]
- .into_iter()
- .map(Some)
- .collect();
- let array2: Float32Array = vec![f32::NAN, f32::NAN, 8.0, 9.0, 10.0,
1.0]
- .into_iter()
- .map(Some)
- .collect();
+ let array1 = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 11.0,
f32::NAN]);
+ let array2 = Float32Array::from(vec![f32::NAN, f32::NAN, 8.0, 9.0,
10.0, 1.0]);
let expected = BooleanArray::from(
vec![Some(false), Some(false), Some(false), Some(false),
Some(true), Some(true)],
@@ -3826,14 +3754,8 @@ mod tests {
assert_eq!(gt_eq(&array1, &array2).unwrap(), expected);
- let array1: Float64Array = vec![f64::NAN, 7.0, 8.0, 8.0, 11.0,
f64::NAN]
- .into_iter()
- .map(Some)
- .collect();
- let array2: Float64Array = vec![f64::NAN, f64::NAN, 8.0, 9.0, 10.0,
1.0]
- .into_iter()
- .map(Some)
- .collect();
+ let array1 = Float64Array::from(vec![f64::NAN, 7.0, 8.0, 8.0, 11.0,
f64::NAN]);
+ let array2 = Float64Array::from(vec![f64::NAN, f64::NAN, 8.0, 9.0,
10.0, 1.0]);
let expected = BooleanArray::from(
vec![Some(false), Some(false), Some(false), Some(false),
Some(true), Some(true)],
@@ -3852,10 +3774,7 @@ mod tests {
#[test]
fn test_eq_dyn_scalar_neq_dyn_scalar_float_nan() {
- let array: Float16Array = vec![f16::NAN, f16::from_f32(7.0),
f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(10.0)]
- .into_iter()
- .map(Some)
- .collect();
+ let array = Float16Array::from(vec![f16::NAN, f16::from_f32(7.0),
f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(10.0)]);
let expected = BooleanArray::from(
vec![Some(true), Some(false), Some(false), Some(false),
Some(false)],
@@ -3867,11 +3786,7 @@ mod tests {
);
assert_eq!(neq_dyn_scalar(&array, f32::NAN).unwrap(), expected);
- let array: Float32Array = vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]
- .into_iter()
- .map(Some)
- .collect();
-
+ let array = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]);
let expected = BooleanArray::from(
vec![Some(true), Some(false), Some(false), Some(false),
Some(false)],
);
@@ -3882,11 +3797,7 @@ mod tests {
);
assert_eq!(neq_dyn_scalar(&array, f32::NAN).unwrap(), expected);
- let array: Float64Array = vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]
- .into_iter()
- .map(Some)
- .collect();
-
+ let array = Float64Array::from(vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]);
let expected = BooleanArray::from(
vec![Some(true), Some(false), Some(false), Some(false),
Some(false)],
);
@@ -3900,10 +3811,7 @@ mod tests {
#[test]
fn test_lt_dyn_scalar_lt_eq_dyn_scalar_float_nan() {
- let array: Float16Array = vec![f16::NAN, f16::from_f32(7.0),
f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(10.0)]
- .into_iter()
- .map(Some)
- .collect();
+ let array = Float16Array::from(vec![f16::NAN, f16::from_f32(7.0),
f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(10.0)]);
let expected = BooleanArray::from(
vec![Some(false), Some(true), Some(true), Some(true), Some(true)],
@@ -3915,10 +3823,7 @@ mod tests {
);
assert_eq!(lt_eq_dyn_scalar(&array, f16::NAN).unwrap(), expected);
- let array: Float32Array = vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]
- .into_iter()
- .map(Some)
- .collect();
+ let array = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]);
let expected = BooleanArray::from(
vec![Some(false), Some(true), Some(true), Some(true), Some(true)],
@@ -3930,11 +3835,7 @@ mod tests {
);
assert_eq!(lt_eq_dyn_scalar(&array, f32::NAN).unwrap(), expected);
- let array: Float64Array = vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]
- .into_iter()
- .map(Some)
- .collect();
-
+ let array = Float64Array::from(vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]);
let expected = BooleanArray::from(
vec![Some(false), Some(true), Some(true), Some(true), Some(true)],
);
@@ -3948,10 +3849,13 @@ mod tests {
#[test]
fn test_gt_dyn_scalar_gt_eq_dyn_scalar_float_nan() {
- let array: Float16Array = vec![f16::NAN, f16::from_f32(7.0),
f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(10.0)]
- .into_iter()
- .map(Some)
- .collect();
+ let array = Float16Array::from(vec![
+ f16::NAN,
+ f16::from_f32(7.0),
+ f16::from_f32(8.0),
+ f16::from_f32(8.0),
+ f16::from_f32(10.0),
+ ]);
let expected = BooleanArray::from(
vec![Some(false), Some(false), Some(false), Some(false),
Some(false)],
);
@@ -3962,10 +3866,7 @@ mod tests {
);
assert_eq!(gt_eq_dyn_scalar(&array, f16::NAN).unwrap(), expected);
- let array: Float32Array = vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]
- .into_iter()
- .map(Some)
- .collect();
+ let array = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]);
let expected = BooleanArray::from(
vec![Some(false), Some(false), Some(false), Some(false),
Some(false)],
);
@@ -3976,10 +3877,7 @@ mod tests {
);
assert_eq!(gt_eq_dyn_scalar(&array, f32::NAN).unwrap(), expected);
- let array: Float64Array = vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]
- .into_iter()
- .map(Some)
- .collect();
+ let array = Float64Array::from(vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]);
let expected = BooleanArray::from(
vec![Some(false), Some(false), Some(false), Some(false),
Some(false)],
);
@@ -3993,8 +3891,8 @@ mod tests {
#[test]
fn test_eq_dyn_neq_dyn_dictionary_to_utf8_array() {
- let test1 = vec!["a", "a", "b", "c"];
- let test2 = vec!["a", "b", "b", "d"];
+ let test1 = ["a", "a", "b", "c"];
+ let test2 = ["a", "b", "b", "d"];
let dict_array: DictionaryArray<Int8Type> = test1
.iter()
@@ -4033,8 +3931,8 @@ mod tests {
#[test]
fn test_lt_dyn_lt_eq_dyn_gt_dyn_gt_eq_dyn_dictionary_to_utf8_array() {
- let test1 = vec!["abc", "abc", "b", "cde"];
- let test2 = vec!["abc", "b", "b", "def"];
+ let test1 = ["abc", "abc", "b", "cde"];
+ let test2 = ["abc", "b", "b", "def"];
let dict_array: DictionaryArray<Int8Type> = test1
.iter()
@@ -4380,7 +4278,7 @@ mod tests {
let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2]);
let dict_array = DictionaryArray::new(keys, Arc::new(values));
- let array: BooleanArray = test2.iter().collect();
+ let array = BooleanArray::from(test2);
let result = eq_dyn(&dict_array, &array);
assert_eq!(
@@ -4416,7 +4314,7 @@ mod tests {
let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2]);
let dict_array = DictionaryArray::new(keys, Arc::new(values));
- let array: BooleanArray = test2.iter().collect();
+ let array = BooleanArray::from(test2);
let result = lt_dyn(&dict_array, &array);
assert_eq!(
diff --git a/arrow-ord/src/partition.rs b/arrow-ord/src/partition.rs
index 0b8447989b..80b25ee2af 100644
--- a/arrow-ord/src/partition.rs
+++ b/arrow-ord/src/partition.rs
@@ -220,8 +220,10 @@ mod tests {
Arc::new(Int32Array::from(vec![1])) as _,
Arc::new(Int32Array::from(vec![1])) as _,
])
- .unwrap();
- assert_eq!(results.ranges(), &[0..1]);
+ .unwrap()
+ .ranges();
+ assert_eq!(results.len(), 1);
+ assert_eq!(results[0], 0..1);
}
#[test]
diff --git a/arrow-ord/src/sort.rs b/arrow-ord/src/sort.rs
index 8785863059..6c8c3b8fac 100644
--- a/arrow-ord/src/sort.rs
+++ b/arrow-ord/src/sort.rs
@@ -1661,22 +1661,26 @@ mod tests {
#[test]
fn test_sort_indices_decimal256() {
+ let data = vec![
+ None,
+ Some(i256::from_i128(5)),
+ Some(i256::from_i128(2)),
+ Some(i256::from_i128(3)),
+ Some(i256::from_i128(1)),
+ Some(i256::from_i128(4)),
+ None,
+ ];
+
// decimal default
test_sort_to_indices_decimal256_array(
- vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None]
- .iter()
- .map(|v| v.map(i256::from_i128))
- .collect(),
+ data.clone(),
None,
None,
vec![0, 6, 4, 2, 3, 5, 1],
);
// decimal descending
test_sort_to_indices_decimal256_array(
- vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None]
- .iter()
- .map(|v| v.map(i256::from_i128))
- .collect(),
+ data.clone(),
Some(SortOptions {
descending: true,
nulls_first: false,
@@ -1686,10 +1690,7 @@ mod tests {
);
// decimal null_first and descending
test_sort_to_indices_decimal256_array(
- vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None]
- .iter()
- .map(|v| v.map(i256::from_i128))
- .collect(),
+ data.clone(),
Some(SortOptions {
descending: true,
nulls_first: true,
@@ -1699,10 +1700,7 @@ mod tests {
);
// decimal null_first
test_sort_to_indices_decimal256_array(
- vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None]
- .iter()
- .map(|v| v.map(i256::from_i128))
- .collect(),
+ data.clone(),
Some(SortOptions {
descending: false,
nulls_first: true,
@@ -1711,21 +1709,10 @@ mod tests {
vec![0, 6, 4, 2, 3, 5, 1],
);
// limit
- test_sort_to_indices_decimal256_array(
- vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None]
- .iter()
- .map(|v| v.map(i256::from_i128))
- .collect(),
- None,
- Some(3),
- vec![0, 6, 4],
- );
+ test_sort_to_indices_decimal256_array(data.clone(), None, Some(3),
vec![0, 6, 4]);
// limit descending
test_sort_to_indices_decimal256_array(
- vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None]
- .iter()
- .map(|v| v.map(i256::from_i128))
- .collect(),
+ data.clone(),
Some(SortOptions {
descending: true,
nulls_first: false,
@@ -1735,10 +1722,7 @@ mod tests {
);
// limit descending null_first
test_sort_to_indices_decimal256_array(
- vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None]
- .iter()
- .map(|v| v.map(i256::from_i128))
- .collect(),
+ data.clone(),
Some(SortOptions {
descending: true,
nulls_first: true,
@@ -1748,10 +1732,7 @@ mod tests {
);
// limit null_first
test_sort_to_indices_decimal256_array(
- vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None]
- .iter()
- .map(|v| v.map(i256::from_i128))
- .collect(),
+ data,
Some(SortOptions {
descending: false,
nulls_first: true,
@@ -1763,14 +1744,15 @@ mod tests {
#[test]
fn test_sort_indices_decimal256_max_min() {
+ let data = vec![
+ None,
+ Some(i256::MIN),
+ Some(i256::from_i128(1)),
+ Some(i256::MAX),
+ Some(i256::from_i128(-1)),
+ ];
test_sort_to_indices_decimal256_array(
- vec![
- None,
- Some(i256::MIN),
- Some(i256::from_i128(1)),
- Some(i256::MAX),
- Some(i256::from_i128(-1)),
- ],
+ data.clone(),
Some(SortOptions {
descending: false,
nulls_first: true,
@@ -1780,13 +1762,7 @@ mod tests {
);
test_sort_to_indices_decimal256_array(
- vec![
- None,
- Some(i256::MIN),
- Some(i256::from_i128(1)),
- Some(i256::MAX),
- Some(i256::from_i128(-1)),
- ],
+ data.clone(),
Some(SortOptions {
descending: true,
nulls_first: true,
@@ -1796,13 +1772,7 @@ mod tests {
);
test_sort_to_indices_decimal256_array(
- vec![
- None,
- Some(i256::MIN),
- Some(i256::from_i128(1)),
- Some(i256::MAX),
- Some(i256::from_i128(-1)),
- ],
+ data.clone(),
Some(SortOptions {
descending: false,
nulls_first: true,
@@ -1812,13 +1782,7 @@ mod tests {
);
test_sort_to_indices_decimal256_array(
- vec![
- None,
- Some(i256::MIN),
- Some(i256::from_i128(1)),
- Some(i256::MAX),
- Some(i256::from_i128(-1)),
- ],
+ data.clone(),
Some(SortOptions {
descending: true,
nulls_first: true,
@@ -1908,124 +1872,109 @@ mod tests {
#[test]
fn test_sort_decimal256() {
+ let data = vec![
+ None,
+ Some(i256::from_i128(5)),
+ Some(i256::from_i128(2)),
+ Some(i256::from_i128(3)),
+ Some(i256::from_i128(1)),
+ Some(i256::from_i128(4)),
+ None,
+ ];
// decimal default
test_sort_decimal256_array(
- vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None]
- .iter()
- .map(|v| v.map(i256::from_i128))
- .collect(),
+ data.clone(),
None,
None,
- vec![None, None, Some(1), Some(2), Some(3), Some(4), Some(5)]
+ [None, None, Some(1), Some(2), Some(3), Some(4), Some(5)]
.iter()
.map(|v| v.map(i256::from_i128))
.collect(),
);
// decimal descending
test_sort_decimal256_array(
- vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None]
- .iter()
- .map(|v| v.map(i256::from_i128))
- .collect(),
+ data.clone(),
Some(SortOptions {
descending: true,
nulls_first: false,
}),
None,
- vec![Some(5), Some(4), Some(3), Some(2), Some(1), None, None]
+ [Some(5), Some(4), Some(3), Some(2), Some(1), None, None]
.iter()
.map(|v| v.map(i256::from_i128))
.collect(),
);
// decimal null_first and descending
test_sort_decimal256_array(
- vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None]
- .iter()
- .map(|v| v.map(i256::from_i128))
- .collect(),
+ data.clone(),
Some(SortOptions {
descending: true,
nulls_first: true,
}),
None,
- vec![None, None, Some(5), Some(4), Some(3), Some(2), Some(1)]
+ [None, None, Some(5), Some(4), Some(3), Some(2), Some(1)]
.iter()
.map(|v| v.map(i256::from_i128))
.collect(),
);
// decimal null_first
test_sort_decimal256_array(
- vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None]
- .iter()
- .map(|v| v.map(i256::from_i128))
- .collect(),
+ data.clone(),
Some(SortOptions {
descending: false,
nulls_first: true,
}),
None,
- vec![None, None, Some(1), Some(2), Some(3), Some(4), Some(5)]
+ [None, None, Some(1), Some(2), Some(3), Some(4), Some(5)]
.iter()
.map(|v| v.map(i256::from_i128))
.collect(),
);
// limit
test_sort_decimal256_array(
- vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None]
- .iter()
- .map(|v| v.map(i256::from_i128))
- .collect(),
+ data.clone(),
None,
Some(3),
- vec![None, None, Some(1)]
+ [None, None, Some(1)]
.iter()
.map(|v| v.map(i256::from_i128))
.collect(),
);
// limit descending
test_sort_decimal256_array(
- vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None]
- .iter()
- .map(|v| v.map(i256::from_i128))
- .collect(),
+ data.clone(),
Some(SortOptions {
descending: true,
nulls_first: false,
}),
Some(3),
- vec![Some(5), Some(4), Some(3)]
+ [Some(5), Some(4), Some(3)]
.iter()
.map(|v| v.map(i256::from_i128))
.collect(),
);
// limit descending null_first
test_sort_decimal256_array(
- vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None]
- .iter()
- .map(|v| v.map(i256::from_i128))
- .collect(),
+ data.clone(),
Some(SortOptions {
descending: true,
nulls_first: true,
}),
Some(3),
- vec![None, None, Some(5)]
+ [None, None, Some(5)]
.iter()
.map(|v| v.map(i256::from_i128))
.collect(),
);
// limit null_first
test_sort_decimal256_array(
- vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None]
- .iter()
- .map(|v| v.map(i256::from_i128))
- .collect(),
+ data,
Some(SortOptions {
descending: false,
nulls_first: true,
}),
Some(3),
- vec![None, None, Some(1)]
+ [None, None, Some(1)]
.iter()
.map(|v| v.map(i256::from_i128))
.collect(),
diff --git a/arrow-row/src/interner.rs b/arrow-row/src/interner.rs
index fde9251952..9f5f0b3d33 100644
--- a/arrow-row/src/interner.rs
+++ b/arrow-row/src/interner.rs
@@ -417,7 +417,7 @@ mod tests {
#[test]
fn test_intern_duplicates() {
// Unsorted with duplicates
- let values = vec![0_u8, 1, 8, 4, 1, 0];
+ let values = [0_u8, 1, 8, 4, 1, 0];
let mut interner = OrderPreservingInterner::default();
let interned =
interner.intern(values.iter().map(std::slice::from_ref).map(Some));
diff --git a/arrow-select/src/concat.rs b/arrow-select/src/concat.rs
index 31846ee1fd..eed20699c2 100644
--- a/arrow-select/src/concat.rs
+++ b/arrow-select/src/concat.rs
@@ -338,10 +338,7 @@ mod tests {
let array_result = concat(&[&list1_array, &list2_array,
&list3_array]).unwrap();
- let expected = list1
- .into_iter()
- .chain(list2.into_iter())
- .chain(list3.into_iter());
+ let expected = list1.into_iter().chain(list2).chain(list3);
let array_expected = ListArray::from_iter_primitive::<Int64Type, _,
_>(expected);
assert_eq!(array_result.as_ref(), &array_expected as &dyn Array);
diff --git a/arrow-select/src/filter.rs b/arrow-select/src/filter.rs
index f2da79e243..1afb8197ba 100644
--- a/arrow-select/src/filter.rs
+++ b/arrow-select/src/filter.rs
@@ -868,7 +868,7 @@ mod tests {
#[test]
fn test_filter_dictionary_array() {
- let values = vec![Some("hello"), None, Some("world"), Some("!")];
+ let values = [Some("hello"), None, Some("world"), Some("!")];
let a: Int8DictionaryArray = values.iter().copied().collect();
let b = BooleanArray::from(vec![false, true, true, false]);
let c = filter(&a, &b).unwrap();
diff --git a/arrow-string/src/length.rs b/arrow-string/src/length.rs
index 25d6414ec8..fb47f70af3 100644
--- a/arrow-string/src/length.rs
+++ b/arrow-string/src/length.rs
@@ -16,6 +16,7 @@
// under the License.
//! Defines kernel for length of string arrays and binary arrays
+#![allow(clippy::redundant_closure_call)]
use arrow_array::*;
use arrow_array::{cast::AsArray, types::*};
diff --git a/arrow-string/src/like.rs b/arrow-string/src/like.rs
index 9d3abea66f..57cc22f2c5 100644
--- a/arrow-string/src/like.rs
+++ b/arrow-string/src/like.rs
@@ -736,15 +736,11 @@ mod tests {
($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr)
=> {
#[test]
fn $test_name() {
+ let expected = BooleanArray::from($expected);
let left = StringArray::from($left);
let right = StringArray::from($right);
let res = $op(&left, &right).unwrap();
- let expected = $expected;
- assert_eq!(expected.len(), res.len());
- for i in 0..res.len() {
- let v = res.value(i);
- assert_eq!(v, expected[i]);
- }
+ assert_eq!(res, expected);
}
};
}
@@ -754,15 +750,11 @@ mod tests {
#[test]
#[cfg(feature = "dyn_cmp_dict")]
fn $test_name() {
+ let expected = BooleanArray::from($expected);
let left: DictionaryArray<Int8Type> =
$left.into_iter().collect();
let right: DictionaryArray<Int8Type> =
$right.into_iter().collect();
let res = $op(&left, &right).unwrap();
- let expected = $expected;
- assert_eq!(expected.len(), res.len());
- for i in 0..res.len() {
- let v = res.value(i);
- assert_eq!(v, expected[i]);
- }
+ assert_eq!(res, expected);
}
};
}
@@ -771,37 +763,15 @@ mod tests {
($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr)
=> {
#[test]
fn $test_name() {
+ let expected = BooleanArray::from($expected);
+
let left = StringArray::from($left);
let res = $op(&left, $right).unwrap();
- let expected = $expected;
- assert_eq!(expected.len(), res.len());
- for i in 0..res.len() {
- let v = res.value(i);
- assert_eq!(
- v,
- expected[i],
- "unexpected result when comparing {} at position {} to
{} ",
- left.value(i),
- i,
- $right
- );
- }
+ assert_eq!(res, expected);
let left = LargeStringArray::from($left);
let res = $op(&left, $right).unwrap();
- let expected = $expected;
- assert_eq!(expected.len(), res.len());
- for i in 0..res.len() {
- let v = res.value(i);
- assert_eq!(
- v,
- expected[i],
- "unexpected result when comparing {} at position {} to
{} ",
- left.value(i),
- i,
- $right
- );
- }
+ assert_eq!(res, expected);
}
};
($test_name:ident, $test_name_dyn:ident, $left:expr, $right:expr,
$op:expr, $op_dyn:expr, $expected:expr) => {
@@ -953,7 +923,7 @@ mod tests {
test_utf8!(
test_utf8_scalar_ilike_regex,
vec!["%%%"],
- vec![r#"\%_\%"#],
+ vec![r"\%_\%"],
ilike_utf8,
vec![true]
);
@@ -961,7 +931,7 @@ mod tests {
test_dict_utf8!(
test_utf8_scalar_ilike_regex_dict,
vec!["%%%"],
- vec![r#"\%_\%"#],
+ vec![r"\%_\%"],
ilike_dyn,
vec![true]
);
diff --git a/arrow-string/src/regexp.rs b/arrow-string/src/regexp.rs
index e28564bdae..af4d66f97f 100644
--- a/arrow-string/src/regexp.rs
+++ b/arrow-string/src/regexp.rs
@@ -398,7 +398,7 @@ mod tests {
vec!["arrow", "arrow", "arrow", "arrow", "arrow", "arrow"],
vec!["^ar", "^AR", "ow$", "OW$", "foo", ""],
regexp_is_match_utf8,
- vec![true, false, true, false, false, true]
+ [true, false, true, false, false, true]
);
test_flag_utf8!(
test_utf8_array_regexp_is_match_insensitive,
@@ -406,7 +406,7 @@ mod tests {
vec!["^ar", "^AR", "ow$", "OW$", "foo", ""],
vec!["i"; 6],
regexp_is_match_utf8,
- vec![true, true, true, true, false, true]
+ [true, true, true, true, false, true]
);
test_flag_utf8_scalar!(
@@ -414,14 +414,14 @@ mod tests {
vec!["arrow", "ARROW", "parquet", "PARQUET"],
"^ar",
regexp_is_match_utf8_scalar,
- vec![true, false, false, false]
+ [true, false, false, false]
);
test_flag_utf8_scalar!(
test_utf8_array_regexp_is_match_empty_scalar,
vec!["arrow", "ARROW", "parquet", "PARQUET"],
"",
regexp_is_match_utf8_scalar,
- vec![true, true, true, true]
+ [true, true, true, true]
);
test_flag_utf8_scalar!(
test_utf8_array_regexp_is_match_insensitive_scalar,
@@ -429,6 +429,6 @@ mod tests {
"^ar",
"i",
regexp_is_match_utf8_scalar,
- vec![true, true, false, false]
+ [true, true, false, false]
);
}
diff --git a/arrow/tests/array_equal.rs b/arrow/tests/array_equal.rs
index 4abe31a36c..317287c102 100644
--- a/arrow/tests/array_equal.rs
+++ b/arrow/tests/array_equal.rs
@@ -399,7 +399,7 @@ fn test_empty_offsets_list_equal() {
true,
))))
.len(0)
- .add_buffer(Buffer::from(vec![0i32, 2, 3, 4, 6, 7, 8].to_byte_slice()))
+ .add_buffer(Buffer::from([0i32, 2, 3, 4, 6, 7, 8].to_byte_slice()))
.add_child_data(Int32Array::from(vec![1, 2, -1, -2, 3, 4, -3,
-4]).into_data())
.null_bit_buffer(Some(Buffer::from(vec![0b00001001])))
.build()
@@ -437,7 +437,7 @@ fn test_list_null() {
true,
))))
.len(6)
- .add_buffer(Buffer::from(vec![0i32, 2, 3, 4, 6, 7, 8].to_byte_slice()))
+ .add_buffer(Buffer::from([0i32, 2, 3, 4, 6, 7, 8].to_byte_slice()))
.add_child_data(c_values.into_data())
.null_bit_buffer(Some(Buffer::from(vec![0b00001001])))
.build()
@@ -460,7 +460,7 @@ fn test_list_null() {
true,
))))
.len(6)
- .add_buffer(Buffer::from(vec![0i32, 2, 3, 4, 6, 7, 8].to_byte_slice()))
+ .add_buffer(Buffer::from([0i32, 2, 3, 4, 6, 7, 8].to_byte_slice()))
.add_child_data(d_values.into_data())
.null_bit_buffer(Some(Buffer::from(vec![0b00001001])))
.build()
diff --git a/object_store/src/memory.rs b/object_store/src/memory.rs
index 1e8e3c1fd0..0e229885b0 100644
--- a/object_store/src/memory.rs
+++ b/object_store/src/memory.rs
@@ -393,7 +393,7 @@ impl AsyncWrite for InMemoryAppend {
if let Some((bytes, _)) = writer.remove(&self.location) {
let buf = std::mem::take(&mut self.data);
- let concat =
Bytes::from_iter(bytes.into_iter().chain(buf.into_iter()));
+ let concat = Bytes::from_iter(bytes.into_iter().chain(buf));
writer.insert(self.location.clone(), (concat, Utc::now()));
} else {
writer.insert(
diff --git a/object_store/src/util.rs b/object_store/src/util.rs
index 79ca4bb7a8..07d3ed44ca 100644
--- a/object_store/src/util.rs
+++ b/object_store/src/util.rs
@@ -207,7 +207,7 @@ mod tests {
let fetches = do_fetch(vec![], 0).await;
assert!(fetches.is_empty());
- let fetches = do_fetch(vec![0..3], 0).await;
+ let fetches = do_fetch(vec![0..3; 1], 0).await;
assert_eq!(fetches, vec![0..3]);
let fetches = do_fetch(vec![0..2, 3..5], 0).await;
diff --git a/parquet/src/arrow/array_reader/byte_array.rs
b/parquet/src/arrow/array_reader/byte_array.rs
index 43db658d93..4612f81614 100644
--- a/parquet/src/arrow/array_reader/byte_array.rs
+++ b/parquet/src/arrow/array_reader/byte_array.rs
@@ -636,7 +636,7 @@ mod tests {
assert_eq!(decoder.read(&mut output, 4..8).unwrap(), 0);
- let valid = vec![false, false, true, true, false, true, true,
false, false];
+ let valid = [false, false, true, true, false, true, true, false,
false];
let valid_buffer = Buffer::from_iter(valid.iter().cloned());
output.pad_nulls(0, 4, valid.len(), valid_buffer.as_slice());
@@ -690,7 +690,7 @@ mod tests {
assert_eq!(decoder.read(&mut output, 4..8).unwrap(), 0);
- let valid = vec![false, false, true, true, false, false];
+ let valid = [false, false, true, true, false, false];
let valid_buffer = Buffer::from_iter(valid.iter().cloned());
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 763a6ccee2..841f5a95fd 100644
--- a/parquet/src/arrow/array_reader/byte_array_dictionary.rs
+++ b/parquet/src/arrow/array_reader/byte_array_dictionary.rs
@@ -510,7 +510,7 @@ mod tests {
assert_eq!(decoder.read(&mut output, 4..5).unwrap(), 1);
assert_eq!(decoder.skip_values(4).unwrap(), 0);
- let valid = vec![true, true, true, true, true];
+ let valid = [true, true, true, true, true];
let valid_buffer = Buffer::from_iter(valid.iter().cloned());
output.pad_nulls(0, 5, 5, valid_buffer.as_slice());
diff --git a/parquet/src/arrow/arrow_writer/mod.rs
b/parquet/src/arrow/arrow_writer/mod.rs
index c4d174b6ad..5417ebe894 100644
--- a/parquet/src/arrow/arrow_writer/mod.rs
+++ b/parquet/src/arrow/arrow_writer/mod.rs
@@ -859,7 +859,7 @@ mod tests {
let expected_batch =
RecordBatch::try_new(schema.clone(), vec![Arc::new(a),
Arc::new(b)]).unwrap();
- for buffer in vec![
+ for buffer in [
get_bytes_after_close(schema.clone(), &expected_batch),
get_bytes_by_into_inner(schema, &expected_batch),
] {
@@ -2158,7 +2158,7 @@ mod tests {
#[test]
fn u32_min_max() {
// check values roundtrip through parquet
- let src = vec![
+ let src = [
u32::MIN,
u32::MIN + 1,
(i32::MAX as u32) - 1,
@@ -2199,7 +2199,7 @@ mod tests {
#[test]
fn u64_min_max() {
// check values roundtrip through parquet
- let src = vec![
+ let src = [
u64::MIN,
u64::MIN + 1,
(i64::MAX as u64) - 1,
diff --git a/parquet/src/arrow/buffer/bit_util.rs
b/parquet/src/arrow/buffer/bit_util.rs
index 2781190331..d01556d24e 100644
--- a/parquet/src/arrow/buffer/bit_util.rs
+++ b/parquet/src/arrow/buffer/bit_util.rs
@@ -35,7 +35,7 @@ pub fn iter_set_bits_rev(bytes: &[u8]) -> impl Iterator<Item
= usize> + '_ {
.prefix()
.into_iter()
.chain(unaligned.chunks().iter().cloned())
- .chain(unaligned.suffix().into_iter());
+ .chain(unaligned.suffix());
iter.rev().flat_map(move |mut chunk| {
let chunk_idx = chunk_end_idx - 64;
diff --git a/parquet/src/arrow/buffer/offset_buffer.rs
b/parquet/src/arrow/buffer/offset_buffer.rs
index c8732bc4ed..07d78e8a32 100644
--- a/parquet/src/arrow/buffer/offset_buffer.rs
+++ b/parquet/src/arrow/buffer/offset_buffer.rs
@@ -281,10 +281,10 @@ mod tests {
buffer.try_push(v.as_bytes(), false).unwrap()
}
- let valid = vec![
+ let valid = [
true, false, false, true, false, true, false, true, true, false,
false,
];
- let valid_mask = Buffer::from_iter(valid.iter().cloned());
+ let valid_mask = Buffer::from_iter(valid.iter().copied());
// Both trailing and leading nulls
buffer.pad_nulls(1, values.len() - 1, valid.len() - 1,
valid_mask.as_slice());
diff --git a/parquet/src/column/writer/mod.rs b/parquet/src/column/writer/mod.rs
index 3d8ce283ae..8c1c554099 100644
--- a/parquet/src/column/writer/mod.rs
+++ b/parquet/src/column/writer/mod.rs
@@ -2108,10 +2108,10 @@ mod tests {
#[test]
fn test_byte_array_statistics() {
- let input = vec!["aawaa", "zz", "aaw", "m", "qrs"]
+ let input = ["aawaa", "zz", "aaw", "m", "qrs"]
.iter()
.map(|&s| s.into())
- .collect::<Vec<ByteArray>>();
+ .collect::<Vec<_>>();
let stats = statistics_roundtrip::<ByteArrayType>(&input);
assert!(!stats.is_min_max_backwards_compatible());
@@ -2126,13 +2126,10 @@ mod tests {
#[test]
fn test_fixed_len_byte_array_statistics() {
- let input = vec!["aawaa", "zz ", "aaw ", "m ", "qrs "]
+ let input = ["aawaa", "zz ", "aaw ", "m ", "qrs "]
.iter()
- .map(|&s| {
- let b: ByteArray = s.into();
- b.into()
- })
- .collect::<Vec<FixedLenByteArray>>();
+ .map(|&s| ByteArray::from(s).into())
+ .collect::<Vec<_>>();
let stats = statistics_roundtrip::<FixedLenByteArrayType>(&input);
assert!(stats.has_min_max_set());
diff --git a/parquet/src/encodings/decoding.rs
b/parquet/src/encodings/decoding.rs
index 8058335875..7aed6df419 100644
--- a/parquet/src/encodings/decoding.rs
+++ b/parquet/src/encodings/decoding.rs
@@ -1128,9 +1128,9 @@ mod tests {
#[test]
fn test_plain_decode_int32() {
- let data = vec![42, 18, 52];
+ let data = [42, 18, 52];
let data_bytes = Int32Type::to_byte_array(&data[..]);
- let mut buffer = vec![0; 3];
+ let mut buffer = [0; 3];
test_plain_decode::<Int32Type>(
ByteBufferPtr::new(data_bytes),
3,
@@ -1142,7 +1142,7 @@ mod tests {
#[test]
fn test_plain_skip_int32() {
- let data = vec![42, 18, 52];
+ let data = [42, 18, 52];
let data_bytes = Int32Type::to_byte_array(&data[..]);
test_plain_skip::<Int32Type>(
ByteBufferPtr::new(data_bytes),
@@ -1155,7 +1155,7 @@ mod tests {
#[test]
fn test_plain_skip_all_int32() {
- let data = vec![42, 18, 52];
+ let data = [42, 18, 52];
let data_bytes = Int32Type::to_byte_array(&data[..]);
test_plain_skip::<Int32Type>(ByteBufferPtr::new(data_bytes), 3, 5, -1,
&[]);
}
@@ -1165,7 +1165,7 @@ mod tests {
let data = [42, 18, 52];
let expected_data = [0, 42, 0, 18, 0, 0, 52, 0];
let data_bytes = Int32Type::to_byte_array(&data[..]);
- let mut buffer = vec![0; 8];
+ let mut buffer = [0; 8];
let num_nulls = 5;
let valid_bits = [0b01001010];
test_plain_decode_spaced::<Int32Type>(
@@ -1181,9 +1181,9 @@ mod tests {
#[test]
fn test_plain_decode_int64() {
- let data = vec![42, 18, 52];
+ let data = [42, 18, 52];
let data_bytes = Int64Type::to_byte_array(&data[..]);
- let mut buffer = vec![0; 3];
+ let mut buffer = [0; 3];
test_plain_decode::<Int64Type>(
ByteBufferPtr::new(data_bytes),
3,
@@ -1195,7 +1195,7 @@ mod tests {
#[test]
fn test_plain_skip_int64() {
- let data = vec![42, 18, 52];
+ let data = [42, 18, 52];
let data_bytes = Int64Type::to_byte_array(&data[..]);
test_plain_skip::<Int64Type>(
ByteBufferPtr::new(data_bytes),
@@ -1208,16 +1208,16 @@ mod tests {
#[test]
fn test_plain_skip_all_int64() {
- let data = vec![42, 18, 52];
+ let data = [42, 18, 52];
let data_bytes = Int64Type::to_byte_array(&data[..]);
test_plain_skip::<Int64Type>(ByteBufferPtr::new(data_bytes), 3, 3, -1,
&[]);
}
#[test]
fn test_plain_decode_float() {
- let data = vec![PI_f32, 2.414, 12.51];
+ let data = [PI_f32, 2.414, 12.51];
let data_bytes = FloatType::to_byte_array(&data[..]);
- let mut buffer = vec![0.0; 3];
+ let mut buffer = [0.0; 3];
test_plain_decode::<FloatType>(
ByteBufferPtr::new(data_bytes),
3,
@@ -1229,7 +1229,7 @@ mod tests {
#[test]
fn test_plain_skip_float() {
- let data = vec![PI_f32, 2.414, 12.51];
+ let data = [PI_f32, 2.414, 12.51];
let data_bytes = FloatType::to_byte_array(&data[..]);
test_plain_skip::<FloatType>(
ByteBufferPtr::new(data_bytes),
@@ -1242,14 +1242,14 @@ mod tests {
#[test]
fn test_plain_skip_all_float() {
- let data = vec![PI_f32, 2.414, 12.51];
+ let data = [PI_f32, 2.414, 12.51];
let data_bytes = FloatType::to_byte_array(&data[..]);
test_plain_skip::<FloatType>(ByteBufferPtr::new(data_bytes), 3, 4, -1,
&[]);
}
#[test]
fn test_plain_skip_double() {
- let data = vec![PI_f64, 2.414f64, 12.51f64];
+ let data = [PI_f64, 2.414f64, 12.51f64];
let data_bytes = DoubleType::to_byte_array(&data[..]);
test_plain_skip::<DoubleType>(
ByteBufferPtr::new(data_bytes),
@@ -1262,16 +1262,16 @@ mod tests {
#[test]
fn test_plain_skip_all_double() {
- let data = vec![PI_f64, 2.414f64, 12.51f64];
+ let data = [PI_f64, 2.414f64, 12.51f64];
let data_bytes = DoubleType::to_byte_array(&data[..]);
test_plain_skip::<DoubleType>(ByteBufferPtr::new(data_bytes), 3, 5,
-1, &[]);
}
#[test]
fn test_plain_decode_double() {
- let data = vec![PI_f64, 2.414f64, 12.51f64];
+ let data = [PI_f64, 2.414f64, 12.51f64];
let data_bytes = DoubleType::to_byte_array(&data[..]);
- let mut buffer = vec![0.0f64; 3];
+ let mut buffer = [0.0f64; 3];
test_plain_decode::<DoubleType>(
ByteBufferPtr::new(data_bytes),
3,
@@ -1283,13 +1283,13 @@ mod tests {
#[test]
fn test_plain_decode_int96() {
- let mut data = vec![Int96::new(); 4];
+ let mut data = [Int96::new(); 4];
data[0].set_data(11, 22, 33);
data[1].set_data(44, 55, 66);
data[2].set_data(10, 20, 30);
data[3].set_data(40, 50, 60);
let data_bytes = Int96Type::to_byte_array(&data[..]);
- let mut buffer = vec![Int96::new(); 4];
+ let mut buffer = [Int96::new(); 4];
test_plain_decode::<Int96Type>(
ByteBufferPtr::new(data_bytes),
4,
@@ -1301,7 +1301,7 @@ mod tests {
#[test]
fn test_plain_skip_int96() {
- let mut data = vec![Int96::new(); 4];
+ let mut data = [Int96::new(); 4];
data[0].set_data(11, 22, 33);
data[1].set_data(44, 55, 66);
data[2].set_data(10, 20, 30);
@@ -1318,7 +1318,7 @@ mod tests {
#[test]
fn test_plain_skip_all_int96() {
- let mut data = vec![Int96::new(); 4];
+ let mut data = [Int96::new(); 4];
data[0].set_data(11, 22, 33);
data[1].set_data(44, 55, 66);
data[2].set_data(10, 20, 30);
@@ -1329,11 +1329,11 @@ mod tests {
#[test]
fn test_plain_decode_bool() {
- let data = vec![
+ let data = [
false, true, false, false, true, false, true, true, false, true,
];
let data_bytes = BoolType::to_byte_array(&data[..]);
- let mut buffer = vec![false; 10];
+ let mut buffer = [false; 10];
test_plain_decode::<BoolType>(
ByteBufferPtr::new(data_bytes),
10,
@@ -1345,7 +1345,7 @@ mod tests {
#[test]
fn test_plain_skip_bool() {
- let data = vec![
+ let data = [
false, true, false, false, true, false, true, true, false, true,
];
let data_bytes = BoolType::to_byte_array(&data[..]);
@@ -1360,7 +1360,7 @@ mod tests {
#[test]
fn test_plain_skip_all_bool() {
- let data = vec![
+ let data = [
false, true, false, false, true, false, true, true, false, true,
];
let data_bytes = BoolType::to_byte_array(&data[..]);
diff --git a/parquet/src/file/serialized_reader.rs
b/parquet/src/file/serialized_reader.rs
index 8eccf3408a..4924dcc6f3 100644
--- a/parquet/src/file/serialized_reader.rs
+++ b/parquet/src/file/serialized_reader.rs
@@ -851,38 +851,23 @@ mod tests {
#[test]
fn test_file_reader_into_iter() {
let path = get_test_path("alltypes_plain.parquet");
- let vec = vec![path.clone(), path]
- .iter()
- .map(|p| SerializedFileReader::try_from(p.as_path()).unwrap())
- .flat_map(|r| r.into_iter())
- .flat_map(|r| r.unwrap().get_int(0))
- .collect::<Vec<_>>();
-
- // rows in the parquet file are not sorted by "id"
- // each file contains [id:4, id:5, id:6, id:7, id:2, id:3, id:0, id:1]
- assert_eq!(vec, vec![4, 5, 6, 7, 2, 3, 0, 1, 4, 5, 6, 7, 2, 3, 0, 1]);
+ let reader = SerializedFileReader::try_from(path.as_path()).unwrap();
+ let iter = reader.into_iter();
+ let values: Vec<_> = iter.flat_map(|x|
x.unwrap().get_int(0)).collect();
+
+ assert_eq!(values, &[4, 5, 6, 7, 2, 3, 0, 1]);
}
#[test]
fn test_file_reader_into_iter_project() {
let path = get_test_path("alltypes_plain.parquet");
- let result = vec![path]
- .iter()
- .map(|p| SerializedFileReader::try_from(p.as_path()).unwrap())
- .flat_map(|r| {
- let schema = "message schema { OPTIONAL INT32 id; }";
- let proj = parse_message_type(schema).ok();
-
- r.into_iter().project(proj).unwrap()
- })
- .map(|r| format!("{}", r.unwrap()))
- .collect::<Vec<_>>()
- .join(",");
+ let reader = SerializedFileReader::try_from(path.as_path()).unwrap();
+ let schema = "message schema { OPTIONAL INT32 id; }";
+ let proj = parse_message_type(schema).ok();
+ let iter = reader.into_iter().project(proj).unwrap();
+ let values: Vec<_> = iter.flat_map(|x|
x.unwrap().get_int(0)).collect();
- assert_eq!(
- result,
- "{id: 4},{id: 5},{id: 6},{id: 7},{id: 2},{id: 3},{id: 0},{id: 1}"
- );
+ assert_eq!(values, &[4, 5, 6, 7, 2, 3, 0, 1]);
}
#[test]
diff --git a/parquet/src/record/reader.rs b/parquet/src/record/reader.rs
index 5a1d840657..1069eab15f 100644
--- a/parquet/src/record/reader.rs
+++ b/parquet/src/record/reader.rs
@@ -828,7 +828,7 @@ mod tests {
use crate::errors::Result;
use crate::file::reader::{FileReader, SerializedFileReader};
- use crate::record::api::{Field, Row, RowAccessor, RowFormatter};
+ use crate::record::api::{Field, Row, RowAccessor};
use crate::schema::parser::parse_message_type;
use crate::util::test_common::file_util::{get_test_file, get_test_path};
use std::convert::TryFrom;
@@ -1500,33 +1500,26 @@ mod tests {
#[test]
fn test_file_reader_iter() {
let path = get_test_path("alltypes_plain.parquet");
- let vec = vec![path]
- .iter()
- .map(|p| SerializedFileReader::try_from(p.as_path()).unwrap())
- .flat_map(|r| RowIter::from_file_into(Box::new(r)))
- .flat_map(|r| r.unwrap().get_int(0))
- .collect::<Vec<_>>();
-
- assert_eq!(vec, vec![4, 5, 6, 7, 2, 3, 0, 1]);
+ let reader = SerializedFileReader::try_from(path.as_path()).unwrap();
+ let iter = RowIter::from_file_into(Box::new(reader));
+
+ let values: Vec<_> = iter.flat_map(|r|
r.unwrap().get_int(0)).collect();
+ assert_eq!(values, &[4, 5, 6, 7, 2, 3, 0, 1]);
}
#[test]
fn test_file_reader_iter_projection() {
let path = get_test_path("alltypes_plain.parquet");
- let values = vec![path]
- .iter()
- .map(|p| SerializedFileReader::try_from(p.as_path()).unwrap())
- .flat_map(|r| {
- let schema = "message schema { OPTIONAL INT32 id; }";
- let proj = parse_message_type(schema).ok();
-
- RowIter::from_file_into(Box::new(r)).project(proj).unwrap()
- })
- .map(|r| format!("id:{}", r.unwrap().fmt(0)))
- .collect::<Vec<_>>()
- .join(", ");
-
- assert_eq!(values, "id:4, id:5, id:6, id:7, id:2, id:3, id:0, id:1");
+ let reader = SerializedFileReader::try_from(path.as_path()).unwrap();
+ let schema = "message schema { OPTIONAL INT32 id; }";
+ let proj = parse_message_type(schema).ok();
+
+ let iter = RowIter::from_file_into(Box::new(reader))
+ .project(proj)
+ .unwrap();
+ let values: Vec<_> = iter.flat_map(|r|
r.unwrap().get_int(0)).collect();
+
+ assert_eq!(values, &[4, 5, 6, 7, 2, 3, 0, 1]);
}
#[test]
diff --git a/parquet/src/schema/types.rs b/parquet/src/schema/types.rs
index f0e1a7f27a..f4cb3a9956 100644
--- a/parquet/src/schema/types.rs
+++ b/parquet/src/schema/types.rs
@@ -1652,8 +1652,8 @@ mod tests {
// required int64 item1 2 1
// optional boolean item2 3 1
// repeated int32 item3 3 2
- let ex_max_def_levels = vec![0, 1, 1, 2, 3, 3];
- let ex_max_rep_levels = vec![0, 0, 1, 1, 1, 2];
+ let ex_max_def_levels = [0, 1, 1, 2, 3, 3];
+ let ex_max_rep_levels = [0, 0, 1, 1, 1, 2];
for i in 0..nleaves {
let col = descr.column(i);
