From 1d36ecd171142c033aec83f6832d19731b6c7530 Mon Sep 17 00:00:00 2001
From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com>
Date: Wed, 20 Oct 2021 15:43:04 +0800
Subject: [PATCH 01/11] Implement datetime parser by bison.

---
 CMakeLists.txt                                |   1 +
 src/common/datatypes/Date.h                   |  13 +
 src/common/time/CMakeLists.txt                |   2 +
 src/common/time/TimeUtils.h                   |  19 ++
 src/common/time/parser/CMakeLists.txt         |  27 ++
 src/common/time/parser/DatetimeReader.cpp     |  62 ++++
 src/common/time/parser/DatetimeReader.h       |  65 +++++
 src/common/time/parser/DatetimeScanner.h      |  70 +++++
 src/common/time/parser/datetime_parser.yy     | 249 ++++++++++++++++
 src/common/time/parser/datetime_scanner.lex   |  87 ++++++
 src/common/time/parser/test/CMakeLists.txt    |  21 ++
 .../time/parser/test/DateTimeParserTest.cpp   | 272 ++++++++++++++++++
 12 files changed, 888 insertions(+)
 create mode 100644 src/common/time/parser/CMakeLists.txt
 create mode 100644 src/common/time/parser/DatetimeReader.cpp
 create mode 100644 src/common/time/parser/DatetimeReader.h
 create mode 100644 src/common/time/parser/DatetimeScanner.h
 create mode 100644 src/common/time/parser/datetime_parser.yy
 create mode 100644 src/common/time/parser/datetime_scanner.lex
 create mode 100644 src/common/time/parser/test/CMakeLists.txt
 create mode 100644 src/common/time/parser/test/DateTimeParserTest.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4c18ea010c9..b5fddb323f4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -87,6 +87,7 @@ macro(nebula_add_library name type)
         # hbase_thrift_generator
         parser_target
         wkt_parser_target
+        datetime_parser_target
     )
 endmacro()
 
diff --git a/src/common/datatypes/Date.h b/src/common/datatypes/Date.h
index 7afd65f4549..2d2d4cfaee1 100644
--- a/src/common/datatypes/Date.h
+++ b/src/common/datatypes/Date.h
@@ -165,6 +165,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/time/CMakeLists.txt b/src/common/time/CMakeLists.txt
index 959efda8a8f..e1d0f8d3e02 100644
--- a/src/common/time/CMakeLists.txt
+++ b/src/common/time/CMakeLists.txt
@@ -17,4 +17,6 @@ nebula_add_library(
     TimeConversion.cpp
 )
 
+nebula_add_subdirectory(parser)
+
 nebula_add_subdirectory(test)
diff --git a/src/common/time/TimeUtils.h b/src/common/time/TimeUtils.h
index 898aa24a358..f0b2108f803 100644
--- a/src/common/time/TimeUtils.h
+++ b/src/common/time/TimeUtils.h
@@ -47,6 +47,25 @@ class TimeUtils {
     return Status::OK();
   }
 
+  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);
+    }
+    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();
+  }
+
   // TODO(shylock) support more format
   static StatusOr<DateTime> parseDateTime(const std::string &str) {
     std::tm tm;
diff --git a/src/common/time/parser/CMakeLists.txt b/src/common/time/parser/CMakeLists.txt
new file mode 100644
index 00000000000..84de7f1e9e4
--- /dev/null
+++ b/src/common/time/parser/CMakeLists.txt
@@ -0,0 +1,27 @@
+# Copyright (c) 2020 vesoft inc. All rights reserved.
+#
+# This source code is licensed under Apache 2.0 License,
+# attached with Common Clause Condition 1.0, found in the LICENSES directory.
+
+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..79fc08c49c5
--- /dev/null
+++ b/src/common/time/parser/DatetimeReader.cpp
@@ -0,0 +1,62 @@
+/* Copyright (c) 2018 vesoft inc. All rights reserved.
+ *
+ * This source code is licensed under Apache 2.0 License,
+ * attached with Common Clause Condition 1.0, found in the LICENSES directory.
+ */
+
+#include "common/time/parser/DatetimeReader.h"
+
+namespace nebula {
+namespace time {
+
+DatetimeReader::DatetimeReader(Type type) : parser_(scanner_, error_, &dt_, type) {
+  // Callback invoked by WKTScanner
+  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 WKTScanner 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..fe8791360cd
--- /dev/null
+++ b/src/common/time/parser/DatetimeReader.h
@@ -0,0 +1,65 @@
+/* Copyright (c) 2018 vesoft inc. All rights reserved.
+ *
+ * This source code is licensed under Apache 2.0 License,
+ * attached with Common Clause Condition 1.0, found in the LICENSES directory.
+ */
+
+#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:
+  // enum class Type {
+  // kDate,
+  // kTime,
+  // kDateTime,
+  // };
+
+  ~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..35b974db16d
--- /dev/null
+++ b/src/common/time/parser/DatetimeScanner.h
@@ -0,0 +1,70 @@
+/* Copyright (c) 2018 vesoft inc. All rights reserved.
+ *
+ * This source code is licensed under Apache 2.0 License,
+ * attached with Common Clause Condition 1.0, found in the LICENSES directory.
+ */
+
+#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 {
+
+// TODO(jie) Try to reuse the class GraphScanner
+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 WKTReader 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 WKTReader 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(jie) 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..4c9c813b31b
--- /dev/null
+++ b/src/common/time/parser/datetime_parser.yy
@@ -0,0 +1,249 @@
+%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 opt_time_zone_name time_zone_offset
+
+%define api.prefix {datetime}
+
+%start datetime
+
+%%
+
+datetime
+  : date date_time_delimiter time opt_time_zone {
+    if (outputType != nebula::time::Type::kDateTime) {
+      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) {
+      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) {
+      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 {
+    auto *d = new nebula::Date($1, $3, $5);
+    auto result = nebula::time::TimeUtils::validateDate(*d);
+    if (!result.ok()) {
+      throw DatetimeParser::syntax_error(@1, result.toString());
+    }
+    $$ = d;
+  }
+  | INTEGER NEGATIVE INTEGER {
+    auto *d = new nebula::Date($1, $3, 1);
+    auto result = nebula::time::TimeUtils::validateDate(*d);
+    if (!result.ok()) {
+      throw DatetimeParser::syntax_error(@1, result.toString());
+    }
+    $$ = d;
+  }
+  ;
+
+time
+  : INTEGER TIME_DELIMITER INTEGER TIME_DELIMITER DOUBLE {
+    double integer = 0;
+    auto fraction = std::modf($5, &integer);
+    auto *t = new nebula::Time($1, $3, static_cast<int>(integer), std::round(fraction * 1000 * 1000));
+    auto result = nebula::time::TimeUtils::validateTime(*t);
+    if (!result.ok()) {
+      throw DatetimeParser::syntax_error(@1, result.toString());
+    }
+    $$ = t;
+  }
+  | INTEGER TIME_DELIMITER INTEGER TIME_DELIMITER INTEGER {
+    auto *t = new nebula::Time($1, $3, $5, 0);
+    auto result = nebula::time::TimeUtils::validateTime(*t);
+    if (!result.ok()) {
+      throw DatetimeParser::syntax_error(@1, result.toString());
+    }
+    $$ = t;
+  }
+  | INTEGER TIME_DELIMITER INTEGER {
+    auto *t = new nebula::Time($1, $3, 0, 0);
+    auto result = nebula::time::TimeUtils::validateTime(*t);
+    if (!result.ok()) {
+      throw DatetimeParser::syntax_error(@1, result.toString());
+    }
+    $$ = t;
+  }
+  ;
+
+opt_time_zone
+  : %empty {
+    $$ = 0;
+  }
+  | POSITIVE time_zone_offset opt_time_zone_name {
+    if ($3 != 0 && $2 != $3) {
+      throw DatetimeParser::syntax_error(@1, "Mismatched timezone offset.");
+    }
+    $$ = $2;
+  }
+  | NEGATIVE time_zone_offset opt_time_zone_name {
+    if ($3 != 0 && $2 != $3) {
+      throw DatetimeParser::syntax_error(@1, "Mismatched timezone 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
+  : %empty {
+    $$ = 0;
+  }
+  | 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..210bbcbec24
--- /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;
+                        }
+
+L_BRACKET[^R_BRACKET]+R_BRACKET {
+                          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..9abbbc4b8b8
--- /dev/null
+++ b/src/common/time/parser/test/CMakeLists.txt
@@ -0,0 +1,21 @@
+# Copyright (c) 2021 vesoft inc. All rights reserved.
+#
+# This source code is licensed under Apache 2.0 License,
+# attached with Common Clause Condition 1.0, found in the LICENSES directory.
+
+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..3dad9cb9ee1
--- /dev/null
+++ b/src/common/time/parser/test/DateTimeParserTest.cpp
@@ -0,0 +1,272 @@
+/* Copyright (c) 2021 vesoft inc. All rights reserved.
+ *
+ * This source code is licensed under Apache 2.0 License,
+ * attached with Common Clause Condition 1.0, found in the LICENSES directory.
+ */
+
+#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();
+}

From a76c8a238d46ef3f891ab84819f5811d82386a5a Mon Sep 17 00:00:00 2001
From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com>
Date: Wed, 20 Oct 2021 15:44:25 +0800
Subject: [PATCH 02/11] Remove unused code.

---
 src/common/time/parser/DatetimeReader.h | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/common/time/parser/DatetimeReader.h b/src/common/time/parser/DatetimeReader.h
index fe8791360cd..bd557876936 100644
--- a/src/common/time/parser/DatetimeReader.h
+++ b/src/common/time/parser/DatetimeReader.h
@@ -17,12 +17,6 @@ namespace time {
 
 class DatetimeReader {
  public:
-  // enum class Type {
-  // kDate,
-  // kTime,
-  // kDateTime,
-  // };
-
   ~DatetimeReader() {
     if (dt_ != nullptr) delete dt_;
   }

From 2cd7805d1bbc2414e6ac018977fac84ff6af9faf Mon Sep 17 00:00:00 2001
From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com>
Date: Tue, 31 Aug 2021 18:32:16 +0800
Subject: [PATCH 03/11] Add the time parser.

---
 src/common/datatypes/Date.cpp                 |  15 +-
 .../function/test/FunctionManagerTest.cpp     |   9 +-
 src/common/time/CMakeLists.txt                |   1 +
 src/common/time/TimeParser.cpp                | 419 ++++++++++++++++++
 src/common/time/TimeParser.h                  | 137 ++++++
 src/common/time/TimeUtils.h                   |  60 +--
 src/common/time/TimezoneInfo.cpp              |   1 -
 src/common/time/test/CMakeLists.txt           |  14 +
 src/common/time/test/TimeParserTest.cpp       | 249 +++++++++++
 src/daemons/GraphDaemon.cpp                   |   7 +
 src/daemons/MetaDaemon.cpp                    |   7 +
 src/daemons/StorageDaemon.cpp                 |   7 +
 tests/common/nebula_service.py                |   4 +-
 .../mutate/InsertWithTimeType.feature         |  70 +++
 14 files changed, 944 insertions(+), 56 deletions(-)
 create mode 100644 src/common/time/TimeParser.cpp
 create mode 100644 src/common/time/TimeParser.h
 create mode 100644 src/common/time/test/TimeParserTest.cpp

diff --git a/src/common/datatypes/Date.cpp b/src/common/datatypes/Date.cpp
index 0bb1fdb0432..53128041ed7 100644
--- a/src/common/datatypes/Date.cpp
+++ b/src/common/datatypes/Date.cpp
@@ -13,6 +13,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};
 
@@ -99,22 +104,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/function/test/FunctionManagerTest.cpp b/src/common/function/test/FunctionManagerTest.cpp
index b8747be60c6..d470ad95581 100644
--- a/src/common/function/test/FunctionManagerTest.cpp
+++ b/src/common/function/test/FunctionManagerTest.cpp
@@ -311,7 +311,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);
   }
   {
@@ -320,8 +320,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");
@@ -330,7 +331,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/time/CMakeLists.txt b/src/common/time/CMakeLists.txt
index e1d0f8d3e02..2b0eaab8aa4 100644
--- a/src/common/time/CMakeLists.txt
+++ b/src/common/time/CMakeLists.txt
@@ -15,6 +15,7 @@ nebula_add_library(
     TimeUtils.cpp
     TimezoneInfo.cpp
     TimeConversion.cpp
+    TimeParser.cpp
 )
 
 nebula_add_subdirectory(parser)
diff --git a/src/common/time/TimeParser.cpp b/src/common/time/TimeParser.cpp
new file mode 100644
index 00000000000..ba559a34976
--- /dev/null
+++ b/src/common/time/TimeParser.cpp
@@ -0,0 +1,419 @@
+/* Copyright (c) 2020 vesoft inc. All rights reserved.
+ *
+ * This source code is licensed under Apache 2.0 License,
+ * attached with Common Clause Condition 1.0, found in the LICENSES directory.
+ */
+
+#include "common/time/TimeParser.h"
+
+#include <sstream>
+
+#include "common/time/TimeConversion.h"
+#include "common/time/TimeUtils.h"
+#include "common/time/TimezoneInfo.h"
+
+namespace nebula {
+namespace time {
+
+/*static*/ const std::vector<TimeParser::Component> TimeParser::dateTimeStates = {
+    // State, ShiftMap
+    {kInitial,
+     [](Token, Token, Context &ctx) -> StatusOr<State> {
+       if (ctx.type == ExpectType::kDateTime) {
+         return kDateYear;
+       } else if (ctx.type == ExpectType::kDate) {
+         return kDateYear;
+       } else if (ctx.type == ExpectType::kTime) {
+         return kTimeHour;
+       }
+       return Status::Error("Unknown time ctx.type.");
+     }},
+    {kDateYear,
+     [](Token t, Token n, Context &ctx) -> StatusOr<State> {
+       if (t.type == TokenType::kNumber) {
+         if (t.val < std::numeric_limits<int16_t>::min() ||
+             t.val > std::numeric_limits<int16_t>::max()) {
+           return Status::Error("The year number `%d' exceed the number limit.",
+                                static_cast<uint32_t>(t.val));
+         }
+         ctx.result.year = t.val;
+         switch (n.type) {
+           case TokenType::kMinus:
+             return kDateMonth;
+           case TokenType::kTimePrefix:
+             if (ctx.type == ExpectType::kDate) {
+               return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
+             }
+             return kTimeHour;
+           case TokenType::kPlaceHolder:
+             return kEnd;
+           default:
+             return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
+         }
+       } else {
+         return Status::Error("Unexpected token `%s'.", toString(n.type));
+       }
+     }},
+    {kDateMonth,
+     [](Token t, Token n, Context &ctx) -> StatusOr<State> {
+       if (t.type == TokenType::kMinus) {
+         return kDateMonth;
+       }
+       if (t.type == TokenType::kNumber) {
+         if (t.val < 1 || t.val > 12) {
+           return Status::Error("The month number `%d' exceed the number limit.",
+                                static_cast<uint32_t>(t.val));
+         }
+         ctx.result.month = t.val;
+         switch (n.type) {
+           case TokenType::kMinus:
+             return kDateDay;
+           case TokenType::kTimePrefix:
+             if (ctx.type == ExpectType::kDate) {
+               return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
+             }
+             return kTimeHour;
+           case TokenType::kPlaceHolder:
+             return kEnd;
+           default:
+             return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
+         }
+       } else {
+         return Status::Error("Unexpected token `%s'.", toString(n.type));
+       }
+     }},
+    {kDateDay,
+     [](Token t, Token n, Context &ctx) -> StatusOr<State> {
+       if (t.type == TokenType::kMinus) {
+         return kDateDay;
+       }
+       if (t.type == TokenType::kNumber) {
+         if (t.val < 1 || t.val > 31) {
+           return Status::Error("The day number `%d' exceed the number limit.",
+                                static_cast<uint32_t>(t.val));
+         }
+         ctx.result.day = t.val;
+         switch (n.type) {
+           case TokenType::kTimePrefix:
+             if (ctx.type == ExpectType::kDate) {
+               return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
+             }
+             return kTimeHour;
+           case TokenType::kPlaceHolder:
+             return kEnd;
+           default:
+             return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
+         }
+       } else {
+         return Status::Error("Unexpected token `%s'.", toString(n.type));
+       }
+     }},
+    {kTimeHour,
+     [](Token t, Token n, Context &ctx) -> StatusOr<State> {
+       if (t.type == TokenType::kTimePrefix) {
+         return kTimeHour;
+       }
+       if (t.type == TokenType::kNumber) {
+         if (t.val < 0 || t.val > 23) {
+           return Status::Error("The hour number `%d' exceed the number limit.",
+                                static_cast<uint32_t>(t.val));
+         }
+         ctx.result.hour = t.val;
+         switch (n.type) {
+           case TokenType::kTimeDelimiter:
+             return kTimeMinute;
+           case TokenType::kPlus:
+           case TokenType::kMinus:
+             return kUtcOffset;
+           case TokenType::kTimeZoneName:
+             return kTimeZone;
+           case TokenType::kPlaceHolder:
+             return kEnd;
+           default:
+             return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
+         }
+       } else {
+         return Status::Error("Unexpected token `%s'.", toString(n.type));
+       }
+       return Status::OK();
+     }},
+    {kTimeMinute,
+     [](Token t, Token n, Context &ctx) -> StatusOr<State> {
+       if (t.type == TokenType::kTimeDelimiter) {
+         return kTimeMinute;
+       }
+       if (t.type == TokenType::kNumber) {
+         if (t.val < 0 || t.val > 59) {
+           return Status::Error("The minute number `%d' exceed the number limit.",
+                                static_cast<uint32_t>(t.val));
+         }
+         ctx.result.minute = t.val;
+         switch (n.type) {
+           case TokenType::kTimeDelimiter:
+             return kTimeSecond;
+           case TokenType::kPlus:
+           case TokenType::kMinus:
+             return kUtcOffset;
+           case TokenType::kTimeZoneName:
+             return kTimeZone;
+           case TokenType::kPlaceHolder:
+             return kEnd;
+           default:
+             return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
+         }
+       } else {
+         return Status::Error("Unexpected token `%s'.", toString(n.type));
+       }
+       return Status::OK();
+     }},
+    {kTimeSecond,
+     [](Token t, Token n, Context &ctx) -> StatusOr<State> {
+       if (t.type == TokenType::kTimeDelimiter) {
+         return kTimeSecond;
+       }
+       if (t.type == TokenType::kNumber) {
+         if (t.val < 0 || t.val >= 60) {
+           return Status::Error("The second number `%f' exceed the number limit.", t.val);
+         }
+         double integer{0};
+         double fraction = std::modf(t.val, &integer);
+         ctx.result.sec = integer;
+         ctx.result.microsec = std::round(fraction * 1000000);
+         switch (n.type) {
+           case TokenType::kPlus:
+           case TokenType::kMinus:
+             return kUtcOffset;
+           case TokenType::kTimeZoneName:
+             return kTimeZone;
+           case TokenType::kPlaceHolder:
+             return kEnd;
+           default:
+             return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
+         }
+       } else {
+         return Status::Error("Unexpected token `%s'.", toString(n.type));
+       }
+       return Status::OK();
+     }},
+    {kUtcOffset,
+     [](Token t, Token, Context &ctx) -> StatusOr<State> {
+       switch (t.type) {
+         case TokenType::kPlus:
+         case TokenType::kMinus:
+           if (ctx.utcSign != TokenType::kUnknown) {
+             return Status::Error("Unexpected token `%s'.", toString(t.type));
+           }
+           ctx.utcSign = t.type;
+           return kUtcOffsetHour;
+         default:
+           return Status::Error("Unexpected token `%s'.", toString(t.type));
+       }
+     }},
+    {kUtcOffsetHour,
+     [](Token t, Token, Context &ctx) -> StatusOr<State> {
+       switch (t.type) {
+         case TokenType::kNumber:
+           if (t.val > 23) {
+             return Status::Error("Unexpected utc offset hours number `%d'.",
+                                  static_cast<uint32_t>(t.val));
+           }
+           ctx.utcOffsetSecs =
+               (ctx.utcSign == TokenType::kPlus ? t.val * 60 * 60 : -t.val * 60 * 60);
+           return kUtcOffsetMinute;
+         default:
+           return Status::Error("Unexpected token `%s'.", toString(t.type));
+       }
+     }},
+    {kUtcOffsetMinute,
+     [](Token t, Token n, Context &ctx) -> StatusOr<State> {
+       switch (t.type) {
+         case TokenType::kTimeDelimiter:
+           if (n.type != TokenType::kNumber) {
+             return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
+           }
+           return kUtcOffsetMinute;
+         case TokenType::kNumber:
+           if (t.val > 59) {
+             return Status::Error("Unexpected utc offset minutes number `%d'.",
+                                  static_cast<uint32_t>(t.val));
+           }
+           ctx.utcOffsetSecs += (ctx.utcSign == TokenType::kPlus ? t.val * 60 : -t.val * 60);
+           if (n.type == TokenType::kPlaceHolder) {
+             ctx.result = TimeConversion::dateTimeShift(ctx.result, -ctx.utcOffsetSecs);
+             return kEnd;
+           } else if (n.type == TokenType::kTimeZoneName) {
+             return kTimeZone;
+           } else {
+             return Status::Error("Unexpected read-head token `%s'.", toString(n.type));
+           }
+         default:
+           return Status::Error("Unexpected token `%s'.", toString(t.type));
+       }
+     }},
+    {kTimeZone,
+     [](Token t, Token n, Context &ctx) -> StatusOr<State> {
+       DCHECK(t.type == TokenType::kTimeZoneName);
+       if (n.type != TokenType::kPlaceHolder) {
+         return Status::Error("Unexpected read-head token `%s'.", toString(n.type));
+       }
+       int32_t utcOffsetSecs = 0;
+       Timezone tz;
+       auto result = tz.loadFromDb(t.str);
+       NG_RETURN_IF_ERROR(result);
+       if (ctx.utcSign != TokenType::kUnknown) {
+         if (tz.utcOffsetSecs() != ctx.utcOffsetSecs) {
+           return Status::Error("Mismatched time zone offset and time zone name.");
+         } else {
+           utcOffsetSecs = ctx.utcOffsetSecs;
+         }
+       } else {
+         utcOffsetSecs = tz.utcOffsetSecs();
+       }
+       ctx.result = TimeConversion::dateTimeShift(ctx.result, -utcOffsetSecs);
+       return kEnd;
+     }},
+    {kEnd, [](Token, Token, Context &) -> StatusOr<State> { return Status::OK(); }},
+};
+
+/*static*/ const char *TimeParser::toString(TokenType t) {
+  switch (t) {
+    case TokenType::kUnknown:
+      return "Unknown";
+    case TokenType::kPlaceHolder:
+      return "PlaceHolder";
+    case TokenType::kNumber:
+      return "Number";
+    case TokenType::kPlus:
+      return "+";
+    case TokenType::kMinus:
+      return "-";
+    case TokenType::kTimeDelimiter:
+      return "TimeDelimiter";
+    case TokenType::kTimePrefix:
+      return "TimePrefix";
+    case TokenType::kTimeZoneName:
+      return "TimeZoneName";
+  }
+  LOG(FATAL) << "Unknown token " << static_cast<int>(t);
+  return "Unknown token";
+}
+
+/*static*/ std::string TimeParser::toString(const Token &t) {
+  std::stringstream ss;
+  ss << toString(t.type);
+  ss << "(";
+  if (t.type == TokenType::kNumber) {
+    ss << t.val;
+  }
+  if (t.type == TokenType::kTimeZoneName) {
+    ss << t.str;
+  }
+  ss << ")";
+  return ss.str();
+}
+
+/*static*/ const char *TimeParser::toString(State state) {
+  switch (state) {
+    case kInitial:
+      return "Initial";
+    case kDateYear:
+      return "DateYear";
+    case kDateMonth:
+      return "DateMonth";
+    case kDateDay:
+      return "DateDay";
+    case kTimeHour:
+      return "TimeHour";
+    case kTimeMinute:
+      return "TimeMinute";
+    case kTimeSecond:
+      return "TimeSecond";
+    case kUtcOffset:
+      return "UtcOffset";
+    case kUtcOffsetHour:
+      return "UtcOffsetHour";
+    case kUtcOffsetMinute:
+      return "UtcOffsetMinute";
+    case kTimeZone:
+      return "TimeZone";
+    case kEnd:
+      return "End";
+    case kSize:
+      return "Size";
+  }
+  DLOG(FATAL) << "Unknown state " << static_cast<int>(state);
+  return "Unknown";
+}
+
+Status TimeParser::lex(folly::StringPiece str) {
+  tokens_.reserve(8);
+  std::string digits;
+  digits.reserve(8);
+  auto c = str.start();
+  while (*c != '\0') {
+    if (std::isdigit(*c) || kFractionPrefix == *c) {
+      digits.push_back(*c);
+      if (!(std::isdigit(*(c + 1)) || kFractionPrefix == *(c + 1))) {
+        if (digits.front() == '.') {
+          return Status::Error("Unexpected character `%c'.", digits.front());
+        }
+        if (digits.back() == '.') {
+          return Status::Error("Expected character fraction.");
+        }
+        Token t;
+        try {
+          t.val = folly::to<double>(digits);
+        } catch (std::exception &e) {
+          return Status::Error("%s", e.what());
+        }
+        t.type = TokenType::kNumber;
+        tokens_.emplace_back(t);
+        digits.clear();
+      }
+    } else if (kTimeDelimiter == *c) {
+      tokens_.emplace_back(Token{TokenType::kTimeDelimiter, 0, ""});
+    } else if (kTimePrefix == *c || kTimeSpacePrefix == *c) {
+      tokens_.emplace_back(Token{TokenType::kTimePrefix, 0, ""});
+    } else if (kPlus == *c) {
+      tokens_.emplace_back(Token{TokenType::kPlus, 0, ""});
+    } else if (kMinus == *c) {
+      tokens_.emplace_back(Token{TokenType::kMinus, 0, ""});
+    } else if (kLeftBracket == *c) {
+      std::string s;
+      while (*(++c) != kRightBracket) {
+        if (*c == '\0') {
+          return Status::Error("Unterminated bracket.");
+        }
+        s.push_back(*c);
+      }
+      tokens_.emplace_back(Token{TokenType::kTimeZoneName, 0, std::move(s)});
+    } else {
+      return Status::Error("Illegal character `%c'.", *c);
+    }
+    ++c;
+  }
+  // Only for read-ahead placeholder
+  tokens_.emplace_back(Token{TokenType::kPlaceHolder, 0, ""});
+  return Status::OK();
+}
+
+Status TimeParser::parse() {
+  auto result = dateTimeStates[kInitial].next({}, {}, ctx_);
+  NG_RETURN_IF_ERROR(result);
+  auto current = result.value();
+  for (std::size_t i = 0; i < tokens_.size() - 1; ++i) {
+    result = dateTimeStates[current].next(tokens_[i], tokens_[i + 1], ctx_);
+    NG_RETURN_IF_ERROR(result);
+    current = result.value();
+    if (current == kEnd) {
+      break;
+    }
+  }
+  if (current != kEnd) {
+    return Status::Error("Not end parse.");
+  }
+  return Status::OK();
+}
+
+}  // namespace time
+}  // namespace nebula
diff --git a/src/common/time/TimeParser.h b/src/common/time/TimeParser.h
new file mode 100644
index 00000000000..0da70851240
--- /dev/null
+++ b/src/common/time/TimeParser.h
@@ -0,0 +1,137 @@
+/* Copyright (c) 2020 vesoft inc. All rights reserved.
+ *
+ * This source code is licensed under Apache 2.0 License,
+ * attached with Common Clause Condition 1.0, found in the LICENSES directory.
+ */
+
+#ifndef COMMON_TIME_TIMEPARSER_H_
+#define COMMON_TIME_TIMEPARSER_H_
+
+#include "common/base/Base.h"
+#include "common/base/Status.h"
+#include "common/base/StatusOr.h"
+#include "common/datatypes/Date.h"
+
+namespace nebula {
+namespace time {
+
+// parser the date/time/datetime literal
+class TimeParser {
+ public:
+  TimeParser() = default;
+
+  StatusOr<Date> parseDate(folly::StringPiece str) {
+    ctx_.type = ExpectType::kDate;
+    NG_RETURN_IF_ERROR(lex(str));
+    NG_RETURN_IF_ERROR(parse());
+    return Date{static_cast<int16_t>(ctx_.result.year),
+                static_cast<int8_t>(ctx_.result.month),
+                static_cast<int8_t>(ctx_.result.day)};
+  }
+
+  StatusOr<Time> parseTime(folly::StringPiece str) {
+    ctx_.type = ExpectType::kTime;
+    NG_RETURN_IF_ERROR(lex(str));
+    NG_RETURN_IF_ERROR(parse());
+    return Time{static_cast<int8_t>(ctx_.result.hour),
+                static_cast<int8_t>(ctx_.result.minute),
+                static_cast<int8_t>(ctx_.result.sec),
+                static_cast<int32_t>(ctx_.result.microsec)};
+  }
+
+  StatusOr<DateTime> parseDateTime(folly::StringPiece str) {
+    ctx_.type = ExpectType::kDateTime;
+    NG_RETURN_IF_ERROR(lex(str));
+    NG_RETURN_IF_ERROR(parse());
+    return ctx_.result;
+  }
+
+ private:
+  static constexpr char kTimeDelimiter = ':';
+
+  static constexpr char kTimePrefix = 'T';
+  static constexpr char kTimeSpacePrefix = ' ';
+  static constexpr char kFractionPrefix = '.';
+  static constexpr char kPlus = '+';
+  static constexpr char kMinus = '-';
+
+  static constexpr char kLeftBracket = '[';
+  static constexpr char kRightBracket = ']';
+
+  enum class ExpectType {
+    kDate,
+    kTime,
+    kDateTime,
+  };
+
+  enum class TokenType {
+    kUnknown,
+    kPlaceHolder,  // Only for read-ahead placeholder
+    kNumber,
+    kPlus,
+    kMinus,
+    kTimeDelimiter,
+    kTimePrefix,
+    kTimeZoneName,
+  };
+
+  static const char* toString(TokenType t);
+
+  struct Token {
+    TokenType type;
+    double val;  // only used for number token
+    std::string str;
+  };
+
+  static std::string toString(const Token& t);
+
+  // TODO(shylock) support weeks/days format when support the convertion
+  // The state of current parser
+  enum State {
+    kInitial,          // 0
+    kDateYear,         // 1
+    kDateMonth,        // 2
+    kDateDay,          // 3
+    kTimeHour,         // 4
+    kTimeMinute,       // 5
+    kTimeSecond,       // 6
+    kUtcOffset,        // 8
+    kUtcOffsetHour,    // 9
+    kUtcOffsetMinute,  // 10
+    kTimeZone,         // 11
+    kEnd,              // 12
+    kSize,             // Just for count
+  };
+
+  static const char* toString(State state);
+
+  struct Context {
+    DateTime result;
+    ExpectType type;
+
+    TokenType utcSign{TokenType::kUnknown};
+    int32_t utcOffsetSecs{0};
+  };
+
+  struct Component {
+    const State state;  // current state
+    // State shift function
+    std::function<StatusOr<State>(Token, Token, Context&)> next;
+  };
+
+  // All states of datetime
+  static const std::vector<Component> dateTimeStates;
+
+  Status lex(folly::StringPiece str);
+
+  Status parse();
+
+ private:
+  std::vector<Token> tokens_;
+  Context ctx_;
+};
+
+}  // namespace time
+}  // namespace nebula
+
+#endif  // COMMON_TIME_TIMEPARSER_H_
diff --git a/src/common/time/TimeUtils.h b/src/common/time/TimeUtils.h
index f0b2108f803..0680a213618 100644
--- a/src/common/time/TimeUtils.h
+++ b/src/common/time/TimeUtils.h
@@ -20,6 +20,7 @@
 #include "common/datatypes/Map.h"
 #include "common/fs/FileUtils.h"
 #include "common/time/TimeConversion.h"
+#include "common/time/TimeParser.h"
 #include "common/time/TimezoneInfo.h"
 #include "common/time/WallClock.h"
 
@@ -66,28 +67,12 @@ 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();
-      }
-    }
-    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;
+    TimeParser p;
+    auto result = p.parseDateTime(str);
+    NG_RETURN_IF_ERROR(result);
+    NG_RETURN_IF_ERROR(validateDate(result.value()));
+    return result.value();
   }
 
   static StatusOr<DateTime> dateTimeFromMap(const Map &m);
@@ -139,20 +124,12 @@ 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;
+    TimeParser p;
+    auto result = p.parseDate(str);
+    NG_RETURN_IF_ERROR(result);
+    NG_RETURN_IF_ERROR(validateDate(result.value()));
+    return result.value();
   }
 
   static StatusOr<Date> localDate() {
@@ -189,20 +166,9 @@ 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;
+    TimeParser p;
+    return p.parseTime(str);
   }
 
   // utc + offset = local
diff --git a/src/common/time/TimezoneInfo.cpp b/src/common/time/TimezoneInfo.cpp
index 5dde8efa5af..74eee39f4d2 100644
--- a/src/common/time/TimezoneInfo.cpp
+++ b/src/common/time/TimezoneInfo.cpp
@@ -37,7 +37,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/test/CMakeLists.txt b/src/common/time/test/CMakeLists.txt
index 36cf1ed429d..90e974e6585 100644
--- a/src/common/time/test/CMakeLists.txt
+++ b/src/common/time/test/CMakeLists.txt
@@ -55,6 +55,20 @@ nebula_add_test(
         gtest
 )
 
+nebula_add_test(
+    NAME
+        time_parser_test
+    SOURCES
+        TimeParserTest.cpp
+    OBJECTS
+        $<TARGET_OBJECTS:base_obj>
+        $<TARGET_OBJECTS:time_obj>
+        $<TARGET_OBJECTS:datatypes_obj>
+        $<TARGET_OBJECTS:time_utils_obj>
+    LIBRARIES
+        gtest
+)
+
 nebula_add_executable(
     NAME
         duration_bm
diff --git a/src/common/time/test/TimeParserTest.cpp b/src/common/time/test/TimeParserTest.cpp
new file mode 100644
index 00000000000..dc71490fa07
--- /dev/null
+++ b/src/common/time/test/TimeParserTest.cpp
@@ -0,0 +1,249 @@
+/* Copyright (c) 2020 vesoft inc. All rights reserved.
+ *
+ * This source code is licensed under Apache 2.0 License,
+ * attached with Common Clause Condition 1.0, found in the LICENSES directory.
+ */
+#include <gtest/gtest.h>
+
+#include "common/base/Base.h"
+#include "common/time/TimeParser.h"
+
+TEST(TimeParser, DateTime) {
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDateTime("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
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDateTime("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
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDateTime("2019-01T22:22:3.2333");
+    ASSERT_TRUE(result.ok()) << result.status();
+    EXPECT_EQ(nebula::DateTime(2019, 1, 1, 22, 22, 3, 233300), result.value());
+  }
+  // lack month
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDateTime("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
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDateTime("2019T22:22:3");
+    ASSERT_TRUE(result.ok()) << result.status();
+    EXPECT_EQ(nebula::DateTime(2019, 1, 1, 22, 22, 3, 0), result.value());
+  }
+  // lack second
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDateTime("2019T22:22");
+    ASSERT_TRUE(result.ok()) << result.status();
+    EXPECT_EQ(nebula::DateTime(2019, 1, 1, 22, 22, 0, 0), result.value());
+  }
+  // lack second
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDateTime("2019T22");
+    ASSERT_TRUE(result.ok()) << result.status();
+    EXPECT_EQ(nebula::DateTime(2019, 1, 1, 22, 0, 0, 0), result.value());
+  }
+}
+
+TEST(TimeParser, DateTimeFailed) {
+  // out of range offset
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDateTime("2019-01-03T22:22:3.2333+24:30");
+    EXPECT_FALSE(result.ok()) << result.status();
+  }
+  // only time
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDateTime("22:22:3.2333");
+    EXPECT_FALSE(result.ok()) << result.status();
+  }
+  // with unexpected character
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDateTime("2019-01-03T22:22:3.2333x");
+    EXPECT_FALSE(result.ok()) << result.status();
+  }
+  // not ending delimiter
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDateTime("2019-01-T22:22:3.2333");
+    EXPECT_FALSE(result.ok()) << result.status();
+  }
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDateTime("2019-01-03T22:22:.2333");
+    EXPECT_FALSE(result.ok()) << result.status();
+  }
+  // not ending prefix
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDateTime("2019-01-03T");
+    EXPECT_FALSE(result.ok()) << result.status();
+  }
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDateTime("2019-01-03T22:22:3.");
+    EXPECT_FALSE(result.ok()) << result.status();
+  }
+  // not exits prefix
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDateTime("-01-03T22:22:3.2333");
+    EXPECT_FALSE(result.ok()) << result.status();
+  }
+}
+
+TEST(TimeParser, Date) {
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDate("2019-01-03");
+    ASSERT_TRUE(result.ok()) << result.status();
+    EXPECT_EQ(nebula::Date(2019, 1, 3), result.value());
+  }
+  // lack day
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDate("2019-01");
+    ASSERT_TRUE(result.ok()) << result.status();
+    EXPECT_EQ(nebula::Date(2019, 1, 1), result.value());
+  }
+  // lack month
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDate("2019");
+    ASSERT_TRUE(result.ok()) << result.status();
+    EXPECT_EQ(nebula::Date(2019, 1, 1), result.value());
+  }
+}
+
+TEST(TimeParser, DateFailed) {
+  // don't support offset
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDate("2019-01-03+23:00");
+    EXPECT_FALSE(result.ok()) << result.status();
+  }
+  // with unexpected character
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDate("2019-01-03*");
+    EXPECT_FALSE(result.ok()) << result.status();
+  }
+  // extra components
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDate("2019-01-03T22:22:3.2333");
+    EXPECT_FALSE(result.ok()) << result.status();
+  }
+  // not ending delimiter
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDate("2019-01-");
+    EXPECT_FALSE(result.ok()) << result.status();
+  }
+  // not exits prefix
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseDate("-01-03");
+    EXPECT_FALSE(result.ok()) << result.status();
+  }
+}
+
+TEST(TimeParser, Time) {
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseTime("22:22:3.2333");
+    ASSERT_TRUE(result.ok()) << result.status();
+    EXPECT_EQ(nebula::Time(22, 22, 3, 233300), result.value());
+  }
+  // with offset
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseTime("22:22:3.2333-03:30");
+    ASSERT_TRUE(result.ok()) << result.status();
+    EXPECT_EQ(nebula::Time(1, 52, 3, 233300), result.value());
+  }
+  // lack us
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseTime("22:22:3");
+    ASSERT_TRUE(result.ok()) << result.status();
+    EXPECT_EQ(nebula::Time(22, 22, 3, 0), result.value());
+  }
+  // lack second
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseTime("22:22");
+    ASSERT_TRUE(result.ok()) << result.status();
+    EXPECT_EQ(nebula::Time(22, 22, 0, 0), result.value());
+  }
+  // lack minute
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseTime("22");
+    ASSERT_TRUE(result.ok()) << result.status();
+    EXPECT_EQ(nebula::Time(22, 0, 0, 0), result.value());
+  }
+}
+
+TEST(TimeParser, TimeFailed) {
+  // out of range offset
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseTime("22:22:3.2333-03:60");
+    EXPECT_FALSE(result.ok()) << result.status();
+  }
+  // unexpected character
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseTime("22:22:3.2333x");
+    EXPECT_FALSE(result.ok()) << result.status();
+  }
+  // extra components
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseTime("2019-01-03T22:22:3.2333");
+    EXPECT_FALSE(result.ok()) << result.status();
+  }
+  // not ending delimiter
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseTime("22:22:.2333");
+    EXPECT_FALSE(result.ok()) << result.status();
+  }
+  // not ending prefix
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseTime("22:22:3.");
+    EXPECT_FALSE(result.ok()) << result.status();
+  }
+  // not exist prefix
+  {
+    nebula::time::TimeParser parser;
+    auto result = parser.parseTime(":22:3.2333");
+    EXPECT_FALSE(result.ok()) << result.status();
+  }
+}
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  folly::init(&argc, &argv, true);
+  google::SetStderrLogging(google::INFO);
+
+  return RUN_ALL_TESTS();
+}
diff --git a/src/daemons/GraphDaemon.cpp b/src/daemons/GraphDaemon.cpp
index 2efa800ee73..1995e0372ea 100644
--- a/src/daemons/GraphDaemon.cpp
+++ b/src/daemons/GraphDaemon.cpp
@@ -114,6 +114,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 0174859311d..f1aa5464d0b 100644
--- a/src/daemons/MetaDaemon.cpp
+++ b/src/daemons/MetaDaemon.cpp
@@ -320,6 +320,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 f1bbf752cd6..24d9f4521dd 100644
--- a/src/daemons/StorageDaemon.cpp
+++ b/src/daemons/StorageDaemon.cpp
@@ -148,6 +148,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/tests/common/nebula_service.py b/tests/common/nebula_service.py
index 9d337258428..cc2db958144 100644
--- a/tests/common/nebula_service.py
+++ b/tests/common/nebula_service.py
@@ -47,10 +47,12 @@ def _copy_nebula_conf(self):
         shutil.copy(storage_conf_path + '/nebula-metad.conf.default',
                     self.work_dir + '/conf/nebula-metad.conf')
 
-        # gflags.json
         resources_dir = self.work_dir + '/share/resources/'
         os.makedirs(resources_dir)
+        # gflags.json
         shutil.copy(self.build_dir + '/../resources/gflags.json', resources_dir)
+        # timezone file
+        shutil.copy(self.build_dir + '/../resources/date_time_zonespec.csv', resources_dir)
 
         # cert files
         shutil.copy(self.src_dir + '/tests/cert/test.ca.key',
diff --git a/tests/tck/features/mutate/InsertWithTimeType.feature b/tests/tck/features/mutate/InsertWithTimeType.feature
index 23bdc90b4b5..1255d82fb4b 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._src | edge_date._dst | edge_date._rank | edge_date.f_date | edge_date.f_time  | edge_date.f_datetime         |
       | 'test_src'     | 'test_dst'     | 0               | '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:
+      | VertexID | tag_date.f_date | tag_date.f_time   | tag_date.f_datetime          |
+      | 'test'   | '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._src | edge_date._dst | edge_date._rank | edge_date.f_date | edge_date.f_time  | edge_date.f_datetime         |
+      | 'test_src'     | 'test_dst'     | 0               | '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:
+      | VertexID | tag_date.f_date | tag_date.f_time   | tag_date.f_datetime          |
+      | 'test'   | '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._src | edge_date._dst | edge_date._rank | edge_date.f_date | edge_date.f_time  | edge_date.f_datetime         |
+      | 'test_src'     | 'test_dst'     | 0               | '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:
+      | VertexID | tag_date.f_date | tag_date.f_time   | tag_date.f_datetime          |
+      | 'test'   | '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._src | edge_date._dst | edge_date._rank | edge_date.f_date | edge_date.f_time  | edge_date.f_datetime         |
+      | 'test_src'     | 'test_dst'     | 0               | '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"

From e09c8093f4aa25c207bc163edff9de73d7c2ec41 Mon Sep 17 00:00:00 2001
From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com>
Date: Mon, 27 Sep 2021 10:23:31 +0800
Subject: [PATCH 04/11] Fix case.

---
 src/common/datatypes/test/ValueToJsonTest.cpp | 35 +++++++++++--------
 1 file changed, 20 insertions(+), 15 deletions(-)

diff --git a/src/common/datatypes/test/ValueToJsonTest.cpp b/src/common/datatypes/test/ValueToJsonTest.cpp
index 3f729d37a6b..f594af1fc92 100644
--- a/src/common/datatypes/test/ValueToJsonTest.cpp
+++ b/src/common/datatypes/test/ValueToJsonTest.cpp
@@ -137,7 +137,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,
@@ -159,7 +159,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 strcuture is unordered_set, so sort before the comparison
   auto actualJson = set.toJson();
   std::sort(actualJson.begin(), actualJson.end());
@@ -180,7 +180,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
@@ -195,18 +195,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());
 }
 

From 477ecd324212d1f059030e7eeb1304957a53bd87 Mon Sep 17 00:00:00 2001
From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com>
Date: Thu, 21 Oct 2021 19:10:53 +0800
Subject: [PATCH 05/11] Tune zone.

---
 src/codec/test/CMakeLists.txt               |   1 +
 src/common/datatypes/test/CMakeLists.txt    |   3 +
 src/common/expression/test/CMakeLists.txt   |  18 +
 src/common/function/FunctionManager.cpp     |   1 +
 src/common/function/test/CMakeLists.txt     |   1 +
 src/common/geo/io/wkb/test/CMakeLists.txt   |   1 +
 src/common/geo/io/wkt/test/CMakeLists.txt   |   1 +
 src/common/geo/test/CMakeLists.txt          |   1 +
 src/common/time/CMakeLists.txt              |   1 -
 src/common/time/TimeParser.cpp              | 419 --------------------
 src/common/time/TimeParser.h                | 137 -------
 src/common/time/TimeUtils.cpp               |  20 +
 src/common/time/TimeUtils.h                 |  22 +-
 src/common/time/parser/datetime_parser.yy   |  28 +-
 src/common/time/parser/datetime_scanner.lex |   4 +-
 src/common/time/test/CMakeLists.txt         |  15 +-
 src/common/time/test/TimeParserTest.cpp     | 249 ------------
 src/daemons/CMakeLists.txt                  |   1 +
 src/graph/context/test/CMakeLists.txt       |   1 +
 src/graph/executor/test/CMakeLists.txt      |   1 +
 src/graph/optimizer/test/CMakeLists.txt     |   1 +
 src/graph/util/test/CMakeLists.txt          |   1 +
 src/graph/validator/BalanceValidator.cpp    |   1 +
 src/graph/validator/IngestValidator.cpp     |   1 +
 src/graph/validator/test/CMakeLists.txt     |   1 +
 src/graph/visitor/test/CMakeLists.txt       |   1 +
 src/kvstore/test/CMakeLists.txt             |   1 +
 src/meta/CMakeLists.txt                     |   1 +
 src/meta/test/CMakeLists.txt                |   2 +
 src/parser/test/CMakeLists.txt              |   1 +
 src/storage/test/CMakeLists.txt             |   1 +
 src/tools/db-dump/CMakeLists.txt            |   1 +
 src/tools/db-upgrade/CMakeLists.txt         |   1 +
 src/tools/meta-dump/CMakeLists.txt          |   1 +
 src/tools/storage-perf/CMakeLists.txt       |   1 +
 35 files changed, 90 insertions(+), 851 deletions(-)
 delete mode 100644 src/common/time/TimeParser.cpp
 delete mode 100644 src/common/time/TimeParser.h
 delete mode 100644 src/common/time/test/TimeParserTest.cpp

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/test/CMakeLists.txt b/src/common/datatypes/test/CMakeLists.txt
index 00c482a57f8..c34c1a6edbe 100644
--- a/src/common/datatypes/test/CMakeLists.txt
+++ b/src/common/datatypes/test/CMakeLists.txt
@@ -45,6 +45,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>
     LIBRARIES
         gtest
@@ -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/expression/test/CMakeLists.txt b/src/common/expression/test/CMakeLists.txt
index 577ce3f2f79..3e1ed6af839 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:fs_obj>
     $<TARGET_OBJECTS:stats_obj>
     $<TARGET_OBJECTS:time_obj>
+    $<TARGET_OBJECTS:datetime_parser_obj>
     $<TARGET_OBJECTS:common_thrift_obj>
     $<TARGET_OBJECTS:thrift_obj>
     $<TARGET_OBJECTS:thread_obj>
@@ -90,6 +91,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>
         ${expression_test_common_libs}
     LIBRARIES
@@ -113,6 +115,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 +139,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
@@ -157,6 +161,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:agg_function_manager_obj>
         $<TARGET_OBJECTS:time_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:fs_obj>
         ${expression_test_common_libs}
     LIBRARIES
@@ -178,6 +183,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:agg_function_manager_obj>
         $<TARGET_OBJECTS:time_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:fs_obj>
         ${expression_test_common_libs}
     LIBRARIES
@@ -199,6 +205,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:agg_function_manager_obj>
         $<TARGET_OBJECTS:time_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:fs_obj>
         ${expression_test_common_libs}
     LIBRARIES
@@ -220,6 +227,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:agg_function_manager_obj>
         $<TARGET_OBJECTS:time_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:fs_obj>
         ${expression_test_common_libs}
     LIBRARIES
@@ -241,6 +249,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:agg_function_manager_obj>
         $<TARGET_OBJECTS:time_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:fs_obj>
         ${expression_test_common_libs}
     LIBRARIES
@@ -262,6 +271,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:agg_function_manager_obj>
         $<TARGET_OBJECTS:time_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:fs_obj>
         ${expression_test_common_libs}
     LIBRARIES
@@ -283,6 +293,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:agg_function_manager_obj>
         $<TARGET_OBJECTS:time_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:fs_obj>
         ${expression_test_common_libs}
     LIBRARIES
@@ -304,6 +315,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:agg_function_manager_obj>
         $<TARGET_OBJECTS:time_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:fs_obj>
         ${expression_test_common_libs}
     LIBRARIES
@@ -325,6 +337,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:agg_function_manager_obj>
         $<TARGET_OBJECTS:time_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:fs_obj>
         ${expression_test_common_libs}
     LIBRARIES
@@ -346,6 +359,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:agg_function_manager_obj>
         $<TARGET_OBJECTS:time_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:fs_obj>
         ${expression_test_common_libs}
     LIBRARIES
@@ -367,6 +381,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:agg_function_manager_obj>
         $<TARGET_OBJECTS:time_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:fs_obj>
         ${expression_test_common_libs}
     LIBRARIES
@@ -388,6 +403,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:agg_function_manager_obj>
         $<TARGET_OBJECTS:time_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:fs_obj>
         ${expression_test_common_libs}
     LIBRARIES
@@ -409,6 +425,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:agg_function_manager_obj>
         $<TARGET_OBJECTS:time_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:fs_obj>
         ${expression_test_common_libs}
     LIBRARIES
@@ -430,6 +447,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:agg_function_manager_obj>
         $<TARGET_OBJECTS:time_obj>
         $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
         $<TARGET_OBJECTS:fs_obj>
         ${expression_test_common_libs}
     LIBRARIES
diff --git a/src/common/function/FunctionManager.cpp b/src/common/function/FunctionManager.cpp
index 07b402e74bb..386b67e849d 100644
--- a/src/common/function/FunctionManager.cpp
+++ b/src/common/function/FunctionManager.cpp
@@ -1683,6 +1683,7 @@ 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());
diff --git a/src/common/function/test/CMakeLists.txt b/src/common/function/test/CMakeLists.txt
index 65c794ca94c..577b64c2ec0 100644
--- a/src/common/function/test/CMakeLists.txt
+++ b/src/common/function/test/CMakeLists.txt
@@ -14,6 +14,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/geo/io/wkb/test/CMakeLists.txt b/src/common/geo/io/wkb/test/CMakeLists.txt
index 8923d630868..2f6df679a59 100644
--- a/src/common/geo/io/wkb/test/CMakeLists.txt
+++ b/src/common/geo/io/wkb/test/CMakeLists.txt
@@ -30,6 +30,7 @@ set(WKB_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/common/geo/io/wkt/test/CMakeLists.txt b/src/common/geo/io/wkt/test/CMakeLists.txt
index 98e3d6236c1..06a61c9b9a8 100644
--- a/src/common/geo/io/wkt/test/CMakeLists.txt
+++ b/src/common/geo/io/wkt/test/CMakeLists.txt
@@ -30,6 +30,7 @@ set(WKT_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/common/geo/test/CMakeLists.txt b/src/common/geo/test/CMakeLists.txt
index e0593ca7652..c6ae306748a 100644
--- a/src/common/geo/test/CMakeLists.txt
+++ b/src/common/geo/test/CMakeLists.txt
@@ -14,6 +14,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/time/CMakeLists.txt b/src/common/time/CMakeLists.txt
index 2b0eaab8aa4..e1d0f8d3e02 100644
--- a/src/common/time/CMakeLists.txt
+++ b/src/common/time/CMakeLists.txt
@@ -15,7 +15,6 @@ nebula_add_library(
     TimeUtils.cpp
     TimezoneInfo.cpp
     TimeConversion.cpp
-    TimeParser.cpp
 )
 
 nebula_add_subdirectory(parser)
diff --git a/src/common/time/TimeParser.cpp b/src/common/time/TimeParser.cpp
deleted file mode 100644
index ba559a34976..00000000000
--- a/src/common/time/TimeParser.cpp
+++ /dev/null
@@ -1,419 +0,0 @@
-/* Copyright (c) 2020 vesoft inc. All rights reserved.
- *
- * This source code is licensed under Apache 2.0 License,
- * attached with Common Clause Condition 1.0, found in the LICENSES directory.
- */
-
-#include "common/time/TimeParser.h"
-
-#include <sstream>
-
-#include "common/time/TimeConversion.h"
-#include "common/time/TimeUtils.h"
-#include "common/time/TimezoneInfo.h"
-
-namespace nebula {
-namespace time {
-
-/*static*/ const std::vector<TimeParser::Component> TimeParser::dateTimeStates = {
-    // State, ShiftMap
-    {kInitial,
-     [](Token, Token, Context &ctx) -> StatusOr<State> {
-       if (ctx.type == ExpectType::kDateTime) {
-         return kDateYear;
-       } else if (ctx.type == ExpectType::kDate) {
-         return kDateYear;
-       } else if (ctx.type == ExpectType::kTime) {
-         return kTimeHour;
-       }
-       return Status::Error("Unknown time ctx.type.");
-     }},
-    {kDateYear,
-     [](Token t, Token n, Context &ctx) -> StatusOr<State> {
-       if (t.type == TokenType::kNumber) {
-         if (t.val < std::numeric_limits<int16_t>::min() ||
-             t.val > std::numeric_limits<int16_t>::max()) {
-           return Status::Error("The year number `%d' exceed the number limit.",
-                                static_cast<uint32_t>(t.val));
-         }
-         ctx.result.year = t.val;
-         switch (n.type) {
-           case TokenType::kMinus:
-             return kDateMonth;
-           case TokenType::kTimePrefix:
-             if (ctx.type == ExpectType::kDate) {
-               return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
-             }
-             return kTimeHour;
-           case TokenType::kPlaceHolder:
-             return kEnd;
-           default:
-             return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
-         }
-       } else {
-         return Status::Error("Unexpected token `%s'.", toString(n.type));
-       }
-     }},
-    {kDateMonth,
-     [](Token t, Token n, Context &ctx) -> StatusOr<State> {
-       if (t.type == TokenType::kMinus) {
-         return kDateMonth;
-       }
-       if (t.type == TokenType::kNumber) {
-         if (t.val < 1 || t.val > 12) {
-           return Status::Error("The month number `%d' exceed the number limit.",
-                                static_cast<uint32_t>(t.val));
-         }
-         ctx.result.month = t.val;
-         switch (n.type) {
-           case TokenType::kMinus:
-             return kDateDay;
-           case TokenType::kTimePrefix:
-             if (ctx.type == ExpectType::kDate) {
-               return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
-             }
-             return kTimeHour;
-           case TokenType::kPlaceHolder:
-             return kEnd;
-           default:
-             return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
-         }
-       } else {
-         return Status::Error("Unexpected token `%s'.", toString(n.type));
-       }
-     }},
-    {kDateDay,
-     [](Token t, Token n, Context &ctx) -> StatusOr<State> {
-       if (t.type == TokenType::kMinus) {
-         return kDateDay;
-       }
-       if (t.type == TokenType::kNumber) {
-         if (t.val < 1 || t.val > 31) {
-           return Status::Error("The day number `%d' exceed the number limit.",
-                                static_cast<uint32_t>(t.val));
-         }
-         ctx.result.day = t.val;
-         switch (n.type) {
-           case TokenType::kTimePrefix:
-             if (ctx.type == ExpectType::kDate) {
-               return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
-             }
-             return kTimeHour;
-           case TokenType::kPlaceHolder:
-             return kEnd;
-           default:
-             return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
-         }
-       } else {
-         return Status::Error("Unexpected token `%s'.", toString(n.type));
-       }
-     }},
-    {kTimeHour,
-     [](Token t, Token n, Context &ctx) -> StatusOr<State> {
-       if (t.type == TokenType::kTimePrefix) {
-         return kTimeHour;
-       }
-       if (t.type == TokenType::kNumber) {
-         if (t.val < 0 || t.val > 23) {
-           return Status::Error("The hour number `%d' exceed the number limit.",
-                                static_cast<uint32_t>(t.val));
-         }
-         ctx.result.hour = t.val;
-         switch (n.type) {
-           case TokenType::kTimeDelimiter:
-             return kTimeMinute;
-           case TokenType::kPlus:
-           case TokenType::kMinus:
-             return kUtcOffset;
-           case TokenType::kTimeZoneName:
-             return kTimeZone;
-           case TokenType::kPlaceHolder:
-             return kEnd;
-           default:
-             return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
-         }
-       } else {
-         return Status::Error("Unexpected token `%s'.", toString(n.type));
-       }
-       return Status::OK();
-     }},
-    {kTimeMinute,
-     [](Token t, Token n, Context &ctx) -> StatusOr<State> {
-       if (t.type == TokenType::kTimeDelimiter) {
-         return kTimeMinute;
-       }
-       if (t.type == TokenType::kNumber) {
-         if (t.val < 0 || t.val > 59) {
-           return Status::Error("The minute number `%d' exceed the number limit.",
-                                static_cast<uint32_t>(t.val));
-         }
-         ctx.result.minute = t.val;
-         switch (n.type) {
-           case TokenType::kTimeDelimiter:
-             return kTimeSecond;
-           case TokenType::kPlus:
-           case TokenType::kMinus:
-             return kUtcOffset;
-           case TokenType::kTimeZoneName:
-             return kTimeZone;
-           case TokenType::kPlaceHolder:
-             return kEnd;
-           default:
-             return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
-         }
-       } else {
-         return Status::Error("Unexpected token `%s'.", toString(n.type));
-       }
-       return Status::OK();
-     }},
-    {kTimeSecond,
-     [](Token t, Token n, Context &ctx) -> StatusOr<State> {
-       if (t.type == TokenType::kTimeDelimiter) {
-         return kTimeSecond;
-       }
-       if (t.type == TokenType::kNumber) {
-         if (t.val < 0 || t.val >= 60) {
-           return Status::Error("The second number `%f' exceed the number limit.", t.val);
-         }
-         double integer{0};
-         double fraction = std::modf(t.val, &integer);
-         ctx.result.sec = integer;
-         ctx.result.microsec = std::round(fraction * 1000000);
-         switch (n.type) {
-           case TokenType::kPlus:
-           case TokenType::kMinus:
-             return kUtcOffset;
-           case TokenType::kTimeZoneName:
-             return kTimeZone;
-           case TokenType::kPlaceHolder:
-             return kEnd;
-           default:
-             return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
-         }
-       } else {
-         return Status::Error("Unexpected token `%s'.", toString(n.type));
-       }
-       return Status::OK();
-     }},
-    {kUtcOffset,
-     [](Token t, Token, Context &ctx) -> StatusOr<State> {
-       switch (t.type) {
-         case TokenType::kPlus:
-         case TokenType::kMinus:
-           if (ctx.utcSign != TokenType::kUnknown) {
-             return Status::Error("Unexpected token `%s'.", toString(t.type));
-           }
-           ctx.utcSign = t.type;
-           return kUtcOffsetHour;
-         default:
-           return Status::Error("Unexpected token `%s'.", toString(t.type));
-       }
-     }},
-    {kUtcOffsetHour,
-     [](Token t, Token, Context &ctx) -> StatusOr<State> {
-       switch (t.type) {
-         case TokenType::kNumber:
-           if (t.val > 23) {
-             return Status::Error("Unexpected utc offset hours number `%d'.",
-                                  static_cast<uint32_t>(t.val));
-           }
-           ctx.utcOffsetSecs =
-               (ctx.utcSign == TokenType::kPlus ? t.val * 60 * 60 : -t.val * 60 * 60);
-           return kUtcOffsetMinute;
-         default:
-           return Status::Error("Unexpected token `%s'.", toString(t.type));
-       }
-     }},
-    {kUtcOffsetMinute,
-     [](Token t, Token n, Context &ctx) -> StatusOr<State> {
-       switch (t.type) {
-         case TokenType::kTimeDelimiter:
-           if (n.type != TokenType::kNumber) {
-             return Status::Error("Unexpected read-ahead token `%s'.", toString(n.type));
-           }
-           return kUtcOffsetMinute;
-         case TokenType::kNumber:
-           if (t.val > 59) {
-             return Status::Error("Unexpected utc offset minutes number `%d'.",
-                                  static_cast<uint32_t>(t.val));
-           }
-           ctx.utcOffsetSecs += (ctx.utcSign == TokenType::kPlus ? t.val * 60 : -t.val * 60);
-           if (n.type == TokenType::kPlaceHolder) {
-             ctx.result = TimeConversion::dateTimeShift(ctx.result, -ctx.utcOffsetSecs);
-             return kEnd;
-           } else if (n.type == TokenType::kTimeZoneName) {
-             return kTimeZone;
-           } else {
-             return Status::Error("Unexpected read-head token `%s'.", toString(n.type));
-           }
-         default:
-           return Status::Error("Unexpected token `%s'.", toString(t.type));
-       }
-     }},
-    {kTimeZone,
-     [](Token t, Token n, Context &ctx) -> StatusOr<State> {
-       DCHECK(t.type == TokenType::kTimeZoneName);
-       if (n.type != TokenType::kPlaceHolder) {
-         return Status::Error("Unexpected read-head token `%s'.", toString(n.type));
-       }
-       int32_t utcOffsetSecs = 0;
-       Timezone tz;
-       auto result = tz.loadFromDb(t.str);
-       NG_RETURN_IF_ERROR(result);
-       if (ctx.utcSign != TokenType::kUnknown) {
-         if (tz.utcOffsetSecs() != ctx.utcOffsetSecs) {
-           return Status::Error("Mismatched time zone offset and time zone name.");
-         } else {
-           utcOffsetSecs = ctx.utcOffsetSecs;
-         }
-       } else {
-         utcOffsetSecs = tz.utcOffsetSecs();
-       }
-       ctx.result = TimeConversion::dateTimeShift(ctx.result, -utcOffsetSecs);
-       return kEnd;
-     }},
-    {kEnd, [](Token, Token, Context &) -> StatusOr<State> { return Status::OK(); }},
-};
-
-/*static*/ const char *TimeParser::toString(TokenType t) {
-  switch (t) {
-    case TokenType::kUnknown:
-      return "Unknown";
-    case TokenType::kPlaceHolder:
-      return "PlaceHolder";
-    case TokenType::kNumber:
-      return "Number";
-    case TokenType::kPlus:
-      return "+";
-    case TokenType::kMinus:
-      return "-";
-    case TokenType::kTimeDelimiter:
-      return "TimeDelimiter";
-    case TokenType::kTimePrefix:
-      return "TimePrefix";
-    case TokenType::kTimeZoneName:
-      return "TimeZoneName";
-  }
-  LOG(FATAL) << "Unknown token " << static_cast<int>(t);
-  return "Unknown token";
-}
-
-/*static*/ std::string TimeParser::toString(const Token &t) {
-  std::stringstream ss;
-  ss << toString(t.type);
-  ss << "(";
-  if (t.type == TokenType::kNumber) {
-    ss << t.val;
-  }
-  if (t.type == TokenType::kTimeZoneName) {
-    ss << t.str;
-  }
-  ss << ")";
-  return ss.str();
-}
-
-/*static*/ const char *TimeParser::toString(State state) {
-  switch (state) {
-    case kInitial:
-      return "Initial";
-    case kDateYear:
-      return "DateYear";
-    case kDateMonth:
-      return "DateMonth";
-    case kDateDay:
-      return "DateDay";
-    case kTimeHour:
-      return "TimeHour";
-    case kTimeMinute:
-      return "TimeMinute";
-    case kTimeSecond:
-      return "TimeSecond";
-    case kUtcOffset:
-      return "UtcOffset";
-    case kUtcOffsetHour:
-      return "UtcOffsetHour";
-    case kUtcOffsetMinute:
-      return "UtcOffsetMinute";
-    case kTimeZone:
-      return "TimeZone";
-    case kEnd:
-      return "End";
-    case kSize:
-      return "Size";
-  }
-  DLOG(FATAL) << "Unknown state " << static_cast<int>(state);
-  return "Unknown";
-}
-
-Status TimeParser::lex(folly::StringPiece str) {
-  tokens_.reserve(8);
-  std::string digits;
-  digits.reserve(8);
-  auto c = str.start();
-  while (*c != '\0') {
-    if (std::isdigit(*c) || kFractionPrefix == *c) {
-      digits.push_back(*c);
-      if (!(std::isdigit(*(c + 1)) || kFractionPrefix == *(c + 1))) {
-        if (digits.front() == '.') {
-          return Status::Error("Unexpected character `%c'.", digits.front());
-        }
-        if (digits.back() == '.') {
-          return Status::Error("Expected character fraction.");
-        }
-        Token t;
-        try {
-          t.val = folly::to<double>(digits);
-        } catch (std::exception &e) {
-          return Status::Error("%s", e.what());
-        }
-        t.type = TokenType::kNumber;
-        tokens_.emplace_back(t);
-        digits.clear();
-      }
-    } else if (kTimeDelimiter == *c) {
-      tokens_.emplace_back(Token{TokenType::kTimeDelimiter, 0, ""});
-    } else if (kTimePrefix == *c || kTimeSpacePrefix == *c) {
-      tokens_.emplace_back(Token{TokenType::kTimePrefix, 0, ""});
-    } else if (kPlus == *c) {
-      tokens_.emplace_back(Token{TokenType::kPlus, 0, ""});
-    } else if (kMinus == *c) {
-      tokens_.emplace_back(Token{TokenType::kMinus, 0, ""});
-    } else if (kLeftBracket == *c) {
-      std::string s;
-      while (*(++c) != kRightBracket) {
-        if (*c == '\0') {
-          return Status::Error("Unterminated bracket.");
-        }
-        s.push_back(*c);
-      }
-      tokens_.emplace_back(Token{TokenType::kTimeZoneName, 0, std::move(s)});
-    } else {
-      return Status::Error("Illegal character `%c'.", *c);
-    }
-    ++c;
-  }
-  // Only for read-ahead placeholder
-  tokens_.emplace_back(Token{TokenType::kPlaceHolder, 0, ""});
-  return Status::OK();
-}
-
-Status TimeParser::parse() {
-  auto result = dateTimeStates[kInitial].next({}, {}, ctx_);
-  NG_RETURN_IF_ERROR(result);
-  auto current = result.value();
-  for (std::size_t i = 0; i < tokens_.size() - 1; ++i) {
-    result = dateTimeStates[current].next(tokens_[i], tokens_[i + 1], ctx_);
-    NG_RETURN_IF_ERROR(result);
-    current = result.value();
-    if (current == kEnd) {
-      break;
-    }
-  }
-  if (current != kEnd) {
-    return Status::Error("Not end parse.");
-  }
-  return Status::OK();
-}
-
-}  // namespace time
-}  // namespace nebula
diff --git a/src/common/time/TimeParser.h b/src/common/time/TimeParser.h
deleted file mode 100644
index 0da70851240..00000000000
--- a/src/common/time/TimeParser.h
+++ /dev/null
@@ -1,137 +0,0 @@
-/* Copyright (c) 2020 vesoft inc. All rights reserved.
- *
- * This source code is licensed under Apache 2.0 License,
- * attached with Common Clause Condition 1.0, found in the LICENSES directory.
- */
-
-#ifndef COMMON_TIME_TIMEPARSER_H_
-#define COMMON_TIME_TIMEPARSER_H_
-
-#include "common/base/Base.h"
-#include "common/base/Status.h"
-#include "common/base/StatusOr.h"
-#include "common/datatypes/Date.h"
-
-namespace nebula {
-namespace time {
-
-// parser the date/time/datetime literal
-class TimeParser {
- public:
-  TimeParser() = default;
-
-  StatusOr<Date> parseDate(folly::StringPiece str) {
-    ctx_.type = ExpectType::kDate;
-    NG_RETURN_IF_ERROR(lex(str));
-    NG_RETURN_IF_ERROR(parse());
-    return Date{static_cast<int16_t>(ctx_.result.year),
-                static_cast<int8_t>(ctx_.result.month),
-                static_cast<int8_t>(ctx_.result.day)};
-  }
-
-  StatusOr<Time> parseTime(folly::StringPiece str) {
-    ctx_.type = ExpectType::kTime;
-    NG_RETURN_IF_ERROR(lex(str));
-    NG_RETURN_IF_ERROR(parse());
-    return Time{static_cast<int8_t>(ctx_.result.hour),
-                static_cast<int8_t>(ctx_.result.minute),
-                static_cast<int8_t>(ctx_.result.sec),
-                static_cast<int32_t>(ctx_.result.microsec)};
-  }
-
-  StatusOr<DateTime> parseDateTime(folly::StringPiece str) {
-    ctx_.type = ExpectType::kDateTime;
-    NG_RETURN_IF_ERROR(lex(str));
-    NG_RETURN_IF_ERROR(parse());
-    return ctx_.result;
-  }
-
- private:
-  static constexpr char kTimeDelimiter = ':';
-
-  static constexpr char kTimePrefix = 'T';
-  static constexpr char kTimeSpacePrefix = ' ';
-  static constexpr char kFractionPrefix = '.';
-  static constexpr char kPlus = '+';
-  static constexpr char kMinus = '-';
-
-  static constexpr char kLeftBracket = '[';
-  static constexpr char kRightBracket = ']';
-
-  enum class ExpectType {
-    kDate,
-    kTime,
-    kDateTime,
-  };
-
-  enum class TokenType {
-    kUnknown,
-    kPlaceHolder,  // Only for read-ahead placeholder
-    kNumber,
-    kPlus,
-    kMinus,
-    kTimeDelimiter,
-    kTimePrefix,
-    kTimeZoneName,
-  };
-
-  static const char* toString(TokenType t);
-
-  struct Token {
-    TokenType type;
-    double val;  // only used for number token
-    std::string str;
-  };
-
-  static std::string toString(const Token& t);
-
-  // TODO(shylock) support weeks/days format when support the convertion
-  // The state of current parser
-  enum State {
-    kInitial,          // 0
-    kDateYear,         // 1
-    kDateMonth,        // 2
-    kDateDay,          // 3
-    kTimeHour,         // 4
-    kTimeMinute,       // 5
-    kTimeSecond,       // 6
-    kUtcOffset,        // 8
-    kUtcOffsetHour,    // 9
-    kUtcOffsetMinute,  // 10
-    kTimeZone,         // 11
-    kEnd,              // 12
-    kSize,             // Just for count
-  };
-
-  static const char* toString(State state);
-
-  struct Context {
-    DateTime result;
-    ExpectType type;
-
-    TokenType utcSign{TokenType::kUnknown};
-    int32_t utcOffsetSecs{0};
-  };
-
-  struct Component {
-    const State state;  // current state
-    // State shift function
-    std::function<StatusOr<State>(Token, Token, Context&)> next;
-  };
-
-  // All states of datetime
-  static const std::vector<Component> dateTimeStates;
-
-  Status lex(folly::StringPiece str);
-
-  Status parse();
-
- private:
-  std::vector<Token> tokens_;
-  Context ctx_;
-};
-
-}  // namespace time
-}  // namespace nebula
-
-#endif  // COMMON_TIME_TIMEPARSER_H_
diff --git a/src/common/time/TimeUtils.cpp b/src/common/time/TimeUtils.cpp
index 01045531ee1..a98ade4dda7 100644
--- a/src/common/time/TimeUtils.cpp
+++ b/src/common/time/TimeUtils.cpp
@@ -10,6 +10,7 @@
 
 #include "common/fs/FileUtils.h"
 #include "common/time/TimezoneInfo.h"
+#include "common/time/parser/DatetimeReader.h"
 
 namespace nebula {
 namespace time {
@@ -171,5 +172,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 0680a213618..ffd61bfd1e2 100644
--- a/src/common/time/TimeUtils.h
+++ b/src/common/time/TimeUtils.h
@@ -20,7 +20,6 @@
 #include "common/datatypes/Map.h"
 #include "common/fs/FileUtils.h"
 #include "common/time/TimeConversion.h"
-#include "common/time/TimeParser.h"
 #include "common/time/TimezoneInfo.h"
 #include "common/time/WallClock.h"
 
@@ -67,13 +66,7 @@ class TimeUtils {
     return Status::OK();
   }
 
-  static StatusOr<DateTime> parseDateTime(const std::string &str) {
-    TimeParser p;
-    auto result = p.parseDateTime(str);
-    NG_RETURN_IF_ERROR(result);
-    NG_RETURN_IF_ERROR(validateDate(result.value()));
-    return result.value();
-  }
+  static StatusOr<DateTime> parseDateTime(const std::string &str);
 
   static StatusOr<DateTime> dateTimeFromMap(const Map &m);
 
@@ -124,13 +117,7 @@ class TimeUtils {
 
   static StatusOr<Date> dateFromMap(const Map &m);
 
-  static StatusOr<Date> parseDate(const std::string &str) {
-    TimeParser p;
-    auto result = p.parseDate(str);
-    NG_RETURN_IF_ERROR(result);
-    NG_RETURN_IF_ERROR(validateDate(result.value()));
-    return result.value();
-  }
+  static StatusOr<Date> parseDate(const std::string &str);
 
   static StatusOr<Date> localDate() {
     Date d;
@@ -166,10 +153,7 @@ class TimeUtils {
 
   static StatusOr<Time> timeFromMap(const Map &m);
 
-  static StatusOr<Time> parseTime(const std::string &str) {
-    TimeParser p;
-    return p.parseTime(str);
-  }
+  static StatusOr<Time> parseTime(const std::string &str);
 
   // utc + offset = local
   static Time timeToUTC(const Time &time) {
diff --git a/src/common/time/parser/datetime_parser.yy b/src/common/time/parser/datetime_parser.yy
index 4c9c813b31b..74157c1d441 100644
--- a/src/common/time/parser/datetime_parser.yy
+++ b/src/common/time/parser/datetime_parser.yy
@@ -69,7 +69,7 @@ enum class Type {
 %type <dtVal> datetime
 %type <dVal> date
 %type <tVal> time
-%type <intVal> opt_time_zone opt_time_zone_name time_zone_offset
+%type <intVal> opt_time_zone time_zone_offset opt_time_zone_offset opt_time_zone_name
 
 %define api.prefix {datetime}
 
@@ -162,16 +162,25 @@ opt_time_zone
   : %empty {
     $$ = 0;
   }
-  | POSITIVE time_zone_offset opt_time_zone_name {
-    if ($3 != 0 && $2 != $3) {
+  | 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 opt_time_zone_name {
-    if ($3 != 0 && $2 != $3) {
-      throw DatetimeParser::syntax_error(@1, "Mismatched timezone offset.");
-    }
+  | NEGATIVE time_zone_offset {
     $$ = -$2;
   }
   ;
@@ -188,10 +197,7 @@ time_zone_offset
   ;
 
 opt_time_zone_name
-  : %empty {
-    $$ = 0;
-  }
-  | TIME_ZONE_NAME {
+  : TIME_ZONE_NAME {
     auto zone = nebula::time::Timezone();
     auto result = zone.loadFromDb(*$1);
     if (!result.ok()) {
diff --git a/src/common/time/parser/datetime_scanner.lex b/src/common/time/parser/datetime_scanner.lex
index 210bbcbec24..99ec72e4d46 100644
--- a/src/common/time/parser/datetime_scanner.lex
+++ b/src/common/time/parser/datetime_scanner.lex
@@ -53,7 +53,8 @@ R_BRACKET                   "]"
                           return TokenType::DOUBLE;
                         }
 
-L_BRACKET[^R_BRACKET]+R_BRACKET {
+\[[^\]]+\]              {
+                          DLOG(ERROR) << "DEBUG POINT: " << " lex time zone name.";
                           std::string *str = new std::string(yytext + 1, yyleng - 2);
                           yylval->strVal = str;
                           return TokenType::TIME_ZONE_NAME;
@@ -72,6 +73,7 @@ L_BRACKET[^R_BRACKET]+R_BRACKET {
                             * Please note that it is not Flex but Bison to regard illegal
                             * characters as errors, in such case.
                             */
+                          DLOG(ERROR) << "DEBUG POINT: unmatched char " << yytext[0];
                           return static_cast<unsigned char>(yytext[0]);
 
                           /**
diff --git a/src/common/time/test/CMakeLists.txt b/src/common/time/test/CMakeLists.txt
index 90e974e6585..cdf28c156df 100644
--- a/src/common/time/test/CMakeLists.txt
+++ b/src/common/time/test/CMakeLists.txt
@@ -51,20 +51,7 @@ nebula_add_test(
         $<TARGET_OBJECTS:base_obj>
         $<TARGET_OBJECTS:fs_obj>
         $<TARGET_OBJECTS:wkt_wkb_io_obj>
-    LIBRARIES
-        gtest
-)
-
-nebula_add_test(
-    NAME
-        time_parser_test
-    SOURCES
-        TimeParserTest.cpp
-    OBJECTS
-        $<TARGET_OBJECTS:base_obj>
-        $<TARGET_OBJECTS:time_obj>
-        $<TARGET_OBJECTS:datatypes_obj>
-        $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
     LIBRARIES
         gtest
 )
diff --git a/src/common/time/test/TimeParserTest.cpp b/src/common/time/test/TimeParserTest.cpp
deleted file mode 100644
index dc71490fa07..00000000000
--- a/src/common/time/test/TimeParserTest.cpp
+++ /dev/null
@@ -1,249 +0,0 @@
-/* Copyright (c) 2020 vesoft inc. All rights reserved.
- *
- * This source code is licensed under Apache 2.0 License,
- * attached with Common Clause Condition 1.0, found in the LICENSES directory.
- */
-#include <gtest/gtest.h>
-
-#include "common/base/Base.h"
-#include "common/time/TimeParser.h"
-
-TEST(TimeParser, DateTime) {
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDateTime("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
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDateTime("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
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDateTime("2019-01T22:22:3.2333");
-    ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::DateTime(2019, 1, 1, 22, 22, 3, 233300), result.value());
-  }
-  // lack month
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDateTime("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
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDateTime("2019T22:22:3");
-    ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::DateTime(2019, 1, 1, 22, 22, 3, 0), result.value());
-  }
-  // lack second
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDateTime("2019T22:22");
-    ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::DateTime(2019, 1, 1, 22, 22, 0, 0), result.value());
-  }
-  // lack second
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDateTime("2019T22");
-    ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::DateTime(2019, 1, 1, 22, 0, 0, 0), result.value());
-  }
-}
-
-TEST(TimeParser, DateTimeFailed) {
-  // out of range offset
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDateTime("2019-01-03T22:22:3.2333+24:30");
-    EXPECT_FALSE(result.ok()) << result.status();
-  }
-  // only time
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDateTime("22:22:3.2333");
-    EXPECT_FALSE(result.ok()) << result.status();
-  }
-  // with unexpected character
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDateTime("2019-01-03T22:22:3.2333x");
-    EXPECT_FALSE(result.ok()) << result.status();
-  }
-  // not ending delimiter
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDateTime("2019-01-T22:22:3.2333");
-    EXPECT_FALSE(result.ok()) << result.status();
-  }
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDateTime("2019-01-03T22:22:.2333");
-    EXPECT_FALSE(result.ok()) << result.status();
-  }
-  // not ending prefix
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDateTime("2019-01-03T");
-    EXPECT_FALSE(result.ok()) << result.status();
-  }
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDateTime("2019-01-03T22:22:3.");
-    EXPECT_FALSE(result.ok()) << result.status();
-  }
-  // not exits prefix
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDateTime("-01-03T22:22:3.2333");
-    EXPECT_FALSE(result.ok()) << result.status();
-  }
-}
-
-TEST(TimeParser, Date) {
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDate("2019-01-03");
-    ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::Date(2019, 1, 3), result.value());
-  }
-  // lack day
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDate("2019-01");
-    ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::Date(2019, 1, 1), result.value());
-  }
-  // lack month
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDate("2019");
-    ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::Date(2019, 1, 1), result.value());
-  }
-}
-
-TEST(TimeParser, DateFailed) {
-  // don't support offset
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDate("2019-01-03+23:00");
-    EXPECT_FALSE(result.ok()) << result.status();
-  }
-  // with unexpected character
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDate("2019-01-03*");
-    EXPECT_FALSE(result.ok()) << result.status();
-  }
-  // extra components
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDate("2019-01-03T22:22:3.2333");
-    EXPECT_FALSE(result.ok()) << result.status();
-  }
-  // not ending delimiter
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDate("2019-01-");
-    EXPECT_FALSE(result.ok()) << result.status();
-  }
-  // not exits prefix
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseDate("-01-03");
-    EXPECT_FALSE(result.ok()) << result.status();
-  }
-}
-
-TEST(TimeParser, Time) {
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseTime("22:22:3.2333");
-    ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::Time(22, 22, 3, 233300), result.value());
-  }
-  // with offset
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseTime("22:22:3.2333-03:30");
-    ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::Time(1, 52, 3, 233300), result.value());
-  }
-  // lack us
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseTime("22:22:3");
-    ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::Time(22, 22, 3, 0), result.value());
-  }
-  // lack second
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseTime("22:22");
-    ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::Time(22, 22, 0, 0), result.value());
-  }
-  // lack minute
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseTime("22");
-    ASSERT_TRUE(result.ok()) << result.status();
-    EXPECT_EQ(nebula::Time(22, 0, 0, 0), result.value());
-  }
-}
-
-TEST(TimeParser, TimeFailed) {
-  // out of range offset
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseTime("22:22:3.2333-03:60");
-    EXPECT_FALSE(result.ok()) << result.status();
-  }
-  // unexpected character
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseTime("22:22:3.2333x");
-    EXPECT_FALSE(result.ok()) << result.status();
-  }
-  // extra components
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseTime("2019-01-03T22:22:3.2333");
-    EXPECT_FALSE(result.ok()) << result.status();
-  }
-  // not ending delimiter
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseTime("22:22:.2333");
-    EXPECT_FALSE(result.ok()) << result.status();
-  }
-  // not ending prefix
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseTime("22:22:3.");
-    EXPECT_FALSE(result.ok()) << result.status();
-  }
-  // not exist prefix
-  {
-    nebula::time::TimeParser parser;
-    auto result = parser.parseTime(":22:3.2333");
-    EXPECT_FALSE(result.ok()) << result.status();
-  }
-}
-
-int main(int argc, char** argv) {
-  testing::InitGoogleTest(&argc, argv);
-  folly::init(&argc, &argv, true);
-  google::SetStderrLogging(google::INFO);
-
-  return RUN_ALL_TESTS();
-}
diff --git a/src/daemons/CMakeLists.txt b/src/daemons/CMakeLists.txt
index 565c2717f54..81ca02d90c7 100644
--- a/src/daemons/CMakeLists.txt
+++ b/src/daemons/CMakeLists.txt
@@ -31,6 +31,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>
 )
diff --git a/src/graph/context/test/CMakeLists.txt b/src/graph/context/test/CMakeLists.txt
index 54f353abbca..480fbda5fb2 100644
--- a/src/graph/context/test/CMakeLists.txt
+++ b/src/graph/context/test/CMakeLists.txt
@@ -27,6 +27,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 6e48b1e4ed4..a080ac59c85 100644
--- a/src/graph/executor/test/CMakeLists.txt
+++ b/src/graph/executor/test/CMakeLists.txt
@@ -34,6 +34,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 c9a3d8245b1..c4480aaa434 100644
--- a/src/graph/optimizer/test/CMakeLists.txt
+++ b/src/graph/optimizer/test/CMakeLists.txt
@@ -29,6 +29,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 c0d01f77833..83d2ad0bf32 100644
--- a/src/graph/util/test/CMakeLists.txt
+++ b/src/graph/util/test/CMakeLists.txt
@@ -29,6 +29,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/BalanceValidator.cpp b/src/graph/validator/BalanceValidator.cpp
index f2603f6133d..34e63acb16f 100644
--- a/src/graph/validator/BalanceValidator.cpp
+++ b/src/graph/validator/BalanceValidator.cpp
@@ -5,6 +5,7 @@
  */
 
 #include "graph/validator/BalanceValidator.h"
+
 #include "graph/planner/plan/Admin.h"
 
 namespace nebula {
diff --git a/src/graph/validator/IngestValidator.cpp b/src/graph/validator/IngestValidator.cpp
index f8fec9d27ed..fb6d9226a39 100644
--- a/src/graph/validator/IngestValidator.cpp
+++ b/src/graph/validator/IngestValidator.cpp
@@ -5,6 +5,7 @@
  */
 
 #include "graph/validator/IngestValidator.h"
+
 #include "graph/planner/plan/Admin.h"
 
 namespace nebula {
diff --git a/src/graph/validator/test/CMakeLists.txt b/src/graph/validator/test/CMakeLists.txt
index f6032fb78d8..e34f1744250 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 cd27f31f110..54f27269824 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 aa039b23854..fa797692e00 100644
--- a/src/kvstore/test/CMakeLists.txt
+++ b/src/kvstore/test/CMakeLists.txt
@@ -28,6 +28,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 90c4835dd0b..eebea63cb01 100644
--- a/src/meta/CMakeLists.txt
+++ b/src/meta/CMakeLists.txt
@@ -158,6 +158,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/meta/test/CMakeLists.txt b/src/meta/test/CMakeLists.txt
index bcedc7f01d2..dc4aaee1056 100644
--- a/src/meta/test/CMakeLists.txt
+++ b/src/meta/test/CMakeLists.txt
@@ -22,6 +22,8 @@ nebula_add_test(
         $<TARGET_OBJECTS:process_obj>
         $<TARGET_OBJECTS:encryption_obj>
         $<TARGET_OBJECTS:ft_es_storage_adapter_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
+        $<TARGET_OBJECTS:time_utils_obj>
     LIBRARIES
         ${THRIFT_LIBRARIES}
         ${PROXYGEN_LIBRARIES}
diff --git a/src/parser/test/CMakeLists.txt b/src/parser/test/CMakeLists.txt
index 86016b7ba1e..423cec3c52d 100644
--- a/src/parser/test/CMakeLists.txt
+++ b/src/parser/test/CMakeLists.txt
@@ -30,6 +30,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 9ad3b3e7529..fb2d639882c 100644
--- a/src/storage/test/CMakeLists.txt
+++ b/src/storage/test/CMakeLists.txt
@@ -45,6 +45,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 893bd53e494..9072c317f51 100644
--- a/src/tools/db-dump/CMakeLists.txt
+++ b/src/tools/db-dump/CMakeLists.txt
@@ -41,6 +41,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 4aa3f68be00..6d9f286dc8f 100644
--- a/src/tools/db-upgrade/CMakeLists.txt
+++ b/src/tools/db-upgrade/CMakeLists.txt
@@ -49,6 +49,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 46c508f3b1f..941ffffcfe3 100644
--- a/src/tools/meta-dump/CMakeLists.txt
+++ b/src/tools/meta-dump/CMakeLists.txt
@@ -46,6 +46,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/storage-perf/CMakeLists.txt b/src/tools/storage-perf/CMakeLists.txt
index e278053ecb2..7b8a2317480 100644
--- a/src/tools/storage-perf/CMakeLists.txt
+++ b/src/tools/storage-perf/CMakeLists.txt
@@ -41,6 +41,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>

From 1af62b618ee761b6b2a39d6d447e4cf9818e44fe Mon Sep 17 00:00:00 2001
From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com>
Date: Fri, 22 Oct 2021 10:38:26 +0800
Subject: [PATCH 06/11] Remove debug code.

---
 src/common/function/FunctionManager.cpp     | 1 -
 src/common/time/parser/datetime_scanner.lex | 2 --
 2 files changed, 3 deletions(-)

diff --git a/src/common/function/FunctionManager.cpp b/src/common/function/FunctionManager.cpp
index 386b67e849d..07b402e74bb 100644
--- a/src/common/function/FunctionManager.cpp
+++ b/src/common/function/FunctionManager.cpp
@@ -1683,7 +1683,6 @@ 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());
diff --git a/src/common/time/parser/datetime_scanner.lex b/src/common/time/parser/datetime_scanner.lex
index 99ec72e4d46..0e14cbb66ce 100644
--- a/src/common/time/parser/datetime_scanner.lex
+++ b/src/common/time/parser/datetime_scanner.lex
@@ -54,7 +54,6 @@ R_BRACKET                   "]"
                         }
 
 \[[^\]]+\]              {
-                          DLOG(ERROR) << "DEBUG POINT: " << " lex time zone name.";
                           std::string *str = new std::string(yytext + 1, yyleng - 2);
                           yylval->strVal = str;
                           return TokenType::TIME_ZONE_NAME;
@@ -73,7 +72,6 @@ R_BRACKET                   "]"
                             * Please note that it is not Flex but Bison to regard illegal
                             * characters as errors, in such case.
                             */
-                          DLOG(ERROR) << "DEBUG POINT: unmatched char " << yytext[0];
                           return static_cast<unsigned char>(yytext[0]);
 
                           /**

From 2f15b7c38b0ffefa859118a8fa04316870db364d Mon Sep 17 00:00:00 2001
From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com>
Date: Fri, 22 Oct 2021 14:54:44 +0800
Subject: [PATCH 07/11] Fix leak.

---
 src/common/time/parser/datetime_parser.yy | 34 +++++++++++++----------
 1 file changed, 19 insertions(+), 15 deletions(-)

diff --git a/src/common/time/parser/datetime_parser.yy b/src/common/time/parser/datetime_parser.yy
index 74157c1d441..7a1b212ad43 100644
--- a/src/common/time/parser/datetime_parser.yy
+++ b/src/common/time/parser/datetime_parser.yy
@@ -80,6 +80,8 @@ enum class Type {
 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));
@@ -89,6 +91,7 @@ datetime
   }
   | date {
     if (outputType != nebula::time::Type::kDate) {
+      delete $1;
       throw DatetimeParser::syntax_error(@1, "Mismatched date time type.");
     }
     $$ = new DateTime(*$1);
@@ -97,6 +100,7 @@ datetime
   }
   | 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));
@@ -112,20 +116,20 @@ date_time_delimiter
 
 date
   : INTEGER NEGATIVE INTEGER NEGATIVE INTEGER {
-    auto *d = new nebula::Date($1, $3, $5);
-    auto result = nebula::time::TimeUtils::validateDate(*d);
+    $$ = new nebula::Date($1, $3, $5);
+    auto result = nebula::time::TimeUtils::validateDate(*$$);
     if (!result.ok()) {
+      delete $$;
       throw DatetimeParser::syntax_error(@1, result.toString());
     }
-    $$ = d;
   }
   | INTEGER NEGATIVE INTEGER {
-    auto *d = new nebula::Date($1, $3, 1);
-    auto result = nebula::time::TimeUtils::validateDate(*d);
+    $$ = new nebula::Date($1, $3, 1);
+    auto result = nebula::time::TimeUtils::validateDate(*$$);
     if (!result.ok()) {
+      delete $$;
       throw DatetimeParser::syntax_error(@1, result.toString());
     }
-    $$ = d;
   }
   ;
 
@@ -133,28 +137,28 @@ time
   : INTEGER TIME_DELIMITER INTEGER TIME_DELIMITER DOUBLE {
     double integer = 0;
     auto fraction = std::modf($5, &integer);
-    auto *t = new nebula::Time($1, $3, static_cast<int>(integer), std::round(fraction * 1000 * 1000));
-    auto result = nebula::time::TimeUtils::validateTime(*t);
+    $$ = 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());
     }
-    $$ = t;
   }
   | INTEGER TIME_DELIMITER INTEGER TIME_DELIMITER INTEGER {
-    auto *t = new nebula::Time($1, $3, $5, 0);
-    auto result = nebula::time::TimeUtils::validateTime(*t);
+    $$ = new nebula::Time($1, $3, $5, 0);
+    auto result = nebula::time::TimeUtils::validateTime(*$$);
     if (!result.ok()) {
+      delete $$;
       throw DatetimeParser::syntax_error(@1, result.toString());
     }
-    $$ = t;
   }
   | INTEGER TIME_DELIMITER INTEGER {
-    auto *t = new nebula::Time($1, $3, 0, 0);
-    auto result = nebula::time::TimeUtils::validateTime(*t);
+    $$ = new nebula::Time($1, $3, 0, 0);
+    auto result = nebula::time::TimeUtils::validateTime(*$$);
     if (!result.ok()) {
+      delete $$;
       throw DatetimeParser::syntax_error(@1, result.toString());
     }
-    $$ = t;
   }
   ;
 

From 5eb1b5be3845deb15efef6447a93623c1d887997 Mon Sep 17 00:00:00 2001
From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com>
Date: Wed, 27 Oct 2021 11:52:09 +0800
Subject: [PATCH 08/11] Fix comments.

---
 src/common/time/parser/DatetimeReader.cpp | 4 ++--
 src/common/time/parser/DatetimeScanner.h  | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/common/time/parser/DatetimeReader.cpp b/src/common/time/parser/DatetimeReader.cpp
index 79fc08c49c5..aa5037e450c 100644
--- a/src/common/time/parser/DatetimeReader.cpp
+++ b/src/common/time/parser/DatetimeReader.cpp
@@ -10,7 +10,7 @@ namespace nebula {
 namespace time {
 
 DatetimeReader::DatetimeReader(Type type) : parser_(scanner_, error_, &dt_, type) {
-  // Callback invoked by WKTScanner
+  // Callback invoked by DatetimeScanner
   auto readBuffer = [this](char *buf, int maxSize) -> int {
     // Reach the end
     if (pos_ >= end_) {
@@ -28,7 +28,7 @@ DatetimeReader::DatetimeReader(Type type) : parser_(scanner_, error_, &dt_, type
 }
 
 StatusOr<DateTime> DatetimeReader::read(std::string input) {
-  // Since WKTScanner needs a writable buffer, we have to copy the query string
+  // Since DatetimeScanner needs a writable buffer, we have to copy the query string
   buffer_ = std::move(input);
   pos_ = &buffer_[0];
   end_ = pos_ + buffer_.size();
diff --git a/src/common/time/parser/DatetimeScanner.h b/src/common/time/parser/DatetimeScanner.h
index 35b974db16d..e4507584350 100644
--- a/src/common/time/parser/DatetimeScanner.h
+++ b/src/common/time/parser/DatetimeScanner.h
@@ -36,11 +36,11 @@ class DatetimeScanner : public yyFlexLexer {
   }
 
  public:
-  // Called by WKTReader to set the `readBuffer' callback, which would be
+  // 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 WKTReader to recover from a failure state.
+  // 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);
@@ -57,7 +57,7 @@ class DatetimeScanner : public yyFlexLexer {
   using TokenType = nebula::time::DatetimeParser::token;
 
  private:
-  // friend class Scanner_Basic_Test; TODO(jie) add it
+  // friend class Scanner_Basic_Test; TODO: add it
   int yylex() override;
 
   nebula::time::DatetimeParser::semantic_type *yylval{nullptr};

From 19636935fa2f17118d2f92285203df8c2109437e Mon Sep 17 00:00:00 2001
From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com>
Date: Wed, 27 Oct 2021 11:52:49 +0800
Subject: [PATCH 09/11] Fix comments.

---
 src/common/time/parser/DatetimeScanner.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/common/time/parser/DatetimeScanner.h b/src/common/time/parser/DatetimeScanner.h
index e4507584350..ac062cbf624 100644
--- a/src/common/time/parser/DatetimeScanner.h
+++ b/src/common/time/parser/DatetimeScanner.h
@@ -25,7 +25,6 @@
 namespace nebula {
 namespace time {
 
-// TODO(jie) Try to reuse the class GraphScanner
 class DatetimeScanner : public yyFlexLexer {
  public:
   int yylex(nebula::time::DatetimeParser::semantic_type *lval,

From dab0dce87513c1c2251d9593258a34d10e1f7a5a Mon Sep 17 00:00:00 2001
From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com>
Date: Mon, 15 Nov 2021 11:45:39 +0800
Subject: [PATCH 10/11] Fix license header

---
 src/common/time/parser/CMakeLists.txt              | 3 +--
 src/common/time/parser/DatetimeReader.cpp          | 5 ++---
 src/common/time/parser/DatetimeReader.h            | 5 ++---
 src/common/time/parser/DatetimeScanner.h           | 5 ++---
 src/common/time/parser/test/CMakeLists.txt         | 5 ++---
 src/common/time/parser/test/DateTimeParserTest.cpp | 3 +--
 6 files changed, 10 insertions(+), 16 deletions(-)

diff --git a/src/common/time/parser/CMakeLists.txt b/src/common/time/parser/CMakeLists.txt
index 84de7f1e9e4..5167484655b 100644
--- a/src/common/time/parser/CMakeLists.txt
+++ b/src/common/time/parser/CMakeLists.txt
@@ -1,7 +1,6 @@
 # Copyright (c) 2020 vesoft inc. All rights reserved.
 #
-# This source code is licensed under Apache 2.0 License,
-# attached with Common Clause Condition 1.0, found in the LICENSES directory.
+# This source code is licensed under Apache 2.0 License.
 
 if(ENABLE_VERBOSE_BISON)
     set(bison_flags "-Werror -v")
diff --git a/src/common/time/parser/DatetimeReader.cpp b/src/common/time/parser/DatetimeReader.cpp
index aa5037e450c..76b2bc265c1 100644
--- a/src/common/time/parser/DatetimeReader.cpp
+++ b/src/common/time/parser/DatetimeReader.cpp
@@ -1,7 +1,6 @@
-/* Copyright (c) 2018 vesoft inc. All rights reserved.
+/* Copyright (c) 2021 vesoft inc. All rights reserved.
  *
- * This source code is licensed under Apache 2.0 License,
- * attached with Common Clause Condition 1.0, found in the LICENSES directory.
+ * This source code is licensed under Apache 2.0 License.
  */
 
 #include "common/time/parser/DatetimeReader.h"
diff --git a/src/common/time/parser/DatetimeReader.h b/src/common/time/parser/DatetimeReader.h
index bd557876936..3fa43d1eb64 100644
--- a/src/common/time/parser/DatetimeReader.h
+++ b/src/common/time/parser/DatetimeReader.h
@@ -1,7 +1,6 @@
-/* Copyright (c) 2018 vesoft inc. All rights reserved.
+/* Copyright (c) 2021 vesoft inc. All rights reserved.
  *
- * This source code is licensed under Apache 2.0 License,
- * attached with Common Clause Condition 1.0, found in the LICENSES directory.
+ * This source code is licensed under Apache 2.0 License.
  */
 
 #pragma once
diff --git a/src/common/time/parser/DatetimeScanner.h b/src/common/time/parser/DatetimeScanner.h
index ac062cbf624..e6dc1584d80 100644
--- a/src/common/time/parser/DatetimeScanner.h
+++ b/src/common/time/parser/DatetimeScanner.h
@@ -1,7 +1,6 @@
-/* Copyright (c) 2018 vesoft inc. All rights reserved.
+/* Copyright (c) 2021 vesoft inc. All rights reserved.
  *
- * This source code is licensed under Apache 2.0 License,
- * attached with Common Clause Condition 1.0, found in the LICENSES directory.
+ * This source code is licensed under Apache 2.0 License.
  */
 
 #pragma once
diff --git a/src/common/time/parser/test/CMakeLists.txt b/src/common/time/parser/test/CMakeLists.txt
index 9abbbc4b8b8..7bf97cfd254 100644
--- a/src/common/time/parser/test/CMakeLists.txt
+++ b/src/common/time/parser/test/CMakeLists.txt
@@ -1,7 +1,6 @@
-# Copyright (c) 2021 vesoft inc. All rights reserved.
+# Copyright (c) 2020 vesoft inc. All rights reserved.
 #
-# This source code is licensed under Apache 2.0 License,
-# attached with Common Clause Condition 1.0, found in the LICENSES directory.
+# This source code is licensed under Apache 2.0 License.
 
 nebula_add_test(
     NAME
diff --git a/src/common/time/parser/test/DateTimeParserTest.cpp b/src/common/time/parser/test/DateTimeParserTest.cpp
index 3dad9cb9ee1..44acb835a14 100644
--- a/src/common/time/parser/test/DateTimeParserTest.cpp
+++ b/src/common/time/parser/test/DateTimeParserTest.cpp
@@ -1,7 +1,6 @@
 /* Copyright (c) 2021 vesoft inc. All rights reserved.
  *
- * This source code is licensed under Apache 2.0 License,
- * attached with Common Clause Condition 1.0, found in the LICENSES directory.
+ * This source code is licensed under Apache 2.0 License.
  */
 
 #include <gtest/gtest.h>

From 29c40d3eeb1367bc0885da77533af28c60368cf0 Mon Sep 17 00:00:00 2001
From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com>
Date: Tue, 30 Nov 2021 11:00:05 +0800
Subject: [PATCH 11/11] Resolve conflict.

---
 src/tools/simple-kv-verify/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

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}