Remove lint issues in parquet-related code. (#9375)

* CacheOptions: `use` in arrow/push_decoder/reader_builder/mod.rs was
  unused. But removing it triggers a doc complaint in array_reader.rs.
  I fix it by spelling out `CacheOptions` at one usage site.

* ExtensionType import was unused in arrow/schema/extension.rs when
  compiling with default features. Only `use` it inside the
  feature-guarded code paths.

* Prefix unused function arguments with `_`.

* Some code in parquet/tests/arrow_reader/io/mod.rs is unused. As I lack
  knowledge of the context, I just add just add #[allow(dead_code)].
# Rationale for this change

rust-analyzer bugs me about those unused symbols & co.

---------

Co-authored-by: Jeffrey Vo <jeffrey.vo.australia@gmail.com>
Co-authored-by: Andrew Lamb <andrew@nerdnetworks.org>

Author: 3 people

parquet/Cargo.toml

@@ -233,7 +233,7 @@ harness = false
 
 [[bench]]
 name = "arrow_reader_clickbench"
-required-features = ["arrow", "async"]
+required-features = ["arrow", "async", "object_store"]
 harness = false
 
 [[bench]]

parquet/src/arrow/push_decoder/reader_builder/mod.rs

@@ -20,7 +20,7 @@ mod filter;
 
 use crate::DecodeResult;
 use crate::arrow::ProjectionMask;
-use crate::arrow::array_reader::{ArrayReaderBuilder, RowGroupCache};
+use crate::arrow::array_reader::{ArrayReaderBuilder, CacheOptions, RowGroupCache};
 use crate::arrow::arrow_reader::metrics::ArrowReaderMetrics;
 use crate::arrow::arrow_reader::selection::RowSelectionStrategy;
 use crate::arrow::arrow_reader::{
@@ -604,7 +604,7 @@ impl RowGroupReaderBuilder {
                 let array_reader_builder = ArrayReaderBuilder::new(&row_group, &self.metrics)
                     .with_parquet_metadata(&self.metadata);
                 let array_reader = if let Some(cache_info) = cache_info.as_ref() {
-                    let cache_options = cache_info.builder().consumer();
+                    let cache_options: CacheOptions = cache_info.builder().consumer();
                     array_reader_builder
                         .with_cache_options(Some(&cache_options))
                         .build_array_reader(self.fields.as_deref(), &self.projection)

parquet/src/arrow/schema/extension.rs

@@ -22,12 +22,16 @@
 //!
 //! Extension types are represented using the metadata from Arrow [`Field`]s
 //! with the key "ARROW:extension:name".
+//!
+//! Extension types are represented using the metadata from Arrow [`Field`]s
+//! with the key "ARROW:extension:name".
+//!
+//! [`ExtensionType`]: arrow_schema::extension::ExtensionType
 
 use crate::basic::LogicalType;
 use crate::errors::ParquetError;
 use crate::schema::types::Type;
 use arrow_schema::Field;
-use arrow_schema::extension::ExtensionType;
 
 /// Adds extension type metadata, if necessary, based on the Parquet field's
 /// [`LogicalType`]
@@ -36,39 +40,48 @@ use arrow_schema::extension::ExtensionType;
 /// Arrow DataType, and instead are represented by an Arrow ExtensionType.
 /// Extension types are attached to Arrow Fields via metadata.
 pub(crate) fn try_add_extension_type(
-    mut arrow_field: Field,
+    arrow_field: Field,
     parquet_type: &Type,
 ) -> Result<Field, ParquetError> {
     let Some(parquet_logical_type) = parquet_type.get_basic_info().logical_type_ref() else {
         return Ok(arrow_field);
     };
-    match parquet_logical_type {
+    Ok(match parquet_logical_type {
         #[cfg(feature = "variant_experimental")]
         LogicalType::Variant { .. } => {
+            let mut arrow_field = arrow_field;
             arrow_field.try_with_extension_type(parquet_variant_compute::VariantType)?;
+            arrow_field
         }
         #[cfg(feature = "arrow_canonical_extension_types")]
         LogicalType::Uuid => {
+            let mut arrow_field = arrow_field;
             arrow_field.try_with_extension_type(arrow_schema::extension::Uuid)?;
+            arrow_field
         }
         #[cfg(feature = "arrow_canonical_extension_types")]
         LogicalType::Json => {
+            let mut arrow_field = arrow_field;
             arrow_field.try_with_extension_type(arrow_schema::extension::Json::default())?;
+            arrow_field
         }
         #[cfg(feature = "geospatial")]
         LogicalType::Geometry { crs } => {
             let md = parquet_geospatial::WkbMetadata::new(crs.as_deref(), None);
+            let mut arrow_field = arrow_field;
             arrow_field.try_with_extension_type(parquet_geospatial::WkbType::new(Some(md)))?;
+            arrow_field
         }
         #[cfg(feature = "geospatial")]
         LogicalType::Geography { crs, algorithm } => {
             let algorithm = algorithm.map(|a| a.try_as_edges()).transpose()?;
             let md = parquet_geospatial::WkbMetadata::new(crs.as_deref(), algorithm);
+            let mut arrow_field = arrow_field;
             arrow_field.try_with_extension_type(parquet_geospatial::WkbType::new(Some(md)))?;
+            arrow_field
         }
-        _ => {}
-    };
-    Ok(arrow_field)
+        _ => arrow_field,
+    })
 }
 
 /// Returns true if [`try_add_extension_type`] would add an extension type
@@ -97,6 +110,7 @@ pub(crate) fn has_extension_type(parquet_type: &Type) -> bool {
 /// Return the Parquet logical type to use for the specified Arrow Struct field, if any.
 #[cfg(feature = "variant_experimental")]
 pub(crate) fn logical_type_for_struct(field: &Field) -> Option<LogicalType> {
+    use arrow_schema::extension::ExtensionType;
     use parquet_variant_compute::VariantType;
     // Check the name (= quick and cheap) and only try_extension_type if the name matches
     // to avoid unnecessary String allocations in ArrowError
@@ -151,6 +165,7 @@ pub(crate) fn logical_type_for_string(_field: &Field) -> Option<LogicalType> {
 
 #[cfg(feature = "geospatial")]
 pub(crate) fn logical_type_for_binary(field: &Field) -> Option<LogicalType> {
+    use arrow_schema::extension::ExtensionType;
     use parquet_geospatial::WkbType;
     use parquet_geospatial::WkbTypeHint;
 
@@ -172,7 +187,7 @@ pub(crate) fn logical_type_for_binary(field: &Field) -> Option<LogicalType> {
 }
 
 #[cfg(not(feature = "geospatial"))]
-pub(crate) fn logical_type_for_binary(field: &Field) -> Option<LogicalType> {
+pub(crate) fn logical_type_for_binary(_field: &Field) -> Option<LogicalType> {
     None
 }
 
@@ -182,6 +197,6 @@ pub(crate) fn logical_type_for_binary_view(field: &Field) -> Option<LogicalType>
 }
 
 #[cfg(not(feature = "geospatial"))]
-pub(crate) fn logical_type_for_binary_view(field: &Field) -> Option<LogicalType> {
+pub(crate) fn logical_type_for_binary_view(_field: &Field) -> Option<LogicalType> {
     None
 }

parquet/tests/arrow_reader/io/mod.rs

@@ -244,6 +244,7 @@ struct TestParquetFile {
     /// The operation log for IO operations performed on this file
     ops: Arc<OperationLog>,
     /// The (pre-parsed) parquet metadata for this file
+    #[cfg(feature = "async")]
     parquet_metadata: Arc<ParquetMetaData>,
 }
 
@@ -288,6 +289,7 @@ impl TestParquetFile {
         TestParquetFile {
             bytes,
             ops,
+            #[cfg(feature = "async")]
             parquet_metadata,
         }
     }
@@ -302,7 +304,7 @@ impl TestParquetFile {
         &self.ops
     }
 
-    /// Return the parquet metadata for this file
+    #[cfg(feature = "async")]
     fn parquet_metadata(&self) -> &Arc<ParquetMetaData> {
         &self.parquet_metadata
     }
@@ -477,10 +479,12 @@ enum LogEntry {
     /// Read the metadata of the parquet file
     ReadMetadata(Range<usize>),
     /// Access previously parsed metadata
+    #[allow(dead_code)]
     GetProvidedMetadata,
     /// Read a single logical data object
     ReadData(ReadInfo),
     /// Read one or more logical data objects in a single operation
+    #[allow(dead_code)]
     ReadMultipleData(Vec<LogEntry>),
     /// Not known where the read came from
     Unknown(Range<usize>),
@@ -572,6 +576,7 @@ impl OperationLog {
     /// accessed by the specified range
     ///
     /// It behaves the same as [`add_entry_for_range`] but for multiple ranges.
+    #[cfg(feature = "async")]
     fn add_entry_for_ranges<'a>(&self, ranges: impl IntoIterator<Item = &'a Range<usize>>) {
         let entries = ranges
             .into_iter()