Merge pull request #45 from Enmk/SimpleAggregateFunction

Implemented reading values of SimpleAggregateFunction

Author: traceon

clickhouse/client.cpp

@@ -55,16 +55,6 @@ struct ClientInfo {
     uint32_t client_revision = 0;
 };
 
-struct ServerInfo {
-    std::string name;
-    std::string timezone;
-    std::string display_name;
-    uint64_t    version_major;
-    uint64_t    version_minor;
-    uint64_t    version_patch;
-    uint64_t    revision;
-};
-
 std::ostream& operator<<(std::ostream& os, const ClientOptions& opt) {
     os << "Client(" << opt.user << '@' << opt.host << ":" << opt.port
        << " ping_before_query:" << opt.ping_before_query
@@ -91,6 +81,8 @@ class Client::Impl {
 
     void ResetConnection();
 
+    const ServerInfo& GetServerInfo() const;
+
 private:
     bool Handshake();
 
@@ -297,6 +289,10 @@ void Client::Impl::ResetConnection() {
     }
 }
 
+const ServerInfo& Client::Impl::GetServerInfo() const {
+    return server_info_;
+}
+
 bool Client::Impl::Handshake() {
     if (!SendHello()) {
         return false;
@@ -789,4 +785,8 @@ void Client::ResetConnection() {
     impl_->ResetConnection();
 }
 
+const ServerInfo& Client::GetServerInfo() const {
+    return impl_->GetServerInfo();
+}
+
 }

clickhouse/client.h

@@ -23,6 +23,16 @@
 
 namespace clickhouse {
 
+struct ServerInfo {
+    std::string name;
+    std::string timezone;
+    std::string display_name;
+    uint64_t    version_major;
+    uint64_t    version_minor;
+    uint64_t    version_patch;
+    uint64_t    revision;
+};
+
 /// Methods of block compression.
 enum class CompressionMethod {
     None    = -1,
@@ -106,6 +116,8 @@ class Client {
     /// Reset connection with initial params.
     void ResetConnection();
 
+    const ServerInfo& GetServerInfo() const;
+
 private:
     ClientOptions options_;
 

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;
 }
 
@@ -135,7 +139,12 @@ bool TypeParser::Parse(TypeAst* type) {
                 type_ = &type_->elements.back();
                 break;
             case Token::EOS:
+            {
+                // Ubalanced braces, brackets, etc is an error.
+                if (open_elements_.size() != 1)
+                    return false;
                 return true;
+            }
             case Token::Invalid:
                 return false;
         }

clickhouse/types/type_parser.h

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

ut/client_ut.cpp

@@ -3,6 +3,19 @@
 
 using namespace clickhouse;
 
+namespace clickhouse
+{
+std::ostream & operator<<(std::ostream & ostr, const ServerInfo & server_info)
+{
+    return ostr << server_info.name << "/" << server_info.display_name
+                << " ver "
+                << server_info.version_major << "."
+                << server_info.version_minor << "."
+                << server_info.version_patch
+                << " (" << server_info.revision << ")";
+}
+}
+
 // Use value-parameterized tests to run same tests with different client
 // options.
 class ClientCase : public testing::TestWithParam<ClientOptions> {
@@ -284,6 +297,40 @@ TEST_P(ClientCase, Numbers) {
     EXPECT_EQ(100000U, num);
 }
 
+TEST_P(ClientCase, SimpleAggregateFunction) {
+    const auto & server_info = client_->GetServerInfo();
+    if (server_info.version_major <= 19 && server_info.version_minor < 9) {
+        std::cout << "Test is skipped since server '" << server_info << "' does not support SimpleAggregateFunction" << std::endl;
+        return;
+    }
+
+    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,26 @@ 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>());
+}
+
+
+TEST(CreateColumnByType, UnmatchedBrackets) {
+    // When type string has unmatched brackets, CreateColumnByType must return nullptr.
+    ASSERT_EQ(nullptr, CreateColumnByType("FixedString(10"));
+    ASSERT_EQ(nullptr, CreateColumnByType("Nullable(FixedString(10000"));
+    ASSERT_EQ(nullptr, CreateColumnByType("Nullable(FixedString(10000)"));
+    ASSERT_EQ(nullptr, CreateColumnByType("LowCardinality(Nullable(FixedString(10000"));
+    ASSERT_EQ(nullptr, CreateColumnByType("LowCardinality(Nullable(FixedString(10000)"));
+    ASSERT_EQ(nullptr, CreateColumnByType("LowCardinality(Nullable(FixedString(10000))"));
+    ASSERT_EQ(nullptr, CreateColumnByType("Array(LowCardinality(Nullable(FixedString(10000"));
+    ASSERT_EQ(nullptr, CreateColumnByType("Array(LowCardinality(Nullable(FixedString(10000)"));
+    ASSERT_EQ(nullptr, CreateColumnByType("Array(LowCardinality(Nullable(FixedString(10000))"));
+    ASSERT_EQ(nullptr, CreateColumnByType("Array(LowCardinality(Nullable(FixedString(10000)))"));
+}

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);
+}