refactor: simplify CDC writer wiring and nest CdcOptions proto message

Follow-up tidy-ups to the parquet CDC options:

* Drop the chunk-size validation in the parquet writer path; the bounds are
  enforced downstream by parquet-rs, so the extra DataFusion-side checks (and
  their two unit tests) are redundant. Reference the `content_defined_chunking`
  fields directly instead of aliasing them.
* Nest the proto `CdcOptions` message inside `ParquetOptions`
  (`parquet_options::CdcOptions`), since it is a parquet write option. Field
  tags are unchanged, so the wire format is unaffected.
* Add `From` helpers in `datafusion-proto-common` for the config <-> proto
  `CdcOptions` mapping in both directions, replacing the inline field copies in
  the `ParquetOptions` conversions. The `datafusion-proto` `file_formats.rs`
  mapping stays inline (the orphan rule blocks a shared impl there) and only
  switches to the nested type path.

Regenerated prost/pbjson for proto-common and proto-models.

Author: kszucs

datafusion/common/src/file_options/parquet_writer.rs

@@ -250,23 +250,11 @@ impl ParquetOptions {
             builder = builder.set_encoding(parse_encoding_string(encoding)?);
         }
         if content_defined_chunking.enabled {
-            let cdc = content_defined_chunking;
-            if cdc.min_chunk_size == 0 {
-                return Err(DataFusionError::Configuration(
-                    "CDC min_chunk_size must be greater than 0".to_string(),
-                ));
-            }
-            if cdc.max_chunk_size <= cdc.min_chunk_size {
-                return Err(DataFusionError::Configuration(format!(
-                    "CDC max_chunk_size ({}) must be greater than min_chunk_size ({})",
-                    cdc.max_chunk_size, cdc.min_chunk_size
-                )));
-            }
             builder = builder.set_content_defined_chunking(Some(
                 parquet::file::properties::CdcOptions {
-                    min_chunk_size: cdc.min_chunk_size,
-                    max_chunk_size: cdc.max_chunk_size,
-                    norm_level: cdc.norm_level,
+                    min_chunk_size: content_defined_chunking.min_chunk_size,
+                    max_chunk_size: content_defined_chunking.max_chunk_size,
+                    norm_level: content_defined_chunking.norm_level,
                 },
             ));
         }
@@ -887,31 +875,6 @@ mod tests {
         assert_eq!(cdc.norm_level, -1);
     }
 
-    #[test]
-    fn test_cdc_validation_zero_min_chunk_size() {
-        let mut opts = TableParquetOptions::default();
-        opts.global.content_defined_chunking = CdcOptions {
-            enabled: true,
-            min_chunk_size: 0,
-            ..CdcOptions::default()
-        };
-        opts.arrow_schema(&Arc::new(Schema::empty()));
-        assert!(WriterPropertiesBuilder::try_from(&opts).is_err());
-    }
-
-    #[test]
-    fn test_cdc_validation_max_not_greater_than_min() {
-        let mut opts = TableParquetOptions::default();
-        opts.global.content_defined_chunking = CdcOptions {
-            enabled: true,
-            min_chunk_size: 512 * 1024,
-            max_chunk_size: 256 * 1024,
-            ..CdcOptions::default()
-        };
-        opts.arrow_schema(&Arc::new(Schema::empty()));
-        assert!(WriterPropertiesBuilder::try_from(&opts).is_err());
-    }
-
     #[test]
     fn test_bloom_filter_set_ndv_only() {
         // the TableParquetOptions::default, with only ndv set

datafusion/proto-common/proto/datafusion_common.proto

@@ -636,13 +636,15 @@ message ParquetOptions {
   oneof coerce_int96_tz_opt {
     string coerce_int96_tz = 36;
   }
-}
 
-message CdcOptions {
-  bool enabled = 1;
-  uint64 min_chunk_size = 2;
-  uint64 max_chunk_size = 3;
-  int32 norm_level = 4;
+  // 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;
+  }
 }
 
 enum JoinSide {

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

@@ -1130,16 +1130,22 @@ impl TryFrom<&protobuf::ParquetOptions> for ParquetOptions {
             max_predicate_cache_size: value.max_predicate_cache_size_opt.map(|opt| match opt {
                 protobuf::parquet_options::MaxPredicateCacheSizeOpt::MaxPredicateCacheSize(v) => Some(v as usize),
             }).unwrap_or(None),
-            content_defined_chunking: value.content_defined_chunking.map(|cdc| CdcOptions {
-                enabled: cdc.enabled,
-                min_chunk_size: cdc.min_chunk_size as usize,
-                max_chunk_size: cdc.max_chunk_size as usize,
-                norm_level: cdc.norm_level,
-            }).unwrap_or_default(),
+            content_defined_chunking: value.content_defined_chunking.map(CdcOptions::from).unwrap_or_default(),
         })
     }
 }
 
+impl From<protobuf::parquet_options::CdcOptions> for CdcOptions {
+    fn from(value: protobuf::parquet_options::CdcOptions) -> Self {
+        CdcOptions {
+            enabled: value.enabled,
+            min_chunk_size: value.min_chunk_size as usize,
+            max_chunk_size: value.max_chunk_size as usize,
+            norm_level: value.norm_level,
+        }
+    }
+}
+
 impl TryFrom<&protobuf::ParquetColumnOptions> for ParquetColumnOptions {
     type Error = DataFusionError;
     fn try_from(