Fixed tests

Author: Enmk

ut/client_ut.cpp

@@ -30,7 +30,29 @@ class ClientCase : public testing::TestWithParam<ClientOptions> {
             client_->Execute("DROP DATABASE test_clickhouse_cpp");
     }
 
+    template <typename T>
+    std::shared_ptr<T> createTableWithOneColumn(Block & block)
+    {
+        auto col = std::make_shared<T>();
+        const auto type_name = col->GetType().GetName();
+
+        client_->Execute("DROP TABLE IF EXISTS " + table_name + ";");
+        client_->Execute("CREATE TABLE IF NOT EXISTS " + table_name + "( " + column_name + " " + type_name + " )"
+                "ENGINE = Memory");
+
+        block.AppendColumn("test_column", col);
+
+        return col;
+    }
+
+    std::string getOneColumnSelectQuery() const
+    {
+        return "SELECT " + column_name + " FROM " + table_name;
+    }
+
     std::unique_ptr<Client> client_;
+    const std::string table_name = "test_clickhouse_cpp.test_ut_table";
+    const std::string column_name = "test_column";
 };
 
 TEST_P(ClientCase, Array) {
@@ -117,22 +139,57 @@ TEST_P(ClientCase, Date) {
 
 TEST_P(ClientCase, LowCardinality) {
     Block block;
-    client_->Execute("DROP TABLE IF EXISTS test_clickhouse_cpp.low_cardinality;");
+    auto lc = createTableWithOneColumn<ColumnLowCardinalityT<ColumnString>>(block);
 
-    client_->Execute("CREATE TABLE IF NOT EXISTS "
-            "test_clickhouse_cpp.low_cardinality (lc LowCardinality(String)) "
-            "ENGINE = Memory");
+    const std::vector<std::string> data{{"FooBar", "1", "2", "Foo", "4", "Bar", "Foo", "7", "8", "Foo"}};
+    lc->AppendMany(data);
+
+    block.RefreshRowCount();
+    client_->Insert(table_name, block);
+
+    size_t total_rows = 0;
+    client_->Select(getOneColumnSelectQuery(),
+        [&total_rows, &data](const Block& block) {
+            total_rows += block.GetRowCount();
+            if (block.GetRowCount() == 0) {
+                return;
+            }
+
+            ASSERT_EQ(1U, block.GetColumnCount());
+            if (auto col = block[0]->As<ColumnLowCardinalityT<ColumnString>>()) {
+                ASSERT_EQ(data.size(), col->Size());
+                for (size_t i = 0; i < col->Size(); ++i) {
+                    EXPECT_EQ(data[i], (*col)[i]) << " at index: " << i;
+                }
+            }
+        }
+    );
+
+    ASSERT_EQ(total_rows, data.size());
+}
+
+TEST_P(ClientCase, LowCardinality_InsertAfterClear) {
+    // User can successfully insert values after invoking Clear() on LC column.
+    Block block;
+    auto lc = createTableWithOneColumn<ColumnLowCardinalityT<ColumnString>>(block);
+
+    // Add some data, but don't care about it much.
+    lc->AppendMany(std::vector<std::string_view>{"abc", "def", "123", "abc", "123", "def", "ghi"});
+    EXPECT_GT(lc->Size(), 0u);
+    EXPECT_GT(lc->GetDictionarySize(), 0u);
 
-    auto lc = std::make_shared<ColumnLowCardinalityT<ColumnString>>();
+    lc->Clear();
 
+    // Now ensure that all data appended after Clear() is inserted properly
     const std::vector<std::string> data{{"FooBar", "1", "2", "Foo", "4", "Bar", "Foo", "7", "8", "Foo"}};
     lc->AppendMany(data);
 
-    block.AppendColumn("lc", lc);
-    client_->Insert("test_clickhouse_cpp.low_cardinality", block);
+    block.RefreshRowCount();
+    client_->Insert(table_name, block);
 
+    // Now validate that data was properly inserted
     size_t total_rows = 0;
-    client_->Select("SELECT lc FROM test_clickhouse_cpp.low_cardinality",
+    client_->Select(getOneColumnSelectQuery(),
         [&total_rows, &data](const Block& block) {
             total_rows += block.GetRowCount();
             if (block.GetRowCount() == 0) {

ut/columns_ut.cpp

@@ -11,7 +11,14 @@
 #include <contrib/gtest/gtest.h>
 #include "utils.h"
 
+#include <string_view>
+
+
+namespace
+{
+
 using namespace clickhouse;
+using namespace std::literals::string_view_literals;
 
 static std::vector<uint32_t> MakeNumbers() {
     return std::vector<uint32_t>
@@ -40,6 +47,17 @@ static std::vector<uint64_t> MakeUUIDs() {
          0x3507213c178649f9llu, 0x9faf035d662f60aellu};
 }
 
+#define BINARY_STRING(x) std::string_view(x, sizeof(x) - 1)
+
+static const auto LOWCARDINALITY_STRING_FOOBAR_10_ITEMS_BINARY =
+        "\x01\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00"
+        "\x09\x00\x00\x00\x00\x00\x00\x00\x00\x06\x46\x6f\x6f\x42\x61\x72"
+        "\x01\x31\x01\x32\x03\x46\x6f\x6f\x01\x34\x03\x42\x61\x72\x01\x37"
+        "\x01\x38\x0a\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06"
+        "\x04\x07\x08\x04"sv;
+
+}
+
 // TODO: add tests for ColumnDecimal.
 
 TEST(ColumnsCase, NumericInit) {
@@ -217,14 +235,26 @@ TEST(ColumnsCase, LowCardinalityWrapperString_Append_and_Read) {
     }
 }
 
-#define BINARY_STRING(x) std::string_view(x, sizeof(x) - 1)
+TEST(ColumnsCase, ColumnLowCardinalityT_String_Clear_and_Append) {
+    const size_t items_count = 11;
+    ColumnLowCardinalityT<ColumnString> col;
+    for (const auto & item : build_vector(&foobar, items_count))
+    {
+        col.Append(item);
+    }
 
-static const auto LOWCARDINALITY_STRING_FOOBAR_10_ITEMS_BINARY =
-        BINARY_STRING("\x01\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00"
-                      "\x09\x00\x00\x00\x00\x00\x00\x00\x00\x06\x46\x6f\x6f\x42\x61\x72"
-                      "\x01\x31\x01\x32\x03\x46\x6f\x6f\x01\x34\x03\x42\x61\x72\x01\x37"
-                      "\x01\x38\x0a\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06"
-                      "\x04\x07\x08\x04");
+    col.Clear();
+    ASSERT_EQ(col.Size(), 0u);
+    ASSERT_EQ(col.GetDictionarySize(), 1u); // null-item
+
+    for (const auto & item : build_vector(&foobar, items_count))
+    {
+        col.Append(item);
+    }
+
+    ASSERT_EQ(col.Size(), items_count);
+    ASSERT_EQ(col.GetDictionarySize(), 8u + 1); // 8 unique items from sequence + 1 null-item
+}
 
 TEST(ColumnsCase, LowCardinalityString_Load) {
     const size_t items_count = 10;