Allow partial date parsing when simple datetime formatter is used

velox/docs/functions/spark/datetime.rst

@@ -117,12 +117,18 @@ These functions support TIMESTAMP and DATE input types.
     date formatter in lenient mode that is align with Spark legacy date parser behavior or
     `Joda <https://www.joda.org/joda-time/>`_ date formatter depends on ``spark.legacy_date_formatter`` configuration.
     Returns NULL for parsing error or NULL input. When `Simple` date formatter is used, null is returned for invalid
-    ``dateFormat``; otherwise, exception is thrown. ::
+    ``dateFormat``; otherwise, exception is thrown. The `Simple` date formatter also permits partial date parsing
+    which means that ``dateFormat`` can match only a part of ``string``. For example, if ``string`` is
+    2015-07-22 10:00:00, it can be parsed using ``dateFormat`` is yyyy-MM-dd because the parser does not require entire
+    input to be consumed. In contrast, the `Joda` date formatter performs strict checks to ensure that the
+    ``dateFormat`` completely matches the ``string``. If there is any mismatch, exception is thrown. ::
 
         SELECT get_timestamp('1970-01-01', 'yyyy-MM-dd);  -- timestamp `1970-01-01`
         SELECT get_timestamp('1970-01-01', 'yyyy-MM');  -- NULL (parsing error)
         SELECT get_timestamp('1970-01-01', null);  -- NULL
         SELECT get_timestamp('2020-06-10', 'A');  -- (throws exception)
+        SELECT get_timestamp('2015-07-22 10:00:00', 'yyyy-MM-dd'); -- timestamp `2015-07-22` (for Simple date formatter)
+        SELECT get_timestamp('2015-07-22 10:00:00', 'yyyy-MM-dd'); -- (throws exception) (for Joda date formatter)
 
 .. spark:function:: hour(timestamp) -> integer
 
@@ -311,7 +317,13 @@ These functions support TIMESTAMP and DATE input types.
     `Datetime patterns for formatting and parsing
     <https://spark.apache.org/docs/latest/sql-ref-datetime-pattern.html>`_.
     Returns null if ``string`` does not match ``format`` or if ``format``
-    is invalid.
+    is invalid. The `Simple` date formatter permits partial date parsing
+    which means that ``format`` can match only a part of ``string``. For example,
+    if ``string`` is 2015-07-22 10:00:00, it can be parsed using ``format`` is
+    yyyy-MM-dd because the parser does not require entire input to be consumed.
+    In contrast, the `Joda` date formatter performs strict checks to ensure that the
+    ``format`` completely matches the ``string``. If there is any mismatch,
+    exception is thrown.
 
 .. function:: week_of_year(x) -> integer
 

velox/functions/lib/DateTimeFormatter.cpp

@@ -1588,8 +1588,9 @@ Expected<DateTimeResult> DateTimeFormatter::parse(
     }
   }
 
-  // Ensure all input was consumed.
-  if (cur < end) {
+  // Ensure all input was consumed if type_ is not simple datetime formatter.
+  if (type_ != DateTimeFormatterType::LENIENT_SIMPLE &&
+      type_ != DateTimeFormatterType::STRICT_SIMPLE && cur < end) {
     return parseFail(input, cur, end);
   }
 

velox/functions/lib/tests/DateTimeFormatterTest.cpp

@@ -2441,4 +2441,13 @@ TEST_F(SimpleDateTimeFormatterTest, formatWeekOfMonth) {
   }
 }
 
+TEST_F(SimpleDateTimeFormatterTest, parseUsingPartialInput) {
+  EXPECT_EQ(
+      fromTimestampString("2024-08-01"),
+      parseSimple("2024 08 01 5", "yyyy MM", true).timestamp);
+  EXPECT_EQ(
+      fromTimestampString("2024-08-01"),
+      parseSimple("2024 08 01 5", "yyyy MM", false).timestamp);
+}
+
 } // namespace facebook::velox::functions