Implemented reading values of SimpleAggregateFunction

Author: Enmk

clickhouse/columns/factory.cpp

@@ -147,6 +147,9 @@ static ColumnRef CreateColumnFromAst(const TypeAst& ast) {
                     throw std::runtime_error("LowCardinality(" + nested.name + ") is not supported");
             }
         }
+        case TypeAst::SimpleAggregateFunction: {
+            return CreateTerminalColumn(ast.elements.back());
+        }
 
         case TypeAst::Null:
         case TypeAst::Number:

clickhouse/types/type_parser.cpp

@@ -79,6 +79,10 @@ static TypeAst::Meta GetTypeMeta(const StringView& name) {
         return TypeAst::LowCardinality;
     }
 
+    if (name == "SimpleAggregateFunction") {
+        return TypeAst::SimpleAggregateFunction;
+    }
+
     return TypeAst::Terminal;
 }
 

clickhouse/types/type_parser.h

@@ -19,6 +19,7 @@ struct TypeAst {
         Tuple,
         Enum,
         LowCardinality,
+        SimpleAggregateFunction
     };
 
     /// Type's category.

ut/client_ut.cpp

@@ -284,6 +284,34 @@ TEST_P(ClientCase, Numbers) {
     EXPECT_EQ(100000U, num);
 }
 
+TEST_P(ClientCase, SimpleAggregateFunction) {
+    client_->Execute("DROP TABLE IF EXISTS test_clickhouse_cpp.SimpleAggregateFunction");
+    client_->Execute(
+            "CREATE TABLE IF NOT EXISTS test_clickhouse_cpp.SimpleAggregateFunction (saf SimpleAggregateFunction(sum, UInt64))"
+            "ENGINE = Memory");
+
+    constexpr size_t EXPECTED_ROWS = 10;
+    client_->Execute("INSERT INTO test_clickhouse_cpp.SimpleAggregateFunction (saf) SELECT number FROM system.numbers LIMIT 10");
+
+    size_t total_rows = 0;
+    client_->Select("Select * FROM test_clickhouse_cpp.SimpleAggregateFunction", [&total_rows](const Block & block) {
+        if (block.GetRowCount() == 0)
+            return;
+
+        total_rows += block.GetRowCount();
+        auto col = block[0]->As<ColumnUInt64>();
+        ASSERT_NE(nullptr, col);
+
+        for (size_t r = 0; r < col->Size(); ++r) {
+            EXPECT_EQ(r, col->At(r));
+        }
+
+        EXPECT_EQ(total_rows, col->Size());
+    });
+
+    EXPECT_EQ(EXPECTED_ROWS, total_rows);
+}
+
 TEST_P(ClientCase, Cancellable) {
     /// Create a table.
     client_->Execute(

ut/columns_ut.cpp

@@ -1,6 +1,7 @@
 #include <clickhouse/columns/array.h>
 #include <clickhouse/columns/date.h>
 #include <clickhouse/columns/enum.h>
+#include <clickhouse/columns/factory.h>
 #include <clickhouse/columns/lowcardinality.h>
 #include <clickhouse/columns/nullable.h>
 #include <clickhouse/columns/numeric.h>
@@ -258,3 +259,11 @@ TEST(ColumnsCase, LowCardinalityString_Save) {
         EXPECT_EQ(col.At(i), foobar(i)) << " at pos: " << i;
     }
 }
+
+TEST(ColumnsCase, CreateSimpleAggregateFunction) {
+    auto col = CreateColumnByType("SimpleAggregateFunction(funt, Int32");
+
+    ASSERT_EQ("Int32", col->Type()->GetName());
+    ASSERT_EQ(Type::Int32, col->Type()->GetCode());
+    ASSERT_NE(nullptr, col->As<ColumnInt32>());
+}

ut/type_parser_ut.cpp

@@ -190,3 +190,20 @@ TEST(TypeParserCase, LowCardinality_FixedString) {
     auto param = TypeAst{TypeAst::Number, Type::Void, "", 10, {}};
     ASSERT_EQ(ast.elements[0].elements[0], param);
 }
+
+TEST(TypeParserCase, SimpleAggregateFunction_UInt64) {
+    TypeAst ast;
+    TypeParser("SimpleAggregateFunction(func, UInt64)").Parse(&ast);
+    ASSERT_EQ(ast.meta, TypeAst::SimpleAggregateFunction);
+    ASSERT_EQ(ast.name, "SimpleAggregateFunction");
+    ASSERT_EQ(ast.code, Type::Void);
+    ASSERT_EQ(ast.elements.size(), 2u);
+    ASSERT_EQ(ast.elements[0].name, "func");
+    ASSERT_EQ(ast.elements[0].code, Type::Void);
+    ASSERT_EQ(ast.elements[0].meta, TypeAst::Terminal);
+    ASSERT_EQ(ast.elements[0].value, 0);
+    ASSERT_EQ(ast.elements[1].name, "UInt64");
+    ASSERT_EQ(ast.elements[1].code, Type::UInt64);
+    ASSERT_EQ(ast.elements[1].meta, TypeAst::Terminal);
+    ASSERT_EQ(ast.elements[1].value, 0);
+}