Merge pull request #70 from Enmk/DateTime_and_DateTime64_timezone

Timezone support for DateTime (artpaul#120)

Author: Enmk

README.md

@@ -8,6 +8,7 @@ C++ client for [Yandex ClickHouse](https://clickhouse.yandex/)
 * Array(T)
 * Date
 * DateTime, DateTime64
+* DateTime([timezone]), DateTime64(N, [timezone])
 * Decimal32, Decimal64, Decimal128
 * Enum8, Enum16
 * FixedString(N)

clickhouse/client.cpp

@@ -36,6 +36,7 @@
 #define DBMS_MIN_REVISION_WITH_SERVER_DISPLAY_NAME      54372
 #define DBMS_MIN_REVISION_WITH_VERSION_PATCH            54401
 #define DBMS_MIN_REVISION_WITH_LOW_CARDINALITY_TYPE     54405
+#define DBMS_MIN_REVISION_WITH_TIME_ZONE_PARAMETER_IN_DATETIME_DATA_TYPE 54337
 
 namespace clickhouse {
 

clickhouse/columns/date.cpp

@@ -65,6 +65,12 @@ ColumnDateTime::ColumnDateTime()
 {
 }
 
+ColumnDateTime::ColumnDateTime(std::string timezone)
+    : Column(Type::CreateDateTime(std::move(timezone)))
+    , data_(std::make_shared<ColumnUInt32>())
+{
+}
+
 void ColumnDateTime::Append(const std::time_t& value) {
     data_->Append(static_cast<uint32_t>(value));
 }
@@ -73,6 +79,10 @@ std::time_t ColumnDateTime::At(size_t n) const {
     return data_->At(n);
 }
 
+std::string ColumnDateTime::Timezone() const {
+    return type_->As<DateTimeType>()->Timezone();
+}
+
 void ColumnDateTime::Append(ColumnRef column) {
     if (auto col = column->As<ColumnDateTime>()) {
         data_->Append(col->data_);
@@ -117,6 +127,10 @@ ColumnDateTime64::ColumnDateTime64(size_t precision)
     : ColumnDateTime64(Type::CreateDateTime64(precision), std::make_shared<ColumnDecimal>(18ul, precision))
 {}
 
+ColumnDateTime64::ColumnDateTime64(size_t precision, std::string timezone)
+    : ColumnDateTime64(Type::CreateDateTime64(precision, std::move(timezone)), std::make_shared<ColumnDecimal>(18ul, precision))
+{}
+
 ColumnDateTime64::ColumnDateTime64(TypeRef type, std::shared_ptr<ColumnDecimal> data)
     : Column(type),
       data_(data),
@@ -137,6 +151,10 @@ Int64 ColumnDateTime64::At(size_t n) const {
     return data_->At(n);
 }
 
+std::string ColumnDateTime64::Timezone() const {
+    return type_->As<DateTime64Type>()->Timezone();
+}
+
 void ColumnDateTime64::Append(ColumnRef column) {
     if (auto col = column->As<ColumnDateTime64>()) {
         data_->Append(col->data_);

clickhouse/columns/date.h

@@ -31,7 +31,7 @@ class ColumnDate : public Column {
 
     /// Clear column data .
     void Clear() override;
-    
+
     /// Returns count of rows in the column.
     size_t Size() const override;
 
@@ -50,13 +50,18 @@ class ColumnDate : public Column {
 class ColumnDateTime : public Column {
 public:
     ColumnDateTime();
+    explicit ColumnDateTime(std::string timezone);
 
     /// Appends one element to the end of column.
     void Append(const std::time_t& value);
 
     /// Returns element at given row number.
     std::time_t At(size_t n) const;
 
+    /// Timezone associated with a data column.
+    std::string Timezone() const;
+
+public:
     /// Appends content of given column to the end of current one.
     void Append(ColumnRef column) override;
 
@@ -87,7 +92,8 @@ class ColumnDateTime : public Column {
 /** */
 class ColumnDateTime64 : public Column {
 public:
-    explicit ColumnDateTime64(size_t);
+    explicit ColumnDateTime64(size_t precision);
+    ColumnDateTime64(size_t precision, std::string timezone);
 
     /// Appends one element to the end of column.
     void Append(const Int64& value);
@@ -98,6 +104,9 @@ class ColumnDateTime64 : public Column {
     /// Returns element at given row number.
     Int64 At(size_t n) const;
 
+    /// Timezone associated with a data column.
+    std::string Timezone() const;
+
 public:
     /// Appends content of given column to the end of current one.
     void Append(ColumnRef column) override;

clickhouse/columns/factory.cpp

@@ -64,9 +64,20 @@ static ColumnRef CreateTerminalColumn(const TypeAst& ast) {
         return std::make_shared<ColumnFixedString>(ast.elements.front().value);
 
     case Type::DateTime:
-        return std::make_shared<ColumnDateTime>();
+        if (ast.elements.empty()) {
+            return std::make_shared<ColumnDateTime>();
+        } else {
+            return std::make_shared<ColumnDateTime>(ast.elements[0].value_string);
+        }
     case Type::DateTime64:
-        return std::make_shared<ColumnDateTime64>(ast.elements.front().value);
+        if (ast.elements.empty()) {
+            return nullptr;
+        }
+        if (ast.elements.size() == 1) {
+            return std::make_shared<ColumnDateTime64>(ast.elements[0].value);
+        } else {
+            return std::make_shared<ColumnDateTime64>(ast.elements[0].value, ast.elements[1].value_string);
+        }
     case Type::Date:
         return std::make_shared<ColumnDate>();
 
@@ -120,10 +131,11 @@ static ColumnRef CreateColumnFromAst(const TypeAst& ast) {
         case TypeAst::Enum: {
             std::vector<Type::EnumItem> enum_items;
 
-            enum_items.reserve(ast.elements.size());
-            for (const auto& elem : ast.elements) {
+            enum_items.reserve(ast.elements.size() / 2);
+            for (size_t i = 0; i < ast.elements.size(); i += 2) {
                 enum_items.push_back(
-                    Type::EnumItem{elem.name, (int16_t)elem.value});
+                    Type::EnumItem{ast.elements[i].value_string,
+                                   (int16_t)ast.elements[i + 1].value});
             }
 
             if (ast.code == Type::Enum8) {
@@ -153,8 +165,10 @@ static ColumnRef CreateColumnFromAst(const TypeAst& ast) {
             return CreateTerminalColumn(ast.elements.back());
         }
 
+        case TypeAst::Assign:
         case TypeAst::Null:
         case TypeAst::Number:
+        case TypeAst::String:
             break;
     }
 

clickhouse/types/type_parser.cpp

@@ -108,9 +108,9 @@ bool TypeParser::Parse(TypeAst* type) {
             {
                 type_->meta = TypeAst::Terminal;
                 if (token.value.length() < 1)
-                    type_->name = {};
+                    type_->value_string = {};
                 else
-                    type_->name = token.value.substr(1, token.value.length() - 2).to_string();
+                    type_->value_string = token.value.substr(1, token.value.length() - 2).to_string();
                 type_->code = Type::String;
                 break;
             }
@@ -123,6 +123,10 @@ bool TypeParser::Parse(TypeAst* type) {
                 type_->meta = TypeAst::Number;
                 type_->value = std::stol(token.value.to_string());
                 break;
+            case Token::String:
+                type_->meta = TypeAst::String;
+                type_->value_string = std::string(token.value);
+                break;
             case Token::LPar:
                 type_->elements.emplace_back(TypeAst());
                 open_elements_.push(type_);
@@ -132,6 +136,7 @@ bool TypeParser::Parse(TypeAst* type) {
                 type_ = open_elements_.top();
                 open_elements_.pop();
                 break;
+            case Token::Assign:
             case Token::Comma:
                 type_ = open_elements_.top();
                 open_elements_.pop();
@@ -160,10 +165,8 @@ TypeParser::Token TypeParser::NextToken() {
             case '\t':
             case '\0':
                 continue;
-
             case '=':
-                continue;
-
+                return Token{Token::Assign, StringView(cur_++, 1)};
             case '(':
                 return Token{Token::LPar, StringView(cur_++, 1)};
             case ')':
@@ -190,6 +193,16 @@ TypeParser::Token TypeParser::NextToken() {
             default: {
                 const char* st = cur_;
 
+                if (*cur_ == '\'') {
+                    for (st = ++cur_; cur_ < end_; ++cur_) {
+                        if (*cur_ == '\'') {
+                            return Token{Token::String, StringView(st, cur_++ - st)};
+                        }
+                    }
+
+                    return Token{Token::Invalid, StringView()};
+                }
+
                 if (isalpha(*cur_) || *cur_ == '_') {
                     for (; cur_ < end_; ++cur_) {
                         if (!isalpha(*cur_) && !isdigit(*cur_) && *cur_ != '_') {

clickhouse/types/type_parser.h

@@ -12,9 +12,11 @@ namespace clickhouse {
 struct TypeAst {
     enum Meta {
         Array,
+        Assign,
         Null,
         Nullable,
         Number,
+        String,
         Terminal,
         Tuple,
         Enum,
@@ -31,6 +33,7 @@ struct TypeAst {
     /// Value associated with the node,
     /// used for fixed-width types and enum values.
     int64_t value = 0;
+    std::string value_string;
     /// Subelements of the type.
     /// Used to store enum's names and values as well.
     std::vector<TypeAst> elements;
@@ -47,8 +50,10 @@ class TypeParser {
     struct Token {
         enum Type {
             Invalid = 0,
+            Assign,
             Name,
             Number,
+            String,
             LPar,
             RPar,
             Comma,

clickhouse/types/types.cpp

@@ -4,8 +4,7 @@
 
 namespace clickhouse {
 
-Type::Type(const Code code) : code_(code) {
-}
+Type::Type(const Code code) : code_(code) {}
 
 std::string Type::GetName() const {
     switch (code_) {
@@ -44,7 +43,9 @@ std::string Type::GetName() const {
         case IPv6:
             return "IPv6";
         case DateTime:
-            return "DateTime";
+        {
+            return As<DateTimeType>()->GetName();
+        }
         case DateTime64:
             return As<DateTime64Type>()->GetName();
         case Date:
@@ -79,12 +80,12 @@ TypeRef Type::CreateDate() {
     return TypeRef(new Type(Type::Date));
 }
 
-TypeRef Type::CreateDateTime() {
-    return TypeRef(new Type(Type::DateTime));
+TypeRef Type::CreateDateTime(std::string timezone) {
+    return TypeRef(new DateTimeType(std::move(timezone)));
 }
 
-TypeRef Type::CreateDateTime64(size_t precision) {
-    return TypeRef(new DateTime64Type(precision));
+TypeRef Type::CreateDateTime64(size_t precision, std::string timezone) {
+    return TypeRef(new DateTime64Type(precision, std::move(timezone)));
 }
 
 TypeRef Type::CreateDecimal(size_t precision, size_t scale) {
@@ -183,7 +184,7 @@ std::string EnumType::GetName() const {
         result = "Enum16(";
     }
 
-    for (auto ei = value_to_name_.begin();;) {
+    for (auto ei = value_to_name_.begin(); ei != value_to_name_.end();) {
         result += "'";
         result += ei->second;
         result += "' = ";
@@ -225,10 +226,36 @@ EnumType::ValueToNameIterator EnumType::EndValueToName() const {
     return value_to_name_.end();
 }
 
+
+namespace details
+{
+TypeWithTimeZoneMixin::TypeWithTimeZoneMixin(std::string timezone)
+    : timezone_(std::move(timezone)) {
+}
+
+const std::string & TypeWithTimeZoneMixin::Timezone() const {
+    return timezone_;
+}
+}
+
+/// class DateTimeType
+DateTimeType::DateTimeType(std::string timezone)
+    : Type(DateTime), details::TypeWithTimeZoneMixin(std::move(timezone)) {
+}
+
+std::string DateTimeType::GetName() const {
+    std::string datetime_representation = "DateTime";
+    const auto & timezone = Timezone();
+    if (!timezone.empty())
+        datetime_representation += "('" + timezone + "')";
+
+    return datetime_representation;
+}
+
 /// class DateTime64Type
 
-DateTime64Type::DateTime64Type(size_t precision)
-    : Type(DateTime64), precision_(precision) {
+DateTime64Type::DateTime64Type(size_t precision, std::string timezone)
+    : Type(DateTime64), details::TypeWithTimeZoneMixin(std::move(timezone)), precision_(precision) {
 
     if (precision_ > 18) {
         throw std::runtime_error("DateTime64 precision is > 18");
@@ -240,6 +267,12 @@ std::string DateTime64Type::GetName() const {
     datetime64_representation.reserve(14);
     datetime64_representation += "DateTime64(";
     datetime64_representation += std::to_string(precision_);
+
+    const auto & timezone = Timezone();
+    if (!timezone.empty()) {
+        datetime64_representation += ", '" + timezone + "'";
+    }
+
     datetime64_representation += ")";
     return datetime64_representation;
 }
@@ -262,8 +295,9 @@ TupleType::TupleType(const std::vector<TypeRef>& item_types) : Type(Tuple), item
 /// class LowCardinalityType
 LowCardinalityType::LowCardinalityType(TypeRef nested_type) : Type(LowCardinality), nested_type_(nested_type) {
 }
-LowCardinalityType::~LowCardinalityType()
-{}
+
+LowCardinalityType::~LowCardinalityType() {
+}
 
 std::string TupleType::GetName() const {
     std::string result("Tuple(");