github-actions[bot] commented on code in PR #16335:
URL: https://github.com/apache/doris/pull/16335#discussion_r1093190260
##########
be/src/vec/data_types/get_least_supertype.cpp:
##########
@@ -50,12 +50,152 @@
}
} // namespace
-DataTypePtr get_least_supertype(const DataTypes& types) {
+Status get_numeric_type(const TypeIndexSet& types, DataTypePtr* type) {
+ bool all_numbers = true;
+
+ size_t max_bits_of_signed_integer = 0;
+ size_t max_bits_of_unsigned_integer = 0;
+ size_t max_mantissa_bits_of_floating = 0;
+
+ auto maximize = [](size_t& what, size_t value) {
+ if (value > what) what = value;
+ };
+
+ for (const auto& type : types) {
+ if (type == TypeIndex::UInt8)
+ maximize(max_bits_of_unsigned_integer, 8);
+ else if (type == TypeIndex::UInt16)
+ maximize(max_bits_of_unsigned_integer, 16);
+ else if (type == TypeIndex::UInt32)
+ maximize(max_bits_of_unsigned_integer, 32);
+ else if (type == TypeIndex::UInt64)
+ maximize(max_bits_of_unsigned_integer, 64);
+ else if (type == TypeIndex::UInt128)
Review Comment:
warning: statement should be inside braces
[readability-braces-around-statements]
```suggestion
else if (type == TypeIndex::UInt128) {
```
be/src/vec/data_types/get_least_supertype.cpp:74:
```diff
- else if (type == TypeIndex::Int8 || type == TypeIndex::Enum8)
+ } else if (type == TypeIndex::Int8 || type == TypeIndex::Enum8)
```
##########
be/src/vec/data_types/get_least_supertype.cpp:
##########
@@ -50,12 +50,152 @@
}
} // namespace
-DataTypePtr get_least_supertype(const DataTypes& types) {
+Status get_numeric_type(const TypeIndexSet& types, DataTypePtr* type) {
+ bool all_numbers = true;
+
+ size_t max_bits_of_signed_integer = 0;
+ size_t max_bits_of_unsigned_integer = 0;
+ size_t max_mantissa_bits_of_floating = 0;
+
+ auto maximize = [](size_t& what, size_t value) {
+ if (value > what) what = value;
+ };
+
+ for (const auto& type : types) {
+ if (type == TypeIndex::UInt8)
+ maximize(max_bits_of_unsigned_integer, 8);
+ else if (type == TypeIndex::UInt16)
+ maximize(max_bits_of_unsigned_integer, 16);
+ else if (type == TypeIndex::UInt32)
+ maximize(max_bits_of_unsigned_integer, 32);
+ else if (type == TypeIndex::UInt64)
+ maximize(max_bits_of_unsigned_integer, 64);
+ else if (type == TypeIndex::UInt128)
+ maximize(max_bits_of_unsigned_integer, 128);
+ else if (type == TypeIndex::Int8 || type == TypeIndex::Enum8)
+ maximize(max_bits_of_signed_integer, 8);
+ else if (type == TypeIndex::Int16 || type == TypeIndex::Enum16)
+ maximize(max_bits_of_signed_integer, 16);
+ else if (type == TypeIndex::Int32)
+ maximize(max_bits_of_signed_integer, 32);
+ else if (type == TypeIndex::Int64)
Review Comment:
warning: statement should be inside braces
[readability-braces-around-statements]
```suggestion
else if (type == TypeIndex::Int64) {
```
be/src/vec/data_types/get_least_supertype.cpp:82:
```diff
- else if (type == TypeIndex::Int128)
+ } else if (type == TypeIndex::Int128)
```
##########
be/src/vec/data_types/get_least_supertype.cpp:
##########
@@ -50,12 +50,152 @@
}
} // namespace
-DataTypePtr get_least_supertype(const DataTypes& types) {
+Status get_numeric_type(const TypeIndexSet& types, DataTypePtr* type) {
+ bool all_numbers = true;
+
+ size_t max_bits_of_signed_integer = 0;
+ size_t max_bits_of_unsigned_integer = 0;
+ size_t max_mantissa_bits_of_floating = 0;
+
+ auto maximize = [](size_t& what, size_t value) {
+ if (value > what) what = value;
+ };
+
+ for (const auto& type : types) {
+ if (type == TypeIndex::UInt8)
+ maximize(max_bits_of_unsigned_integer, 8);
+ else if (type == TypeIndex::UInt16)
+ maximize(max_bits_of_unsigned_integer, 16);
+ else if (type == TypeIndex::UInt32)
+ maximize(max_bits_of_unsigned_integer, 32);
+ else if (type == TypeIndex::UInt64)
Review Comment:
warning: statement should be inside braces
[readability-braces-around-statements]
```suggestion
else if (type == TypeIndex::UInt64) {
```
be/src/vec/data_types/get_least_supertype.cpp:72:
```diff
- else if (type == TypeIndex::UInt128)
+ } else if (type == TypeIndex::UInt128)
```
##########
be/src/vec/data_types/get_least_supertype.cpp:
##########
@@ -50,12 +50,152 @@
}
} // namespace
-DataTypePtr get_least_supertype(const DataTypes& types) {
+Status get_numeric_type(const TypeIndexSet& types, DataTypePtr* type) {
+ bool all_numbers = true;
+
+ size_t max_bits_of_signed_integer = 0;
+ size_t max_bits_of_unsigned_integer = 0;
+ size_t max_mantissa_bits_of_floating = 0;
+
+ auto maximize = [](size_t& what, size_t value) {
+ if (value > what) what = value;
+ };
+
+ for (const auto& type : types) {
+ if (type == TypeIndex::UInt8)
+ maximize(max_bits_of_unsigned_integer, 8);
+ else if (type == TypeIndex::UInt16)
+ maximize(max_bits_of_unsigned_integer, 16);
+ else if (type == TypeIndex::UInt32)
+ maximize(max_bits_of_unsigned_integer, 32);
+ else if (type == TypeIndex::UInt64)
+ maximize(max_bits_of_unsigned_integer, 64);
+ else if (type == TypeIndex::UInt128)
+ maximize(max_bits_of_unsigned_integer, 128);
+ else if (type == TypeIndex::Int8 || type == TypeIndex::Enum8)
+ maximize(max_bits_of_signed_integer, 8);
+ else if (type == TypeIndex::Int16 || type == TypeIndex::Enum16)
Review Comment:
warning: statement should be inside braces
[readability-braces-around-statements]
```suggestion
else if (type == TypeIndex::Int16 || type == TypeIndex::Enum16) {
```
be/src/vec/data_types/get_least_supertype.cpp:78:
```diff
- else if (type == TypeIndex::Int32)
+ } else if (type == TypeIndex::Int32)
```
##########
be/src/vec/data_types/get_least_supertype.cpp:
##########
@@ -50,12 +50,152 @@
}
} // namespace
-DataTypePtr get_least_supertype(const DataTypes& types) {
+Status get_numeric_type(const TypeIndexSet& types, DataTypePtr* type) {
+ bool all_numbers = true;
+
+ size_t max_bits_of_signed_integer = 0;
+ size_t max_bits_of_unsigned_integer = 0;
+ size_t max_mantissa_bits_of_floating = 0;
+
+ auto maximize = [](size_t& what, size_t value) {
+ if (value > what) what = value;
+ };
+
+ for (const auto& type : types) {
+ if (type == TypeIndex::UInt8)
+ maximize(max_bits_of_unsigned_integer, 8);
+ else if (type == TypeIndex::UInt16)
+ maximize(max_bits_of_unsigned_integer, 16);
+ else if (type == TypeIndex::UInt32)
+ maximize(max_bits_of_unsigned_integer, 32);
+ else if (type == TypeIndex::UInt64)
+ maximize(max_bits_of_unsigned_integer, 64);
+ else if (type == TypeIndex::UInt128)
+ maximize(max_bits_of_unsigned_integer, 128);
+ else if (type == TypeIndex::Int8 || type == TypeIndex::Enum8)
+ maximize(max_bits_of_signed_integer, 8);
+ else if (type == TypeIndex::Int16 || type == TypeIndex::Enum16)
+ maximize(max_bits_of_signed_integer, 16);
+ else if (type == TypeIndex::Int32)
Review Comment:
warning: statement should be inside braces
[readability-braces-around-statements]
```suggestion
else if (type == TypeIndex::Int32) {
```
be/src/vec/data_types/get_least_supertype.cpp:80:
```diff
- else if (type == TypeIndex::Int64)
+ } else if (type == TypeIndex::Int64)
```
##########
be/src/vec/data_types/get_least_supertype.cpp:
##########
@@ -50,12 +50,152 @@
}
} // namespace
-DataTypePtr get_least_supertype(const DataTypes& types) {
+Status get_numeric_type(const TypeIndexSet& types, DataTypePtr* type) {
+ bool all_numbers = true;
+
+ size_t max_bits_of_signed_integer = 0;
+ size_t max_bits_of_unsigned_integer = 0;
+ size_t max_mantissa_bits_of_floating = 0;
+
+ auto maximize = [](size_t& what, size_t value) {
+ if (value > what) what = value;
+ };
+
+ for (const auto& type : types) {
+ if (type == TypeIndex::UInt8)
+ maximize(max_bits_of_unsigned_integer, 8);
+ else if (type == TypeIndex::UInt16)
+ maximize(max_bits_of_unsigned_integer, 16);
+ else if (type == TypeIndex::UInt32)
+ maximize(max_bits_of_unsigned_integer, 32);
+ else if (type == TypeIndex::UInt64)
+ maximize(max_bits_of_unsigned_integer, 64);
+ else if (type == TypeIndex::UInt128)
+ maximize(max_bits_of_unsigned_integer, 128);
+ else if (type == TypeIndex::Int8 || type == TypeIndex::Enum8)
+ maximize(max_bits_of_signed_integer, 8);
+ else if (type == TypeIndex::Int16 || type == TypeIndex::Enum16)
+ maximize(max_bits_of_signed_integer, 16);
+ else if (type == TypeIndex::Int32)
+ maximize(max_bits_of_signed_integer, 32);
+ else if (type == TypeIndex::Int64)
+ maximize(max_bits_of_signed_integer, 64);
+ else if (type == TypeIndex::Int128)
+ maximize(max_bits_of_signed_integer, 128);
+ else if (type == TypeIndex::Float32)
+ maximize(max_mantissa_bits_of_floating, 24);
+ else if (type == TypeIndex::Float64)
Review Comment:
warning: statement should be inside braces
[readability-braces-around-statements]
```suggestion
else if (type == TypeIndex::Float64) {
```
be/src/vec/data_types/get_least_supertype.cpp:88:
```diff
- else
+ } else
```
##########
be/src/vec/data_types/get_least_supertype.cpp:
##########
@@ -81,7 +224,8 @@
if (!typeid_cast<const DataTypeNothing*>(type.get()))
non_nothing_types.emplace_back(type);
- if (non_nothing_types.size() < types.size()) return
get_least_supertype(non_nothing_types);
+ if (non_nothing_types.size() < types.size())
+ return get_least_supertype(non_nothing_types, type,
compatible_with_string);
Review Comment:
warning: statement should be inside braces
[readability-braces-around-statements]
```suggestion
if (non_nothing_types.size() < types.size()) {
return get_least_supertype(non_nothing_types, type,
compatible_with_string);
}
```
##########
be/src/vec/data_types/get_least_supertype.cpp:
##########
@@ -50,12 +50,152 @@
}
} // namespace
-DataTypePtr get_least_supertype(const DataTypes& types) {
+Status get_numeric_type(const TypeIndexSet& types, DataTypePtr* type) {
+ bool all_numbers = true;
+
+ size_t max_bits_of_signed_integer = 0;
+ size_t max_bits_of_unsigned_integer = 0;
+ size_t max_mantissa_bits_of_floating = 0;
+
+ auto maximize = [](size_t& what, size_t value) {
+ if (value > what) what = value;
+ };
+
+ for (const auto& type : types) {
+ if (type == TypeIndex::UInt8)
+ maximize(max_bits_of_unsigned_integer, 8);
+ else if (type == TypeIndex::UInt16)
+ maximize(max_bits_of_unsigned_integer, 16);
+ else if (type == TypeIndex::UInt32)
+ maximize(max_bits_of_unsigned_integer, 32);
+ else if (type == TypeIndex::UInt64)
+ maximize(max_bits_of_unsigned_integer, 64);
+ else if (type == TypeIndex::UInt128)
+ maximize(max_bits_of_unsigned_integer, 128);
+ else if (type == TypeIndex::Int8 || type == TypeIndex::Enum8)
+ maximize(max_bits_of_signed_integer, 8);
+ else if (type == TypeIndex::Int16 || type == TypeIndex::Enum16)
+ maximize(max_bits_of_signed_integer, 16);
+ else if (type == TypeIndex::Int32)
+ maximize(max_bits_of_signed_integer, 32);
+ else if (type == TypeIndex::Int64)
+ maximize(max_bits_of_signed_integer, 64);
+ else if (type == TypeIndex::Int128)
+ maximize(max_bits_of_signed_integer, 128);
+ else if (type == TypeIndex::Float32)
+ maximize(max_mantissa_bits_of_floating, 24);
+ else if (type == TypeIndex::Float64)
+ maximize(max_mantissa_bits_of_floating, 53);
+ else
+ all_numbers = false;
+ }
+
+ if (max_bits_of_signed_integer || max_bits_of_unsigned_integer ||
+ max_mantissa_bits_of_floating) {
+ if (!all_numbers) {
+ LOG(INFO) << " because some of them are numbers and some of them
are not";
+ *type = nullptr;
+ return Status::InvalidArgument("some of them are numbers and some
of them are not");
+ }
+
+ /// If there are signed and unsigned types of same bit-width, the
result must be signed number with at least one more bit.
+ /// Example, common of Int32, UInt32 = Int64.
+
+ size_t min_bit_width_of_integer =
+ std::max(max_bits_of_signed_integer,
max_bits_of_unsigned_integer);
+
+ /// If unsigned is not covered by signed.
+ if (max_bits_of_signed_integer &&
+ max_bits_of_unsigned_integer >= max_bits_of_signed_integer)
+ ++min_bit_width_of_integer;
Review Comment:
warning: statement should be inside braces
[readability-braces-around-statements]
```suggestion
max_bits_of_unsigned_integer >= max_bits_of_signed_integer) {
++min_bit_width_of_integer;
}
```
##########
be/src/vec/exec/scan/vfile_scanner.cpp:
##########
@@ -454,6 +510,32 @@
slot_desc->col_name()));
}
+ // handle dynamic generated columns
+ if (_full_base_schema_view && !_full_base_schema_view->empty()) {
+ CHECK(_is_dynamic_schema);
+ for (size_t i = block->columns(); i < _src_block.columns(); ++i) {
+ auto& column_type_name = _src_block.get_by_position(i);
+ // Column from schema change response
+ const TColumn& tcolumn =
+
_full_base_schema_view->column_name_to_column[column_type_name.name];
+ auto original_type =
vectorized::DataTypeFactory::instance().create_data_type(tcolumn);
+ // Detect type conflict, there may exist another load procedure,
whitch has already added some columns
+ // but, this load detects different type, we go type conflict free
path, always cast to original type
+ // TODO need to add type conflict abort feature
+ if (!column_type_name.type->equals(*original_type)) {
+ vectorized::ColumnPtr column_ptr;
+
RETURN_IF_ERROR(vectorized::schema_util::cast_column(column_type_name,
+
original_type, &column_ptr));
+ column_type_name.column = column_ptr;
+ column_type_name.type = original_type;
+ }
+ DCHECK(column_type_name.column != nullptr);
+
block->insert(vectorized::ColumnWithTypeAndName(std::move(column_type_name.column),
+
std::move(column_type_name.type),
Review Comment:
warning: passing result of std::move() as a const reference argument; no
move will actually happen [performance-move-const-arg]
```suggestion
column_type_name.type,
```
##########
be/src/vec/data_types/get_least_supertype.cpp:
##########
@@ -50,12 +50,152 @@
}
} // namespace
-DataTypePtr get_least_supertype(const DataTypes& types) {
+Status get_numeric_type(const TypeIndexSet& types, DataTypePtr* type) {
+ bool all_numbers = true;
+
+ size_t max_bits_of_signed_integer = 0;
+ size_t max_bits_of_unsigned_integer = 0;
+ size_t max_mantissa_bits_of_floating = 0;
+
+ auto maximize = [](size_t& what, size_t value) {
+ if (value > what) what = value;
+ };
+
+ for (const auto& type : types) {
+ if (type == TypeIndex::UInt8)
+ maximize(max_bits_of_unsigned_integer, 8);
+ else if (type == TypeIndex::UInt16)
+ maximize(max_bits_of_unsigned_integer, 16);
+ else if (type == TypeIndex::UInt32)
+ maximize(max_bits_of_unsigned_integer, 32);
+ else if (type == TypeIndex::UInt64)
+ maximize(max_bits_of_unsigned_integer, 64);
+ else if (type == TypeIndex::UInt128)
+ maximize(max_bits_of_unsigned_integer, 128);
+ else if (type == TypeIndex::Int8 || type == TypeIndex::Enum8)
+ maximize(max_bits_of_signed_integer, 8);
+ else if (type == TypeIndex::Int16 || type == TypeIndex::Enum16)
+ maximize(max_bits_of_signed_integer, 16);
+ else if (type == TypeIndex::Int32)
+ maximize(max_bits_of_signed_integer, 32);
+ else if (type == TypeIndex::Int64)
+ maximize(max_bits_of_signed_integer, 64);
+ else if (type == TypeIndex::Int128)
+ maximize(max_bits_of_signed_integer, 128);
+ else if (type == TypeIndex::Float32)
+ maximize(max_mantissa_bits_of_floating, 24);
+ else if (type == TypeIndex::Float64)
+ maximize(max_mantissa_bits_of_floating, 53);
+ else
+ all_numbers = false;
Review Comment:
warning: statement should be inside braces
[readability-braces-around-statements]
```suggestion
else {
all_numbers = false;
}
```
##########
be/src/vec/data_types/get_least_supertype.cpp:
##########
@@ -50,12 +50,152 @@ String get_exception_message_prefix(const DataTypes&
types) {
}
} // namespace
-DataTypePtr get_least_supertype(const DataTypes& types) {
+Status get_numeric_type(const TypeIndexSet& types, DataTypePtr* type) {
+ bool all_numbers = true;
+
+ size_t max_bits_of_signed_integer = 0;
+ size_t max_bits_of_unsigned_integer = 0;
+ size_t max_mantissa_bits_of_floating = 0;
+
+ auto maximize = [](size_t& what, size_t value) {
+ if (value > what) what = value;
+ };
+
+ for (const auto& type : types) {
+ if (type == TypeIndex::UInt8)
+ maximize(max_bits_of_unsigned_integer, 8);
+ else if (type == TypeIndex::UInt16)
+ maximize(max_bits_of_unsigned_integer, 16);
+ else if (type == TypeIndex::UInt32)
Review Comment:
warning: statement should be inside braces
[readability-braces-around-statements]
```suggestion
else if (type == TypeIndex::UInt32) {
```
be/src/vec/data_types/get_least_supertype.cpp:70:
```diff
- else if (type == TypeIndex::UInt64)
+ } else if (type == TypeIndex::UInt64)
```
##########
be/src/vec/data_types/get_least_supertype.cpp:
##########
@@ -50,12 +50,152 @@
}
} // namespace
-DataTypePtr get_least_supertype(const DataTypes& types) {
+Status get_numeric_type(const TypeIndexSet& types, DataTypePtr* type) {
+ bool all_numbers = true;
+
+ size_t max_bits_of_signed_integer = 0;
+ size_t max_bits_of_unsigned_integer = 0;
+ size_t max_mantissa_bits_of_floating = 0;
+
+ auto maximize = [](size_t& what, size_t value) {
+ if (value > what) what = value;
+ };
+
+ for (const auto& type : types) {
+ if (type == TypeIndex::UInt8)
+ maximize(max_bits_of_unsigned_integer, 8);
+ else if (type == TypeIndex::UInt16)
+ maximize(max_bits_of_unsigned_integer, 16);
+ else if (type == TypeIndex::UInt32)
+ maximize(max_bits_of_unsigned_integer, 32);
+ else if (type == TypeIndex::UInt64)
+ maximize(max_bits_of_unsigned_integer, 64);
+ else if (type == TypeIndex::UInt128)
+ maximize(max_bits_of_unsigned_integer, 128);
+ else if (type == TypeIndex::Int8 || type == TypeIndex::Enum8)
+ maximize(max_bits_of_signed_integer, 8);
+ else if (type == TypeIndex::Int16 || type == TypeIndex::Enum16)
+ maximize(max_bits_of_signed_integer, 16);
+ else if (type == TypeIndex::Int32)
+ maximize(max_bits_of_signed_integer, 32);
+ else if (type == TypeIndex::Int64)
+ maximize(max_bits_of_signed_integer, 64);
+ else if (type == TypeIndex::Int128)
Review Comment:
warning: statement should be inside braces
[readability-braces-around-statements]
```suggestion
else if (type == TypeIndex::Int128) {
```
be/src/vec/data_types/get_least_supertype.cpp:84:
```diff
- else if (type == TypeIndex::Float32)
+ } else if (type == TypeIndex::Float32)
```
##########
be/src/vec/data_types/get_least_supertype.cpp:
##########
@@ -50,12 +50,152 @@
}
} // namespace
-DataTypePtr get_least_supertype(const DataTypes& types) {
+Status get_numeric_type(const TypeIndexSet& types, DataTypePtr* type) {
+ bool all_numbers = true;
+
+ size_t max_bits_of_signed_integer = 0;
+ size_t max_bits_of_unsigned_integer = 0;
+ size_t max_mantissa_bits_of_floating = 0;
+
+ auto maximize = [](size_t& what, size_t value) {
+ if (value > what) what = value;
+ };
+
+ for (const auto& type : types) {
+ if (type == TypeIndex::UInt8)
+ maximize(max_bits_of_unsigned_integer, 8);
+ else if (type == TypeIndex::UInt16)
+ maximize(max_bits_of_unsigned_integer, 16);
+ else if (type == TypeIndex::UInt32)
+ maximize(max_bits_of_unsigned_integer, 32);
+ else if (type == TypeIndex::UInt64)
+ maximize(max_bits_of_unsigned_integer, 64);
+ else if (type == TypeIndex::UInt128)
+ maximize(max_bits_of_unsigned_integer, 128);
+ else if (type == TypeIndex::Int8 || type == TypeIndex::Enum8)
Review Comment:
warning: statement should be inside braces
[readability-braces-around-statements]
```suggestion
else if (type == TypeIndex::Int8 || type == TypeIndex::Enum8) {
```
be/src/vec/data_types/get_least_supertype.cpp:76:
```diff
- else if (type == TypeIndex::Int16 || type == TypeIndex::Enum16)
+ } else if (type == TypeIndex::Int16 || type == TypeIndex::Enum16)
```
##########
be/src/vec/data_types/get_least_supertype.cpp:
##########
@@ -209,136 +350,95 @@
}
if (min_precision > DataTypeDecimal<Decimal128>::max_precision()) {
- LOG(FATAL) << fmt::format("{} because the least supertype is
Decimal({},{})",
- get_exception_message_prefix(types),
min_precision,
- max_scale);
+ LOG(INFO) << fmt::format("{} because the least supertype is
Decimal({},{})",
+ get_exception_message_prefix(types),
min_precision,
+ max_scale);
+ return Status::InvalidArgument(
+ fmt::format("{} because the least supertype is
Decimal({},{})",
+ get_exception_message_prefix(types),
min_precision, max_scale));
}
- if (have_decimal128 || min_precision >
DataTypeDecimal<Decimal64>::max_precision())
- return std::make_shared<DataTypeDecimal<Decimal128>>(
+ if (have_decimal128 || min_precision >
DataTypeDecimal<Decimal64>::max_precision()) {
+ *type = std::make_shared<DataTypeDecimal<Decimal128>>(
DataTypeDecimal<Decimal128>::max_precision(),
max_scale);
- if (have_decimal128i || min_precision >
DataTypeDecimal<Decimal64>::max_precision())
- return std::make_shared<DataTypeDecimal<Decimal128I>>(
+ return Status::OK();
+ }
+ if (have_decimal128i || min_precision >
DataTypeDecimal<Decimal64>::max_precision()) {
+ *type = std::make_shared<DataTypeDecimal<Decimal128I>>(
DataTypeDecimal<Decimal128I>::max_precision(),
max_scale);
- if (have_decimal64 || min_precision >
DataTypeDecimal<Decimal32>::max_precision())
- return std::make_shared<DataTypeDecimal<Decimal64>>(
+ return Status::OK();
+ }
+ if (have_decimal64 || min_precision >
DataTypeDecimal<Decimal32>::max_precision()) {
+ *type = std::make_shared<DataTypeDecimal<Decimal64>>(
DataTypeDecimal<Decimal64>::max_precision(),
max_scale);
- return std::make_shared<DataTypeDecimal<Decimal32>>(
+ return Status::OK();
+ }
+ *type = std::make_shared<DataTypeDecimal<Decimal32>>(
DataTypeDecimal<Decimal32>::max_precision(), max_scale);
+ return Status::OK();
}
}
/// For numeric types, the most complicated part.
{
- bool all_numbers = true;
-
- size_t max_bits_of_signed_integer = 0;
- size_t max_bits_of_unsigned_integer = 0;
- size_t max_mantissa_bits_of_floating = 0;
+ DataTypePtr numeric_type = nullptr;
+ Status st = get_numeric_type(type_ids, &numeric_type);
+ if (numeric_type) {
+ DCHECK(st.ok());
+ *type = numeric_type;
+ return Status::OK();
+ }
+ }
- auto maximize = [](size_t& what, size_t value) {
- if (value > what) what = value;
- };
+ /// All other data types (UUID, AggregateFunction, Enum...) are compatible
only if they are the same (checked in trivial cases).
+ *type = nullptr;
+ return Status::InvalidArgument(get_exception_message_prefix(types));
+}
- for (const auto& type : types) {
- if (typeid_cast<const DataTypeUInt8*>(type.get()))
- maximize(max_bits_of_unsigned_integer, 8);
- else if (typeid_cast<const DataTypeUInt16*>(type.get()))
- maximize(max_bits_of_unsigned_integer, 16);
- else if (typeid_cast<const DataTypeUInt32*>(type.get()))
- maximize(max_bits_of_unsigned_integer, 32);
- else if (typeid_cast<const DataTypeUInt64*>(type.get()))
- maximize(max_bits_of_unsigned_integer, 64);
- else if (typeid_cast<const DataTypeInt8*>(type.get()))
- maximize(max_bits_of_signed_integer, 8);
- else if (typeid_cast<const DataTypeInt16*>(type.get()))
- maximize(max_bits_of_signed_integer, 16);
- else if (typeid_cast<const DataTypeInt32*>(type.get()))
- maximize(max_bits_of_signed_integer, 32);
- else if (typeid_cast<const DataTypeInt64*>(type.get()))
- maximize(max_bits_of_signed_integer, 64);
- else if (typeid_cast<const DataTypeFloat32*>(type.get()))
- maximize(max_mantissa_bits_of_floating, 24);
- else if (typeid_cast<const DataTypeFloat64*>(type.get()))
- maximize(max_mantissa_bits_of_floating, 53);
- else
- all_numbers = false;
+Status get_least_supertype(const TypeIndexSet& types, DataTypePtr* type,
+ bool compatible_with_string) {
+ TypeIndexSet types_set;
+ for (const auto& t : types) {
+ if (WhichDataType(t).is_nothing()) continue;
Review Comment:
warning: statement should be inside braces
[readability-braces-around-statements]
```suggestion
if (WhichDataType(t).is_nothing()) { continue;
}
```
##########
be/src/vec/data_types/get_least_supertype.cpp:
##########
@@ -50,12 +50,152 @@
}
} // namespace
-DataTypePtr get_least_supertype(const DataTypes& types) {
+Status get_numeric_type(const TypeIndexSet& types, DataTypePtr* type) {
+ bool all_numbers = true;
+
+ size_t max_bits_of_signed_integer = 0;
+ size_t max_bits_of_unsigned_integer = 0;
+ size_t max_mantissa_bits_of_floating = 0;
+
+ auto maximize = [](size_t& what, size_t value) {
+ if (value > what) what = value;
+ };
+
+ for (const auto& type : types) {
+ if (type == TypeIndex::UInt8)
+ maximize(max_bits_of_unsigned_integer, 8);
+ else if (type == TypeIndex::UInt16)
+ maximize(max_bits_of_unsigned_integer, 16);
+ else if (type == TypeIndex::UInt32)
+ maximize(max_bits_of_unsigned_integer, 32);
+ else if (type == TypeIndex::UInt64)
+ maximize(max_bits_of_unsigned_integer, 64);
+ else if (type == TypeIndex::UInt128)
+ maximize(max_bits_of_unsigned_integer, 128);
+ else if (type == TypeIndex::Int8 || type == TypeIndex::Enum8)
+ maximize(max_bits_of_signed_integer, 8);
+ else if (type == TypeIndex::Int16 || type == TypeIndex::Enum16)
+ maximize(max_bits_of_signed_integer, 16);
+ else if (type == TypeIndex::Int32)
+ maximize(max_bits_of_signed_integer, 32);
+ else if (type == TypeIndex::Int64)
+ maximize(max_bits_of_signed_integer, 64);
+ else if (type == TypeIndex::Int128)
+ maximize(max_bits_of_signed_integer, 128);
+ else if (type == TypeIndex::Float32)
Review Comment:
warning: statement should be inside braces
[readability-braces-around-statements]
```suggestion
else if (type == TypeIndex::Float32) {
```
be/src/vec/data_types/get_least_supertype.cpp:86:
```diff
- else if (type == TypeIndex::Float64)
+ } else if (type == TypeIndex::Float64)
```
##########
be/src/vec/exec/scan/vfile_scanner.cpp:
##########
@@ -454,6 +510,32 @@ Status VFileScanner::_convert_to_output_block(Block*
block) {
slot_desc->col_name()));
}
+ // handle dynamic generated columns
+ if (_full_base_schema_view && !_full_base_schema_view->empty()) {
+ CHECK(_is_dynamic_schema);
+ for (size_t i = block->columns(); i < _src_block.columns(); ++i) {
+ auto& column_type_name = _src_block.get_by_position(i);
+ // Column from schema change response
+ const TColumn& tcolumn =
+
_full_base_schema_view->column_name_to_column[column_type_name.name];
+ auto original_type =
vectorized::DataTypeFactory::instance().create_data_type(tcolumn);
+ // Detect type conflict, there may exist another load procedure,
whitch has already added some columns
+ // but, this load detects different type, we go type conflict free
path, always cast to original type
+ // TODO need to add type conflict abort feature
+ if (!column_type_name.type->equals(*original_type)) {
+ vectorized::ColumnPtr column_ptr;
+
RETURN_IF_ERROR(vectorized::schema_util::cast_column(column_type_name,
+
original_type, &column_ptr));
+ column_type_name.column = column_ptr;
+ column_type_name.type = original_type;
+ }
+ DCHECK(column_type_name.column != nullptr);
+
block->insert(vectorized::ColumnWithTypeAndName(std::move(column_type_name.column),
Review Comment:
warning: passing result of std::move() as a const reference argument; no
move will actually happen [performance-move-const-arg]
```suggestion
block->insert(vectorized::ColumnWithTypeAndName(column_type_name.column,
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscr...@doris.apache.org
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscr...@doris.apache.org
For additional commands, e-mail: commits-h...@doris.apache.org
