Extract out date time parsing to a DateTimeParser trait

datafusion-examples/examples/builtin_functions/date_time.rs

@@ -417,7 +417,7 @@ async fn query_to_timestamp() -> Result<()> {
         .collect()
         .await;
 
-    let expected = "Execution error: Error parsing timestamp from '01-14-2023 01/01/30' using format '%d-%m-%Y %H:%M:%S': input is out of range";
+    let expected = "Error parsing timestamp from '01-14-2023 01/01/30' using formats: [\"%d-%m-%Y %H:%M:%S\"]: input is out of range";
     assert_contains!(result.unwrap_err().to_string(), expected);
 
     // note that using arrays for the chrono formats is not supported

datafusion/common/src/config.rs

@@ -24,7 +24,7 @@ use crate::encryption::{FileDecryptionProperties, FileEncryptionProperties};
 use crate::error::_config_err;
 use crate::format::{ExplainAnalyzeLevel, ExplainFormat};
 use crate::parquet_config::DFParquetWriterVersion;
-use crate::parsers::CompressionTypeVariant;
+use crate::parsers::{CompressionTypeVariant, DateTimeParserType};
 use crate::utils::get_available_parallelism;
 use crate::{DataFusionError, Result};
 #[cfg(feature = "parquet_encryption")]
@@ -505,6 +505,11 @@ config_namespace! {
         /// Defaults to the number of CPU cores on the system
         pub target_partitions: usize, transform = ExecutionOptions::normalized_parallelism, default = get_available_parallelism()
 
+        /// The date time parser to use when parsing date time values.
+        ///
+        /// Defaults to 'chrono'. 'jiff' is supported when the 'jiff' feature is enabled.
+        pub date_time_parser: Option<DateTimeParserType>, default = Some(DateTimeParserType::Chrono)
+
         /// The default time zone
         ///
         /// Some functions, e.g. `now` return timestamps in this time zone

datafusion/common/src/parsers.rs

@@ -17,11 +17,11 @@
 
 //! Interval parsing logic
 
+use crate::DataFusionError;
+use crate::config::{ConfigField, Visit};
 use std::fmt::Display;
 use std::str::FromStr;
 
-use crate::DataFusionError;
-
 /// Readable file compression type
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum CompressionTypeVariant {
@@ -73,3 +73,48 @@ impl CompressionTypeVariant {
         !matches!(self, &Self::UNCOMPRESSED)
     }
 }
+
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum DateTimeParserType {
+    #[default]
+    Chrono,
+    Jiff,
+}
+
+impl ConfigField for DateTimeParserType {
+    fn visit<V: Visit>(&self, v: &mut V, key: &str, description: &'static str) {
+        v.some(key, self, description)
+    }
+
+    fn set(&mut self, _: &str, value: &str) -> crate::Result<()> {
+        *self = DateTimeParserType::from_str(value)?;
+        Ok(())
+    }
+}
+
+impl FromStr for DateTimeParserType {
+    type Err = DataFusionError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let s = s.to_uppercase();
+        match s.as_str() {
+            "CHRONO" => Ok(Self::Chrono),
+            "JIFF" => Ok(Self::Jiff),
+            _ => Err(DataFusionError::NotImplemented(format!(
+                "Unsupported datetime parser type {s}"
+            ))),
+        }
+    }
+}
+
+impl Display for DateTimeParserType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let str = match self {
+            Self::Chrono => "chrono",
+            Self::Jiff => "jiff",
+        };
+        write!(f, "{str}")
+    }
+}
+
+impl DateTimeParserType {}

datafusion/core/Cargo.toml

@@ -109,6 +109,7 @@ unicode_expressions = [
     "datafusion-functions/unicode_expressions",
 ]
 extended_tests = []
+jiff = ["datafusion-functions/jiff"]
 
 [dependencies]
 arrow = { workspace = true }

datafusion/functions/Cargo.toml

@@ -52,6 +52,8 @@ default = [
 ]
 # enable encode/decode functions
 encoding_expressions = ["base64", "hex"]
+# enable jiff timestamp parsing
+jiff = ["dep:jiff"]
 # enable math functions
 math_expressions = []
 # enable regular expressions
@@ -78,8 +80,11 @@ datafusion-execution = { workspace = true }
 datafusion-expr = { workspace = true }
 datafusion-expr-common = { workspace = true }
 datafusion-macros = { workspace = true }
+dyn-eq = "0.1.3"
+dyn-hash = "1.0.0"
 hex = { workspace = true, optional = true }
 itertools = { workspace = true }
+jiff = { version = "0.2.18", optional = true }
 log = { workspace = true }
 md-5 = { version = "^0.10.0", optional = true }
 memchr = { workspace = true }
@@ -116,7 +121,7 @@ required-features = ["string_expressions"]
 [[bench]]
 harness = false
 name = "to_timestamp"
-required-features = ["datetime_expressions"]
+required-features = ["datetime_expressions", "jiff"]
 
 [[bench]]
 harness = false