One more format with leading whitespace

Author: parthchandra

native/spark-expr/src/conversion_funcs/string.rs

@@ -1243,11 +1243,24 @@ fn timestamp_parser<T: TimeZone>(
     if trimmed.is_empty() {
         return Ok(None);
     }
-    // For T-hour-only format (T\d{1,2}, no colon), Spark rejects leading whitespace
-    // but accepts trailing whitespace.  Check the raw (pre-trim) value for a leading
-    // space before allowing the match.
-    if value.len() > value.trim_start().len() && RE_TIME_ONLY_H.is_match(trimmed) {
-        return Ok(None);
+    // Spark rejects leading whitespace for ALL T-prefixed time-only strings
+    // (T<h>, T<h>:<m>, T<h>:<m>:<s>, T<h>:<m>:<s>.<f>), but accepts trailing whitespace.
+    // Check the raw (pre-trim) value for leading whitespace before any T-time-only match.
+    if value.len() > value.trim_start().len()
+        && (RE_TIME_ONLY_H.is_match(trimmed)
+            || RE_TIME_ONLY_HM.is_match(trimmed)
+            || RE_TIME_ONLY_HMS.is_match(trimmed)
+            || RE_TIME_ONLY_HMSU.is_match(trimmed))
+    {
+        return if eval_mode == EvalMode::Ansi {
+            Err(SparkError::InvalidInputInCastToDatetime {
+                value: value.to_string(),
+                from_type: "STRING".to_string(),
+                to_type: "TIMESTAMP".to_string(),
+            })
+        } else {
+            Ok(None)
+        };
     }
     let value = trimmed;
     // Spark accepts a leading '+' year sign on full date-time strings (e.g. "+2020-01-01T12:34:56")
@@ -1875,6 +1888,34 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_leading_whitespace_t_hm() {
+        let tz = &timezone::Tz::from_str("UTC").unwrap();
+        // Spark rejects leading whitespace for ALL T-prefixed time-only patterns.
+        for ws_input in &[" T2:30", "\tT2:30", "\nT2:30", " T2", "\tT2", "\nT2"] {
+            assert!(
+                timestamp_parser(ws_input, EvalMode::Legacy, tz)
+                    .unwrap()
+                    .is_none(),
+                "'{ws_input}' should be null in Legacy mode"
+            );
+            // In ANSI mode the same inputs must raise an error (not silently return null).
+            assert!(
+                timestamp_parser(ws_input, EvalMode::Ansi, tz).is_err(),
+                "'{ws_input}' should error in ANSI mode"
+            );
+        }
+        // Without leading whitespace, these must be valid.
+        for ok_input in &["T2:30", "T2"] {
+            assert!(
+                timestamp_parser(ok_input, EvalMode::Legacy, tz)
+                    .unwrap()
+                    .is_some(),
+                "'{ok_input}' should be valid"
+            );
+        }
+    }
+
     #[test]
     fn plus_sign_year_test() {
         let tz = &timezone::Tz::from_str("UTC").unwrap();

spark/src/test/scala/org/apache/comet/CometCastSuite.scala

@@ -1065,6 +1065,42 @@ class CometCastSuite extends CometTestBase with AdaptiveSparkPlanHelper {
     }
   }
 
+  test("cast StringType to TimestampType - T-hour-only whitespace handling") {
+    // RE_TIME_ONLY_H ("T<h>", no colon) has a Spark-specific rule:
+    //   - leading whitespace  → null
+    //   - trailing whitespace → valid (treated as trimmed)
+    // Adjacent patterns (T<h>:<m>, full datetime) behave differently under
+    // leading whitespace, so those cases are included for completeness.
+    withSQLConf(SQLConf.SESSION_LOCAL_TIMEZONE.key -> "UTC") {
+      val values = Seq(
+        // Bare T-hour-only: no leading whitespace (valid)
+        "T2", // single-digit hour
+        "T23", // two-digit hour
+        "T0", // midnight
+        // Bare T-hour-only: trailing whitespace only (valid)
+        "T2 ", // trailing space
+        "T2\t", // trailing tab
+        "T2\n", // trailing newline
+        // Bare T-hour-only: leading whitespace (null per Spark)
+        " T2", // leading space
+        "\tT2", // leading tab
+        "\nT2", // leading newline
+        "\r\nT2", // leading CRLF
+        "\t T2", // tab then space
+        "  T2", // double space
+        // T-hour:minute with leading whitespace — Spark ALSO returns null (same rule applies)
+        " T2:30",
+        "\tT2:30",
+        "\nT2:30",
+        // Full datetime: leading whitespace (Spark trims, so valid)
+        " 2020-01-01T12:34:56",
+        "\t2020-01-01T12:34:56",
+        "\n2020-01-01T12:34:56",
+        "\r\n2020-01-01T12:34:56")
+      castTimestampTest(values.toDF("a"), DataTypes.TimestampType, assertNative = true)
+    }
+  }
+
   // CAST from BinaryType
 
   test("cast BinaryType to StringType") {
@@ -1557,7 +1593,8 @@ class CometCastSuite extends CometTestBase with AdaptiveSparkPlanHelper {
           case (None, Some(e)) =>
             throw e
           case (Some(e), None) =>
-            fail(s"Comet should have failed with ${e.getCause.getMessage}")
+            val msg = if (e.getCause != null) e.getCause.getMessage else e.getMessage
+            fail(s"Comet should have failed with $msg")
           case (Some(sparkException), Some(cometException)) =>
             val sparkMessage =
               if (sparkException.getCause != null) sparkException.getCause.getMessage