thevar1able/ClickHouse
1
0
Fork 0
mirror of https://github.com/ClickHouse/ClickHouse.git synced 2024-11-10 01:25:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix code review

Browse Source
This commit is contained in:
chloro 2024-06-18 08:14:14 +08:00
parent f576ad5b60
commit 42dd981fe4
2 changed files with 21 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/Analyzer/SetUtils.cpp
View File

@ -9,6 +9,8 @@
#include <Interpreters/convertFieldToType.h> #include <Interpreters/convertFieldToType.h>
#include <Interpreters/Set.h> #include <Interpreters/Set.h>
#include <Common/assert_cast.h>
namespace DB namespace DB
{ {
@ -66,17 +68,16 @@ Block createBlockFromCollection(const Collection & collection, const DataTypes&
} }
Row tuple_values; Row tuple_values;
size_t value_types_index = 0;
for (const auto & value : collection) for (size_t collection_index = 0; collection_index < collection.size(); ++collection_index)
{ {
const auto & value = collection[collection_index];
if (columns_size == 1) if (columns_size == 1)
{ {
const DataTypePtr & data_type = value_types[value_types_index]; const DataTypePtr & data_type = value_types[collection_index];
auto field = convertFieldToTypeStrict(value, *data_type, *block_types[0]); auto field = convertFieldToTypeStrict(value, *data_type, *block_types[0]);
if (!field) if (!field)
{ {
value_types_index += 1;
continue; continue;
} }
@ -84,7 +85,6 @@ Block createBlockFromCollection(const Collection & collection, const DataTypes&
if (!field->isNull() || need_insert_null) if (!field->isNull() || need_insert_null)
columns[0]->insert(*field); columns[0]->insert(*field);
value_types_index += 1;
continue; continue;
} }
@ -94,7 +94,7 @@ Block createBlockFromCollection(const Collection & collection, const DataTypes&
value.getTypeName()); value.getTypeName());
const auto & tuple = value.template get<const Tuple &>(); const auto & tuple = value.template get<const Tuple &>();
const DataTypePtr & value_type = value_types[value_types_index]; const DataTypePtr & value_type = value_types[collection_index];
const DataTypes & tuple_value_type = typeid_cast<const DataTypeTuple *>(value_type.get())->getElements(); const DataTypes & tuple_value_type = typeid_cast<const DataTypeTuple *>(value_type.get())->getElements();
size_t tuple_size = tuple.size(); size_t tuple_size = tuple.size();
@ -124,8 +124,6 @@ Block createBlockFromCollection(const Collection & collection, const DataTypes&
if (i == tuple_size) if (i == tuple_size)
for (i = 0; i < tuple_size; ++i) for (i = 0; i < tuple_size; ++i)
columns[i]->insert(tuple_values[i]); columns[i]->insert(tuple_values[i]);
value_types_index += 1;
} }
Block res; Block res;
@ -170,20 +168,14 @@ Block getSetElementsForConstantValue(const DataTypePtr & expression_type, const
if (rhs_which_type.isArray()) if (rhs_which_type.isArray())
{ {
const DataTypeArray * value_array_type = typeid_cast<const DataTypeArray *>(value_type.get()); const DataTypeArray * value_array_type = assert_cast<const DataTypeArray *>(value_type.get());
size_t value_array_size = value.get<const Array &>().size(); size_t value_array_size = value.get<const Array &>().size();
DataTypes value_types; DataTypes value_types(value_array_size, value_array_type->getNestedType());
value_types.reserve(value_array_size);
for (size_t i = 0; i < value_array_size; ++i)
{
value_types.push_back(value_array_type->getNestedType());
}
result_block = createBlockFromCollection(value.get<const Array &>(), value_types, set_element_types, transform_null_in); result_block = createBlockFromCollection(value.get<const Array &>(), value_types, set_element_types, transform_null_in);
} }
else if (rhs_which_type.isTuple()) else if (rhs_which_type.isTuple())
{ {
const DataTypeTuple * value_tuple_type = typeid_cast<const DataTypeTuple *>(value_type.get()); const DataTypeTuple * value_tuple_type = assert_cast<const DataTypeTuple *>(value_type.get());
const DataTypes & value_types = value_tuple_type->getElements(); const DataTypes & value_types = value_tuple_type->getElements();
result_block = createBlockFromCollection(value.get<const Tuple &>(), value_types, set_element_types, transform_null_in); result_block = createBlockFromCollection(value.get<const Tuple &>(), value_types, set_element_types, transform_null_in);
} }

30
src/Interpreters/ActionsVisitor.cpp
View File

@ -4,6 +4,7 @@
#include <Common/typeid_cast.h> #include <Common/typeid_cast.h>
#include <Common/FieldVisitorsAccurateComparison.h> #include <Common/FieldVisitorsAccurateComparison.h>
#include <Common/checkStackSize.h> #include <Common/checkStackSize.h>
#include <Common/assert_cast.h>
#include <Core/ColumnNumbers.h> #include <Core/ColumnNumbers.h>
#include <Core/ColumnWithTypeAndName.h> #include <Core/ColumnWithTypeAndName.h>
@ -113,16 +114,15 @@ static Block createBlockFromCollection(const Collection & collection, const Data
} }
Row tuple_values; Row tuple_values;
size_t value_type_index = 0; for (size_t collection_index = 0; collection_index < collection.size(); ++collection_index)
for (const auto & value : collection)
{ {
const auto& value = collection[collection_index];
if (columns_num == 1) if (columns_num == 1)
{ {
auto field = convertFieldToTypeStrict(value, *value_types[value_type_index], *types[0]); auto field = convertFieldToTypeStrict(value, *value_types[collection_index], *types[0]);
bool need_insert_null = transform_null_in && types[0]->isNullable(); bool need_insert_null = transform_null_in && types[0]->isNullable();
if (field && (!field->isNull() || need_insert_null)) if (field && (!field->isNull() || need_insert_null))
columns[0]->insert(*field); columns[0]->insert(*field);
value_type_index += 1;
} }
else else
{ {
@ -139,7 +139,7 @@ static Block createBlockFromCollection(const Collection & collection, const Data
if (tuple_values.empty()) if (tuple_values.empty())
tuple_values.resize(tuple_size); tuple_values.resize(tuple_size);
const DataTypePtr & value_type = value_types[value_type_index]; const DataTypePtr & value_type = value_types[collection_index];
const DataTypes & tuple_value_type = typeid_cast<const DataTypeTuple *>(value_type.get())->getElements(); const DataTypes & tuple_value_type = typeid_cast<const DataTypeTuple *>(value_type.get())->getElements();
size_t i = 0; size_t i = 0;
@ -158,7 +158,6 @@ static Block createBlockFromCollection(const Collection & collection, const Data
if (i == tuple_size) if (i == tuple_size)
for (i = 0; i < tuple_size; ++i) for (i = 0; i < tuple_size; ++i)
columns[i]->insert(tuple_values[i]); columns[i]->insert(tuple_values[i]);
value_type_index += 1;
} }
} }
@ -322,8 +321,8 @@ Block createBlockForSet(
if (left_type_depth == right_type_depth) if (left_type_depth == right_type_depth)
{ {
Array array{right_arg_value}; Array array{right_arg_value};
DataTypes data_types{right_arg_type}; DataTypes value_types{right_arg_type};
block = createBlockFromCollection(array, data_types, set_element_types, tranform_null_in); block = createBlockFromCollection(array, value_types, set_element_types, tranform_null_in);
} }
/// 1 in (1, 2); (1, 2) in ((1, 2), (3, 4)); etc. /// 1 in (1, 2); (1, 2) in ((1, 2), (3, 4)); etc.
else if (left_type_depth + 1 == right_type_depth) else if (left_type_depth + 1 == right_type_depth)
@ -331,20 +330,15 @@ Block createBlockForSet(
auto type_index = right_arg_type->getTypeId(); auto type_index = right_arg_type->getTypeId();
if (type_index == TypeIndex::Tuple) if (type_index == TypeIndex::Tuple)
{ {
const DataTypes & data_types = typeid_cast<const DataTypeTuple *>(right_arg_type.get())->getElements(); const DataTypes & value_types = assert_cast<const DataTypeTuple *>(right_arg_type.get())->getElements();
block = createBlockFromCollection(right_arg_value.get<const Tuple &>(), data_types, set_element_types, tranform_null_in); block = createBlockFromCollection(right_arg_value.get<const Tuple &>(), value_types, set_element_types, tranform_null_in);
} }
else if (type_index == TypeIndex::Array) else if (type_index == TypeIndex::Array)
{ {
const auto* right_arg_array_type = typeid_cast<const DataTypeArray *>(right_arg_type.get()); const auto* right_arg_array_type = assert_cast<const DataTypeArray *>(right_arg_type.get());
size_t right_arg_array_size = right_arg_value.get<const Array &>().size(); size_t right_arg_array_size = right_arg_value.get<const Array &>().size();
DataTypes data_types; DataTypes value_types(right_arg_array_size, right_arg_array_type->getNestedType());
data_types.reserve(right_arg_array_size); block = createBlockFromCollection(right_arg_value.get<const Array &>(), value_types, set_element_types, tranform_null_in);
for (size_t i = 0; i < right_arg_array_size; ++i)
{
data_types.push_back(right_arg_array_type->getNestedType());
}
block = createBlockFromCollection(right_arg_value.get<const Array &>(), data_types, set_element_types, tranform_null_in);
} }
else else
throw_unsupported_type(right_arg_type); throw_unsupported_type(right_arg_type);