Remove parseDateString function (facebookincubator#10094)

Summary:
Pull Request resolved: facebookincubator#10094

Remove fromDateString function. Rename castFromDateString to fromDateString. This makes it consistent with fromTimestampString.

Reviewed By: xiaoxmeng

Differential Revision: D58260593

fbshipit-source-id: cec60fc11e90faeba9879fa1bf7a1b52d5cee3ff

velox/connectors/hive/HiveConnectorUtil.cpp

@@ -584,7 +584,7 @@ bool applyPartitionFilter(
     const std::string& partitionValue,
     common::Filter* filter) {
   if (type->isDate()) {
-    const auto result = util::castFromDateString(
+    const auto result = util::fromDateString(
         StringView(partitionValue), util::ParseMode::kPrestoCast);
     VELOX_CHECK(!result.hasError());
     return applyFilter(*filter, result.value());

velox/connectors/hive/SplitReader.cpp

@@ -40,13 +40,9 @@ VectorPtr newConstantFromString(
   }
 
   if (type->isDate()) {
-    auto copy = util::castFromDateString(
-                    StringView(value.value()), util::ParseMode::kPrestoCast)
-                    .thenOrThrow(folly::identity, [&](const Status& status) {
-                      VELOX_USER_FAIL("{}", status.message());
-                    });
+    auto days = DATE()->toDays((folly::StringPiece)value.value());
     return std::make_shared<ConstantVector<int32_t>>(
-        pool, size, false, type, std::move(copy));
+        pool, size, false, type, std::move(days));
   }
 
   if constexpr (std::is_same_v<T, StringView>) {

velox/expression/PrestoCastHooks.cpp

@@ -62,7 +62,7 @@ Expected<int32_t> PrestoCastHooks::castStringToDate(
     const StringView& dateString) const {
   // Cast from string to date allows only complete ISO 8601 formatted strings:
   // [+-](YYYY-MM-DD).
-  return util::castFromDateString(dateString, util::ParseMode::kPrestoCast);
+  return util::fromDateString(dateString, util::ParseMode::kPrestoCast);
 }
 
 StringView PrestoCastHooks::removeWhiteSpaces(const StringView& view) const {

velox/functions/prestosql/DateTimeFunctions.h

@@ -124,7 +124,7 @@ struct DateFunction : public TimestampWithTimezoneSupport<T> {
 
   FOLLY_ALWAYS_INLINE Status
   call(out_type<Date>& result, const arg_type<Varchar>& date) {
-    auto days = util::castFromDateString(date, util::ParseMode::kPrestoCast);
+    auto days = util::fromDateString(date, util::ParseMode::kPrestoCast);
     if (days.hasError()) {
       return days.error();
     }
@@ -1246,7 +1246,7 @@ struct FromIso8601Date {
 
   FOLLY_ALWAYS_INLINE Status
   call(out_type<Date>& result, const arg_type<Varchar>& input) {
-    const auto castResult = util::castFromDateString(
+    const auto castResult = util::fromDateString(
         input.data(), input.size(), util::ParseMode::kIso8601);
     if (castResult.hasError()) {
       return castResult.error();

velox/functions/prestosql/tests/utils/FunctionBaseTest.h

@@ -331,7 +331,7 @@ class FunctionBaseTest : public testing::Test,
   /// Parses a date string into days since epoch.
   /// Accepts strings formatted as 'YYYY-MM-DD'.
   static int32_t parseDate(const std::string& text) {
-    return util::fromDateString(text.data(), text.size());
+    return DATE()->toDays(text);
   }
 
   /// Returns a vector of signatures for the given function name and return

velox/functions/sparksql/specialforms/SparkCastHooks.cpp

@@ -39,7 +39,7 @@ Expected<int32_t> SparkCastHooks::castStringToDate(
   // sequence of characters, e.g:
   //   "1970-01-01 123"
   //   "1970-01-01 (BC)"
-  return util::castFromDateString(
+  return util::fromDateString(
       removeWhiteSpaces(dateString), util::ParseMode::kSparkCast);
 }
 

velox/type/TimestampConversion.cpp

@@ -663,20 +663,7 @@ daysSinceEpochFromDayOfYear(int32_t year, int32_t dayOfYear, int64_t& out) {
   return Status::OK();
 }
 
-int32_t fromDateString(const char* str, size_t len) {
-  int64_t daysSinceEpoch;
-  size_t pos = 0;
-
-  if (!tryParseDateString(str, len, pos, daysSinceEpoch, ParseMode::kStrict)) {
-    VELOX_USER_FAIL(
-        "Unable to parse date value: \"{}\", expected format is (YYYY-MM-DD)",
-        std::string(str, len));
-  }
-  return daysSinceEpoch;
-}
-
-Expected<int32_t>
-castFromDateString(const char* str, size_t len, ParseMode mode) {
+Expected<int32_t> fromDateString(const char* str, size_t len, ParseMode mode) {
   int64_t daysSinceEpoch;
   size_t pos = 0;
 

velox/type/TimestampConversion.h

@@ -112,28 +112,14 @@ Status daysSinceEpochFromWeekDate(
 Status
 daysSinceEpochFromDayOfYear(int32_t year, int32_t dayOfYear, int64_t& out);
 
-/// Returns the (signed) number of days since unix epoch (1970-01-01), following
-/// the "YYYY-MM-DD" format (ISO 8601). ' ', '/' and '\' are also acceptable
-/// separators. Negative years and a trailing "(BC)" are also supported.
-///
-/// Throws VeloxUserError if the format or date is invalid.
-int32_t fromDateString(const char* buf, size_t len);
-
-inline int32_t fromDateString(const StringView& str) {
-  return fromDateString(str.data(), str.size());
-}
-
 /// Cast string to date. Supported date formats vary, depending on input
 /// ParseMode. Refer to ParseMode enum for further info.
 ///
 /// Throws VeloxUserError if the format or date is invalid.
-Expected<int32_t>
-castFromDateString(const char* buf, size_t len, ParseMode mode);
+Expected<int32_t> fromDateString(const char* buf, size_t len, ParseMode mode);
 
-inline Expected<int32_t> castFromDateString(
-    const StringView& str,
-    ParseMode mode) {
-  return castFromDateString(str.data(), str.size(), mode);
+inline Expected<int32_t> fromDateString(const StringView& str, ParseMode mode) {
+  return fromDateString(str.data(), str.size(), mode);
 }
 
 // Extracts the day of the week from the number of days since epoch

velox/type/Type.cpp

@@ -1006,11 +1006,14 @@ std::string DateType::toIso8601(int32_t days) {
 }
 
 int32_t DateType::toDays(folly::StringPiece in) const {
-  return util::fromDateString(in.data(), in.size());
+  return toDays(in.data(), in.size());
 }
 
 int32_t DateType::toDays(const char* in, size_t len) const {
-  return util::fromDateString(in, len);
+  return util::fromDateString(in, len, util::ParseMode::kPrestoCast)
+      .thenOrThrow(folly::identity, [&](const Status& status) {
+        VELOX_USER_FAIL("{}", status.message());
+      });
 }
 
 namespace {

velox/type/tests/TimestampConversionTest.cpp

@@ -35,7 +35,7 @@ Timestamp parseTimestamp(
 }
 
 int32_t parseDate(const StringView& str, ParseMode mode) {
-  return castFromDateString(str.data(), str.size(), mode)
+  return fromDateString(str.data(), str.size(), mode)
       .thenOrThrow(folly::identity, [&](const Status& status) {
         VELOX_USER_FAIL("{}", status.message());
       });
@@ -105,58 +105,6 @@ TEST(DateTimeUtilTest, fromDateInvalid) {
 }
 
 TEST(DateTimeUtilTest, fromDateString) {
-  EXPECT_EQ(10957, fromDateString("2000-01-01"));
-  EXPECT_EQ(0, fromDateString("1970-01-01"));
-  EXPECT_EQ(1, fromDateString("1970-01-02"));
-
-  // Single character
-  EXPECT_EQ(1, fromDateString("1970-1-2"));
-
-  // Old and negative years.
-  EXPECT_EQ(-719528, fromDateString("0-1-1"));
-  EXPECT_EQ(-719162, fromDateString("1-1-1"));
-  EXPECT_EQ(-719893, fromDateString("-1-1-1"));
-  EXPECT_EQ(-720258, fromDateString("-2-1-1"));
-
-  // 1BC is equal 0-1-1.
-  EXPECT_EQ(-719528, fromDateString("1-1-1 (BC)"));
-  EXPECT_EQ(-719893, fromDateString("2-1-1 (BC)"));
-
-  // Leading zeros and spaces.
-  EXPECT_EQ(-719162, fromDateString("00001-1-1"));
-  EXPECT_EQ(-719162, fromDateString(" 1-1-1"));
-  EXPECT_EQ(-719162, fromDateString("     1-1-1"));
-  EXPECT_EQ(-719162, fromDateString("\t1-1-1"));
-  EXPECT_EQ(-719162, fromDateString("  \t    \n 00001-1-1  \n"));
-
-  // Different separators.
-  EXPECT_EQ(-719162, fromDateString("1/1/1"));
-  EXPECT_EQ(-719162, fromDateString("1 1 1"));
-  EXPECT_EQ(-719162, fromDateString("1\\1\\1"));
-
-  // Other string types.
-  EXPECT_EQ(0, fromDateString(StringView("1970-01-01")));
-}
-
-TEST(DateTimeUtilTest, fromDateStrInvalid) {
-  EXPECT_THROW(fromDateString(""), VeloxUserError);
-  EXPECT_THROW(fromDateString("     "), VeloxUserError);
-  EXPECT_THROW(fromDateString("2000"), VeloxUserError);
-
-  // Different separators.
-  EXPECT_THROW(fromDateString("2000/01-01"), VeloxUserError);
-  EXPECT_THROW(fromDateString("2000 01-01"), VeloxUserError);
-
-  // Trailing characters.
-  EXPECT_THROW(fromDateString("2000-01-01   asdf"), VeloxUserError);
-  EXPECT_THROW(fromDateString("2000-01-01 0"), VeloxUserError);
-
-  // Too large of a year.
-  EXPECT_THROW(fromDateString("1000000"), VeloxUserError);
-  EXPECT_THROW(fromDateString("-1000000"), VeloxUserError);
-}
-
-TEST(DateTimeUtilTest, castFromDateString) {
   for (ParseMode mode : {ParseMode::kPrestoCast, ParseMode::kSparkCast}) {
     EXPECT_EQ(0, parseDate("1970-01-01", mode));
     EXPECT_EQ(3789742, parseDate("12345-12-18", mode));
@@ -182,7 +130,7 @@ TEST(DateTimeUtilTest, castFromDateString) {
   EXPECT_EQ(16512, parseDate("2015-03-18 (BC)", ParseMode::kSparkCast));
 }
 
-TEST(DateTimeUtilTest, castFromDateStringInvalid) {
+TEST(DateTimeUtilTest, fromDateStringInvalid) {
   auto testCastFromDateStringInvalid = [&](const StringView& str,
                                            ParseMode mode) {
     if (mode == ParseMode::kPrestoCast) {