diff --git a/CMakeLists.txt b/CMakeLists.txt
index 05fe56e0351..da676c5716f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -79,6 +79,7 @@ macro(nebula_add_library name type)
         # hbase_thrift_generator
         parser_target
         wkt_parser_target
+        datetime_parser_target
     )
 endmacro()
 
diff --git a/src/codec/test/CMakeLists.txt b/src/codec/test/CMakeLists.txt
index 1d761a12d88..f529f16431e 100644
--- a/src/codec/test/CMakeLists.txt
+++ b/src/codec/test/CMakeLists.txt
@@ -31,6 +31,7 @@ set(CODEC_TEST_LIBS
     $<TARGET_OBJECTS:wkt_wkb_io_obj>
     $<TARGET_OBJECTS:agg_function_manager_obj>
     $<TARGET_OBJECTS:time_utils_obj>
+    $<TARGET_OBJECTS:datetime_parser_obj>
     $<TARGET_OBJECTS:version_obj>
     $<TARGET_OBJECTS:ssl_obj>
 )
diff --git a/src/common/datatypes/Date.cpp b/src/common/datatypes/Date.cpp
index 6252588ec7e..7c2fd9861a6 100644
--- a/src/common/datatypes/Date.cpp
+++ b/src/common/datatypes/Date.cpp
@@ -12,6 +12,11 @@
 
 namespace nebula {
 
+static inline std::string decimal(const std::string& number) {
+  auto find = std::find(number.begin(), number.end(), '.');
+  return std::string(find, number.end());
+}
+
 const int64_t kDaysSoFar[] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
 const int64_t kLeapDaysSoFar[] = {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366};
 
@@ -98,22 +103,26 @@ std::string Date::toString() const {
 }
 
 std::string Time::toString() const {
+  auto microsecStr = folly::stringPrintf("%.9f", static_cast<uint32_t>(microsec) / 1000000.0);
+  auto decimalPart = decimal(microsecStr);
   // It's in current timezone already
-  return folly::stringPrintf("%02d:%02d:%02d.%06d", hour, minute, sec, microsec);
+  return folly::stringPrintf("%02d:%02d:%02d%s", hour, minute, sec, decimalPart.c_str());
 }
 
 std::string DateTime::toString() const {
+  auto microsecStr = folly::stringPrintf("%.9f", static_cast<uint32_t>(microsec) / 1000000.0);
+  auto decimalPart = decimal(microsecStr);
   // It's in current timezone already
   return folly::stringPrintf(
       "%hd-%02hhu-%02hhu"
-      "T%02hhu:%02hhu:%02hhu.%u",
+      "T%02hhu:%02hhu:%02hhu%s",
       static_cast<int16_t>(year),
       static_cast<uint8_t>(month),
       static_cast<uint8_t>(day),
       static_cast<uint8_t>(hour),
       static_cast<uint8_t>(minute),
       static_cast<uint8_t>(sec),
-      static_cast<uint32_t>(microsec));
+      decimalPart.c_str());
 }
 
 }  // namespace nebula
diff --git a/src/common/datatypes/Date.h b/src/common/datatypes/Date.h
index 80b58243bb6..a7bd42e0c48 100644
--- a/src/common/datatypes/Date.h
+++ b/src/common/datatypes/Date.h
@@ -164,6 +164,19 @@ struct DateTime {
     sec = 0;
     microsec = 0;
   }
+  explicit DateTime(const Date& date, const Time& time) {
+    year = date.year;
+    month = date.month;
+    day = date.day;
+    hour = time.hour;
+    minute = time.minute;
+    sec = time.sec;
+    microsec = time.microsec;
+  }
+
+  Date date() const { return Date(year, month, day); }
+
+  Time time() const { return Time(hour, minute, sec, microsec); }
 
   void clear() {
     year = 0;
diff --git a/src/common/datatypes/test/CMakeLists.txt b/src/common/datatypes/test/CMakeLists.txt
index e2feb822850..beff0176017 100644
--- a/src/common/datatypes/test/CMakeLists.txt
+++ b/src/common/datatypes/test/CMakeLists.txt
@@ -44,6 +44,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:agg_function_manager_obj>
         $<TARGET_OBJECTS:time_utils_obj>
         $<TARGET_OBJECTS:time_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:fs_obj>
         $<TARGET_OBJECTS:wkt_wkb_io_obj>
     LIBRARIES
@@ -65,6 +66,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:wkt_wkb_io_obj>
         $<TARGET_OBJECTS:time_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:fs_obj>
     LIBRARIES
         gtest
@@ -110,6 +112,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:function_manager_obj>
         $<TARGET_OBJECTS:agg_function_manager_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:time_obj>
         $<TARGET_OBJECTS:fs_obj>
     LIBRARIES
diff --git a/src/common/datatypes/test/ValueToJsonTest.cpp b/src/common/datatypes/test/ValueToJsonTest.cpp
index a35220fc78a..457b666051d 100644
--- a/src/common/datatypes/test/ValueToJsonTest.cpp
+++ b/src/common/datatypes/test/ValueToJsonTest.cpp
@@ -136,7 +136,7 @@ TEST(ValueToJson, list) {
                            Time(13, 30, 15, 0),                       // time
                            DateTime(2021, 12, 21, 13, 30, 15, 0)}));  // datetime
   dynamic expectedListJsonObj = dynamic::array(
-      2, 2.33, true, "str", "2021-12-21", "13:30:15.000000Z", "2021-12-21T13:30:15.0Z");
+      2, 2.33, true, "str", "2021-12-21", "13:30:15.000000000Z", "2021-12-21T13:30:15.000000000Z");
   ASSERT_EQ(expectedListJsonObj, list1.toJson());
 
   dynamic expectedListMetaObj = dynamic::array(nullptr,
@@ -158,7 +158,7 @@ TEST(ValueToJson, Set) {
                         Time(13, 30, 15, 0),                       // time
                         DateTime(2021, 12, 21, 13, 30, 15, 0)}));  // datetime
   dynamic expectedSetJsonObj = dynamic::array(
-      2, 2.33, true, "str", "2021-12-21", "13:30:15.000000Z", "2021-12-21T13:30:15.0Z");
+      2, 2.33, true, "str", "2021-12-21", "13:30:15.000000000Z", "2021-12-21T13:30:15.000000000Z");
   // The underlying data structure is unordered_set, so sort before the comparison
   auto actualJson = set.toJson();
   std::sort(actualJson.begin(), actualJson.end());
@@ -179,7 +179,7 @@ TEST(ValueToJson, map) {
                         {"key7", DateTime(2021, 12, 21, 13, 30, 15, 0)}}));  // datetime
   dynamic expectedMapJsonObj =
       dynamic::object("key1", 2)("key2", 2.33)("key3", true)("key4", "str")("key5", "2021-12-21")(
-          "key6", "13:30:15.000000Z")("key7", "2021-12-21T13:30:15.0Z");
+          "key6", "13:30:15.000000000Z")("key7", "2021-12-21T13:30:15.000000000Z");
   ASSERT_EQ(expectedMapJsonObj, map.toJson());
   // Skip meta json comparison since nested dynamic objects cannot be sorted. i.g. dynamic::object
   // inside dynamic::array
@@ -194,18 +194,23 @@ TEST(ValueToJson, dataset) {
                              Date(2021, 12, 21),   // date
                              Time(13, 30, 15, 0),  // time
                              DateTime(2021, 12, 21, 13, 30, 15, 0)}));
-  dynamic expectedDatasetJsonObj = dynamic::array(dynamic::object(
-      "row",
-      dynamic::array(
-          2, 2.33, true, "str", "2021-12-21", "13:30:15.000000Z", "2021-12-21T13:30:15.0Z"))(
-      "meta",
-      dynamic::array(nullptr,
-                     nullptr,
-                     nullptr,
-                     nullptr,
-                     dynamic::object("type", "date"),
-                     dynamic::object("type", "time"),
-                     dynamic::object("type", "datetime"))));
+  dynamic expectedDatasetJsonObj =
+      dynamic::array(dynamic::object("row",
+                                     dynamic::array(2,
+                                                    2.33,
+                                                    true,
+                                                    "str",
+                                                    "2021-12-21",
+                                                    "13:30:15.000000000Z",
+                                                    "2021-12-21T13:30:15.000000000Z"))(
+          "meta",
+          dynamic::array(nullptr,
+                         nullptr,
+                         nullptr,
+                         nullptr,
+                         dynamic::object("type", "date"),
+                         dynamic::object("type", "time"),
+                         dynamic::object("type", "datetime"))));
   ASSERT_EQ(expectedDatasetJsonObj, dataset.toJson());
 }
 
diff --git a/src/common/expression/test/CMakeLists.txt b/src/common/expression/test/CMakeLists.txt
index 1cda6272cd3..4457d468103 100644
--- a/src/common/expression/test/CMakeLists.txt
+++ b/src/common/expression/test/CMakeLists.txt
@@ -11,6 +11,7 @@ set(expression_test_common_libs
     $<TARGET_OBJECTS:stats_obj>
     $<TARGET_OBJECTS:datatypes_obj>
     $<TARGET_OBJECTS:time_obj>
+    $<TARGET_OBJECTS:datetime_parser_obj>
     $<TARGET_OBJECTS:common_thrift_obj>
     $<TARGET_OBJECTS:thrift_obj>
     $<TARGET_OBJECTS:thread_obj>
@@ -113,6 +114,7 @@ nebula_add_executable(
         $<TARGET_OBJECTS:wkt_wkb_io_obj>
         $<TARGET_OBJECTS:time_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:fs_obj>
         $<TARGET_OBJECTS:agg_function_manager_obj>
     LIBRARIES
@@ -136,6 +138,7 @@ nebula_add_executable(
         $<TARGET_OBJECTS:agg_function_manager_obj>
         $<TARGET_OBJECTS:time_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:fs_obj>
     LIBRARIES
         follybenchmark
diff --git a/src/common/function/test/CMakeLists.txt b/src/common/function/test/CMakeLists.txt
index a1e5366cc08..b8517314dfe 100644
--- a/src/common/function/test/CMakeLists.txt
+++ b/src/common/function/test/CMakeLists.txt
@@ -13,6 +13,7 @@ nebula_add_test(
         $<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
diff --git a/src/common/function/test/FunctionManagerTest.cpp b/src/common/function/test/FunctionManagerTest.cpp
index a34a88e0d06..0bcc1f133d7 100644
--- a/src/common/function/test/FunctionManagerTest.cpp
+++ b/src/common/function/test/FunctionManagerTest.cpp
@@ -318,7 +318,7 @@ TEST_F(FunctionManagerTest, functionCall) {
     TEST_FUNCTION(toString, args_["toString_bool"], "true");
     TEST_FUNCTION(toString, args_["string"], "AbcDeFG");
     TEST_FUNCTION(toString, args_["date"], "1984-10-11");
-    TEST_FUNCTION(toString, args_["datetime"], "1984-10-11T12:31:14.341");
+    TEST_FUNCTION(toString, args_["datetime"], "1984-10-11T12:31:14.000341000");
     TEST_FUNCTION(toString, args_["nullvalue"], Value::kNullValue);
   }
   {
@@ -327,8 +327,9 @@ TEST_F(FunctionManagerTest, functionCall) {
     DateTime dateTime(2021, 10, 31, 8, 5, 34, 29);
     TEST_FUNCTION(concat, std::vector<Value>({"hello", 1, "world"}), "hello1world");
     TEST_FUNCTION(concat, std::vector<Value>({true, 2, date}), "true22021-10-31");
-    TEST_FUNCTION(concat, std::vector<Value>({true, dateTime}), "true2021-10-31T08:05:34.29");
-    TEST_FUNCTION(concat, std::vector<Value>({2.3, time}), "2.309:39:21.000012");
+    TEST_FUNCTION(
+        concat, std::vector<Value>({true, dateTime}), "true2021-10-31T08:05:34.000029000");
+    TEST_FUNCTION(concat, std::vector<Value>({2.3, time}), "2.309:39:21.000012000");
     TEST_FUNCTION(concat, args_["two"], "24");
     TEST_FUNCTION(concat_ws, std::vector<Value>({",", 1}), "1");
     TEST_FUNCTION(concat_ws, std::vector<Value>({"@", 1, "world"}), "1@world");
@@ -337,7 +338,7 @@ TEST_F(FunctionManagerTest, functionCall) {
                   "1ABtrueABworld");
     TEST_FUNCTION(concat_ws,
                   std::vector<Value>({".", 1, true, Value::kNullValue, "world", time}),
-                  "1.true.world.09:39:21.000012");
+                  "1.true.world.09:39:21.000012000");
   }
   {
     TEST_FUNCTION(toBoolean, args_["int"], Value::kNullBadType);
diff --git a/src/common/geo/test/CMakeLists.txt b/src/common/geo/test/CMakeLists.txt
index e1455c56154..932fffb14e6 100644
--- a/src/common/geo/test/CMakeLists.txt
+++ b/src/common/geo/test/CMakeLists.txt
@@ -13,6 +13,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:base_obj>
         $<TARGET_OBJECTS:datatypes_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:time_obj>
     LIBRARIES
         gtest
diff --git a/src/common/time/CMakeLists.txt b/src/common/time/CMakeLists.txt
index f1f239a3150..5fef0592a4c 100644
--- a/src/common/time/CMakeLists.txt
+++ b/src/common/time/CMakeLists.txt
@@ -16,4 +16,6 @@ nebula_add_library(
     TimeConversion.cpp
 )
 
+nebula_add_subdirectory(parser)
+
 nebula_add_subdirectory(test)
diff --git a/src/common/time/TimeUtils.cpp b/src/common/time/TimeUtils.cpp
index e9e65fb6361..5733fa72be1 100644
--- a/src/common/time/TimeUtils.cpp
+++ b/src/common/time/TimeUtils.cpp
@@ -9,6 +9,7 @@
 
 #include "common/fs/FileUtils.h"
 #include "common/time/TimezoneInfo.h"
+#include "common/time/parser/DatetimeReader.h"
 
 namespace nebula {
 namespace time {
@@ -170,5 +171,24 @@ StatusOr<Value> TimeUtils::toTimestamp(const Value &val) {
   return timestamp;
 }
 
+/*static*/ StatusOr<DateTime> TimeUtils::parseDateTime(const std::string &str) {
+  auto p = DatetimeReader::makeDateTimeReader();
+  auto result = p.readDatetime(str);
+  NG_RETURN_IF_ERROR(result);
+  return result.value();
+}
+
+/*static*/ StatusOr<Date> TimeUtils::parseDate(const std::string &str) {
+  auto p = DatetimeReader::makeDateReader();
+  auto result = p.readDate(str);
+  NG_RETURN_IF_ERROR(result);
+  return result.value();
+}
+
+/*static*/ StatusOr<Time> TimeUtils::parseTime(const std::string &str) {
+  auto p = DatetimeReader::makeTimeReader();
+  return p.readTime(str);
+}
+
 }  // namespace time
 }  // namespace nebula
diff --git a/src/common/time/TimeUtils.h b/src/common/time/TimeUtils.h
index 2c409817391..0a9355b3ef1 100644
--- a/src/common/time/TimeUtils.h
+++ b/src/common/time/TimeUtils.h
@@ -46,30 +46,27 @@ class TimeUtils {
     return Status::OK();
   }
 
-  // TODO(shylock) support more format
-  static StatusOr<DateTime> parseDateTime(const std::string &str) {
-    std::tm tm;
-    std::istringstream ss(str);
-    ss >> std::get_time(&tm, "%Y-%m-%dT%H:%M:%S");
-    if (ss.fail()) {
-      std::istringstream ss2(str);
-      ss2 >> std::get_time(&tm, "%Y-%m-%d %H:%M:%S");
-      if (ss2.fail()) {
-        return Status::Error();
-      }
+  template <
+      typename D,
+      typename = std::enable_if_t<std::is_same<D, Time>::value || std::is_same<D, DateTime>::value>>
+  static Status validateTime(const D &time) {
+    if (time.hour < 0 || time.hour >= 24) {
+      return Status::Error("Invalid hour number %d.", time.hour);
     }
-    DateTime dt;
-    dt.year = tm.tm_year + 1900;
-    dt.month = tm.tm_mon + 1;
-    dt.day = tm.tm_mday;
-    dt.hour = tm.tm_hour;
-    dt.minute = tm.tm_min;
-    dt.sec = tm.tm_sec;
-    dt.microsec = 0;
-    NG_RETURN_IF_ERROR(validateDate(dt));
-    return dt;
+    if (time.minute < 0 || time.minute >= 60) {
+      return Status::Error("Invalid minute number %d.", time.minute);
+    }
+    if (time.sec < 0 || time.sec >= 60) {
+      return Status::Error("Invalid second number %d.", time.sec);
+    }
+    if (time.microsec < 0 || time.microsec >= 1000000) {
+      return Status::Error("Invalid microsecond number %d.", time.microsec);
+    }
+    return Status::OK();
   }
 
+  static StatusOr<DateTime> parseDateTime(const std::string &str);
+
   static StatusOr<DateTime> dateTimeFromMap(const Map &m);
 
   // utc + offset = local
@@ -119,21 +116,7 @@ class TimeUtils {
 
   static StatusOr<Date> dateFromMap(const Map &m);
 
-  // TODO(shylock) support more format
-  static StatusOr<Date> parseDate(const std::string &str) {
-    std::tm tm;
-    std::istringstream ss(str);
-    ss >> std::get_time(&tm, "%Y-%m-%d");
-    if (ss.fail()) {
-      return Status::Error();
-    }
-    Date d;
-    d.year = tm.tm_year + 1900;
-    d.month = tm.tm_mon + 1;
-    d.day = tm.tm_mday;
-    NG_RETURN_IF_ERROR(validateDate(d));
-    return d;
-  }
+  static StatusOr<Date> parseDate(const std::string &str);
 
   static StatusOr<Date> localDate() {
     Date d;
@@ -169,21 +152,7 @@ class TimeUtils {
 
   static StatusOr<Time> timeFromMap(const Map &m);
 
-  // TODO(shylock) support more format
-  static StatusOr<Time> parseTime(const std::string &str) {
-    std::tm tm;
-    std::istringstream ss(str);
-    ss >> std::get_time(&tm, "%H:%M:%S");
-    if (ss.fail()) {
-      return Status::Error();
-    }
-    Time t;
-    t.hour = tm.tm_hour;
-    t.minute = tm.tm_min;
-    t.sec = tm.tm_sec;
-    t.microsec = 0;
-    return t;
-  }
+  static StatusOr<Time> parseTime(const std::string &str);
 
   // utc + offset = local
   static Time timeToUTC(const Time &time) {
diff --git a/src/common/time/TimezoneInfo.cpp b/src/common/time/TimezoneInfo.cpp
index c82007f1f7b..0094ccc1cca 100644
--- a/src/common/time/TimezoneInfo.cpp
+++ b/src/common/time/TimezoneInfo.cpp
@@ -36,7 +36,6 @@ namespace time {
   }
   if (!FLAGS_timezone_name.empty()) {
     if (FLAGS_timezone_name.front() == ':') {
-      NG_RETURN_IF_ERROR(Timezone::init());
       return globalTimezone.loadFromDb(
           std::string(FLAGS_timezone_name.begin() + 1, FLAGS_timezone_name.end()));
     } else {
diff --git a/src/common/time/parser/CMakeLists.txt b/src/common/time/parser/CMakeLists.txt
new file mode 100644
index 00000000000..5167484655b
--- /dev/null
+++ b/src/common/time/parser/CMakeLists.txt
@@ -0,0 +1,26 @@
+# Copyright (c) 2020 vesoft inc. All rights reserved.
+#
+# This source code is licensed under Apache 2.0 License.
+
+if(ENABLE_VERBOSE_BISON)
+    set(bison_flags "-Werror -v")
+else()
+    set(bison_flags "-Werror")
+endif()
+bison_target(Parser datetime_parser.yy ${CMAKE_CURRENT_BINARY_DIR}/DatetimeParser.cpp COMPILE_FLAGS ${bison_flags})
+flex_target(Scanner datetime_scanner.lex ${CMAKE_CURRENT_BINARY_DIR}/DatetimeScanner.cpp)
+
+add_custom_target(datetime_parser_target DEPENDS ${FLEX_Scanner_OUTPUTS} ${BISON_Parser_OUTPUTS})
+
+add_flex_bison_dependency(Scanner Parser)
+
+add_compile_options(-Wno-sign-compare -Wno-conversion-null -Wno-pedantic -Wno-extra)
+
+nebula_add_library(
+    datetime_parser_obj OBJECT
+    ${FLEX_Scanner_OUTPUTS}
+    ${BISON_Parser_OUTPUTS}
+    DatetimeReader.cpp
+)
+
+nebula_add_subdirectory(test)
diff --git a/src/common/time/parser/DatetimeReader.cpp b/src/common/time/parser/DatetimeReader.cpp
new file mode 100644
index 00000000000..76b2bc265c1
--- /dev/null
+++ b/src/common/time/parser/DatetimeReader.cpp
@@ -0,0 +1,61 @@
+/* Copyright (c) 2021 vesoft inc. All rights reserved.
+ *
+ * This source code is licensed under Apache 2.0 License.
+ */
+
+#include "common/time/parser/DatetimeReader.h"
+
+namespace nebula {
+namespace time {
+
+DatetimeReader::DatetimeReader(Type type) : parser_(scanner_, error_, &dt_, type) {
+  // Callback invoked by DatetimeScanner
+  auto readBuffer = [this](char *buf, int maxSize) -> int {
+    // Reach the end
+    if (pos_ >= end_) {
+      pos_ = nullptr;
+      end_ = nullptr;
+      return 0;
+    }
+    int left = end_ - pos_;
+    auto n = maxSize > left ? left : maxSize;
+    ::memcpy(buf, pos_, n);
+    pos_ += n;
+    return n;  // Number of bytes we actually filled in `buf'
+  };
+  scanner_.setReadBuffer(std::move(readBuffer));
+}
+
+StatusOr<DateTime> 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];
+  end_ = pos_ + buffer_.size();
+
+  scanner_.setInput(&buffer_);
+  if (parser_.parse() != 0) {
+    pos_ = nullptr;
+    end_ = nullptr;
+    // To flush the internal buffer to recover from a failure
+    scanner_.flushBuffer();
+    if (dt_ != nullptr) {
+      delete dt_;
+      dt_ = nullptr;
+    }
+    scanner_.setInput(nullptr);
+    return Status::SyntaxError(error_);
+  }
+
+  if (dt_ == nullptr) {
+    return Status::StatementEmpty();  // empty
+  }
+  auto dt = dt_;
+  dt_ = nullptr;
+  scanner_.setInput(nullptr);
+  auto tmp = std::move(*dt);
+  delete dt;
+  return tmp;
+}
+
+}  // namespace time
+}  // namespace nebula
diff --git a/src/common/time/parser/DatetimeReader.h b/src/common/time/parser/DatetimeReader.h
new file mode 100644
index 00000000000..3fa43d1eb64
--- /dev/null
+++ b/src/common/time/parser/DatetimeReader.h
@@ -0,0 +1,58 @@
+/* Copyright (c) 2021 vesoft inc. All rights reserved.
+ *
+ * This source code is licensed under Apache 2.0 License.
+ */
+
+#pragma once
+
+#include "common/base/Base.h"
+#include "common/base/StatusOr.h"
+#include "common/datatypes/Date.h"
+#include "common/time/parser/DatetimeParser.hpp"
+#include "common/time/parser/DatetimeScanner.h"
+
+namespace nebula {
+namespace time {
+
+class DatetimeReader {
+ public:
+  ~DatetimeReader() {
+    if (dt_ != nullptr) delete dt_;
+  }
+
+  static inline DatetimeReader makeDateReader() { return DatetimeReader(Type::kDate); }
+
+  static inline DatetimeReader makeTimeReader() { return DatetimeReader(Type::kTime); }
+
+  static inline DatetimeReader makeDateTimeReader() { return DatetimeReader(Type::kDateTime); }
+
+  StatusOr<DateTime> readDatetime(std::string input) { return read(std::move(input)); }
+
+  StatusOr<Date> readDate(std::string input) {
+    auto result = read(std::move(input));
+    NG_RETURN_IF_ERROR(result);
+    return result.value().date();
+  }
+
+  StatusOr<Time> readTime(std::string input) {
+    auto result = read(std::move(input));
+    NG_RETURN_IF_ERROR(result);
+    return result.value().time();
+  }
+
+ private:
+  explicit DatetimeReader(Type type);
+
+  StatusOr<DateTime> read(std::string input);
+
+  std::string buffer_;
+  const char *pos_{nullptr};
+  const char *end_{nullptr};
+  DatetimeScanner scanner_;
+  DatetimeParser parser_;
+  std::string error_;
+  DateTime *dt_{nullptr};
+};
+
+}  // namespace time
+}  // namespace nebula
diff --git a/src/common/time/parser/DatetimeScanner.h b/src/common/time/parser/DatetimeScanner.h
new file mode 100644
index 00000000000..e6dc1584d80
--- /dev/null
+++ b/src/common/time/parser/DatetimeScanner.h
@@ -0,0 +1,68 @@
+/* Copyright (c) 2021 vesoft inc. All rights reserved.
+ *
+ * This source code is licensed under Apache 2.0 License.
+ */
+
+#pragma once
+
+#include "common/base/Base.h"
+
+// This macro must be defined before #include <FlexLexer.h> !!!
+#define yyFlexLexer datetimeFlexLexer
+
+// Only include FlexLexer.h if it hasn't been already included
+#if !defined(yyFlexLexerOnce)
+#include <FlexLexer.h>
+#endif
+
+// Override the interface for yylex since we namespaced it
+#undef YY_DECL
+#define YY_DECL int nebula::time::DatetimeScanner::yylex()
+
+#include "common/time/parser/DatetimeParser.hpp"
+
+namespace nebula {
+namespace time {
+
+class DatetimeScanner : public yyFlexLexer {
+ public:
+  int yylex(nebula::time::DatetimeParser::semantic_type *lval,
+            nebula::time::DatetimeParser::location_type *loc) {
+    yylval = lval;
+    yylloc = loc;
+    return yylex();
+  }
+
+ public:
+  // Called by DatetimeReader to set the `readBuffer' callback, which would be
+  // invoked by LexerInput to fill the stream buffer.
+  void setReadBuffer(std::function<int(char *, int)> readBuffer) { readBuffer_ = readBuffer; }
+
+  // Manually invoked by DatetimeReader to recover from a failure state.
+  // This makes the scanner reentrant.
+  void flushBuffer() {
+    yy_flush_buffer(yy_buffer_stack ? yy_buffer_stack[yy_buffer_stack_top] : nullptr);
+  }
+
+  void setInput(std::string *input) { input_ = input; }
+
+  std::string *input() { return input_; }
+
+ protected:
+  // Called when YY_INPUT is invoked
+  int LexerInput(char *buf, int maxSize) override { return readBuffer_(buf, maxSize); }
+
+  using TokenType = nebula::time::DatetimeParser::token;
+
+ private:
+  // friend class Scanner_Basic_Test; TODO: add it
+  int yylex() override;
+
+  nebula::time::DatetimeParser::semantic_type *yylval{nullptr};
+  nebula::time::DatetimeParser::location_type *yylloc{nullptr};
+  std::function<int(char *, int)> readBuffer_;
+  std::string *input_{nullptr};
+};
+
+}  // namespace time
+}  // namespace nebula
diff --git a/src/common/time/parser/datetime_parser.yy b/src/common/time/parser/datetime_parser.yy
new file mode 100644
index 00000000000..7a1b212ad43
--- /dev/null
+++ b/src/common/time/parser/datetime_parser.yy
@@ -0,0 +1,259 @@
+%language "C++"
+%skeleton "lalr1.cc"
+%no-lines
+%locations
+%define api.namespace { nebula::time }
+%define parser_class_name { DatetimeParser }
+%lex-param { nebula::time::DatetimeScanner& scanner }
+%parse-param { nebula::time::DatetimeScanner& scanner }
+%parse-param { std::string &errmsg }
+%parse-param { nebula::DateTime** output }
+%parse-param { nebula::time::Type outputType }
+
+%code requires {
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <cstddef>
+#include "common/datatypes/Date.h"
+#include "common/time/TimeConversion.h"
+#include "common/time/TimezoneInfo.h"
+#include "common/time/TimeUtils.h"
+
+namespace nebula {
+namespace time {
+class DatetimeScanner;
+
+enum class Type {
+  kDate,
+  kTime,
+  kDateTime,
+};
+}
+}
+
+}
+
+%code {
+    #include "common/time/parser/DatetimeScanner.h"
+    static int yylex(nebula::time::DatetimeParser::semantic_type* yylval,
+                     nebula::time::DatetimeParser::location_type *yylloc,
+                     nebula::time::DatetimeScanner& scanner);
+}
+
+%union {
+    int64_t                                 intVal;
+    double                                  doubleVal;
+    nebula::DateTime                       *dtVal;
+    nebula::Date                           *dVal;
+    nebula::Time                           *tVal;
+    std::string                            *strVal;
+}
+
+/* destructors */
+%destructor {} <intVal> <doubleVal>
+%destructor {} <dtVal>  // for output
+%destructor { delete $$; } <*>
+
+/* keyword */
+%token KW_TIME_ID
+
+/* symbols */
+%token TIME_DELIMITER SPACE POSITIVE NEGATIVE
+
+/* token type specification */
+%token <intVal> INTEGER
+%token <strVal> TIME_ZONE_NAME
+%token <doubleVal> DOUBLE
+
+%type <dtVal> datetime
+%type <dVal> date
+%type <tVal> time
+%type <intVal> opt_time_zone time_zone_offset opt_time_zone_offset opt_time_zone_name
+
+%define api.prefix {datetime}
+
+%start datetime
+
+%%
+
+datetime
+  : date date_time_delimiter time opt_time_zone {
+    if (outputType != nebula::time::Type::kDateTime) {
+      delete $1;
+      delete $3;
+      throw DatetimeParser::syntax_error(@1, "Mismatched date time type.");
+    }
+    $$ = new DateTime(TimeConversion::dateTimeShift(DateTime(*$1, *$3), -$4));
+    *output = $$;
+    delete $1;
+    delete $3;
+  }
+  | date {
+    if (outputType != nebula::time::Type::kDate) {
+      delete $1;
+      throw DatetimeParser::syntax_error(@1, "Mismatched date time type.");
+    }
+    $$ = new DateTime(*$1);
+    *output = $$;
+    delete $1;
+  }
+  | time opt_time_zone {
+    if (outputType != nebula::time::Type::kTime) {
+      delete $1;
+      throw DatetimeParser::syntax_error(@1, "Mismatched date time type.");
+    }
+    $$ = new DateTime(TimeConversion::dateTimeShift(DateTime(1970, 1, 1, $1->hour, $1->minute, $1->sec, $1->microsec), -$2));
+    *output = $$;
+    delete $1;
+  }
+  ;
+
+date_time_delimiter
+  : KW_TIME_ID
+  | SPACE
+  ;
+
+date
+  : INTEGER NEGATIVE INTEGER NEGATIVE INTEGER {
+    $$ = new nebula::Date($1, $3, $5);
+    auto result = nebula::time::TimeUtils::validateDate(*$$);
+    if (!result.ok()) {
+      delete $$;
+      throw DatetimeParser::syntax_error(@1, result.toString());
+    }
+  }
+  | INTEGER NEGATIVE INTEGER {
+    $$ = new nebula::Date($1, $3, 1);
+    auto result = nebula::time::TimeUtils::validateDate(*$$);
+    if (!result.ok()) {
+      delete $$;
+      throw DatetimeParser::syntax_error(@1, result.toString());
+    }
+  }
+  ;
+
+time
+  : INTEGER TIME_DELIMITER INTEGER TIME_DELIMITER DOUBLE {
+    double integer = 0;
+    auto fraction = std::modf($5, &integer);
+    $$ = new nebula::Time($1, $3, static_cast<int>(integer), std::round(fraction * 1000 * 1000));
+    auto result = nebula::time::TimeUtils::validateTime(*$$);
+    if (!result.ok()) {
+      delete $$;
+      throw DatetimeParser::syntax_error(@1, result.toString());
+    }
+  }
+  | INTEGER TIME_DELIMITER INTEGER TIME_DELIMITER INTEGER {
+    $$ = new nebula::Time($1, $3, $5, 0);
+    auto result = nebula::time::TimeUtils::validateTime(*$$);
+    if (!result.ok()) {
+      delete $$;
+      throw DatetimeParser::syntax_error(@1, result.toString());
+    }
+  }
+  | INTEGER TIME_DELIMITER INTEGER {
+    $$ = new nebula::Time($1, $3, 0, 0);
+    auto result = nebula::time::TimeUtils::validateTime(*$$);
+    if (!result.ok()) {
+      delete $$;
+      throw DatetimeParser::syntax_error(@1, result.toString());
+    }
+  }
+  ;
+
+opt_time_zone
+  : %empty {
+    $$ = 0;
+  }
+  | opt_time_zone_offset opt_time_zone_name {
+    if ($1 != $2) {
+      throw DatetimeParser::syntax_error(@1, "Mismatched timezone offset.");
+    }
+    $$ = $1;
+  }
+  | opt_time_zone_offset {
+    $$ = $1;
+  }
+  | opt_time_zone_name {
+    $$ = $1;
+  }
+  ;
+
+opt_time_zone_offset
+  : POSITIVE time_zone_offset {
+    $$ = $2;
+  }
+  | NEGATIVE time_zone_offset {
+    $$ = -$2;
+  }
+  ;
+
+time_zone_offset
+  : INTEGER TIME_DELIMITER INTEGER {
+    auto time = nebula::Time($1, $3, 0, 0);
+    auto result = nebula::time::TimeUtils::validateTime(time);
+    if (!result.ok()) {
+      throw DatetimeParser::syntax_error(@1, result.toString());
+    }
+    $$ = nebula::time::TimeConversion::timeToSeconds(time);
+  }
+  ;
+
+opt_time_zone_name
+  : TIME_ZONE_NAME {
+    auto zone = nebula::time::Timezone();
+    auto result = zone.loadFromDb(*$1);
+    if (!result.ok()) {
+      throw DatetimeParser::syntax_error(@1, result.toString());
+    }
+    $$ = zone.utcOffsetSecs();
+    delete $1;
+  }
+  ;
+
+%%
+
+void nebula::time::DatetimeParser::error(const nebula::time::DatetimeParser::location_type& loc,
+                                         const std::string &msg) {
+    std::ostringstream os;
+    if (msg.empty()) {
+        os << "syntax error";
+    } else {
+        os << msg;
+    }
+
+    auto *input = scanner.input();
+    if (input == nullptr) {
+        os << " at " << loc;
+        errmsg = os.str();
+        return;
+    }
+
+    auto begin = loc.begin.column > 0 ? loc.begin.column - 1 : 0;
+    if ((loc.end.filename
+        && (!loc.begin.filename
+            || *loc.begin.filename != *loc.end.filename))
+        || loc.begin.line < loc.end.line
+        || begin >= input->size()) {
+        os << " at " << loc;
+    } else if (loc.begin.column < (loc.end.column ? loc.end.column - 1 : 0)) {
+        uint32_t len = loc.end.column - loc.begin.column;
+        if (len > 80) {
+            len = 80;
+        }
+        os << " near `" << input->substr(begin, len) << "'";
+    } else {
+        os << " near `" << input->substr(begin, 8) << "'";
+    }
+
+    errmsg = os.str();
+}
+
+static int yylex(nebula::time::DatetimeParser::semantic_type* yylval,
+                 nebula::time::DatetimeParser::location_type *yylloc,
+                 nebula::time::DatetimeScanner& scanner) {
+    auto token = scanner.yylex(yylval, yylloc);
+    return token;
+}
+
diff --git a/src/common/time/parser/datetime_scanner.lex b/src/common/time/parser/datetime_scanner.lex
new file mode 100644
index 00000000000..0e14cbb66ce
--- /dev/null
+++ b/src/common/time/parser/datetime_scanner.lex
@@ -0,0 +1,87 @@
+%option c++
+%option yyclass="DatetimeScanner"
+%option nodefault noyywrap
+%option never-interactive
+%option yylineno
+%option case-sensitive
+%option prefix="datetime"
+
+%{
+#include "common/time/parser/DatetimeScanner.h"
+#include "DatetimeParser.hpp"
+#include <stdlib.h>
+#include <string>
+
+#define YY_USER_ACTION                  \
+    yylloc->step();                     \
+    yylloc->columns(yyleng);
+
+%}
+
+DEC                         ([0-9])
+L_BRACKET                   "["
+R_BRACKET                   "]"
+
+%%
+
+ /* date time shape type prefix */
+"T"                     { return TokenType::KW_TIME_ID; }
+":"                     { return TokenType::TIME_DELIMITER; }
+" "                     { return TokenType::SPACE; }
+"+"                     { return TokenType::POSITIVE; }
+"-"                     { return TokenType::NEGATIVE; }
+
+
+{DEC}+                  {
+                          try {
+                            folly::StringPiece text(yytext, yyleng);
+                            uint64_t val = folly::to<uint64_t>(text);
+                            yylval->intVal = val;
+                          } catch (...) {
+                            throw DatetimeParser::syntax_error(*yylloc, "Invalid integer:");
+                          }
+                          return TokenType::INTEGER;
+                        }
+
+{DEC}+\.{DEC}+          {
+                          try {
+                            folly::StringPiece text(yytext, yyleng);
+                            yylval->doubleVal = folly::to<double>(text);
+                          } catch (...) {
+                            throw DatetimeParser::syntax_error(*yylloc, "Invalid double value:");
+                          }
+                          return TokenType::DOUBLE;
+                        }
+
+\[[^\]]+\]              {
+                          std::string *str = new std::string(yytext + 1, yyleng - 2);
+                          yylval->strVal = str;
+                          return TokenType::TIME_ZONE_NAME;
+                        }
+
+.                       {
+                          /**
+                            * Any other unmatched byte sequences will get us here,
+                            * including the non-ascii ones, which are negative
+                            * in terms of type of `signed char'. At the same time, because
+                            * Bison translates all negative tokens to EOF(i.e. YY_NULL),
+                            * so we have to cast illegal characters to type of `unsinged char'
+                            * This will make Bison receive an unknown token, which leads to
+                            * a syntax error.
+                            *
+                            * Please note that it is not Flex but Bison to regard illegal
+                            * characters as errors, in such case.
+                            */
+                          return static_cast<unsigned char>(yytext[0]);
+
+                          /**
+                            * Alternatively, we could report illegal characters by
+                            * throwing a `syntax_error' exception.
+                            * In such a way, we could distinguish illegal characters
+                            * from normal syntax errors, but at cost of poor performance
+                            * incurred by the expensive exception handling.
+                            */
+                          // throw DatetimeParser::syntax_error(*yylloc, "char illegal");
+                          }
+
+%%
diff --git a/src/common/time/parser/test/CMakeLists.txt b/src/common/time/parser/test/CMakeLists.txt
new file mode 100644
index 00000000000..7bf97cfd254
--- /dev/null
+++ b/src/common/time/parser/test/CMakeLists.txt
@@ -0,0 +1,20 @@
+# Copyright (c) 2020 vesoft inc. All rights reserved.
+#
+# This source code is licensed under Apache 2.0 License.
+
+nebula_add_test(
+    NAME
+        datetime_parser_test
+    SOURCES
+        DateTimeParserTest.cpp
+    OBJECTS
+        $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:thread_obj>
+        $<TARGET_OBJECTS:datatypes_obj>
+        $<TARGET_OBJECTS:base_obj>
+        $<TARGET_OBJECTS:fs_obj>
+        $<TARGET_OBJECTS:wkt_wkb_io_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
+    LIBRARIES
+        gtest
+)
diff --git a/src/common/time/parser/test/DateTimeParserTest.cpp b/src/common/time/parser/test/DateTimeParserTest.cpp
new file mode 100644
index 00000000000..44acb835a14
--- /dev/null
+++ b/src/common/time/parser/test/DateTimeParserTest.cpp
@@ -0,0 +1,271 @@
+/* Copyright (c) 2021 vesoft inc. All rights reserved.
+ *
+ * This source code is licensed under Apache 2.0 License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "common/base/Base.h"
+#include "common/time/TimezoneInfo.h"
+#include "common/time/parser/DatetimeReader.h"
+
+namespace nebula {
+
+TEST(DatetimeReader, DateTime) {
+  {
+    auto parser = time::DatetimeReader::makeDateTimeReader();
+    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());
+  }
+  // with offset
+  {
+    auto parser = time::DatetimeReader::makeDateTimeReader();
+    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());
+  }
+  // lack day
+  {
+    auto parser = time::DatetimeReader::makeDateTimeReader();
+    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());
+  }
+  // TODO
+  // lack month
+  // {
+  // auto parser = time::DatetimeReader::makeDateTimeReader();
+  // 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());
+  // }
+  // lack us
+  {
+    auto parser = time::DatetimeReader::makeDateTimeReader();
+    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());
+  }
+  // lack second
+  {
+    auto parser = time::DatetimeReader::makeDateTimeReader();
+    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());
+  }
+  // TODO
+  // lack minute
+  // {
+  // auto parser = time::DatetimeReader::makeDateTimeReader();
+  // 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());
+  // }
+}
+
+TEST(DatetimeReader, DateTimeFailed) {
+  // out of range offset
+  {
+    auto parser = time::DatetimeReader::makeDateTimeReader();
+    auto result = parser.readDatetime("2019-01-03T22:22:3.2333+24:30");
+    EXPECT_FALSE(result.ok()) << result.value();
+  }
+  // only time
+  {
+    auto parser = time::DatetimeReader::makeDateTimeReader();
+    auto result = parser.readDatetime("22:22:3.2333");
+    EXPECT_FALSE(result.ok()) << result.value();
+  }
+  // with unexpected character
+  {
+    auto parser = time::DatetimeReader::makeDateTimeReader();
+    auto result = parser.readDatetime("2019-01-03T22:22:3.2333x");
+    EXPECT_FALSE(result.ok()) << result.value();
+  }
+  // not ending delimiter
+  {
+    auto parser = time::DatetimeReader::makeDateTimeReader();
+    auto result = parser.readDatetime("2019-01-T22:22:3.2333");
+    EXPECT_FALSE(result.ok()) << result.value();
+  }
+  {
+    auto parser = time::DatetimeReader::makeDateTimeReader();
+    auto result = parser.readDatetime("2019-01-03T22:22:.2333");
+    EXPECT_FALSE(result.ok()) << result.value();
+  }
+  // not ending prefix
+  {
+    auto parser = time::DatetimeReader::makeDateTimeReader();
+    auto result = parser.readDatetime("2019-01-03T");
+    EXPECT_FALSE(result.ok()) << result.value();
+  }
+  {
+    auto parser = time::DatetimeReader::makeDateTimeReader();
+    auto result = parser.readDatetime("2019-01-03T22:22:3.");
+    EXPECT_FALSE(result.ok()) << result.value();
+  }
+  // not exits prefix
+  {
+    auto parser = time::DatetimeReader::makeDateTimeReader();
+    auto result = parser.readDatetime("-01-03T22:22:3.2333");
+    EXPECT_FALSE(result.ok()) << result.value();
+  }
+}
+
+TEST(DatetimeReader, Date) {
+  {
+    auto parser = time::DatetimeReader::makeDateReader();
+    auto result = parser.readDate("2019-01-03");
+    ASSERT_TRUE(result.ok()) << result.status();
+    EXPECT_EQ(nebula::Date(2019, 1, 3), result.value());
+  }
+  // lack day
+  {
+    auto parser = time::DatetimeReader::makeDateReader();
+    auto result = parser.readDate("2019-01");
+    ASSERT_TRUE(result.ok()) << result.status();
+    EXPECT_EQ(nebula::Date(2019, 1, 1), result.value());
+  }
+  // TODO
+  // lack month
+  // {
+  // auto parser = time::DatetimeReader::makeDateReader();
+  // auto result = parser.readDate("2019");
+  // ASSERT_TRUE(result.ok()) << result.status();
+  // EXPECT_EQ(nebula::Date(2019, 1, 1), result.value());
+  // }
+}
+
+TEST(DatetimeReader, DateFailed) {
+  // don't support offset
+  {
+    auto parser = time::DatetimeReader::makeDateReader();
+    auto result = parser.readDate("2019-01-03+23:00");
+    EXPECT_FALSE(result.ok()) << result.value();
+  }
+  // with unexpected character
+  {
+    auto parser = time::DatetimeReader::makeDateReader();
+    auto result = parser.readDate("2019-01-03*");
+    EXPECT_FALSE(result.ok()) << result.value();
+  }
+  // extra components
+  {
+    auto parser = time::DatetimeReader::makeDateReader();
+    auto result = parser.readDate("2019-01-03T22:22:3.2333");
+    EXPECT_FALSE(result.ok()) << result.value();
+  }
+  // not ending delimiter
+  {
+    auto parser = time::DatetimeReader::makeDateReader();
+    auto result = parser.readDate("2019-01-");
+    EXPECT_FALSE(result.ok()) << result.value();
+  }
+  // not exits prefix
+  {
+    auto parser = time::DatetimeReader::makeDateReader();
+    auto result = parser.readDate("-01-03");
+    EXPECT_FALSE(result.ok()) << result.value();
+  }
+}
+
+TEST(DatetimeReader, Time) {
+  {
+    auto parser = time::DatetimeReader::makeTimeReader();
+    auto result = parser.readTime("22:22:3.2333");
+    ASSERT_TRUE(result.ok()) << result.status();
+    EXPECT_EQ(nebula::Time(22, 22, 3, 233300), result.value());
+  }
+  // with offset
+  {
+    auto parser = time::DatetimeReader::makeTimeReader();
+    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());
+  }
+  {
+    auto parser = time::DatetimeReader::makeTimeReader();
+    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());
+  }
+  // lack us
+  {
+    auto parser = time::DatetimeReader::makeTimeReader();
+    auto result = parser.readTime("22:22:3");
+    ASSERT_TRUE(result.ok()) << result.status();
+    EXPECT_EQ(nebula::Time(22, 22, 3, 0), result.value());
+  }
+  // lack second
+  {
+    auto parser = time::DatetimeReader::makeTimeReader();
+    auto result = parser.readTime("22:22");
+    ASSERT_TRUE(result.ok()) << result.status();
+    EXPECT_EQ(nebula::Time(22, 22, 0, 0), result.value());
+  }
+  // TODO
+  // lack minute
+  // {
+  // auto parser = time::DatetimeReader::makeTimeReader();
+  // auto result = parser.readTime("22");
+  // ASSERT_TRUE(result.ok()) << result.status();
+  // EXPECT_EQ(nebula::Time(22, 0, 0, 0), result.value());
+  // }
+}
+
+TEST(DatetimeReader, TimeFailed) {
+  // out of range offset
+  {
+    auto parser = time::DatetimeReader::makeTimeReader();
+    auto result = parser.readTime("22:22:3.2333-03:60");
+    EXPECT_FALSE(result.ok()) << result.value();
+  }
+  // unexpected character
+  {
+    auto parser = time::DatetimeReader::makeTimeReader();
+    auto result = parser.readTime("22:22:3.2333x");
+    EXPECT_FALSE(result.ok()) << result.value();
+  }
+  // extra components
+  {
+    auto parser = time::DatetimeReader::makeTimeReader();
+    auto result = parser.readTime("2019-01-03T22:22:3.2333");
+    EXPECT_FALSE(result.ok()) << result.value();
+  }
+  // not ending delimiter
+  {
+    auto parser = time::DatetimeReader::makeTimeReader();
+    auto result = parser.readTime("22:22:.2333");
+    EXPECT_FALSE(result.ok()) << result.value();
+  }
+  // not ending prefix
+  {
+    auto parser = time::DatetimeReader::makeTimeReader();
+    auto result = parser.readTime("22:22:3.");
+    EXPECT_FALSE(result.ok()) << result.value();
+  }
+  // not exist prefix
+  {
+    auto parser = time::DatetimeReader::makeTimeReader();
+    auto result = parser.readTime(":22:3.2333");
+    EXPECT_FALSE(result.ok()) << result.value();
+  }
+}
+
+}  // namespace nebula
+
+int main(int argc, char **argv) {
+  testing::InitGoogleTest(&argc, argv);
+  folly::init(&argc, &argv, true);
+  google::SetStderrLogging(google::INFO);
+  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/test/CMakeLists.txt b/src/common/time/test/CMakeLists.txt
index ba14f0fd95e..4cc5b067fd2 100644
--- a/src/common/time/test/CMakeLists.txt
+++ b/src/common/time/test/CMakeLists.txt
@@ -51,6 +51,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:base_obj>
         $<TARGET_OBJECTS:fs_obj>
         $<TARGET_OBJECTS:wkt_wkb_io_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
     LIBRARIES
         gtest
 )
diff --git a/src/daemons/CMakeLists.txt b/src/daemons/CMakeLists.txt
index e44c95f7eec..292c3936d78 100644
--- a/src/daemons/CMakeLists.txt
+++ b/src/daemons/CMakeLists.txt
@@ -30,6 +30,7 @@ set(common_deps
     $<TARGET_OBJECTS:wkt_wkb_io_obj>
     $<TARGET_OBJECTS:agg_function_manager_obj>
     $<TARGET_OBJECTS:time_utils_obj>
+    $<TARGET_OBJECTS:datetime_parser_obj>
     $<TARGET_OBJECTS:version_obj>
     $<TARGET_OBJECTS:ssl_obj>
     $<TARGET_OBJECTS:geo_index_obj>
diff --git a/src/daemons/GraphDaemon.cpp b/src/daemons/GraphDaemon.cpp
index 877b2c6064b..78cfdd36370 100644
--- a/src/daemons/GraphDaemon.cpp
+++ b/src/daemons/GraphDaemon.cpp
@@ -113,6 +113,13 @@ int main(int argc, char *argv[]) {
   }
   nebula::HostAddr localhost{FLAGS_local_ip, FLAGS_port};
 
+  // load the time zone data
+  status = nebula::time::Timezone::init();
+  if (!status.ok()) {
+    LOG(ERROR) << status;
+    return EXIT_FAILURE;
+  }
+
   // Initialize the global timezone, it's only used for datetime type compute
   // won't affect the process timezone.
   status = nebula::time::Timezone::initializeGlobalTimezone();
diff --git a/src/daemons/MetaDaemon.cpp b/src/daemons/MetaDaemon.cpp
index e1df6369c29..a4acb2f757e 100644
--- a/src/daemons/MetaDaemon.cpp
+++ b/src/daemons/MetaDaemon.cpp
@@ -319,6 +319,13 @@ int main(int argc, char* argv[]) {
     return EXIT_FAILURE;
   }
 
+  // load the time zone data
+  status = nebula::time::Timezone::init();
+  if (!status.ok()) {
+    LOG(ERROR) << status;
+    return EXIT_FAILURE;
+  }
+
   // Initialize the global timezone, it's only used for datetime type compute
   // won't affect the process timezone.
   status = nebula::time::Timezone::initializeGlobalTimezone();
diff --git a/src/daemons/StorageDaemon.cpp b/src/daemons/StorageDaemon.cpp
index 00d5ba3b173..37e5957c4f8 100644
--- a/src/daemons/StorageDaemon.cpp
+++ b/src/daemons/StorageDaemon.cpp
@@ -147,6 +147,13 @@ int main(int argc, char *argv[]) {
     return EXIT_FAILURE;
   }
 
+  // load the time zone data
+  status = nebula::time::Timezone::init();
+  if (!status.ok()) {
+    LOG(ERROR) << status;
+    return EXIT_FAILURE;
+  }
+
   // Initialize the global timezone, it's only used for datetime type compute
   // won't affect the process timezone.
   status = nebula::time::Timezone::initializeGlobalTimezone();
diff --git a/src/graph/context/test/CMakeLists.txt b/src/graph/context/test/CMakeLists.txt
index 54cd9fe3237..4fd9cdcef5c 100644
--- a/src/graph/context/test/CMakeLists.txt
+++ b/src/graph/context/test/CMakeLists.txt
@@ -26,6 +26,7 @@ SET(CONTEXT_TEST_LIBS
     $<TARGET_OBJECTS:http_client_obj>
     $<TARGET_OBJECTS:process_obj>
     $<TARGET_OBJECTS:time_utils_obj>
+    $<TARGET_OBJECTS:datetime_parser_obj>
     $<TARGET_OBJECTS:graph_obj>
     $<TARGET_OBJECTS:ft_es_graph_adapter_obj>
     $<TARGET_OBJECTS:ws_common_obj>
diff --git a/src/graph/executor/test/CMakeLists.txt b/src/graph/executor/test/CMakeLists.txt
index f664ee5f192..2dc394bfeb0 100644
--- a/src/graph/executor/test/CMakeLists.txt
+++ b/src/graph/executor/test/CMakeLists.txt
@@ -33,6 +33,7 @@ SET(EXEC_QUERY_TEST_OBJS
     $<TARGET_OBJECTS:encryption_obj>
     $<TARGET_OBJECTS:http_client_obj>
     $<TARGET_OBJECTS:time_utils_obj>
+    $<TARGET_OBJECTS:datetime_parser_obj>
     $<TARGET_OBJECTS:ft_es_graph_adapter_obj>
     $<TARGET_OBJECTS:ws_common_obj>
     $<TARGET_OBJECTS:version_obj>
diff --git a/src/graph/optimizer/test/CMakeLists.txt b/src/graph/optimizer/test/CMakeLists.txt
index f014c9abfa4..0f3c0fc72ad 100644
--- a/src/graph/optimizer/test/CMakeLists.txt
+++ b/src/graph/optimizer/test/CMakeLists.txt
@@ -28,6 +28,7 @@ set(OPTIMIZER_TEST_LIB
     $<TARGET_OBJECTS:http_client_obj>
     $<TARGET_OBJECTS:process_obj>
     $<TARGET_OBJECTS:time_utils_obj>
+    $<TARGET_OBJECTS:datetime_parser_obj>
     $<TARGET_OBJECTS:graph_obj>
     $<TARGET_OBJECTS:ft_es_graph_adapter_obj>
     $<TARGET_OBJECTS:ws_common_obj>
diff --git a/src/graph/util/test/CMakeLists.txt b/src/graph/util/test/CMakeLists.txt
index abf1373d1e9..4e0b0235e0e 100644
--- a/src/graph/util/test/CMakeLists.txt
+++ b/src/graph/util/test/CMakeLists.txt
@@ -28,6 +28,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:http_client_obj>
         $<TARGET_OBJECTS:process_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:graph_obj>
         $<TARGET_OBJECTS:ft_es_graph_adapter_obj>
         $<TARGET_OBJECTS:ws_common_obj>
diff --git a/src/graph/validator/test/CMakeLists.txt b/src/graph/validator/test/CMakeLists.txt
index f01755e0938..0363a74afc5 100644
--- a/src/graph/validator/test/CMakeLists.txt
+++ b/src/graph/validator/test/CMakeLists.txt
@@ -50,6 +50,7 @@ set(VALIDATOR_TEST_LIBS
     $<TARGET_OBJECTS:http_client_obj>
     $<TARGET_OBJECTS:process_obj>
     $<TARGET_OBJECTS:time_utils_obj>
+    $<TARGET_OBJECTS:datetime_parser_obj>
     $<TARGET_OBJECTS:graph_obj>
     $<TARGET_OBJECTS:ft_es_graph_adapter_obj>
     $<TARGET_OBJECTS:ws_common_obj>
diff --git a/src/graph/visitor/test/CMakeLists.txt b/src/graph/visitor/test/CMakeLists.txt
index 9cc8cb43d5b..bbf2e21b564 100644
--- a/src/graph/visitor/test/CMakeLists.txt
+++ b/src/graph/visitor/test/CMakeLists.txt
@@ -53,6 +53,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:http_client_obj>
         $<TARGET_OBJECTS:process_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:graph_obj>
         $<TARGET_OBJECTS:ft_es_graph_adapter_obj>
         $<TARGET_OBJECTS:ws_common_obj>
diff --git a/src/kvstore/test/CMakeLists.txt b/src/kvstore/test/CMakeLists.txt
index a9a844f1786..cdcb719cf33 100644
--- a/src/kvstore/test/CMakeLists.txt
+++ b/src/kvstore/test/CMakeLists.txt
@@ -30,6 +30,7 @@ set(KVSTORE_TEST_LIBS
     $<TARGET_OBJECTS:wkt_wkb_io_obj>
     $<TARGET_OBJECTS:agg_function_manager_obj>
     $<TARGET_OBJECTS:time_utils_obj>
+    $<TARGET_OBJECTS:datetime_parser_obj>
     $<TARGET_OBJECTS:process_obj>
     $<TARGET_OBJECTS:encryption_obj>
     $<TARGET_OBJECTS:ft_es_storage_adapter_obj>
diff --git a/src/meta/CMakeLists.txt b/src/meta/CMakeLists.txt
index 7faf784bc26..bb86d66eb99 100644
--- a/src/meta/CMakeLists.txt
+++ b/src/meta/CMakeLists.txt
@@ -150,6 +150,7 @@ set(meta_test_deps
     $<TARGET_OBJECTS:wkt_wkb_io_obj>
     $<TARGET_OBJECTS:agg_function_manager_obj>
     $<TARGET_OBJECTS:time_utils_obj>
+    $<TARGET_OBJECTS:datetime_parser_obj>
     $<TARGET_OBJECTS:encryption_obj>
     $<TARGET_OBJECTS:ft_es_storage_adapter_obj>
     $<TARGET_OBJECTS:version_obj>
diff --git a/src/parser/test/CMakeLists.txt b/src/parser/test/CMakeLists.txt
index 6e71a9cf044..8a08473f042 100644
--- a/src/parser/test/CMakeLists.txt
+++ b/src/parser/test/CMakeLists.txt
@@ -29,6 +29,7 @@ set(PARSER_TEST_LIBS
     $<TARGET_OBJECTS:file_based_cluster_id_man_obj>
     $<TARGET_OBJECTS:process_obj>
     $<TARGET_OBJECTS:time_utils_obj>
+    $<TARGET_OBJECTS:datetime_parser_obj>
     $<TARGET_OBJECTS:ft_es_graph_adapter_obj>
     $<TARGET_OBJECTS:ws_common_obj>
     $<TARGET_OBJECTS:version_obj>
diff --git a/src/storage/test/CMakeLists.txt b/src/storage/test/CMakeLists.txt
index 44f27faa41f..2c6e0ea5a3c 100644
--- a/src/storage/test/CMakeLists.txt
+++ b/src/storage/test/CMakeLists.txt
@@ -46,6 +46,7 @@ set(storage_test_deps
     $<TARGET_OBJECTS:agg_function_manager_obj>
     $<TARGET_OBJECTS:expression_obj>
     $<TARGET_OBJECTS:time_utils_obj>
+    $<TARGET_OBJECTS:datetime_parser_obj>
     $<TARGET_OBJECTS:encryption_obj>
     $<TARGET_OBJECTS:ft_es_storage_adapter_obj>
     $<TARGET_OBJECTS:version_obj>
diff --git a/src/tools/db-dump/CMakeLists.txt b/src/tools/db-dump/CMakeLists.txt
index 8618259bf4b..a90c14639ed 100644
--- a/src/tools/db-dump/CMakeLists.txt
+++ b/src/tools/db-dump/CMakeLists.txt
@@ -43,6 +43,7 @@ set(tools_test_deps
     $<TARGET_OBJECTS:wkt_wkb_io_obj>
     $<TARGET_OBJECTS:agg_function_manager_obj>
     $<TARGET_OBJECTS:time_utils_obj>
+    $<TARGET_OBJECTS:datetime_parser_obj>
     $<TARGET_OBJECTS:encryption_obj>
     $<TARGET_OBJECTS:ft_es_storage_adapter_obj>
     $<TARGET_OBJECTS:version_obj>
diff --git a/src/tools/db-upgrade/CMakeLists.txt b/src/tools/db-upgrade/CMakeLists.txt
index d43c203ab71..3a5985fa4dd 100644
--- a/src/tools/db-upgrade/CMakeLists.txt
+++ b/src/tools/db-upgrade/CMakeLists.txt
@@ -51,6 +51,7 @@ nebula_add_executable(
         $<TARGET_OBJECTS:wkt_wkb_io_obj>
         $<TARGET_OBJECTS:agg_function_manager_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:encryption_obj>
         $<TARGET_OBJECTS:ft_es_storage_adapter_obj>
         $<TARGET_OBJECTS:version_obj>
diff --git a/src/tools/meta-dump/CMakeLists.txt b/src/tools/meta-dump/CMakeLists.txt
index 9fe5765a612..37a804eac3e 100644
--- a/src/tools/meta-dump/CMakeLists.txt
+++ b/src/tools/meta-dump/CMakeLists.txt
@@ -48,6 +48,7 @@ nebula_add_executable(
         $<TARGET_OBJECTS:wkt_wkb_io_obj>
         $<TARGET_OBJECTS:agg_function_manager_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:encryption_obj>
         $<TARGET_OBJECTS:ft_es_storage_adapter_obj>
         $<TARGET_OBJECTS:version_obj>
diff --git a/src/tools/simple-kv-verify/CMakeLists.txt b/src/tools/simple-kv-verify/CMakeLists.txt
index 2aff91b1a5b..e5c95581711 100644
--- a/src/tools/simple-kv-verify/CMakeLists.txt
+++ b/src/tools/simple-kv-verify/CMakeLists.txt
@@ -52,6 +52,7 @@ nebula_add_executable(
         $<TARGET_OBJECTS:version_obj>
         $<TARGET_OBJECTS:ssl_obj>
         $<TARGET_OBJECTS:geo_index_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
     LIBRARIES
         ${ROCKSDB_LIBRARIES}
         ${THRIFT_LIBRARIES}
diff --git a/src/tools/storage-perf/CMakeLists.txt b/src/tools/storage-perf/CMakeLists.txt
index ff7ebc52b71..5bff542fca6 100644
--- a/src/tools/storage-perf/CMakeLists.txt
+++ b/src/tools/storage-perf/CMakeLists.txt
@@ -43,6 +43,7 @@ set(perf_test_deps
     $<TARGET_OBJECTS:wkt_wkb_io_obj>
     $<TARGET_OBJECTS:agg_function_manager_obj>
     $<TARGET_OBJECTS:time_utils_obj>
+    $<TARGET_OBJECTS:datetime_parser_obj>
     $<TARGET_OBJECTS:encryption_obj>
     $<TARGET_OBJECTS:ft_es_storage_adapter_obj>
     $<TARGET_OBJECTS:version_obj>
diff --git a/tests/common/nebula_service.py b/tests/common/nebula_service.py
index c5d7ae8faff..532e236c1f9 100644
--- a/tests/common/nebula_service.py
+++ b/tests/common/nebula_service.py
@@ -232,10 +232,11 @@ def _copy_nebula_conf(self):
                 self.work_dir + '/conf/{}.conf'.format(item),
             )
 
-        # gflags.json
         resources_dir = self.work_dir + '/share/resources/'
         os.makedirs(resources_dir)
 
+        # timezone file
+        shutil.copy(self.build_dir + '/../resources/date_time_zonespec.csv', resources_dir)
         shutil.copy(self.build_dir + '/../resources/gflags.json', resources_dir)
         # cert files
         shutil.copy(self.src_dir + '/tests/cert/test.ca.key', resources_dir)
diff --git a/tests/tck/features/mutate/InsertWithTimeType.feature b/tests/tck/features/mutate/InsertWithTimeType.feature
index 8f0bbb140cb..d39916211ed 100644
--- a/tests/tck/features/mutate/InsertWithTimeType.feature
+++ b/tests/tck/features/mutate/InsertWithTimeType.feature
@@ -107,6 +107,76 @@ Feature: Insert with time-dependent types
     Then the result should be, in any order:
       | edge_date.f_date | edge_date.f_time  | edge_date.f_datetime         |
       | '2017-03-04'     | '23:01:00.000000' | '2017-03-04T22:30:40.000000' |
+    # insert with timezone offset and microseconds
+    When try to execute query:
+      """
+      INSERT VERTEX tag_date(f_date, f_time, f_datetime) VALUES "test":(date("2017-03-04"), time("23:01:00.010000+01:00"), datetime("2017-03-04T22:30:40.003000-02:30"));
+      INSERT EDGE edge_date(f_date, f_time, f_datetime) VALUES "test_src"->"test_dst":(date("2017-03-04"), time("23:01:00.010000+01:00"), datetime("2017-03-04T22:30:40.003000-02:30"));
+      """
+    Then the execution should be successful
+    When executing query:
+      """
+      FETCH PROP ON tag_date "test" YIELD tag_date.f_date, tag_date.f_time, tag_date.f_datetime;
+      """
+    Then the result should be, in any order:
+      | tag_date.f_date | tag_date.f_time   | tag_date.f_datetime          |
+      | '2017-03-04'    | '22:01:00.010000' | '2017-03-05T01:00:40.003000' |
+    When executing query:
+      """
+      FETCH PROP ON edge_date "test_src"->"test_dst" YIELD edge_date.f_date, edge_date.f_time, edge_date.f_datetime;
+      """
+    Then the result should be, in any order:
+      | edge_date.f_date | edge_date.f_time  | edge_date.f_datetime         |
+      | '2017-03-04'     | '22:01:00.010000' | '2017-03-05T01:00:40.003000' |
+    # insert with timezone name and microseconds
+    When try to execute query:
+      """
+      INSERT VERTEX tag_date(f_date, f_time, f_datetime) VALUES "test":(date("2017-03-04"), time("23:01:00.010000[Asia/Shanghai]"), datetime("2017-03-04T22:30:40.003000[Asia/Shanghai]"));
+      INSERT EDGE edge_date(f_date, f_time, f_datetime) VALUES "test_src"->"test_dst":(date("2017-03-04"), time("23:01:00.010000[Asia/Shanghai]"), datetime("2017-03-04T22:30:40.003000[Asia/Shanghai]"));
+      """
+    Then the execution should be successful
+    When executing query:
+      """
+      FETCH PROP ON tag_date "test" YIELD tag_date.f_date, tag_date.f_time, tag_date.f_datetime;
+      """
+    Then the result should be, in any order:
+      | tag_date.f_date | tag_date.f_time   | tag_date.f_datetime          |
+      | '2017-03-04'    | '15:01:00.010000' | '2017-03-04T14:30:40.003000' |
+    When executing query:
+      """
+      FETCH PROP ON edge_date "test_src"->"test_dst" YIELD edge_date.f_date, edge_date.f_time, edge_date.f_datetime;
+      """
+    Then the result should be, in any order:
+      | edge_date.f_date | edge_date.f_time  | edge_date.f_datetime         |
+      | '2017-03-04'     | '15:01:00.010000' | '2017-03-04T14:30:40.003000' |
+    # insert with timezone name and utc offset
+    When try to execute query:
+      """
+      INSERT VERTEX tag_date(f_date, f_time, f_datetime) VALUES "test":(date("2017-03-04"), time("23:01:00.010000+08:00[Asia/Shanghai]"), datetime("2017-03-04T22:30:40.003000+08:00[Asia/Shanghai]"));
+      INSERT EDGE edge_date(f_date, f_time, f_datetime) VALUES "test_src"->"test_dst":(date("2017-03-04"), time("23:01:00.010000+08:00[Asia/Shanghai]"), datetime("2017-03-04T22:30:40.003000+08:00[Asia/Shanghai]"));
+      """
+    Then the execution should be successful
+    When executing query:
+      """
+      FETCH PROP ON tag_date "test" YIELD tag_date.f_date, tag_date.f_time, tag_date.f_datetime;
+      """
+    Then the result should be, in any order:
+      | tag_date.f_date | tag_date.f_time   | tag_date.f_datetime          |
+      | '2017-03-04'    | '15:01:00.010000' | '2017-03-04T14:30:40.003000' |
+    When executing query:
+      """
+      FETCH PROP ON edge_date "test_src"->"test_dst" YIELD edge_date.f_date, edge_date.f_time, edge_date.f_datetime;
+      """
+    Then the result should be, in any order:
+      | edge_date.f_date | edge_date.f_time  | edge_date.f_datetime         |
+      | '2017-03-04'     | '15:01:00.010000' | '2017-03-04T14:30:40.003000' |
+    # insert with timezone name and mismatched utc offset
+    When try to execute query:
+      """
+      INSERT VERTEX tag_date(f_date, f_time, f_datetime) VALUES "test":(date("2017-03-04"), time("23:01:00.010000-03:00[Asia/Shanghai]"), datetime("2017-03-04T22:30:40.003000+03:00[Asia/Shanghai]"));
+      INSERT EDGE edge_date(f_date, f_time, f_datetime) VALUES "test_src"->"test_dst":(date("2017-03-04"), time("23:01:00.010000-03:00[Asia/Shanghai]"), datetime("2017-03-04T22:30:40.003000+03:00[Asia/Shanghai]"));
+      """
+    Then a ExecutionError should be raised at runtime: Wrong value type: time("23:01:00.010000-03:00[Asia/Shanghai]")
     When executing query:
       """
       UPDATE VERTEX "test"