refactor: rename config CdcOptions to ParquetCdcOptions

Rename the DataFusion config struct `CdcOptions` to `ParquetCdcOptions` for
explicitness and consistency with the other parquet sub-option structs
(`ParquetColumnOptions`, `ParquetEncryptionOptions`), and to disambiguate from
the unrelated "change data capture" meaning of CDC.

Only the config type is renamed; parquet-rs's `CdcOptions` and the proto
`parquet_options::CdcOptions` message keep their names (the latter already
carries the parquet context via the module path).

Author: kszucs

datafusion/common/src/config.rs

@@ -713,11 +713,11 @@ config_namespace! {
     /// Options for content-defined chunking (CDC) when writing parquet files.
     /// Mirrors `parquet::file::properties::CdcOptions`.
     ///
-    /// Carried as a [`CdcOptions`] in [`ParquetOptions::content_defined_chunking`]
+    /// Carried as a [`ParquetCdcOptions`] in [`ParquetOptions::content_defined_chunking`]
     /// with an explicit `enabled` flag, so it can be toggled with dotted config
     /// keys (`content_defined_chunking.enabled = true|false`) and the result is
     /// independent of the order in which the keys are set.
-    pub struct CdcOptions {
+    pub struct ParquetCdcOptions {
         /// (writing) EXPERIMENTAL: Enable content-defined chunking (CDC) when writing
         /// parquet files. When enabled, parallel writing is automatically disabled
         /// since the chunker state must persist across row groups.
@@ -737,20 +737,20 @@ config_namespace! {
     }
 }
 
-impl CdcOptions {
+impl ParquetCdcOptions {
     /// Returns enabled CDC options with the default chunking parameters.
     ///
-    /// Shorthand for `CdcOptions { enabled: true, ..Default::default() }`; combine
-    /// with struct-update syntax to override parameters, e.g.
-    /// `CdcOptions { min_chunk_size: 4096, ..CdcOptions::enabled() }`.
+    /// Shorthand for `ParquetCdcOptions { enabled: true, ..Default::default() }`;
+    /// combine with struct-update syntax to override parameters, e.g.
+    /// `ParquetCdcOptions { min_chunk_size: 4096, ..ParquetCdcOptions::enabled() }`.
     pub fn enabled() -> Self {
         Self {
             enabled: true,
             ..Default::default()
         }
     }
 
-    /// Returns disabled CDC options (equivalent to [`CdcOptions::default`]).
+    /// Returns disabled CDC options (equivalent to [`ParquetCdcOptions::default`]).
     pub fn disabled() -> Self {
         Self::default()
     }
@@ -959,7 +959,7 @@ config_namespace! {
         /// enabled, parallel writing is automatically disabled since the chunker state
         /// must persist across row groups. Mirrors
         /// `parquet::file::properties::WriterProperties::content_defined_chunking`.
-        pub content_defined_chunking: CdcOptions, default = Default::default()
+        pub content_defined_chunking: ParquetCdcOptions, default = Default::default()
     }
 }
 

datafusion/common/src/file_options/parquet_writer.rs

@@ -21,7 +21,7 @@ use std::sync::Arc;
 
 use crate::{
     _internal_datafusion_err, DataFusionError, Result,
-    config::{CdcOptions, ParquetOptions, TableParquetOptions},
+    config::{ParquetCdcOptions, ParquetOptions, TableParquetOptions},
 };
 
 use arrow::datatypes::Schema;
@@ -166,13 +166,13 @@ impl TryFrom<&TableParquetOptions> for WriterPropertiesBuilder {
     }
 }
 
-/// Convert DataFusion's [`CdcOptions`] into parquet-rs's `Option<CdcOptions>`.
+/// Convert DataFusion's [`ParquetCdcOptions`] into parquet-rs's `Option<CdcOptions>`.
 ///
 /// parquet-rs has no `enabled` flag; CDC is on when the option is `Some`. So a
-/// disabled [`CdcOptions`] maps to `None`, and an enabled one to `Some` with the
-/// chunking parameters.
-impl From<&CdcOptions> for Option<parquet::file::properties::CdcOptions> {
-    fn from(value: &CdcOptions) -> Self {
+/// disabled [`ParquetCdcOptions`] maps to `None`, and an enabled one to `Some`
+/// with the chunking parameters.
+impl From<&ParquetCdcOptions> for Option<parquet::file::properties::CdcOptions> {
+    fn from(value: &ParquetCdcOptions) -> Self {
         value
             .enabled
             .then_some(parquet::file::properties::CdcOptions {
@@ -183,20 +183,21 @@ impl From<&CdcOptions> for Option<parquet::file::properties::CdcOptions> {
     }
 }
 
-/// Convert parquet-rs's `Option<&CdcOptions>` back into DataFusion's [`CdcOptions`].
+/// Convert parquet-rs's `Option<&CdcOptions>` back into DataFusion's
+/// [`ParquetCdcOptions`].
 ///
 /// The presence of parquet-rs options means CDC was enabled, so `Some` maps to
 /// `enabled: true`; `None` yields the disabled default.
-impl From<Option<&parquet::file::properties::CdcOptions>> for CdcOptions {
+impl From<Option<&parquet::file::properties::CdcOptions>> for ParquetCdcOptions {
     fn from(value: Option<&parquet::file::properties::CdcOptions>) -> Self {
         match value {
-            Some(cdc) => CdcOptions {
+            Some(cdc) => ParquetCdcOptions {
                 enabled: true,
                 min_chunk_size: cdc.min_chunk_size,
                 max_chunk_size: cdc.max_chunk_size,
                 norm_level: cdc.norm_level,
             },
-            None => CdcOptions::default(),
+            None => ParquetCdcOptions::default(),
         }
     }
 }
@@ -427,7 +428,7 @@ mod tests {
     #[cfg(feature = "parquet_encryption")]
     use crate::config::ConfigFileEncryptionProperties;
     use crate::config::{
-        CdcOptions, ParquetColumnOptions, ParquetEncryptionOptions, ParquetOptions,
+        ParquetCdcOptions, ParquetColumnOptions, ParquetEncryptionOptions, ParquetOptions,
     };
     use crate::parquet_config::DFParquetWriterVersion;
     use parquet::basic::Compression;
@@ -833,7 +834,7 @@ mod tests {
     #[test]
     fn test_cdc_enabled_with_custom_options() {
         let mut opts = TableParquetOptions::default();
-        opts.global.content_defined_chunking = CdcOptions {
+        opts.global.content_defined_chunking = ParquetCdcOptions {
             enabled: true,
             min_chunk_size: 128 * 1024,
             max_chunk_size: 512 * 1024,
@@ -861,7 +862,7 @@ mod tests {
     fn test_cdc_params_ignored_when_disabled() {
         // Parameters are customized but `enabled` is false, so CDC stays off.
         let mut opts = TableParquetOptions::default();
-        opts.global.content_defined_chunking = CdcOptions {
+        opts.global.content_defined_chunking = ParquetCdcOptions {
             enabled: false,
             min_chunk_size: 128 * 1024,
             max_chunk_size: 512 * 1024,
@@ -876,7 +877,7 @@ mod tests {
     #[test]
     fn test_cdc_round_trip_through_writer_props() {
         let mut opts = TableParquetOptions::default();
-        opts.global.content_defined_chunking = CdcOptions {
+        opts.global.content_defined_chunking = ParquetCdcOptions {
             enabled: true,
             min_chunk_size: 64 * 1024,
             max_chunk_size: 2 * 1024 * 1024,

datafusion/core/tests/parquet/content_defined_chunking.rs

@@ -25,7 +25,7 @@ use arrow::array::{AsArray, Int32Array, StringArray};
 use arrow::datatypes::{DataType, Field, Int32Type, Int64Type, Schema};
 use arrow::record_batch::RecordBatch;
 use datafusion::prelude::{ParquetReadOptions, SessionContext};
-use datafusion_common::config::{CdcOptions, TableParquetOptions};
+use datafusion_common::config::{ParquetCdcOptions, TableParquetOptions};
 use parquet::arrow::ArrowWriter;
 use parquet::arrow::arrow_reader::ArrowReaderMetadata;
 use parquet::file::properties::WriterProperties;
@@ -97,7 +97,7 @@ async fn cdc_data_round_trip() {
     let batch = make_test_batch(5000);
 
     let mut opts = TableParquetOptions::default();
-    opts.global.content_defined_chunking = CdcOptions::enabled();
+    opts.global.content_defined_chunking = ParquetCdcOptions::enabled();
     let props = writer_props(&mut opts, &batch.schema());
 
     let tmp = write_parquet_file(&batch, props);
@@ -145,7 +145,7 @@ async fn cdc_affects_page_boundaries() {
 
     // Write WITH CDC using small chunk sizes to maximize effect
     let mut cdc_opts = TableParquetOptions::default();
-    cdc_opts.global.content_defined_chunking = CdcOptions {
+    cdc_opts.global.content_defined_chunking = ParquetCdcOptions {
         enabled: true,
         min_chunk_size: 512,
         max_chunk_size: 2048,

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

@@ -39,7 +39,7 @@ use datafusion_common::{
     DataFusionError, JoinSide, ScalarValue, Statistics, TableReference,
     arrow_datafusion_err,
     config::{
-        CdcOptions, CsvOptions, JsonOptions, ParquetColumnOptions, ParquetOptions,
+        CsvOptions, JsonOptions, ParquetCdcOptions, ParquetColumnOptions, ParquetOptions,
         TableParquetOptions,
     },
     file_options::{csv_writer::CsvWriterOptions, json_writer::JsonWriterOptions},
@@ -1130,14 +1130,14 @@ 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(CdcOptions::from).unwrap_or_default(),
+            content_defined_chunking: value.content_defined_chunking.map(ParquetCdcOptions::from).unwrap_or_default(),
         })
     }
 }
 
-impl From<protobuf::parquet_options::CdcOptions> for CdcOptions {
+impl From<protobuf::parquet_options::CdcOptions> for ParquetCdcOptions {
     fn from(value: protobuf::parquet_options::CdcOptions) -> Self {
-        CdcOptions {
+        ParquetCdcOptions {
             enabled: value.enabled,
             min_chunk_size: value.min_chunk_size as usize,
             max_chunk_size: value.max_chunk_size as usize,
@@ -1330,7 +1330,9 @@ pub(crate) fn csv_writer_options_from_proto(
 
 #[cfg(test)]
 mod tests {
-    use datafusion_common::config::{CdcOptions, ParquetOptions, TableParquetOptions};
+    use datafusion_common::config::{
+        ParquetCdcOptions, ParquetOptions, TableParquetOptions,
+    };
 
     fn parquet_options_proto_round_trip(opts: ParquetOptions) -> ParquetOptions {
         let proto: crate::protobuf_common::ParquetOptions =
@@ -1390,7 +1392,7 @@ mod tests {
     #[test]
     fn test_parquet_options_cdc_enabled_round_trip() {
         let opts = ParquetOptions {
-            content_defined_chunking: CdcOptions {
+            content_defined_chunking: ParquetCdcOptions {
                 enabled: true,
                 min_chunk_size: 128 * 1024,
                 max_chunk_size: 512 * 1024,
@@ -1409,10 +1411,10 @@ mod tests {
     #[test]
     fn test_parquet_options_cdc_negative_norm_level_round_trip() {
         let opts = ParquetOptions {
-            content_defined_chunking: CdcOptions {
+            content_defined_chunking: ParquetCdcOptions {
                 enabled: true,
                 norm_level: -3,
-                ..CdcOptions::default()
+                ..ParquetCdcOptions::default()
             },
             ..ParquetOptions::default()
         };
@@ -1423,7 +1425,7 @@ mod tests {
     #[test]
     fn test_table_parquet_options_cdc_round_trip() {
         let mut opts = TableParquetOptions::default();
-        opts.global.content_defined_chunking = CdcOptions {
+        opts.global.content_defined_chunking = ParquetCdcOptions {
             enabled: true,
             min_chunk_size: 64 * 1024,
             max_chunk_size: 2 * 1024 * 1024,

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

@@ -36,7 +36,7 @@ use datafusion_common::{
     Column, ColumnStatistics, Constraint, Constraints, DFSchema, DFSchemaRef,
     DataFusionError, JoinSide, ScalarValue, Statistics,
     config::{
-        CdcOptions, CsvOptions, JsonOptions, ParquetColumnOptions, ParquetOptions,
+        CsvOptions, JsonOptions, ParquetCdcOptions, ParquetColumnOptions, ParquetOptions,
         TableParquetOptions,
     },
     file_options::{csv_writer::CsvWriterOptions, json_writer::JsonWriterOptions},
@@ -943,8 +943,8 @@ impl TryFrom<&ParquetOptions> for protobuf::ParquetOptions {
     }
 }
 
-impl From<&CdcOptions> for protobuf::parquet_options::CdcOptions {
-    fn from(value: &CdcOptions) -> Self {
+impl From<&ParquetCdcOptions> for protobuf::parquet_options::CdcOptions {
+    fn from(value: &ParquetCdcOptions) -> Self {
         protobuf::parquet_options::CdcOptions {
             enabled: value.enabled,
             min_chunk_size: value.min_chunk_size as u64,

datafusion/proto/src/logical_plan/file_formats.rs

@@ -382,7 +382,7 @@ mod parquet {
         parquet_options, parquet_options::CdcOptions as CdcOptionsProto,
     };
     use datafusion_common::config::{
-        CdcOptions, ParquetColumnOptions, ParquetOptions, TableParquetOptions,
+        ParquetCdcOptions, ParquetColumnOptions, ParquetOptions, TableParquetOptions,
     };
     use datafusion_datasource_parquet::file_format::ParquetFormatFactory;
 
@@ -562,7 +562,7 @@ mod parquet {
             max_predicate_cache_size: proto.max_predicate_cache_size_opt.as_ref().map(|opt| match opt {
                 parquet_options::MaxPredicateCacheSizeOpt::MaxPredicateCacheSize(size) => *size as usize,
             }),
-            content_defined_chunking: proto.content_defined_chunking.map(|cdc| CdcOptions {
+            content_defined_chunking: proto.content_defined_chunking.map(|cdc| ParquetCdcOptions {
                 enabled: cdc.enabled,
                 min_chunk_size: cdc.min_chunk_size as usize,
                 max_chunk_size: cdc.max_chunk_size as usize,