Skip to content

Commit 14aa16c

Browse files
den818den818
committed
refactoring
1 parent eccff7f commit 14aa16c

File tree

3 files changed

+73
-82
lines changed

3 files changed

+73
-82
lines changed

‎ut/Column_ut.cpp

Lines changed: 31 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@
22
#include <clickhouse/columns/tuple.h>
33
#include <clickhouse/columns/date.h>
44
#include <clickhouse/columns/enum.h>
5+
#include <clickhouse/columns/geo.h>
56
#include <clickhouse/columns/lowcardinality.h>
67
#include <clickhouse/columns/nullable.h>
78
#include <clickhouse/columns/numeric.h>
@@ -61,6 +62,10 @@ class GenericColumnTest : public testing::Test {
6162
}
6263

6364
static auto GenerateValues(size_t values_size) {
65+
using Point = std::tuple<double, double>;
66+
using Ring = std::vector<Point>;
67+
using Polygon = std::vector<Ring>;
68+
using MultyPolygon = std::vector<Polygon>;
6469
if constexpr (std::is_same_v<ColumnType, ColumnString>) {
6570
return GenerateVector(values_size, FooBarGenerator);
6671
} else if constexpr (std::is_same_v<ColumnType, ColumnFixedString>) {
@@ -83,6 +88,14 @@ class GenericColumnTest : public testing::Test {
8388
return GenerateVector(values_size, FromVectorGenerator{MakeDecimals(3, 10)});
8489
} else if constexpr (std::is_same_v<ColumnType, ColumnUUID>) {
8590
return GenerateVector(values_size, FromVectorGenerator{MakeUUIDs()});
91+
} else if constexpr (std::is_same_v<ColumnType, ColumnPoint>) {
92+
return GenerateVector(values_size, RandomGenerator<Point>());
93+
} else if constexpr (std::is_same_v<ColumnType, ColumnRing>) {
94+
return GenerateVector(values_size, RandomGenerator<Ring>());
95+
} else if constexpr (std::is_same_v<ColumnType, ColumnPolygon>) {
96+
return GenerateVector(values_size, RandomGenerator<Polygon>());
97+
} else if constexpr (std::is_same_v<ColumnType, ColumnMultiPolygon>) {
98+
return GenerateVector(values_size, RandomGenerator<MultyPolygon>());
8699
} else if constexpr (std::is_integral_v<typename ColumnType::ValueType>) {
87100
// ColumnUIntX and ColumnIntX
88101
return GenerateVector<typename ColumnType::ValueType>(values_size, RandomGenerator<int>());
@@ -118,6 +131,7 @@ using ValueColumns = ::testing::Types<
118131
, ColumnInt128
119132
, ColumnDecimal
120133
, ColumnUUID
134+
, ColumnPoint, ColumnRing //, ColumnPolygon, ColumnMultiPolygon
121135
>;
122136
TYPED_TEST_SUITE(GenericColumnTest, ValueColumns);
123137

@@ -186,21 +200,29 @@ inline auto convertValueForGetItem(const ColumnType& col, ValueType&& t) {
186200
} else if constexpr (std::is_same_v<ColumnType, ColumnDateTime>) {
187201
return static_cast<uint32_t>(t);
188202
} else {
189-
return t;
203+
return std::move(t);
190204
}
191205
}
192206

193207
TYPED_TEST(GenericColumnTest, GetItem) {
194-
auto [column, values] = this->MakeColumnWithValues(100);
208+
using GeneratedValueType = std::decay_t<decltype(this->GenerateValues(1)[0])>;
209+
using ConvertedValueType = decltype(convertValueForGetItem(std::declval<TypeParam>(), std::declval<GeneratedValueType>()));
210+
using ItemViewGetType = decltype(std::declval<ItemView>().template get<ConvertedValueType>());
211+
if constexpr (!std::is_same_v<ItemViewGetType, void>) {
212+
auto [column, values] = this->MakeColumnWithValues(100);
195213

196-
ASSERT_EQ(values.size(), column->Size());
197-
ASSERT_EQ(column->GetItem(0).type, column->GetType().GetCode());
214+
ASSERT_EQ(values.size(), column->Size());
215+
ASSERT_EQ(column->GetItem(0).type, column->GetType().GetCode());
198216

199-
for (size_t i = 0; i < values.size(); ++i) {
200-
const auto v = convertValueForGetItem(*column, values[i]);
201-
const ItemView item = column->GetItem(i);
217+
for (size_t i = 0; i < values.size(); ++i) {
218+
const auto v = convertValueForGetItem(*column, values[i]);
219+
const ItemView item = column->GetItem(i);
202220

203-
ASSERT_TRUE(CompareRecursive(item.get<decltype(v)>(), v));
221+
ASSERT_TRUE(CompareRecursive(item.get<decltype(v)>(), v));
222+
}
223+
} else {
224+
// Column does not suppotr GetItem
225+
SUCCEED();
204226
}
205227
}
206228

@@ -249,7 +271,7 @@ TYPED_TEST(GenericColumnTest, Swap) {
249271
TYPED_TEST(GenericColumnTest, LoadAndSave) {
250272
auto [column_A, values] = this->MakeColumnWithValues(100);
251273

252-
char buffer[4096] = {'\0'};
274+
char buffer[1024 * 100] = {'\0'};
253275
{
254276
ArrayOutput output(buffer, sizeof(buffer));
255277
// Save

‎ut/client_ut.cpp

Lines changed: 0 additions & 73 deletions
Original file line numberDiff line numberDiff line change
@@ -1066,79 +1066,6 @@ TEST_P(ClientCase, RoundtripMapUUID_Tuple_String_Array_Uint64) {
10661066
EXPECT_TRUE(CompareRecursive(*map, *result_typed));
10671067
}
10681068

1069-
TEST_P(ClientCase, RoundtripPoint) {
1070-
if (GetSettingValue("allow_experimental_geo_types") != "1") {
1071-
GTEST_SKIP() << "Test is skipped because experimental geo types are not allowed. Set setting allow_experimental_geo_types = 1 in order to allow it." << std::endl;
1072-
}
1073-
1074-
auto col = std::make_shared<ColumnPoint>();
1075-
col->Append({1.0, 2.0});
1076-
col->Append({0.1, 0.2});
1077-
1078-
auto result_typed = RoundtripColumnValues(*client_, col)->AsStrict<ColumnPoint>();
1079-
EXPECT_TRUE(CompareRecursive(*col, *result_typed));
1080-
}
1081-
1082-
TEST_P(ClientCase, RoundtripRing) {
1083-
if (GetSettingValue("allow_experimental_geo_types") != "1") {
1084-
GTEST_SKIP() << "Test is skipped because experimental geo types are not allowed. Set setting allow_experimental_geo_types = 1 in order to allow it." << std::endl;
1085-
}
1086-
1087-
auto col = std::make_shared<ColumnRing>();
1088-
{
1089-
std::vector<ColumnPoint::ValueType> ring{{1.0, 2.0}, {3.0, 4.0}};
1090-
col->Append(ring);
1091-
}
1092-
{
1093-
std::vector<ColumnPoint::ValueType> ring{{0.1, 0.2}, {0.3, 0.4}};
1094-
col->Append(ring);
1095-
}
1096-
auto result_typed = RoundtripColumnValues(*client_, col)->AsStrict<ColumnRing>();
1097-
EXPECT_TRUE(CompareRecursive(*col, *result_typed));
1098-
}
1099-
1100-
TEST_P(ClientCase, RoundtripPolygon) {
1101-
if (GetSettingValue("allow_experimental_geo_types") != "1") {
1102-
GTEST_SKIP() << "Test is skipped because experimental geo types are not allowed. Set setting allow_experimental_geo_types = 1 in order to allow it." << std::endl;
1103-
}
1104-
1105-
auto col = std::make_shared<ColumnPolygon>();
1106-
{
1107-
std::vector<std::vector<ColumnPoint::ValueType>> polygon
1108-
{{{1.0, 2.0}, {3.0, 4.0}}, {{5.0, 6.0}, {7.0, 8.0}}};
1109-
col->Append(polygon);
1110-
}
1111-
{
1112-
std::vector<std::vector<ColumnPoint::ValueType>> polygon
1113-
{{{0.1, 0.2}, {0.3, 0.4}}, {{0.5, 0.6}, {0.7, 0.8}}};
1114-
col->Append(polygon);
1115-
}
1116-
auto result_typed = RoundtripColumnValues(*client_, col)->AsStrict<ColumnPolygon>();
1117-
EXPECT_TRUE(CompareRecursive(*col, *result_typed));
1118-
}
1119-
1120-
TEST_P(ClientCase, RoundtripMultiPolygon) {
1121-
if (GetSettingValue("allow_experimental_geo_types") != "1") {
1122-
GTEST_SKIP() << "Test is skipped because experimental geo types are not allowed. Set setting allow_experimental_geo_types = 1 in order to allow it." << std::endl;
1123-
}
1124-
1125-
auto col = std::make_shared<ColumnMultiPolygon>();
1126-
{
1127-
std::vector<std::vector<std::vector<ColumnPoint::ValueType>>> multi_polygon
1128-
{{{{1.0, 2.0}, {3.0, 4.0}}, {{5.0, 6.0}, {7.0, 8.0}}},
1129-
{{{1.1, 2.2}, {3.3, 4.4}}, {{5.5, 6.6}, {7.7, 8.8}}}};
1130-
col->Append(multi_polygon);
1131-
}
1132-
{
1133-
std::vector<std::vector<std::vector<ColumnPoint::ValueType>>> multi_polygon
1134-
{{{{0.1, 0.2}, {0.3, 0.4}}, {{0.5, 0.6}, {0.7, 0.8}}},
1135-
{{{1.1, 1.2}, {1.3, 1.4}}, {{1.5, 1.6}, {1.7, 1.8}}}};
1136-
col->Append(multi_polygon);
1137-
}
1138-
auto result_typed = RoundtripColumnValues(*client_, col)->AsStrict<ColumnMultiPolygon>();
1139-
EXPECT_TRUE(CompareRecursive(*col, *result_typed));
1140-
}
1141-
11421069
TEST_P(ClientCase, OnProgress) {
11431070
Block block;
11441071
createTableWithOneColumn<ColumnString>(block);

‎ut/value_generators.h

Lines changed: 42 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -95,6 +95,48 @@ struct RandomGenerator {
9595
uniform_distribution distribution;
9696
};
9797

98+
template<>
99+
struct RandomGenerator <std::tuple<double, double>> {
100+
explicit RandomGenerator(double seed = 0, double value_min = std::numeric_limits<double>::min(), double value_max = std::numeric_limits<double>::max())
101+
: generator_(seed, value_min, value_max)
102+
{
103+
}
104+
105+
template <typename U>
106+
std::tuple<double, double> operator()(U val) {
107+
return std::make_tuple(generator_(val), generator_(val));
108+
}
109+
110+
private:
111+
RandomGenerator<double> generator_;
112+
};
113+
114+
template<typename T>
115+
struct RandomGenerator <std::vector<T>> {
116+
explicit RandomGenerator(
117+
RandomGenerator<T> elemet_generator = RandomGenerator<T>{},
118+
RandomGenerator<size_t> size_generator = RandomGenerator<size_t>{0, 1, 10})
119+
: elemet_generator_(std::move(elemet_generator))
120+
, size_generator_(std::move(size_generator))
121+
{
122+
}
123+
124+
template <typename U>
125+
std::vector<T> operator()(U val) {
126+
size_t size = size_generator_(val);
127+
std::vector<T> result;
128+
result.reserve(size);
129+
for (size_t i = 0; i < size; ++i) {
130+
result.push_back(elemet_generator_(val));
131+
}
132+
return result;
133+
}
134+
135+
private:
136+
RandomGenerator<T> elemet_generator_;
137+
RandomGenerator<size_t> size_generator_;
138+
};
139+
98140
template <typename T>
99141
std::vector<T> ConcatSequences(std::vector<T> && vec1, std::vector<T> && vec2) {
100142
std::vector<T> result(vec1);

0 commit comments

Comments
 (0)