feat: Support timestamp and date types for Spark unix_timestamp function (facebookincubator#11128)

Summary:
Adds timestamp and date support for Spark `unix_timestamp` and `to_unix_timestamp`
functions.

Spark's implementation: https://github.com/apache/spark/blob/v3.5.1/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/datetimeExpressions.scala#L1246-L1247.

Pull Request resolved: facebookincubator#11128

Reviewed By: xiaoxmeng

Differential Revision: D70260312

Pulled By: kevinwilfong

fbshipit-source-id: 961c1b859f9cf2b5a9abe7bc0504c0ccb65f35dc

Author: boneanxs

velox/docs/functions/spark/datetime.rst

@@ -248,6 +248,11 @@ These functions support TIMESTAMP and DATE input types.
 
         SELECT timestamp_millis(1230219000123); -- '2008-12-25 15:30:00.123'
 
+.. spark:function:: to_unix_timestamp(date) -> integer
+   :noindex:
+
+    Alias for ``unix_timestamp(date) -> integer``.
+
 .. spark:function:: to_unix_timestamp(string) -> integer
 
     Alias for ``unix_timestamp(string) -> integer``.
@@ -257,6 +262,11 @@ These functions support TIMESTAMP and DATE input types.
 
     Alias for ``unix_timestamp(string, format) -> integer``.
 
+.. spark:function:: to_unix_timestamp(timestamp) -> integer
+   :noindex:
+
+    Alias for ``unix_timestamp(timestamp) -> integer``.
+
 .. spark:function:: to_utc_timestamp(timestamp, string) -> timestamp
 
     Returns the timestamp value from the given timezone to UTC timezone. ::
@@ -294,6 +304,14 @@ These functions support TIMESTAMP and DATE input types.
 
     Returns the current UNIX timestamp in seconds.
 
+.. spark:function:: unix_timestamp(date) -> integer
+
+    Converts the time represented by ``date`` at the configured session timezone to the GMT time, and extracts the seconds. ::
+
+        SELECT unix_timestamp('1970-01-01'); -- 0
+        SELECT unix_timestamp('2024-10-01'); -- 1727740800
+        SELECT unix_timestamp('-2025-02-18'); -- -126065894400
+
 .. spark:function:: unix_timestamp(string) -> integer
    :noindex:
 
@@ -311,6 +329,14 @@ These functions support TIMESTAMP and DATE input types.
     Returns null if ``string`` does not match ``format`` or if ``format``
     is invalid.
 
+.. spark:function:: unix_timestamp(timestamp) -> integer
+
+    Returns the UNIX timestamp of the given ``timestamp`` in seconds. ::
+
+        SELECT unix_timestamp(CAST(0 AS TIMESTAMP)); -- 0
+        SELECT unix_timestamp(CAST(1739933174 AS TIMESTAMP)); -- 1739933174
+        SELECT unix_timestamp(CAST(-1739933174 AS TIMESTAMP)); -- -1739933174
+
 .. function:: week_of_year(x) -> integer
 
     Returns the `ISO-Week`_ of the year from x. The value ranges from ``1`` to ``53``.

velox/functions/sparksql/DateTimeFunctions.h

@@ -222,6 +222,13 @@ struct UnixTimestampParseWithFormatFunction
     this->setTimezone(config);
   }
 
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const arg_type<Date>* /*input*/) {
+    this->setTimezone(config);
+  }
+
   FOLLY_ALWAYS_INLINE bool call(
       int64_t& result,
       const arg_type<Varchar>& input,
@@ -252,6 +259,18 @@ struct UnixTimestampParseWithFormatFunction
     return true;
   }
 
+  FOLLY_ALWAYS_INLINE void call(
+      int64_t& result,
+      const arg_type<Timestamp>& input) {
+    result = input.getSeconds();
+  }
+
+  FOLLY_ALWAYS_INLINE void call(int64_t& result, const arg_type<Date>& input) {
+    auto timestamp = Timestamp::fromDate(input);
+    timestamp.toGMT(*this->sessionTimeZone_);
+    result = timestamp.getSeconds();
+  }
+
  private:
   bool isConstFormat_{false};
   bool invalidFormat_{false};

velox/functions/sparksql/registration/RegisterDatetime.cpp

@@ -40,6 +40,10 @@ void registerDatetimeFunctions(const std::string& prefix) {
       int64_t,
       Varchar,
       Varchar>({prefix + "unix_timestamp", prefix + "to_unix_timestamp"});
+  registerFunction<UnixTimestampParseWithFormatFunction, int64_t, Timestamp>(
+      {prefix + "unix_timestamp", prefix + "to_unix_timestamp"});
+  registerFunction<UnixTimestampParseWithFormatFunction, int64_t, Date>(
+      {prefix + "unix_timestamp", prefix + "to_unix_timestamp"});
   registerFunction<FromUnixtimeFunction, Varchar, int64_t, Varchar>(
       {prefix + "from_unixtime"});
   registerFunction<MakeDateFunction, Date, int32_t, int32_t, int32_t>(

velox/functions/sparksql/tests/DateTimeFunctionsTest.cpp

@@ -312,6 +312,41 @@ TEST_F(DateTimeFunctionsTest, unixTimestampCustomFormat) {
       unixTimestamp("2022-12-12 asd 07:45:31", "yyyy-MM-dd 'asd HH:mm:ss"));
 }
 
+TEST_F(DateTimeFunctionsTest, unixTimestampTimestampInput) {
+  const auto unixTimestamp = [&](std::optional<Timestamp> timestamp) {
+    return evaluateOnce<int64_t>("unix_timestamp(c0)", timestamp);
+  };
+  EXPECT_EQ(0, unixTimestamp(Timestamp(0, 0)));
+  EXPECT_EQ(1, unixTimestamp(Timestamp(1, 990)));
+  EXPECT_EQ(61, unixTimestamp(Timestamp(61, 0)));
+  EXPECT_EQ(-1, unixTimestamp(Timestamp(-1, 0)));
+  EXPECT_EQ(1739933174, unixTimestamp(Timestamp(1739933174, 0)));
+  EXPECT_EQ(-1739933174, unixTimestamp(Timestamp(-1739933174, 0)));
+  EXPECT_EQ(kMax, unixTimestamp(Timestamp(kMax, 0)));
+  EXPECT_EQ(kMin, unixTimestamp(Timestamp(kMin, 0)));
+}
+
+TEST_F(DateTimeFunctionsTest, unixTimestampDateInput) {
+  const auto unixTimestamp = [&](std::optional<int32_t> date) {
+    return evaluateOnce<int64_t>("unix_timestamp(c0)", {DATE()}, date);
+  };
+  EXPECT_EQ(0, unixTimestamp(parseDate("1970-01-01")));
+  EXPECT_EQ(1727740800, unixTimestamp(parseDate("2024-10-01")));
+  EXPECT_EQ(-126065894400, unixTimestamp(parseDate("-2025-02-18")));
+  setQueryTimeZone("America/Los_Angeles");
+  EXPECT_EQ(1727766000, unixTimestamp(parseDate("2024-10-01")));
+  EXPECT_EQ(-126065866022, unixTimestamp(parseDate("-2025-02-18")));
+
+  // Test invalid inputs.
+  VELOX_ASSERT_THROW(
+      unixTimestamp(kMax), "Timepoint is outside of supported year range");
+  VELOX_ASSERT_THROW(
+      unixTimestamp(kMin), "Timepoint is outside of supported year range");
+  VELOX_ASSERT_THROW(
+      unixTimestamp(parseDate("2045-12-31")),
+      "Unable to convert timezone 'America/Los_Angeles' past 2037-11-01 09:00:00");
+}
+
 // unix_timestamp and to_unix_timestamp are aliases.
 TEST_F(DateTimeFunctionsTest, toUnixTimestamp) {
   std::optional<StringView> dateStr = "1970-01-01 08:32:11"_sv;

velox/type/Timestamp.cpp

@@ -66,7 +66,7 @@ void Timestamp::toGMT(const tz::TimeZone& zone) {
     // Invalid argument means we hit a conversion not supported by
     // external/date. Need to throw a RuntimeError so that try() statements do
     // not suppress it.
-    VELOX_FAIL(e.what());
+    VELOX_FAIL_UNSUPPORTED_INPUT_UNCATCHABLE(e.what());
   }
   seconds_ = sysSeconds.count();
 }