clippy fixes

Author: etseidl

parquet/benches/metadata.rs

@@ -15,6 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#[cfg(feature = "arrow")]
+use parquet::file::metadata::ParquetMetaData;
 use parquet::file::metadata::ParquetMetaDataReader;
 use rand::Rng;
 use thrift::protocol::TCompactOutputProtocol;
@@ -164,7 +166,7 @@ fn get_footer_bytes(data: Bytes) -> Bytes {
 }
 
 #[cfg(feature = "arrow")]
-fn rewrite_file(bytes: Bytes) -> (Bytes, FileMetaData) {
+fn rewrite_file(bytes: Bytes) -> (Bytes, ParquetMetaData) {
     use arrow::array::RecordBatchReader;
     use parquet::arrow::{arrow_reader::ParquetRecordBatchReaderBuilder, ArrowWriter};
     use parquet::file::properties::{EnabledStatistics, WriterProperties};
@@ -242,40 +244,36 @@ fn criterion_benchmark(c: &mut Criterion) {
     #[cfg(feature = "arrow")]
     c.bench_function("page headers", |b| {
         b.iter(|| {
-            metadata.row_groups.iter().for_each(|rg| {
-                rg.columns.iter().for_each(|col| {
-                    if let Some(col_meta) = &col.meta_data {
-                        if let Some(dict_offset) = col_meta.dictionary_page_offset {
-                            parquet::thrift::bench_page_header(
-                                &file_bytes.slice(dict_offset as usize..),
-                            );
-                        }
+            for rg in metadata.row_groups() {
+                for col in rg.columns() {
+                    if let Some(dict_offset) = col.dictionary_page_offset() {
                         parquet::thrift::bench_page_header(
-                            &file_bytes.slice(col_meta.data_page_offset as usize..),
+                            &file_bytes.slice(dict_offset as usize..),
                         );
                     }
-                });
-            });
+                    parquet::thrift::bench_page_header(
+                        &file_bytes.slice(col.data_page_offset() as usize..),
+                    );
+                }
+            }
         })
     });
 
     #[cfg(feature = "arrow")]
     c.bench_function("page headers (no stats)", |b| {
         b.iter(|| {
-            metadata.row_groups.iter().for_each(|rg| {
-                rg.columns.iter().for_each(|col| {
-                    if let Some(col_meta) = &col.meta_data {
-                        if let Some(dict_offset) = col_meta.dictionary_page_offset {
-                            parquet::thrift::bench_page_header_no_stats(
-                                &file_bytes.slice(dict_offset as usize..),
-                            );
-                        }
+            for rg in metadata.row_groups() {
+                for col in rg.columns() {
+                    if let Some(dict_offset) = col.dictionary_page_offset() {
                         parquet::thrift::bench_page_header_no_stats(
-                            &file_bytes.slice(col_meta.data_page_offset as usize..),
+                            &file_bytes.slice(dict_offset as usize..),
                         );
                     }
-                });
-            });
+                    parquet::thrift::bench_page_header_no_stats(
+                        &file_bytes.slice(col.data_page_offset() as usize..),
+                    );
+                }
+            }
         })
     });
 }

parquet/src/file/metadata/thrift_gen.rs

@@ -1444,7 +1444,7 @@ impl WriteThrift for ColumnChunkMetaData {
         // only write the ColumnMetaData if we haven't already encrypted it
         if self.encrypted_column_metadata.is_none() {
             writer.write_field_begin(FieldType::Struct, 3, last_field_id)?;
-            serialize_column_meta_data(&self, writer)?;
+            serialize_column_meta_data(self, writer)?;
             last_field_id = 3;
         }
 
@@ -1488,7 +1488,7 @@ impl WriteThrift for ColumnChunkMetaData {
 
         // always write the ColumnMetaData
         writer.write_field_begin(FieldType::Struct, 3, last_field_id)?;
-        serialize_column_meta_data(&self, writer)?;
+        serialize_column_meta_data(self, writer)?;
         last_field_id = 3;
 
         if let Some(offset_idx_off) = self.offset_index_offset() {

parquet/src/file/metadata/writer.rs

@@ -433,8 +433,9 @@ impl<'a, W: Write> ParquetMetaDataWriter<'a, W> {
     fn convert_column_indexes(&self) -> Option<Vec<Vec<Option<ColumnIndexMetaData>>>> {
         // FIXME(ets): we're converting from ParquetColumnIndex to vec<vec<option>>,
         // but then converting back to ParquetColumnIndex in the end. need to unify this.
-        if let Some(row_group_column_indexes) = self.metadata.column_index() {
-            Some(
+        self.metadata
+            .column_index()
+            .map(|row_group_column_indexes| {
                 (0..self.metadata.row_groups().len())
                     .map(|rg_idx| {
                         let column_indexes = &row_group_column_indexes[rg_idx];
@@ -443,16 +444,14 @@ impl<'a, W: Write> ParquetMetaDataWriter<'a, W> {
                             .map(|column_index| Some(column_index.clone()))
                             .collect()
                     })
-                    .collect(),
-            )
-        } else {
-            None
-        }
+                    .collect()
+            })
     }
 
     fn convert_offset_index(&self) -> Option<Vec<Vec<Option<OffsetIndexMetaData>>>> {
-        if let Some(row_group_offset_indexes) = self.metadata.offset_index() {
-            Some(
+        self.metadata
+            .offset_index()
+            .map(|row_group_offset_indexes| {
                 (0..self.metadata.row_groups().len())
                     .map(|rg_idx| {
                         let offset_indexes = &row_group_offset_indexes[rg_idx];
@@ -461,11 +460,8 @@ impl<'a, W: Write> ParquetMetaDataWriter<'a, W> {
                             .map(|offset_index| Some(offset_index.clone()))
                             .collect()
                     })
-                    .collect(),
-            )
-        } else {
-            None
-        }
+                    .collect()
+            })
     }
 }
 

parquet/src/file/writer.rs

@@ -2098,7 +2098,7 @@ mod tests {
             unenc_size,
             meta_data.unencoded_byte_array_data_bytes().unwrap()
         );
-        check_def_hist(&meta_data.definition_level_histogram().unwrap().values());
+        check_def_hist(meta_data.definition_level_histogram().unwrap().values());
 
         // check that the read metadata is also correct
         let options = ReadOptionsBuilder::new().with_page_index().build();

parquet/src/schema/types.rs

@@ -1125,13 +1125,10 @@ pub(crate) fn num_nodes(tp: &TypePtr) -> usize {
 
 pub(crate) fn count_nodes(tp: &TypePtr, n_nodes: &mut usize) {
     *n_nodes += 1;
-    match tp.as_ref() {
-        Type::GroupType { ref fields, .. } => {
-            for f in fields {
-                count_nodes(f, n_nodes);
-            }
+    if let Type::GroupType { ref fields, .. } = tp.as_ref() {
+        for f in fields {
+            count_nodes(f, n_nodes);
         }
-        _ => (),
     }
 }