Refactor format and casting options handling

Remove OwnedFormatOptions and OwnedCastOptions from
format.rs, and eliminate public re-exports from lib.rs.
Refactor CastColumnExpr to directly accept Arrow
options (Option<CastOptions<'_>>), using internal
non-public structs in cast_column.rs to store owned
values. Update proto serialization/deserialization to
utilize Arrow CastOptions/FormatOptions borrows,
replacing DataFusion-owned wrapper types in
from_proto.rs and to_proto.rs.

Author: kosiew

datafusion/common/src/format.rs

@@ -35,206 +35,6 @@ pub const DEFAULT_CAST_OPTIONS: CastOptions<'static> = CastOptions {
     format_options: DEFAULT_FORMAT_OPTIONS,
 };
 
-/// Owned version of Arrow's `FormatOptions` with all `String` values instead of `&str`.
-///
-/// While Arrow's `FormatOptions<'a>` accepts generic lifetimes, the default constants and
-/// public APIs are designed around `'static` strings (e.g., hardcoded format strings).
-/// This struct uses `String` values, allowing format options to be created and owned at
-/// runtime without lifetime constraints.
-///
-/// # Conversion to Arrow Types
-///
-/// Use the `as_arrow_options()` method to temporarily convert to `FormatOptions<'a>`
-/// with borrowed references for passing to Arrow compute kernels:
-///
-/// ```ignore
-/// let owned_options = OwnedFormatOptions::default();
-/// let arrow_options = owned_options.as_arrow_options(); // borrows owned strings
-/// ```
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct OwnedFormatOptions {
-    /// String representation of null values
-    pub null: String,
-    /// Date format string
-    pub date_format: Option<String>,
-    /// Datetime format string
-    pub datetime_format: Option<String>,
-    /// Timestamp format string
-    pub timestamp_format: Option<String>,
-    /// Timestamp with timezone format string
-    pub timestamp_tz_format: Option<String>,
-    /// Time format string
-    pub time_format: Option<String>,
-    /// Duration format (owned, since DurationFormat is a simple enum)
-    pub duration_format: DurationFormat,
-    /// Include type information in formatted output
-    pub types_info: bool,
-}
-
-impl OwnedFormatOptions {
-    /// Create a new `OwnedFormatOptions` with default values.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Set the null string.
-    pub fn with_null(mut self, null: String) -> Self {
-        self.null = null;
-        self
-    }
-
-    /// Set the date format.
-    pub fn with_date_format(mut self, date_format: Option<String>) -> Self {
-        self.date_format = date_format;
-        self
-    }
-
-    /// Set the datetime format.
-    pub fn with_datetime_format(mut self, datetime_format: Option<String>) -> Self {
-        self.datetime_format = datetime_format;
-        self
-    }
-
-    /// Set the timestamp format.
-    pub fn with_timestamp_format(mut self, timestamp_format: Option<String>) -> Self {
-        self.timestamp_format = timestamp_format;
-        self
-    }
-
-    /// Set the timestamp with timezone format.
-    pub fn with_timestamp_tz_format(
-        mut self,
-        timestamp_tz_format: Option<String>,
-    ) -> Self {
-        self.timestamp_tz_format = timestamp_tz_format;
-        self
-    }
-
-    /// Set the time format.
-    pub fn with_time_format(mut self, time_format: Option<String>) -> Self {
-        self.time_format = time_format;
-        self
-    }
-
-    /// Set the duration format.
-    pub fn with_duration_format(mut self, duration_format: DurationFormat) -> Self {
-        self.duration_format = duration_format;
-        self
-    }
-
-    /// Set whether to include type information in formatted output.
-    pub fn with_types_info(mut self, types_info: bool) -> Self {
-        self.types_info = types_info;
-        self
-    }
-
-    /// Convert to Arrow's `FormatOptions<'a>` with borrowed references.
-    ///
-    /// This creates a temporary `FormatOptions` with borrowed `&str` references
-    /// to the owned strings. The returned options can be passed to Arrow compute
-    /// kernels. The borrowed references are valid only as long as `self` is alive.
-    pub fn as_arrow_options<'a>(&'a self) -> FormatOptions<'a> {
-        FormatOptions::new()
-            .with_null(self.null.as_str())
-            .with_date_format(self.date_format.as_deref())
-            .with_datetime_format(self.datetime_format.as_deref())
-            .with_timestamp_format(self.timestamp_format.as_deref())
-            .with_timestamp_tz_format(self.timestamp_tz_format.as_deref())
-            .with_time_format(self.time_format.as_deref())
-            .with_duration_format(self.duration_format)
-            .with_display_error(false)
-            .with_types_info(self.types_info)
-    }
-}
-
-impl Default for OwnedFormatOptions {
-    fn default() -> Self {
-        Self {
-            null: "NULL".to_string(),
-            date_format: None,
-            datetime_format: None,
-            timestamp_format: None,
-            timestamp_tz_format: None,
-            time_format: None,
-            duration_format: DurationFormat::Pretty,
-            types_info: false,
-        }
-    }
-}
-
-/// Owned version of Arrow's `CastOptions` with `OwnedFormatOptions` instead of `FormatOptions<'a>`.
-///
-/// While Arrow's `CastOptions<'a>` accepts generic lifetimes, the default constants and
-/// public APIs are designed around `'static` strings (e.g., hardcoded format strings).
-/// This struct uses `OwnedFormatOptions` with `String` values, allowing dynamic cast options
-/// to be created and owned at runtime without lifetime constraints.
-///
-/// # Conversion to Arrow Types
-///
-/// Use the `as_arrow_options()` method to temporarily convert to `CastOptions<'a>`
-/// with borrowed references for passing to Arrow compute kernels:
-///
-/// ```ignore
-/// let owned_options = OwnedCastOptions { ... };
-/// let arrow_options = owned_options.as_arrow_options(); // borrows owned strings
-/// arrow::compute::cast(&array, &data_type, Some(&arrow_options))?;
-/// ```
-#[derive(Debug, Clone, Default, Eq, PartialEq, Hash)]
-pub struct OwnedCastOptions {
-    /// Whether to use safe casting (return errors instead of overflowing)
-    pub safe: bool,
-    /// Format options for string output
-    pub format_options: OwnedFormatOptions,
-}
-
-impl OwnedCastOptions {
-    /// Create a new `OwnedCastOptions` with default values.
-    pub fn new(safe: bool) -> Self {
-        Self {
-            safe,
-            format_options: OwnedFormatOptions::default(),
-        }
-    }
-
-    /// Create a new `OwnedCastOptions` from an Arrow `CastOptions`.
-    pub fn from_arrow_options(options: &CastOptions<'_>) -> Self {
-        Self {
-            safe: options.safe,
-            format_options: OwnedFormatOptions {
-                null: options.format_options.null().to_string(),
-                date_format: options.format_options.date_format().map(|s| s.to_string()),
-                datetime_format: options
-                    .format_options
-                    .datetime_format()
-                    .map(|s| s.to_string()),
-                timestamp_format: options
-                    .format_options
-                    .timestamp_format()
-                    .map(|s| s.to_string()),
-                timestamp_tz_format: options
-                    .format_options
-                    .timestamp_tz_format()
-                    .map(|s| s.to_string()),
-                time_format: options.format_options.time_format().map(|s| s.to_string()),
-                duration_format: options.format_options.duration_format(),
-                types_info: options.format_options.types_info(),
-            },
-        }
-    }
-
-    /// Convert to Arrow's `CastOptions<'a>` with borrowed references.
-    ///
-    /// This creates a temporary `CastOptions` with borrowed `&str` references
-    /// to the owned strings. The returned options can be passed to Arrow compute
-    /// kernels. The borrowed references are valid only as long as `self` is alive.
-    pub fn as_arrow_options<'a>(&'a self) -> CastOptions<'a> {
-        CastOptions {
-            safe: self.safe,
-            format_options: self.format_options.as_arrow_options(),
-        }
-    }
-}
-
 /// Output formats for controlling for Explain plans
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum ExplainFormat {

datafusion/common/src/lib.rs

@@ -79,7 +79,6 @@ pub use file_options::file_type::{
     DEFAULT_ARROW_EXTENSION, DEFAULT_AVRO_EXTENSION, DEFAULT_CSV_EXTENSION,
     DEFAULT_JSON_EXTENSION, DEFAULT_PARQUET_EXTENSION, GetExt,
 };
-pub use format::{OwnedCastOptions, OwnedFormatOptions};
 pub use functional_dependencies::{
     Constraint, Constraints, Dependency, FunctionalDependence, FunctionalDependencies,
     aggregate_functional_dependencies, get_required_group_by_exprs_indices,

datafusion/physical-expr/src/expressions/cast_column.rs

@@ -19,13 +19,13 @@
 
 use crate::{expressions::Column, physical_expr::PhysicalExpr};
 use arrow::{
-    compute::can_cast_types,
+    compute::{CastOptions, can_cast_types},
     datatypes::{DataType, FieldRef, Schema},
     record_batch::RecordBatch,
+    util::display::{DurationFormat, FormatOptions},
 };
 use datafusion_common::{
     Result, ScalarValue,
-    format::OwnedCastOptions,
     nested_struct::{
         cast_column, validate_field_compatibility, validate_struct_compatibility,
     },
@@ -60,7 +60,7 @@ pub struct CastColumnExpr {
     /// The field metadata describing the desired output column.
     target_field: FieldRef,
     /// Options forwarded to [`cast_column`] (owned, allowing dynamic format strings).
-    cast_options: OwnedCastOptions,
+    cast_options: CastOptionsStore,
     /// Schema used to resolve expression data types during construction.
     input_schema: Arc<Schema>,
 }
@@ -85,8 +85,89 @@ impl Hash for CastColumnExpr {
     }
 }
 
-fn normalize_cast_options(cast_options: Option<OwnedCastOptions>) -> OwnedCastOptions {
-    cast_options.unwrap_or_default()
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+struct FormatOptionsStore {
+    null: String,
+    date_format: Option<String>,
+    datetime_format: Option<String>,
+    timestamp_format: Option<String>,
+    timestamp_tz_format: Option<String>,
+    time_format: Option<String>,
+    duration_format: DurationFormat,
+    types_info: bool,
+}
+
+impl Default for FormatOptionsStore {
+    fn default() -> Self {
+        Self {
+            null: "NULL".to_string(),
+            date_format: None,
+            datetime_format: None,
+            timestamp_format: None,
+            timestamp_tz_format: None,
+            time_format: None,
+            duration_format: DurationFormat::Pretty,
+            types_info: false,
+        }
+    }
+}
+
+impl FormatOptionsStore {
+    fn from_arrow_options(options: &FormatOptions<'_>) -> Self {
+        Self {
+            null: options.null().to_string(),
+            date_format: options.date_format().map(str::to_owned),
+            datetime_format: options.datetime_format().map(str::to_owned),
+            timestamp_format: options.timestamp_format().map(str::to_owned),
+            timestamp_tz_format: options.timestamp_tz_format().map(str::to_owned),
+            time_format: options.time_format().map(str::to_owned),
+            duration_format: options.duration_format(),
+            types_info: options.types_info(),
+        }
+    }
+
+    fn as_arrow_options(&self) -> FormatOptions<'_> {
+        FormatOptions::new()
+            .with_null(self.null.as_str())
+            .with_date_format(self.date_format.as_deref())
+            .with_datetime_format(self.datetime_format.as_deref())
+            .with_timestamp_format(self.timestamp_format.as_deref())
+            .with_timestamp_tz_format(self.timestamp_tz_format.as_deref())
+            .with_time_format(self.time_format.as_deref())
+            .with_duration_format(self.duration_format)
+            .with_display_error(false)
+            .with_types_info(self.types_info)
+    }
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Default)]
+struct CastOptionsStore {
+    safe: bool,
+    format_options: FormatOptionsStore,
+}
+
+impl CastOptionsStore {
+    fn from_arrow_options(options: &CastOptions<'_>) -> Self {
+        Self {
+            safe: options.safe,
+            format_options: FormatOptionsStore::from_arrow_options(
+                &options.format_options,
+            ),
+        }
+    }
+
+    fn as_arrow_options(&self) -> CastOptions<'_> {
+        CastOptions {
+            safe: self.safe,
+            format_options: self.format_options.as_arrow_options(),
+        }
+    }
+}
+
+fn normalize_cast_options(cast_options: Option<CastOptions<'_>>) -> CastOptionsStore {
+    cast_options
+        .map(|options| CastOptionsStore::from_arrow_options(&options))
+        .unwrap_or_default()
 }
 
 /// Validates that a Column expression matches the input field's data type.
@@ -217,7 +298,7 @@ impl CastColumnExpr {
         expr: Arc<dyn PhysicalExpr>,
         input_field: FieldRef,
         target_field: FieldRef,
-        cast_options: Option<OwnedCastOptions>,
+        cast_options: Option<CastOptions<'_>>,
         input_schema: Arc<Schema>,
     ) -> Result<Self> {
         let cast_options = normalize_cast_options(cast_options);
@@ -245,7 +326,7 @@ impl CastColumnExpr {
         expr: Arc<dyn PhysicalExpr>,
         input_field: FieldRef,
         target_field: FieldRef,
-        cast_options: Option<OwnedCastOptions>,
+        cast_options: Option<CastOptions<'_>>,
     ) -> Result<Self> {
         let input_schema = Arc::new(Schema::new(vec![Arc::unwrap_or_clone(Arc::clone(
             &input_field,
@@ -269,7 +350,7 @@ impl CastColumnExpr {
         expr: Arc<dyn PhysicalExpr>,
         input_field: FieldRef,
         target_field: FieldRef,
-        cast_options: Option<OwnedCastOptions>,
+        cast_options: Option<CastOptions<'_>>,
         input_schema: Arc<Schema>,
     ) -> Result<Self> {
         Self::build(expr, input_field, target_field, cast_options, input_schema)
@@ -291,8 +372,8 @@ impl CastColumnExpr {
     }
 
     /// Casting options forwarded to [`cast_column`].
-    pub fn cast_options(&self) -> &OwnedCastOptions {
-        &self.cast_options
+    pub fn cast_options(&self) -> CastOptions<'_> {
+        self.cast_options.as_arrow_options()
     }
 }
 
@@ -357,7 +438,7 @@ impl PhysicalExpr for CastColumnExpr {
             child,
             Arc::clone(&self.input_field),
             Arc::clone(&self.target_field),
-            Some(self.cast_options.clone()),
+            Some(self.cast_options.as_arrow_options()),
             Arc::clone(&self.input_schema),
         )?))
     }