cargo fmt

src/array/utf8/ffi.rs

@@ -33,6 +33,8 @@ impl<O: Offset, A: ffi::ArrowArrayRef> FromFfi<A> for Utf8Array<O> {
             validity = validity.map(|x| x.slice(offset, length))
         }
         let data_type = Self::default_data_type();
-        Ok(Self::from_data_unchecked(data_type, offsets, values, validity))
+        Ok(Self::from_data_unchecked(
+            data_type, offsets, values, validity,
+        ))
     }
 }

src/io/parquet/read/mod.rs

@@ -1,5 +1,9 @@
 //! APIs to read from Parquet format.
-use std::{convert::TryInto, io::{Read, Seek}, sync::Arc};
+use std::{
+    convert::TryInto,
+    io::{Read, Seek},
+    sync::Arc,
+};
 
 use futures::{AsyncRead, AsyncSeek, Stream};
 pub use parquet2::{
@@ -18,7 +22,11 @@ pub use parquet2::{
     types::int96_to_i64_ns,
 };
 
-use crate::{array::{Array, DictionaryKey, PrimitiveArray}, datatypes::{DataType, IntervalUnit, TimeUnit}, error::{ArrowError, Result}};
+use crate::{
+    array::{Array, DictionaryKey, PrimitiveArray},
+    datatypes::{DataType, IntervalUnit, TimeUnit},
+    error::{ArrowError, Result},
+};
 
 mod binary;
 mod boolean;
@@ -205,45 +213,47 @@ pub fn page_iter_to_array<
             iter, data_type, metadata,
         )?)),
         Decimal(_, _) => match metadata.descriptor().type_() {
-            ParquetType::PrimitiveType { physical_type, ..} => match physical_type{
-                PhysicalType::Int32 => primitive::iter_to_array(
-                    iter,
-                    metadata,
-                    data_type,
-                    |x: i32| x as i128,
-                ),
-                PhysicalType::Int64 => primitive::iter_to_array(
-                    iter,
-                    metadata,
-                    data_type,
-                    |x: i64| x as i128,
-                ),
+            ParquetType::PrimitiveType { physical_type, .. } => match physical_type {
+                PhysicalType::Int32 => {
+                    primitive::iter_to_array(iter, metadata, data_type, |x: i32| x as i128)
+                }
+                PhysicalType::Int64 => {
+                    primitive::iter_to_array(iter, metadata, data_type, |x: i64| x as i128)
+                }
                 PhysicalType::FixedLenByteArray(n) => {
                     if *n > 16 {
                         Err(ArrowError::NotYetImplemented(format!(
                             "Can't decode Decimal128 type from Fixed Size Byte Array of len {:?}",
                             n
                         )))
                     } else {
-                        let paddings = (0..(16-*n)).map(|_| 0u8).collect::<Vec<_>>();
-                        fixed_size_binary::iter_to_array(iter, DataType::FixedSizeBinary(*n), metadata)
-                        .map(|e|{
-                            let a = e.into_iter().map(|v| 
-                                    v.and_then(|v1| {
-                                        [&paddings, v1].concat().try_into().map(
-                                            |pad16| i128::from_be_bytes(pad16)
-                                        ).ok()   
-                                    }
-                                )
-                            ).collect::<Vec<_>>();
-                            Box::new(PrimitiveArray::<i128>::from(a).to(data_type)) as Box<dyn Array>
-                        }
+                        let paddings = (0..(16 - *n)).map(|_| 0u8).collect::<Vec<_>>();
+                        fixed_size_binary::iter_to_array(
+                            iter,
+                            DataType::FixedSizeBinary(*n),
+                            metadata,
                         )
+                        .map(|e| {
+                            let a = e
+                                .into_iter()
+                                .map(|v| {
+                                    v.and_then(|v1| {
+                                        [&paddings, v1]
+                                            .concat()
+                                            .try_into()
+                                            .map(|pad16| i128::from_be_bytes(pad16))
+                                            .ok()
+                                    })
+                                })
+                                .collect::<Vec<_>>();
+                            Box::new(PrimitiveArray::<i128>::from(a).to(data_type))
+                                as Box<dyn Array>
+                        })
                     }
-                },
-                _ => unreachable!()
+                }
+                _ => unreachable!(),
             },
-            _ => unreachable!()
+            _ => unreachable!(),
         },
         List(ref inner) => match inner.data_type() {
             UInt8 => primitive::iter_to_array_nested(iter, metadata, data_type, |x: i32| x as u8),

src/io/parquet/read/schema/convert.rs

@@ -167,7 +167,7 @@ pub fn from_int64(
             ParquetTimeUnit::MICROS(_) => DataType::Time64(TimeUnit::Microsecond),
             ParquetTimeUnit::NANOS(_) => DataType::Time64(TimeUnit::Nanosecond),
         },
-        (Some(PrimitiveConvertedType::Decimal(precision,scale)), _) => {
+        (Some(PrimitiveConvertedType::Decimal(precision, scale)), _) => {
             DataType::Decimal(*precision as usize, *scale as usize)
         }
         (c, l) => {

src/io/parquet/write/fixed_len_bytes.rs

@@ -3,7 +3,7 @@ use parquet2::{
     encoding::Encoding,
     metadata::ColumnDescriptor,
     page::CompressedDataPage,
-    statistics::{serialize_statistics, deserialize_statistics, ParquetStatistics},
+    statistics::{deserialize_statistics, serialize_statistics, ParquetStatistics},
     write::WriteOptions,
 };
 
@@ -98,7 +98,7 @@ pub(super) fn build_statistics(
             .min_by(|x, y| ord_binary(x, y))
             .map(|x| x.to_vec()),
     };
-    deserialize_statistics(pq_statistics,descriptor).map(
-        |e| serialize_statistics(&*e)
-    ).ok()
+    deserialize_statistics(pq_statistics, descriptor)
+        .map(|e| serialize_statistics(&*e))
+        .ok()
 }

src/scalar/primitive.rs

@@ -1,7 +1,7 @@
 use crate::{
     datatypes::DataType,
-    types::{NativeType, NaturalDataType},
     error::ArrowError,
+    types::{NativeType, NaturalDataType},
 };
 
 use super::Scalar;