Implement Append for ColumnTuple

clickhouse/columns/tuple.cpp

@@ -20,9 +20,29 @@ size_t ColumnTuple::TupleSize() const {
     return columns_.size();
 }
 
+void ColumnTuple::Append(ColumnRef column) {
+    if (!this->Type()->IsEqual(column->Type())) {
+        throw std::runtime_error(
+            "can't append column of type " + column->Type()->GetName() + " "
+            "to column type " + this->Type()->GetName());
+    }
+    const auto & source_tuple_column = column->As<ColumnTuple>();
+    for (size_t ci = 0; ci < columns_.size(); ++ci) {
+        columns_[ci]->Append((*source_tuple_column)[ci]);
+    }
+}
 size_t ColumnTuple::Size() const {
     return columns_.empty() ? 0 : columns_[0]->Size();
 }
+ColumnRef ColumnTuple::Slice(size_t begin, size_t len) const {
+    std::vector<ColumnRef> sliced_columns;
+    sliced_columns.reserve(columns_.size());
+    for(const auto &column : columns_){
+        sliced_columns.push_back(column->Slice(begin, len));
+    }
+
+    return std::make_shared<ColumnTuple>(sliced_columns);
+}
 
 bool ColumnTuple::Load(InputStream* input, size_t rows) {
     for (auto ci = columns_.begin(); ci != columns_.end(); ++ci) {

clickhouse/columns/tuple.h

@@ -22,7 +22,7 @@ class ColumnTuple : public Column {
 
 public:
     /// Appends content of given column to the end of current one.
-    void Append(ColumnRef) override { }
+    void Append(ColumnRef column) override;
 
     /// Loads column data from input stream.
     bool Load(InputStream* input, size_t rows) override;
@@ -37,7 +37,7 @@ class ColumnTuple : public Column {
     size_t Size() const override;
 
     /// Makes slice of the current column.
-    ColumnRef Slice(size_t, size_t) const override { return ColumnRef(); }
+    ColumnRef Slice(size_t, size_t) const override;
     void Swap(Column& other) override;
 
 private:

ut/columns_ut.cpp

@@ -1,4 +1,5 @@
 #include <clickhouse/columns/array.h>
+#include <clickhouse/columns/tuple.h>
 #include <clickhouse/columns/date.h>
 #include <clickhouse/columns/enum.h>
 #include <clickhouse/columns/factory.h>
@@ -219,6 +220,39 @@ TEST(ColumnsCase, ArrayAppend) {
     //ASSERT_EQ(col->As<ColumnUInt64>()->At(1), 3u);
 }
 
+TEST(ColumnsCase, TupleAppend){
+    auto tuple1 = std::make_shared<ColumnTuple>(std::vector<ColumnRef>({
+                                std::make_shared<ColumnUInt64>(),
+                                std::make_shared<ColumnString>()
+                            }));
+    auto tuple2 = std::make_shared<ColumnTuple>(std::vector<ColumnRef>({
+                                std::make_shared<ColumnUInt64>(),
+                                std::make_shared<ColumnString>()
+                            }));
+    (*tuple1)[0]->As<ColumnUInt64>()->Append(2u);
+    (*tuple1)[1]->As<ColumnString>()->Append("2");
+    tuple2->Append(tuple1);
+
+    ASSERT_EQ((*tuple2)[0]->As<ColumnUInt64>()->At(0), 2u);
+    ASSERT_EQ((*tuple2)[1]->As<ColumnString>()->At(0), "2");
+}
+
+TEST(ColumnsCase, TupleSlice){
+    auto tuple1 = std::make_shared<ColumnTuple>(std::vector<ColumnRef>({
+                                std::make_shared<ColumnUInt64>(),
+                                std::make_shared<ColumnString>()
+                            }));
+
+    (*tuple1)[0]->As<ColumnUInt64>()->Append(2u);
+    (*tuple1)[1]->As<ColumnString>()->Append("2");
+    (*tuple1)[0]->As<ColumnUInt64>()->Append(3u);
+    (*tuple1)[1]->As<ColumnString>()->Append("3");
+    auto tuple2 = tuple1->Slice(1,1)->As<ColumnTuple>();
+
+    ASSERT_EQ((*tuple2)[0]->As<ColumnUInt64>()->At(0), 3u);
+    ASSERT_EQ((*tuple2)[1]->As<ColumnString>()->At(0), "3");
+}
+
 TEST(ColumnsCase, DateAppend) {
     auto col1 = std::make_shared<ColumnDate>();
     auto col2 = std::make_shared<ColumnDate>();