majic format

Author: alamb

parquet/src/arrow/schema/complex.rs

@@ -18,14 +18,14 @@
 use std::collections::HashMap;
 use std::sync::Arc;
 
+use crate::arrow::schema::extension::add_extension_type;
 use crate::arrow::schema::primitive::convert_primitive;
 use crate::arrow::{ProjectionMask, PARQUET_FIELD_ID_META_KEY};
 use crate::basic::{ConvertedType, Repetition};
 use crate::errors::ParquetError;
 use crate::errors::Result;
 use crate::schema::types::{SchemaDescriptor, Type, TypePtr};
 use arrow_schema::{DataType, Field, Fields, SchemaBuilder};
-use crate::arrow::schema::extension::{add_extension_type};
 
 fn get_repetition(t: &Type) -> Repetition {
     let info = t.get_basic_info();
@@ -545,7 +545,11 @@ impl Visitor {
 ///
 /// The resulting Arrow [`Field`] will have the type dictated by the Parquet `field`, a name
 /// dictated by the `parquet_type`, and any metadata from `arrow_hint`
-fn convert_field(parquet_type: &Type, field: &mut ParquetField, arrow_hint: Option<&Field>) -> Field {
+fn convert_field(
+    parquet_type: &Type,
+    field: &mut ParquetField,
+    arrow_hint: Option<&Field>,
+) -> Field {
     let name = parquet_type.name();
     let data_type = field.arrow_type.clone();
     let nullable = field.nullable;

parquet/src/arrow/schema/extension.rs

@@ -23,10 +23,10 @@
 //! Extension types are represented using the metadata from Arrow [`Field`]s
 //! with the key "ARROW:extension:name".
 
-use arrow_schema::{Field};
-use arrow_schema::extension::ExtensionType;
 use crate::basic::LogicalType;
 use crate::schema::types::Type;
+use arrow_schema::extension::ExtensionType;
+use arrow_schema::Field;
 
 /// Adds extension type metadata, if necessary, based on the Parquet field's
 /// [`LogicalType`]
@@ -38,11 +38,10 @@ pub(crate) fn add_extension_type(arrow_field: Field, parquet_type: &Type) -> Fie
     let result = match parquet_type.get_basic_info().logical_type() {
         #[cfg(feature = "variant_experimental")]
         Some(LogicalType::Variant) => {
-            arrow_field
-                .with_extension_type(parquet_variant_compute::VariantType)
+            arrow_field.with_extension_type(parquet_variant_compute::VariantType)
         }
         // TODO add other LogicalTypes here
-        _ => arrow_field
+        _ => arrow_field,
     };
     result
 }
@@ -52,12 +51,12 @@ pub(crate) fn add_extension_type(arrow_field: Field, parquet_type: &Type) -> Fie
 pub(crate) fn logical_type_for_struct(field: &Field) -> Option<LogicalType> {
     use parquet_variant_compute::VariantType;
     if field.extension_type_name()? == VariantType::NAME {
-        return Some(LogicalType::Variant)
+        return Some(LogicalType::Variant);
     };
     None
 }
 
 #[cfg(not(feature = "variant_experimental"))]
 pub(crate) fn logical_type_for_struct(field: &Field) -> Option<LogicalType> {
     None
-}
+}

parquet/src/arrow/schema/mod.rs

@@ -35,13 +35,13 @@ use crate::file::{metadata::KeyValue, properties::WriterProperties};
 use crate::schema::types::{ColumnDescriptor, SchemaDescriptor, Type};
 
 mod complex;
-mod primitive;
 mod extension;
+mod primitive;
 
+use super::PARQUET_FIELD_ID_META_KEY;
+use crate::arrow::schema::extension::logical_type_for_struct;
 use crate::arrow::ProjectionMask;
 pub(crate) use complex::{ParquetField, ParquetFieldType};
-use crate::arrow::schema::extension::logical_type_for_struct;
-use super::PARQUET_FIELD_ID_META_KEY;
 
 /// Convert Parquet schema to Arrow schema including optional metadata
 ///