refactor: un-nest proto CDC message as top-level ParquetCdcOptions

Replace the nested `ParquetOptions.CdcOptions` proto message with a top-level
`ParquetCdcOptions` message, matching the config type name. The explicit name
carries the parquet context, so nesting is no longer needed, and config <->
proto names line up. Defined after `ParquetOptions` as the original standalone
message was.

Field tags are unchanged (message tags 1-4, parent field 35), so the wire
format is unaffected. Regenerated prost/pbjson for proto-common and
proto-models and updated the `From` mappings to the top-level type.

Author: kszucs

datafusion/proto-common/proto/datafusion_common.proto

@@ -627,7 +627,7 @@ message ParquetOptions {
     uint64 max_predicate_cache_size = 33;
   }
 
-  CdcOptions content_defined_chunking = 35;
+  ParquetCdcOptions content_defined_chunking = 35;
 
   // Optional timezone applied to INT96-coerced timestamps when `coerce_int96`
   // is set. When `Some`, INT96 columns coerce to
@@ -636,15 +636,14 @@ message ParquetOptions {
   oneof coerce_int96_tz_opt {
     string coerce_int96_tz = 36;
   }
+}
 
-  // Content-defined chunking (CDC) options. Nested here as it is a parquet
-  // write option.
-  message CdcOptions {
-    bool enabled = 1;
-    uint64 min_chunk_size = 2;
-    uint64 max_chunk_size = 3;
-    int32 norm_level = 4;
-  }
+// Content-defined chunking (CDC) options for writing parquet files.
+message ParquetCdcOptions {
+  bool enabled = 1;
+  uint64 min_chunk_size = 2;
+  uint64 max_chunk_size = 3;
+  int32 norm_level = 4;
 }
 
 enum JoinSide {

datafusion/proto-common/src/from_proto/mod.rs

@@ -1135,8 +1135,8 @@ impl TryFrom<&protobuf::ParquetOptions> for ParquetOptions {
     }
 }
 
-impl From<protobuf::parquet_options::CdcOptions> for ParquetCdcOptions {
-    fn from(value: protobuf::parquet_options::CdcOptions) -> Self {
+impl From<protobuf::ParquetCdcOptions> for ParquetCdcOptions {
+    fn from(value: protobuf::ParquetCdcOptions) -> Self {
         ParquetCdcOptions {
             enabled: value.enabled,
             min_chunk_size: value.min_chunk_size as usize,

datafusion/proto-common/src/generated/pbjson.rs

@@ -5758,6 +5758,161 @@ impl<'de> serde::Deserialize<'de> for NullEquality {
         deserializer.deserialize_any(GeneratedVisitor)
     }
 }
+impl serde::Serialize for ParquetCdcOptions {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.enabled {
+            len += 1;
+        }
+        if self.min_chunk_size != 0 {
+            len += 1;
+        }
+        if self.max_chunk_size != 0 {
+            len += 1;
+        }
+        if self.norm_level != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion_common.ParquetCdcOptions", len)?;
+        if self.enabled {
+            struct_ser.serialize_field("enabled", &self.enabled)?;
+        }
+        if self.min_chunk_size != 0 {
+            #[allow(clippy::needless_borrow)]
+            #[allow(clippy::needless_borrows_for_generic_args)]
+            struct_ser.serialize_field("minChunkSize", ToString::to_string(&self.min_chunk_size).as_str())?;
+        }
+        if self.max_chunk_size != 0 {
+            #[allow(clippy::needless_borrow)]
+            #[allow(clippy::needless_borrows_for_generic_args)]
+            struct_ser.serialize_field("maxChunkSize", ToString::to_string(&self.max_chunk_size).as_str())?;
+        }
+        if self.norm_level != 0 {
+            struct_ser.serialize_field("normLevel", &self.norm_level)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ParquetCdcOptions {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "enabled",
+            "min_chunk_size",
+            "minChunkSize",
+            "max_chunk_size",
+            "maxChunkSize",
+            "norm_level",
+            "normLevel",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Enabled,
+            MinChunkSize,
+            MaxChunkSize,
+            NormLevel,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl serde::de::Visitor<'_> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "enabled" => Ok(GeneratedField::Enabled),
+                            "minChunkSize" | "min_chunk_size" => Ok(GeneratedField::MinChunkSize),
+                            "maxChunkSize" | "max_chunk_size" => Ok(GeneratedField::MaxChunkSize),
+                            "normLevel" | "norm_level" => Ok(GeneratedField::NormLevel),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ParquetCdcOptions;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion_common.ParquetCdcOptions")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ParquetCdcOptions, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut enabled__ = None;
+                let mut min_chunk_size__ = None;
+                let mut max_chunk_size__ = None;
+                let mut norm_level__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Enabled => {
+                            if enabled__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("enabled"));
+                            }
+                            enabled__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::MinChunkSize => {
+                            if min_chunk_size__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("minChunkSize"));
+                            }
+                            min_chunk_size__ = 
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::MaxChunkSize => {
+                            if max_chunk_size__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("maxChunkSize"));
+                            }
+                            max_chunk_size__ = 
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::NormLevel => {
+                            if norm_level__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("normLevel"));
+                            }
+                            norm_level__ = 
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(ParquetCdcOptions {
+                    enabled: enabled__.unwrap_or_default(),
+                    min_chunk_size: min_chunk_size__.unwrap_or_default(),
+                    max_chunk_size: max_chunk_size__.unwrap_or_default(),
+                    norm_level: norm_level__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion_common.ParquetCdcOptions", FIELDS, GeneratedVisitor)
+    }
+}
 impl serde::Serialize for ParquetColumnOptions {
     #[allow(deprecated)]
     fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
@@ -6955,161 +7110,6 @@ impl<'de> serde::Deserialize<'de> for ParquetOptions {
         deserializer.deserialize_struct("datafusion_common.ParquetOptions", FIELDS, GeneratedVisitor)
     }
 }
-impl serde::Serialize for parquet_options::CdcOptions {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.enabled {
-            len += 1;
-        }
-        if self.min_chunk_size != 0 {
-            len += 1;
-        }
-        if self.max_chunk_size != 0 {
-            len += 1;
-        }
-        if self.norm_level != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion_common.ParquetOptions.CdcOptions", len)?;
-        if self.enabled {
-            struct_ser.serialize_field("enabled", &self.enabled)?;
-        }
-        if self.min_chunk_size != 0 {
-            #[allow(clippy::needless_borrow)]
-            #[allow(clippy::needless_borrows_for_generic_args)]
-            struct_ser.serialize_field("minChunkSize", ToString::to_string(&self.min_chunk_size).as_str())?;
-        }
-        if self.max_chunk_size != 0 {
-            #[allow(clippy::needless_borrow)]
-            #[allow(clippy::needless_borrows_for_generic_args)]
-            struct_ser.serialize_field("maxChunkSize", ToString::to_string(&self.max_chunk_size).as_str())?;
-        }
-        if self.norm_level != 0 {
-            struct_ser.serialize_field("normLevel", &self.norm_level)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for parquet_options::CdcOptions {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "enabled",
-            "min_chunk_size",
-            "minChunkSize",
-            "max_chunk_size",
-            "maxChunkSize",
-            "norm_level",
-            "normLevel",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Enabled,
-            MinChunkSize,
-            MaxChunkSize,
-            NormLevel,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl serde::de::Visitor<'_> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "enabled" => Ok(GeneratedField::Enabled),
-                            "minChunkSize" | "min_chunk_size" => Ok(GeneratedField::MinChunkSize),
-                            "maxChunkSize" | "max_chunk_size" => Ok(GeneratedField::MaxChunkSize),
-                            "normLevel" | "norm_level" => Ok(GeneratedField::NormLevel),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = parquet_options::CdcOptions;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion_common.ParquetOptions.CdcOptions")
-            }
-
-            fn visit_map<V>(self, mut map_: V) -> std::result::Result<parquet_options::CdcOptions, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut enabled__ = None;
-                let mut min_chunk_size__ = None;
-                let mut max_chunk_size__ = None;
-                let mut norm_level__ = None;
-                while let Some(k) = map_.next_key()? {
-                    match k {
-                        GeneratedField::Enabled => {
-                            if enabled__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("enabled"));
-                            }
-                            enabled__ = Some(map_.next_value()?);
-                        }
-                        GeneratedField::MinChunkSize => {
-                            if min_chunk_size__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("minChunkSize"));
-                            }
-                            min_chunk_size__ = 
-                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::MaxChunkSize => {
-                            if max_chunk_size__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("maxChunkSize"));
-                            }
-                            max_chunk_size__ = 
-                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::NormLevel => {
-                            if norm_level__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("normLevel"));
-                            }
-                            norm_level__ = 
-                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(parquet_options::CdcOptions {
-                    enabled: enabled__.unwrap_or_default(),
-                    min_chunk_size: min_chunk_size__.unwrap_or_default(),
-                    max_chunk_size: max_chunk_size__.unwrap_or_default(),
-                    norm_level: norm_level__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion_common.ParquetOptions.CdcOptions", FIELDS, GeneratedVisitor)
-    }
-}
 impl serde::Serialize for Precision {
     #[allow(deprecated)]
     fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>