diff --git a/src/common/function/FunctionManager.cpp b/src/common/function/FunctionManager.cpp
index f73053cdc1f..ef5af9050f3 100644
--- a/src/common/function/FunctionManager.cpp
+++ b/src/common/function/FunctionManager.cpp
@@ -1712,9 +1712,14 @@ FunctionManager::FunctionManager() {
           if (args[0].get().isStr()) {
             auto result = time::TimeUtils::parseTime(args[0].get().getStr());
             if (!result.ok()) {
+              DLOG(ERROR) << "DEBUG POINT: " << result.status();
               return Value::kNullBadData;
             }
-            return time::TimeUtils::timeToUTC(result.value());
+            if (result.value().withTimeZone) {
+              return result.value().t;
+            } else {
+              return time::TimeUtils::timeToUTC(result.value().t);
+            }
           } else if (args[0].get().isMap()) {
             auto result = time::TimeUtils::timeFromMap(args[0].get().getMap());
             if (!result.ok()) {
@@ -1749,7 +1754,11 @@ FunctionManager::FunctionManager() {
             if (!result.ok()) {
               return Value::kNullBadData;
             }
-            return time::TimeUtils::dateTimeToUTC(result.value());
+            if (result.value().withTimeZone) {
+              return result.value().dt;
+            } else {
+              return time::TimeUtils::dateTimeToUTC(result.value().dt);
+            }
           } else if (args[0].get().isMap()) {
             auto result = time::TimeUtils::dateTimeFromMap(args[0].get().getMap());
             if (!result.ok()) {
diff --git a/src/common/function/test/CMakeLists.txt b/src/common/function/test/CMakeLists.txt
index b8517314dfe..ab547cf44a6 100644
--- a/src/common/function/test/CMakeLists.txt
+++ b/src/common/function/test/CMakeLists.txt
@@ -21,6 +21,24 @@ nebula_add_test(
         gtest_main
 )
 
+nebula_add_test(
+    NAME
+        twice_timezone_conversion_test
+    SOURCES
+        TwiceTimezoneConversionTest.cpp
+    OBJECTS
+        $<TARGET_OBJECTS:function_manager_obj>
+        $<TARGET_OBJECTS:wkt_wkb_io_obj>
+        $<TARGET_OBJECTS:base_obj>
+        $<TARGET_OBJECTS:datatypes_obj>
+        $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
+        $<TARGET_OBJECTS:time_obj>
+        $<TARGET_OBJECTS:fs_obj>
+    LIBRARIES
+        gtest
+)
+
 nebula_add_test(
     NAME
         agg_function_manager_test
diff --git a/src/common/function/test/TwiceTimezoneConversionTest.cpp b/src/common/function/test/TwiceTimezoneConversionTest.cpp
new file mode 100644
index 00000000000..c5e983043c5
--- /dev/null
+++ b/src/common/function/test/TwiceTimezoneConversionTest.cpp
@@ -0,0 +1,62 @@
+// Copyright (c) 2022 vesoft inc. All rights reserved.
+//
+// This source code is licensed under Apache 2.0 License.
+
+#include <gtest/gtest.h>
+
+#include "common/datatypes/Date.h"
+#include "common/function/FunctionManager.h"
+#include "common/time/TimezoneInfo.h"
+
+DECLARE_string(timezone_name);
+
+// #4432
+TEST(DatetimeFunction, TwiceTimezoneConversion) {
+  // date
+  {
+    auto result = nebula::FunctionManager::get("date", 1);
+    ASSERT_TRUE(result.ok());
+    nebula::Value arg = nebula::Value("2019-01-01");
+    auto res = std::move(result).value()({arg});
+    ASSERT_EQ(res.type(), nebula::Value::Type::DATE);
+    EXPECT_EQ(res.getDate(), nebula::Date(2019, 1, 1));
+  }
+
+  // time
+  {
+    auto result = nebula::FunctionManager::get("time", 1);
+    ASSERT_TRUE(result.ok());
+    nebula::Value arg = nebula::Value("23:04:05+08:00");
+    auto res = std::move(result).value()({arg});
+    ASSERT_EQ(res.type(), nebula::Value::Type::TIME);
+    EXPECT_EQ(res.getTime(), nebula::Time(15, 4, 5, 0));
+  }
+
+  // datetime
+  {
+    auto result = nebula::FunctionManager::get("datetime", 1);
+    ASSERT_TRUE(result.ok());
+    nebula::Value arg = nebula::Value("2019-01-01T23:04:05+08:00");
+    auto res = std::move(result).value()({arg});
+    ASSERT_EQ(res.type(), nebula::Value::Type::DATETIME);
+    EXPECT_EQ(res.getDateTime(), nebula::DateTime(2019, 1, 1, 15, 4, 5, 0));
+  }
+}
+
+int main(int argc, char **argv) {
+  testing::InitGoogleTest(&argc, argv);
+  folly::init(&argc, &argv, true);
+  google::SetStderrLogging(google::INFO);
+
+  FLAGS_timezone_name = "UTC+08:00";
+
+  auto result = nebula::time::Timezone::initializeGlobalTimezone();
+  if (!result.ok()) {
+    LOG(FATAL) << result;
+  }
+
+  DLOG(INFO) << "Timezone: " << nebula::time::Timezone::getGlobalTimezone().stdZoneName();
+  DLOG(INFO) << "Timezone offset: " << nebula::time::Timezone::getGlobalTimezone().utcOffsetSecs();
+
+  return RUN_ALL_TESTS();
+}
diff --git a/src/common/time/TimeUtils.cpp b/src/common/time/TimeUtils.cpp
index 4b1c1630700..16ccea8455d 100644
--- a/src/common/time/TimeUtils.cpp
+++ b/src/common/time/TimeUtils.cpp
@@ -154,7 +154,8 @@ StatusOr<Value> TimeUtils::toTimestamp(const Value &val) {
     if (!status.ok()) {
       return status.status();
     }
-    auto dateTime = std::move(status).value();
+    auto result = std::move(status).value();
+    auto dateTime = result.withTimeZone ? result.dt : dateTimeToUTC(result.dt);
     if (dateTime.microsec != 0) {
       return Status::Error("The timestamp  only supports seconds unit.");
     }
@@ -206,7 +207,7 @@ StatusOr<Value> TimeUtils::toTimestamp(const Value &val) {
   return d;
 }
 
-/*static*/ StatusOr<DateTime> TimeUtils::parseDateTime(const std::string &str) {
+/*static*/ StatusOr<Result> TimeUtils::parseDateTime(const std::string &str) {
   auto p = DatetimeReader();
   auto result = p.readDatetime(str);
   NG_RETURN_IF_ERROR(result);
@@ -220,7 +221,7 @@ StatusOr<Value> TimeUtils::toTimestamp(const Value &val) {
   return result.value();
 }
 
-/*static*/ StatusOr<Time> TimeUtils::parseTime(const std::string &str) {
+/*static*/ StatusOr<TimeResult> TimeUtils::parseTime(const std::string &str) {
   auto p = DatetimeReader();
   return p.readTime(str);
 }
diff --git a/src/common/time/TimeUtils.h b/src/common/time/TimeUtils.h
index 64a107cf4ec..6f3aa2c71d6 100644
--- a/src/common/time/TimeUtils.h
+++ b/src/common/time/TimeUtils.h
@@ -22,6 +22,7 @@
 #include "common/time/TimeConversion.h"
 #include "common/time/TimezoneInfo.h"
 #include "common/time/WallClock.h"
+#include "common/time/parser/Result.h"
 
 namespace nebula {
 namespace time {
@@ -66,7 +67,7 @@ class TimeUtils {
     return Status::OK();
   }
 
-  static StatusOr<DateTime> parseDateTime(const std::string &str);
+  static StatusOr<Result> parseDateTime(const std::string &str);
 
   static StatusOr<DateTime> dateTimeFromMap(const Map &m);
 
@@ -153,7 +154,7 @@ class TimeUtils {
 
   static StatusOr<Time> timeFromMap(const Map &m);
 
-  static StatusOr<Time> parseTime(const std::string &str);
+  static StatusOr<TimeResult> parseTime(const std::string &str);
 
   // utc + offset = local
   static Time timeToUTC(const Time &time) {
diff --git a/src/common/time/parser/DatetimeReader.cpp b/src/common/time/parser/DatetimeReader.cpp
index 5213c58ab4e..82c3a77d256 100644
--- a/src/common/time/parser/DatetimeReader.cpp
+++ b/src/common/time/parser/DatetimeReader.cpp
@@ -8,7 +8,7 @@
 namespace nebula {
 namespace time {
 
-DatetimeReader::DatetimeReader() : parser_(scanner_, error_, &dt_) {
+DatetimeReader::DatetimeReader() : parser_(scanner_, error_, &result_) {
   // Callback invoked by DatetimeScanner
   auto readBuffer = [this](char *buf, int maxSize) -> int {
     // Reach the end
@@ -26,7 +26,7 @@ DatetimeReader::DatetimeReader() : parser_(scanner_, error_, &dt_) {
   scanner_.setReadBuffer(std::move(readBuffer));
 }
 
-StatusOr<DateTime> DatetimeReader::read(std::string input) {
+StatusOr<Result> DatetimeReader::read(std::string input) {
   // Since DatetimeScanner needs a writable buffer, we have to copy the query string
   buffer_ = std::move(input);
   pos_ = &buffer_[0];
@@ -38,19 +38,19 @@ StatusOr<DateTime> DatetimeReader::read(std::string input) {
     end_ = nullptr;
     // To flush the internal buffer to recover from a failure
     scanner_.flushBuffer();
-    if (dt_ != nullptr) {
-      delete dt_;
-      dt_ = nullptr;
+    if (result_ != nullptr) {
+      delete result_;
+      result_ = nullptr;
     }
     scanner_.setInput(nullptr);
     return Status::SyntaxError(error_);
   }
 
-  if (dt_ == nullptr) {
+  if (result_ == nullptr) {
     return Status::StatementEmpty();  // empty
   }
-  auto dt = dt_;
-  dt_ = nullptr;
+  auto dt = result_;
+  result_ = nullptr;
   scanner_.setInput(nullptr);
   auto tmp = std::move(*dt);
   delete dt;
diff --git a/src/common/time/parser/DatetimeReader.h b/src/common/time/parser/DatetimeReader.h
index 248c66c00f6..b1da0cdcb7e 100644
--- a/src/common/time/parser/DatetimeReader.h
+++ b/src/common/time/parser/DatetimeReader.h
@@ -11,6 +11,7 @@
 #include "common/datatypes/Date.h"
 #include "common/time/parser/DatetimeParser.hpp"
 #include "common/time/parser/DatetimeScanner.h"
+#include "common/time/parser/Result.h"
 
 namespace nebula {
 namespace time {
@@ -20,10 +21,10 @@ class DatetimeReader {
   DatetimeReader();
 
   ~DatetimeReader() {
-    if (dt_ != nullptr) delete dt_;
+    if (result_ != nullptr) delete result_;
   }
 
-  StatusOr<DateTime> readDatetime(std::string input) {
+  StatusOr<Result> readDatetime(std::string input) {
     input = kDatetimePrefix + input;
     return read(std::move(input));
   }
@@ -32,10 +33,10 @@ class DatetimeReader {
     input = kDatePrefix + input;
     auto result = read(std::move(input));
     NG_RETURN_IF_ERROR(result);
-    return result.value().date();
+    return result.value().dt.date();
   }
 
-  StatusOr<Time> readTime(std::string input) {
+  StatusOr<TimeResult> readTime(std::string input) {
     input = kTimePrefix + input;
     auto result = read(std::move(input));
     NG_RETURN_IF_ERROR(result);
@@ -43,7 +44,7 @@ class DatetimeReader {
   }
 
  private:
-  StatusOr<DateTime> read(std::string input);
+  StatusOr<Result> read(std::string input);
 
   std::string buffer_;
   const char *pos_{nullptr};
@@ -51,7 +52,7 @@ class DatetimeReader {
   DatetimeScanner scanner_;
   DatetimeParser parser_;
   std::string error_;
-  DateTime *dt_{nullptr};
+  Result *result_{nullptr};
 
   inline static const std::string kDatetimePrefix = "DATETIME__";
   inline static const std::string kDatePrefix = "DATE__";
diff --git a/src/common/time/parser/Result.h b/src/common/time/parser/Result.h
new file mode 100644
index 00000000000..388f3a1bac3
--- /dev/null
+++ b/src/common/time/parser/Result.h
@@ -0,0 +1,52 @@
+/* Copyright (c) 2022 vesoft inc. All rights reserved.
+ *
+ * This source code is licensed under Apache 2.0 License.
+ */
+
+#pragma once
+
+#include "common/datatypes/Date.h"
+
+namespace nebula {
+namespace time {
+
+struct TimeResult {
+  Time t;
+  bool withTimeZone{false};
+};
+
+static inline bool operator==(const TimeResult& lhs, const TimeResult& rhs) {
+  return lhs.t == rhs.t && lhs.withTimeZone == rhs.withTimeZone;
+}
+
+static inline std::ostream& operator<<(std::ostream& os, const TimeResult& result) {
+  os << result.t;
+  if (result.withTimeZone) {
+    os << "Z";
+  }
+  return os;
+}
+
+struct Result {
+  TimeResult time() const {
+    return TimeResult{dt.time(), withTimeZone};
+  }
+
+  DateTime dt;
+  bool withTimeZone{false};
+};
+
+static inline bool operator==(const Result& lhs, const Result& rhs) {
+  return lhs.dt == rhs.dt && lhs.withTimeZone == rhs.withTimeZone;
+}
+
+static inline std::ostream& operator<<(std::ostream& os, const Result& result) {
+  os << result.dt;
+  if (result.withTimeZone) {
+    os << "Z";
+  }
+  return os;
+}
+
+}  // namespace time
+}  // namespace nebula
diff --git a/src/common/time/parser/datetime_parser.yy b/src/common/time/parser/datetime_parser.yy
index 5d19a1a4e33..7ea6bda157a 100644
--- a/src/common/time/parser/datetime_parser.yy
+++ b/src/common/time/parser/datetime_parser.yy
@@ -7,7 +7,7 @@
 %lex-param { nebula::time::DatetimeScanner& scanner }
 %parse-param { nebula::time::DatetimeScanner& scanner }
 %parse-param { std::string &errmsg }
-%parse-param { nebula::DateTime** output }
+%parse-param { Result** output }
 
 %code requires {
 #include <iostream>
@@ -18,6 +18,7 @@
 #include "common/time/TimeConversion.h"
 #include "common/time/TimezoneInfo.h"
 #include "common/time/TimeUtils.h"
+#include "common/time/parser/Result.h"
 
 namespace nebula {
 namespace time {
@@ -41,11 +42,12 @@ class DatetimeScanner;
     nebula::Date                           *dVal;
     nebula::Time                           *tVal;
     std::string                            *strVal;
+    Result                                 *result;
 }
 
 /* destructors */
 %destructor {} <intVal> <doubleVal>
-%destructor {} <dtVal>  // for output
+%destructor {} <result>  // for output
 %destructor { delete $$; } <*>
 
 /* keyword */
@@ -59,10 +61,10 @@ class DatetimeScanner;
 %token <strVal> TIME_ZONE_NAME
 %token <doubleVal> DOUBLE
 
-%type <dtVal> datetime
+%type <result> datetime
 %type <dVal> date
 %type <tVal> time
-%type <intVal> opt_time_zone time_zone_offset opt_time_zone_offset opt_time_zone_name
+%type <intVal> time_zone time_zone_offset unsigned_time_zone_offset time_zone_name
 
 %define api.prefix {datetime}
 
@@ -71,24 +73,35 @@ class DatetimeScanner;
 %%
 
 datetime
-  : KW_DATETIME date date_time_delimiter time opt_time_zone {
-    $$ = new DateTime(TimeConversion::dateTimeShift(DateTime(*$2, *$4), -$5));
+  : KW_DATETIME date date_time_delimiter time time_zone {
+    $$ = new Result {DateTime(TimeConversion::dateTimeShift(DateTime(*$2, *$4), -$5)), true};
+    *output = $$;
+    delete $2;
+    delete $4;
+  }
+  | KW_DATETIME date date_time_delimiter time {
+    $$ = new Result {DateTime(*$2, *$4), false};
     *output = $$;
     delete $2;
     delete $4;
   }
   | KW_DATETIME date {
-    $$ = new DateTime(*$2);
+    $$ = new Result {DateTime(*$2), false};
     *output = $$;
     delete $2;
   }
   | KW_DATE date {
-    $$ = new DateTime(*$2);
+    $$ = new Result {DateTime(*$2), false};
+    *output = $$;
+    delete $2;
+  }
+  | KW_TIME time time_zone {
+    $$ = new Result {DateTime(TimeConversion::dateTimeShift(DateTime(1970, 1, 1, $2->hour, $2->minute, $2->sec, $2->microsec), -$3)), true};
     *output = $$;
     delete $2;
   }
-  | KW_TIME time opt_time_zone {
-    $$ = new DateTime(TimeConversion::dateTimeShift(DateTime(1970, 1, 1, $2->hour, $2->minute, $2->sec, $2->microsec), -$3));
+  | KW_TIME time {
+    $$ = new Result {DateTime(1970, 1, 1, $2->hour, $2->minute, $2->sec, $2->microsec), false};
     *output = $$;
     delete $2;
   }
@@ -163,34 +176,31 @@ time
   }
   ;
 
-opt_time_zone
-  : %empty {
-    $$ = 0;
-  }
-  | opt_time_zone_offset opt_time_zone_name {
+time_zone
+  : time_zone_offset time_zone_name {
     if ($1 != $2) {
       throw DatetimeParser::syntax_error(@1, "Mismatched timezone offset.");
     }
     $$ = $1;
   }
-  | opt_time_zone_offset {
+  | time_zone_offset {
     $$ = $1;
   }
-  | opt_time_zone_name {
+  | time_zone_name {
     $$ = $1;
   }
   ;
 
-opt_time_zone_offset
-  : POSITIVE time_zone_offset {
+time_zone_offset
+  : POSITIVE unsigned_time_zone_offset {
     $$ = $2;
   }
-  | NEGATIVE time_zone_offset {
+  | NEGATIVE unsigned_time_zone_offset {
     $$ = -$2;
   }
   ;
 
-time_zone_offset
+unsigned_time_zone_offset
   : INTEGER TIME_DELIMITER INTEGER {
     auto time = nebula::Time($1, $3, 0, 0);
     auto result = nebula::time::TimeUtils::validateTime(time);
@@ -201,7 +211,7 @@ time_zone_offset
   }
   ;
 
-opt_time_zone_name
+time_zone_name
   : TIME_ZONE_NAME {
     auto zone = nebula::time::Timezone();
     auto result = zone.loadFromDb(*$1);
diff --git a/src/common/time/parser/test/DateTimeParserTest.cpp b/src/common/time/parser/test/DateTimeParserTest.cpp
index d5f2693fac9..0a5455cedbf 100644
--- a/src/common/time/parser/test/DateTimeParserTest.cpp
+++ b/src/common/time/parser/test/DateTimeParserTest.cpp
@@ -8,6 +8,7 @@
 #include "common/base/Base.h"
 #include "common/time/TimezoneInfo.h"
 #include "common/time/parser/DatetimeReader.h"
+#include "common/time/parser/Result.h"
 
 namespace nebula {
 
@@ -16,80 +17,84 @@ TEST(DatetimeReader, DateTime) {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("2019-01-03T22:22:3.2333");
     ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::DateTime(2019, 1, 3, 22, 22, 3, 233300), result.value());
+    EXPECT_EQ((time::Result{nebula::DateTime(2019, 1, 3, 22, 22, 3, 233300), false}),
+              result.value());
   }
   // with offset
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("2019-01-03T22:22:3.2333+02:30");
     ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::DateTime(2019, 1, 3, 19, 52, 3, 233300), result.value());
+    EXPECT_EQ((time::Result{nebula::DateTime(2019, 1, 3, 19, 52, 3, 233300), true}),
+              result.value());
   }
   // lack day
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("2019-01T22:22:3.2333");
     ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::DateTime(2019, 1, 1, 22, 22, 3, 233300), result.value());
+    EXPECT_EQ((time::Result{nebula::DateTime(2019, 1, 1, 22, 22, 3, 233300), false}),
+              result.value());
   }
   // lack month
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("2019T22:22:3.2333");
     ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::DateTime(2019, 1, 1, 22, 22, 3, 233300), result.value());
+    EXPECT_EQ((time::Result{nebula::DateTime(2019, 1, 1, 22, 22, 3, 233300), false}),
+              result.value());
   }
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("2019T22:22");
     ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::DateTime(2019, 1, 1, 22, 22, 0, 0), result.value());
+    EXPECT_EQ((time::Result{nebula::DateTime(2019, 1, 1, 22, 22, 0, 0), false}), result.value());
   }
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("2019T22");
     ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::DateTime(2019, 1, 1, 22, 0, 0, 0), result.value());
+    EXPECT_EQ((time::Result{nebula::DateTime(2019, 1, 1, 22, 0, 0, 0), false}), result.value());
   }
   // lack us
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("2019-1T22:22:3");
     ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::DateTime(2019, 1, 1, 22, 22, 3, 0), result.value());
+    EXPECT_EQ((time::Result{nebula::DateTime(2019, 1, 1, 22, 22, 3, 0), false}), result.value());
   }
   // lack second
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("2019-1T22:22");
     ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::DateTime(2019, 1, 1, 22, 22, 0, 0), result.value());
+    EXPECT_EQ((time::Result{nebula::DateTime(2019, 1, 1, 22, 22, 0, 0), false}), result.value());
   }
   // lack minute
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("2019-1T22");
     ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::DateTime(2019, 1, 1, 22, 0, 0, 0), result.value());
+    EXPECT_EQ((time::Result{nebula::DateTime(2019, 1, 1, 22, 0, 0, 0), false}), result.value());
   }
   // datetime just include date
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("2019-1-1");
     ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::DateTime(2019, 1, 1, 0, 0, 0, 0), result.value());
+    EXPECT_EQ((time::Result{nebula::DateTime(2019, 1, 1, 0, 0, 0, 0), false}), result.value());
   }
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("2019-1");
     ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::DateTime(2019, 1, 1, 0, 0, 0, 0), result.value());
+    EXPECT_EQ((time::Result{nebula::DateTime(2019, 1, 1, 0, 0, 0, 0), false}), result.value());
   }
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("2019");
     ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::DateTime(2019, 1, 1, 0, 0, 0, 0), result.value());
+    EXPECT_EQ((time::Result{nebula::DateTime(2019, 1, 1, 0, 0, 0, 0), false}), result.value());
   }
 }
 
@@ -98,57 +103,57 @@ TEST(DatetimeReader, DateTimeFailed) {
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("2019-01-03T22:22:3.2333+24:30");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   // only time
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("22:22:3.2333");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   // with unexpected character
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("2019-01-03T22:22:3.2333x");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("2019-01-03T22:22:3.2333\n");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("\t2019-01-03T22:22:3.2333");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   // not ending delimiter
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("2019-01-T22:22:3.2333");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("2019-01-03T22:22:.2333");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   // not ending prefix
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("2019-01-03T");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("2019-01-03T22:22:3.");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   // not exits prefix
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDatetime("-01-03T22:22:3.2333");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
 }
 
@@ -187,46 +192,46 @@ TEST(DatetimeReader, DateFailed) {
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDate("2019-01-03+23:00");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   // with unexpected character
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDate("2019-01-03*");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDate("2019-01-03\n");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDate("\t2019-01-03");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   // extra components
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDate("2019-01-03T22:22:3.2333");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   // not ending delimiter
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDate("2019-01-");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDate("2019-");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   // not exits prefix
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readDate("-01-03");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
 }
 
@@ -235,41 +240,41 @@ TEST(DatetimeReader, Time) {
     auto parser = time::DatetimeReader();
     auto result = parser.readTime("22:22:3.2333");
     ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::Time(22, 22, 3, 233300), result.value());
+    EXPECT_EQ((time::TimeResult{nebula::Time(22, 22, 3, 233300), false}), result.value());
   }
   // with offset
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readTime("22:22:3.2333-03:30");
     ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::Time(1, 52, 3, 233300), result.value());
+    EXPECT_EQ((time::TimeResult{nebula::Time(1, 52, 3, 233300), true}), result.value());
   }
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readTime("22:22:3.2333-03:30");
     ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::Time(1, 52, 3, 233300), result.value());
+    EXPECT_EQ((time::TimeResult{nebula::Time(1, 52, 3, 233300), true}), result.value());
   }
   // lack us
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readTime("22:22:3");
     ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::Time(22, 22, 3, 0), result.value());
+    EXPECT_EQ((time::TimeResult{nebula::Time(22, 22, 3, 0), false}), result.value());
   }
   // lack second
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readTime("22:22");
     ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::Time(22, 22, 0, 0), result.value());
+    EXPECT_EQ((time::TimeResult{nebula::Time(22, 22, 0, 0), false}), result.value());
   }
   // lack minute
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readTime("22");
     ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::Time(22, 0, 0, 0), result.value());
+    EXPECT_EQ((time::TimeResult{nebula::Time(22, 0, 0, 0), false}), result.value());
   }
 }
 
@@ -278,47 +283,47 @@ TEST(DatetimeReader, TimeFailed) {
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readTime("22:22:3.2333-03:60");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   // unexpected character
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readTime("22:22:3.2333x");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readTime("22:22:3.2333\n");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readTime("\t22:22:3.2333\n");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   // extra components
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readTime("2019-01-03T22:22:3.2333");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   // not ending delimiter
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readTime("22:22:.2333");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   // not ending prefix
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readTime("22:22:3.");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
   // not exist prefix
   {
     auto parser = time::DatetimeReader();
     auto result = parser.readTime(":22:3.2333");
-    EXPECT_FALSE(result.ok()) << result.value();
+    EXPECT_FALSE(result.ok());
   }
 }
 
diff --git a/src/common/time/test/TimeUtilsTest.cpp b/src/common/time/test/TimeUtilsTest.cpp
index d0cc1edf7be..9bc70e5f356 100644
--- a/src/common/time/test/TimeUtilsTest.cpp
+++ b/src/common/time/test/TimeUtilsTest.cpp
@@ -160,12 +160,12 @@ TEST(Time, Parse) {
   {
     auto result = time::TimeUtils::parseDateTime("2019-03-04 22:00:30");
     ASSERT_TRUE(result.ok());
-    EXPECT_EQ(result.value(), DateTime(2019, 3, 4, 22, 0, 30, 0));
+    EXPECT_EQ(result.value(), (time::Result{DateTime(2019, 3, 4, 22, 0, 30, 0), false}));
   }
   {
     auto result = time::TimeUtils::parseDateTime("2019-03-04T22:00:30");
     ASSERT_TRUE(result.ok());
-    EXPECT_EQ(result.value(), DateTime(2019, 3, 4, 22, 0, 30, 0));
+    EXPECT_EQ(result.value(), (time::Result{DateTime(2019, 3, 4, 22, 0, 30, 0), false}));
   }
 }
 
diff --git a/src/meta/test/MetaClientTest.cpp b/src/meta/test/MetaClientTest.cpp
index 7bccd04d379..212eb03734c 100644
--- a/src/meta/test/MetaClientTest.cpp
+++ b/src/meta/test/MetaClientTest.cpp
@@ -15,6 +15,7 @@
 #include "common/meta/GflagsManager.h"
 #include "common/meta/ServerBasedSchemaManager.h"
 #include "common/network/NetworkUtils.h"
+#include "common/time/TimezoneInfo.h"
 #include "common/utils/MetaKeyUtils.h"
 #include "interface/gen-cpp2/common_constants.h"
 #include "meta/processors/zone/AddHostsProcessor.h"
@@ -2799,5 +2800,12 @@ int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   folly::init(&argc, &argv, true);
   google::SetStderrLogging(google::INFO);
+  // Initialize the global timezone, it's only used for datetime type compute
+  // won't affect the process timezone.
+  auto status = nebula::time::Timezone::initializeGlobalTimezone();
+  if (!status.ok()) {
+    LOG(ERROR) << status;
+    return EXIT_FAILURE;
+  }
   return RUN_ALL_TESTS();
 }