[Issue-36] Use Int64 for datetime, add tests for DateTime64, and getters for Decimals and DateTime64

Author: tshev

clickhouse/columns/date.cpp

@@ -113,28 +113,23 @@ ItemView ColumnDateTime::GetItem(size_t index) const {
     return data_->GetItem(index);
 }
 
-
-ColumnDateTime64::ColumnDateTime64()
-    : Column(Type::CreateDateTime64(3ul))
-    , data_(std::make_shared<ColumnDecimal>(18ul, 3ul))
-{}
-
 ColumnDateTime64::ColumnDateTime64(size_t precision)
     : Column(Type::CreateDateTime64(precision))
     , data_(std::make_shared<ColumnDecimal>(18ul, precision))
 {}
 
 
-void ColumnDateTime64::Append(const Int128& value) {
+void ColumnDateTime64::Append(const Int64& value) {
+    // TODO: we need a type, which represents datetime
+    // The precision of Poco.DateTime is not big enough.
     data_->Append(value);
 }
 
 void ColumnDateTime64::Append(const std::string& value) {
     data_->Append(value);
 }
 
-
-Int128 ColumnDateTime64::At(size_t n) const {
+Int64 ColumnDateTime64::At(size_t n) const {
     return data_->At(n);
 }
 
@@ -178,4 +173,8 @@ ColumnRef ColumnDateTime64::Slice(size_t begin, size_t len) {
     return result;
 }
 
+size_t ColumnDateTime64::GetPrecision() const {
+    return data_->Type()->As<DecimalType>()->GetScale();
+}
+
 }

clickhouse/columns/date.h

@@ -87,15 +87,14 @@ class ColumnDateTime : public Column {
 /** */
 class ColumnDateTime64 : public Column {
 public:
-    ColumnDateTime64();
-    ColumnDateTime64(size_t);
+    explicit ColumnDateTime64(size_t);
 
     /// Appends one element to the end of column.
-    void Append(const Int128& value);
+    void Append(const Int64& value);
     void Append(const std::string& value);
 
     /// Returns element at given row number.
-    Int128 At(size_t n) const;
+    Int64 At(size_t n) const;
 
 public:
     /// Appends content of given column to the end of current one.
@@ -119,6 +118,8 @@ class ColumnDateTime64 : public Column {
     void Swap(Column& other) override;
 
     ItemView GetItem(size_t index) const override;
+
+    size_t GetPrecision() const;
 private:
     std::shared_ptr<ColumnDecimal> data_;
 };

clickhouse/columns/numeric.h

@@ -54,6 +54,7 @@ class ColumnVector : public Column {
 };
 
 using Int128 = __int128;
+using Int64 = int64_t;
 
 using ColumnUInt8   = ColumnVector<uint8_t>;
 using ColumnUInt16  = ColumnVector<uint16_t>;

clickhouse/types/type_parser.cpp

@@ -9,6 +9,7 @@
 namespace clickhouse {
 
 bool TypeAst::operator==(const TypeAst & other) const {
+    // TODO: operator == must be a friend function.
     return meta == other.meta
         && code == other.code
         && name == other.name

clickhouse/types/types.h

@@ -142,6 +142,7 @@ class DecimalType : public Type {
     std::string GetName() const;
 
     inline size_t GetScale() const { return scale_; }
+    inline size_t GetPrecision() const { return precision_; }
 
 private:
     const size_t precision_, scale_;

tests/simple/main.cpp

@@ -4,6 +4,7 @@
 
 #include <stdexcept>
 #include <iostream>
+#include <cmath>
 
 #if defined(_MSC_VER)
 #   pragma warning(disable : 4996)
@@ -129,6 +130,36 @@ inline void DateExample(Client& client) {
     client.Execute("DROP TABLE test.date");
 }
 
+inline void DateTime64Example(Client& client) {
+    Block b;
+
+    /// Create a table.
+    client.Execute("CREATE TABLE IF NOT EXISTS test.date (d DateTime64(6)) ENGINE = Memory");
+
+    size_t precision = 6ul;
+    auto d = std::make_shared<ColumnDateTime64>(precision);
+    assert(d->GetPrecision() == precision);
+    Int64 precision_multiplier = std::pow(10ull, precision);
+    Int64 datetime = Int64(std::time(nullptr)) * precision_multiplier;
+
+    d->Append(datetime);
+    b.AppendColumn("d", d);
+    client.Insert("test.date", b);
+
+    client.Select("SELECT d FROM test.date", [precision_multiplier](const Block& block)
+        {
+            for (size_t c = 0; c < block.GetRowCount(); ++c) {
+                auto col = block[0]->As<ColumnDateTime64>();
+                Int64 t = col->At(c) / precision_multiplier;
+                std::cerr << std::asctime(std::localtime(&t)) << " " << std::endl;
+            }
+        }
+    );
+
+    /// Delete table.
+    client.Execute("DROP TABLE test.date");
+}
+
 inline void DecimalExample(Client& client) {
     Block b;
 
@@ -442,6 +473,7 @@ static void RunTests(Client& client) {
     ArrayExample(client);
     CancelableExample(client);
     DateExample(client);
+    DateTime64Example(client);
     DecimalExample(client);
     EnumExample(client);
     ExecptionExample(client);

ut/columns_ut.cpp

@@ -132,6 +132,18 @@ TEST(ColumnsCase, DateAppend) {
     ASSERT_EQ(col2->At(0), (now / 86400) * 86400);
 }
 
+TEST(ColumnsCase, DateTime64Precision) {
+    auto column = std::make_shared<ColumnDateTime64>(6ul);
+    ASSERT_EQ(column->GetPrecision(), 6ul);
+}
+
+TEST(ColumnsCase, DateTime64Append) {
+    auto column = std::make_shared<ColumnDateTime64>(6ul);
+    column->Append(Int64(1ll));
+    ASSERT_EQ(column->Size(), 1ul);
+    ASSERT_EQ(column->At(0), Int64(1ll));
+}
+
 TEST(ColumnsCase, Date2038) {
     auto col1 = std::make_shared<ColumnDate>();
     std::time_t largeDate(25882ul * 86400ul);