This is an automated email from the ASF dual-hosted git repository.
yiguolei pushed a commit to branch branch-4.1
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/branch-4.1 by this push:
new 3bfc2b1c091 [refine](type)use new type dispatch (#56990) (#66762)
3bfc2b1c091 is described below
commit 3bfc2b1c0912715789bc2c6e5692dc9316617aa5
Author: Mryange <[email protected]>
AuthorDate: Sun Aug 16 07:52:35 2026 +0800
[refine](type)use new type dispatch (#56990) (#66762)
before
```
case TYPE_DATE:
case TYPE_DATETIME:
case TYPE_DATEV2:
case TYPE_DATETIMEV2:
case TYPE_BOOLEAN:
case TYPE_TINYINT:
```
now
```
dispatch_switch_scalar(left_element_type->get_primitive_type(), call));
```
(cherry picked from commit af9fb9d82e4c63cbaaa5cba6a6b5315fad02c568)
### What problem does this PR solve?
Issue Number: close #xxx
Related PR: #xxx
Problem Summary:
### Release note
None
### Check List (For Author)
- Test <!-- At least one of them must be included. -->
- [ ] Regression test
- [ ] Unit Test
- [ ] Manual test (add detailed scripts or steps below)
- [ ] No need to test or manual test. Explain why:
- [ ] This is a refactor/code format and no logic has been changed.
- [ ] Previous test can cover this change.
- [ ] No code files have been changed.
- [ ] Other reason <!-- Add your reason? -->
- Behavior changed:
- [ ] No.
- [ ] Yes. <!-- Explain the behavior change -->
- Does this need documentation?
- [ ] No.
- [ ] Yes. <!-- Add document PR link here. eg:
https://github.com/apache/doris-website/pull/1214 -->
### Check List (For Reviewer who merge this PR)
- [ ] Confirm the release note
- [ ] Confirm test cases
- [ ] Confirm document
- [ ] Add branch pick label <!-- Add branch pick label that this PR
should merge into -->
---
.../function/array/function_array_contains_all.cpp | 130 ++-----------
.../exprs/function/array/function_array_distinct.h | 75 +-------
.../exprs/function/array/function_array_element.h | 103 +----------
.../array/function_array_enumerate_uniq.cpp | 77 ++------
.../exprs/function/array/function_array_remove.h | 75 +-------
.../exprs/function/array/function_arrays_overlap.h | 120 ++----------
be/src/exprs/function/function_map.cpp | 1 -
be/src/exprs/function/functions_comparison.h | 19 +-
be/src/exprs/function/if.cpp | 18 +-
be/src/exprs/function/least_greast.cpp | 204 ++-------------------
10 files changed, 106 insertions(+), 716 deletions(-)
diff --git a/be/src/exprs/function/array/function_array_contains_all.cpp
b/be/src/exprs/function/array/function_array_contains_all.cpp
index 8063aa1cab5..cd675d1296c 100644
--- a/be/src/exprs/function/array/function_array_contains_all.cpp
+++ b/be/src/exprs/function/array/function_array_contains_all.cpp
@@ -68,7 +68,6 @@ public:
unpack_if_const(block.get_by_position(arguments[1]).column);
ColumnArrayExecutionData left_exec_data;
ColumnArrayExecutionData right_exec_data;
- Status ret = Status::OK();
// extract array column
if (!extract_column_array_info(*left_column, left_exec_data) ||
@@ -87,120 +86,29 @@ public:
auto array_type =
remove_nullable(block.get_by_position(arguments[0]).type);
auto left_element_type = remove_nullable(
assert_cast<const
DataTypeArray*>(array_type.get())->get_nested_type());
- switch (left_element_type->get_primitive_type()) {
- case TYPE_STRING:
- case TYPE_CHAR:
- case TYPE_VARCHAR:
- ret = _execute_internal<ColumnString>(left_exec_data,
right_exec_data,
- dst_null_map_data,
-
dst_nested_col->get_data().data(),
- input_rows_count,
left_is_const, right_is_const);
- break;
- case TYPE_DATE:
- ret = _execute_internal<ColumnDate>(left_exec_data,
right_exec_data, dst_null_map_data,
-
dst_nested_col->get_data().data(), input_rows_count,
- left_is_const, right_is_const);
- break;
- case TYPE_DATETIME:
- ret = _execute_internal<ColumnDateTime>(
- left_exec_data, right_exec_data, dst_null_map_data,
- dst_nested_col->get_data().data(), input_rows_count,
left_is_const,
- right_is_const);
- break;
- case TYPE_DATEV2:
- ret = _execute_internal<ColumnDateV2>(left_exec_data,
right_exec_data,
- dst_null_map_data,
-
dst_nested_col->get_data().data(),
- input_rows_count,
left_is_const, right_is_const);
- break;
- case TYPE_DATETIMEV2:
- ret = _execute_internal<ColumnDateTimeV2>(
- left_exec_data, right_exec_data, dst_null_map_data,
- dst_nested_col->get_data().data(), input_rows_count,
left_is_const,
- right_is_const);
- break;
- case TYPE_BOOLEAN:
- ret = _execute_internal<ColumnUInt8>(left_exec_data,
right_exec_data, dst_null_map_data,
-
dst_nested_col->get_data().data(),
- input_rows_count,
left_is_const, right_is_const);
- break;
- case TYPE_TINYINT:
- ret = _execute_internal<ColumnInt8>(left_exec_data,
right_exec_data, dst_null_map_data,
-
dst_nested_col->get_data().data(), input_rows_count,
- left_is_const, right_is_const);
- break;
- case TYPE_SMALLINT:
- ret = _execute_internal<ColumnInt16>(left_exec_data,
right_exec_data, dst_null_map_data,
-
dst_nested_col->get_data().data(),
- input_rows_count,
left_is_const, right_is_const);
- break;
- case TYPE_INT:
- ret = _execute_internal<ColumnInt32>(left_exec_data,
right_exec_data, dst_null_map_data,
-
dst_nested_col->get_data().data(),
- input_rows_count,
left_is_const, right_is_const);
- break;
- case TYPE_BIGINT:
- ret = _execute_internal<ColumnInt64>(left_exec_data,
right_exec_data, dst_null_map_data,
-
dst_nested_col->get_data().data(),
- input_rows_count,
left_is_const, right_is_const);
- break;
- case TYPE_LARGEINT:
- ret = _execute_internal<ColumnInt128>(left_exec_data,
right_exec_data,
- dst_null_map_data,
-
dst_nested_col->get_data().data(),
- input_rows_count,
left_is_const, right_is_const);
- break;
- case TYPE_FLOAT:
- ret = _execute_internal<ColumnFloat32>(left_exec_data,
right_exec_data,
- dst_null_map_data,
-
dst_nested_col->get_data().data(),
- input_rows_count,
left_is_const, right_is_const);
- break;
- case TYPE_DOUBLE:
- ret = _execute_internal<ColumnFloat64>(left_exec_data,
right_exec_data,
- dst_null_map_data,
-
dst_nested_col->get_data().data(),
- input_rows_count,
left_is_const, right_is_const);
- break;
- case TYPE_DECIMAL32:
- ret = _execute_internal<ColumnDecimal32>(
- left_exec_data, right_exec_data, dst_null_map_data,
- dst_nested_col->get_data().data(), input_rows_count,
left_is_const,
- right_is_const);
- break;
- case TYPE_DECIMAL64:
- ret = _execute_internal<ColumnDecimal64>(
- left_exec_data, right_exec_data, dst_null_map_data,
- dst_nested_col->get_data().data(), input_rows_count,
left_is_const,
- right_is_const);
- break;
- case TYPE_DECIMAL128I:
- ret = _execute_internal<ColumnDecimal128V3>(
- left_exec_data, right_exec_data, dst_null_map_data,
- dst_nested_col->get_data().data(), input_rows_count,
left_is_const,
- right_is_const);
- break;
- case TYPE_DECIMALV2:
- ret = _execute_internal<ColumnDecimal128V2>(
- left_exec_data, right_exec_data, dst_null_map_data,
- dst_nested_col->get_data().data(), input_rows_count,
left_is_const,
- right_is_const);
- break;
- case TYPE_DECIMAL256:
- ret = _execute_internal<ColumnDecimal256>(
+
+ Status status = Status::OK();
+ auto call = [&](const auto& type) -> bool {
+ using DataType = std::decay_t<decltype(type)>;
+ status = _execute_internal<typename DataType::ColumnType>(
left_exec_data, right_exec_data, dst_null_map_data,
dst_nested_col->get_data().data(), input_rows_count,
left_is_const,
right_is_const);
- break;
- default:
- ret = Status::RuntimeError(
- fmt::format("execute failed about function {}, the
argument not support {} ",
- get_name(),
block.get_by_position(arguments[0]).type->get_name()));
- }
- if (ret.ok()) {
- block.replace_by_position(result, std::move(dst_nested_col));
+ return true;
+ };
+
+ if (!dispatch_switch_all(left_element_type->get_primitive_type(),
call)) {
+ return Status::InternalError(
+ "execute failed, unsupported types for function {}({},
{})", get_name(),
+ block.get_by_position(arguments[0]).type->get_name(),
+ block.get_by_position(arguments[1]).type->get_name());
}
- return ret;
+
+ RETURN_IF_ERROR(status);
+
+ block.replace_by_position(result, std::move(dst_nested_col));
+
+ return Status::OK();
}
private:
diff --git a/be/src/exprs/function/array/function_array_distinct.h
b/be/src/exprs/function/array/function_array_distinct.h
index 8961b638827..edd0d82a45b 100644
--- a/be/src/exprs/function/array/function_array_distinct.h
+++ b/be/src/exprs/function/array/function_array_distinct.h
@@ -255,75 +255,18 @@ private:
IColumn& dest_column, ColumnArray::Offsets64&
dest_offsets,
const NullMapType* src_null_map, NullMapType*
dest_null_map,
DataTypePtr& nested_type) const {
- switch (nested_type->get_primitive_type()) {
- case TYPE_BOOLEAN:
- return _execute_number<ColumnUInt8>(src_column, src_offsets,
dest_column, dest_offsets,
- src_null_map, dest_null_map);
- case TYPE_TINYINT:
- return _execute_number<ColumnInt8>(src_column, src_offsets,
dest_column, dest_offsets,
- src_null_map, dest_null_map);
- case TYPE_SMALLINT:
- return _execute_number<ColumnInt16>(src_column, src_offsets,
dest_column, dest_offsets,
- src_null_map, dest_null_map);
- case TYPE_INT:
- return _execute_number<ColumnInt32>(src_column, src_offsets,
dest_column, dest_offsets,
- src_null_map, dest_null_map);
- case TYPE_BIGINT:
- return _execute_number<ColumnInt64>(src_column, src_offsets,
dest_column, dest_offsets,
- src_null_map, dest_null_map);
- case TYPE_LARGEINT:
- return _execute_number<ColumnInt128>(src_column, src_offsets,
dest_column, dest_offsets,
- src_null_map, dest_null_map);
- case TYPE_FLOAT:
- return _execute_number<ColumnFloat32>(src_column, src_offsets,
dest_column,
- dest_offsets, src_null_map,
dest_null_map);
- case TYPE_DOUBLE:
- return _execute_number<ColumnFloat64>(src_column, src_offsets,
dest_column,
- dest_offsets, src_null_map,
dest_null_map);
- case TYPE_DATE:
- return _execute_number<ColumnDate>(src_column, src_offsets,
dest_column, dest_offsets,
- src_null_map, dest_null_map);
- case TYPE_DATETIME:
- return _execute_number<ColumnDateTime>(src_column, src_offsets,
dest_column,
- dest_offsets, src_null_map,
dest_null_map);
- case TYPE_DATEV2:
- return _execute_number<ColumnDateV2>(src_column, src_offsets,
dest_column, dest_offsets,
- src_null_map, dest_null_map);
- case TYPE_DATETIMEV2:
- return _execute_number<ColumnDateTimeV2>(src_column, src_offsets,
dest_column,
- dest_offsets,
src_null_map, dest_null_map);
- case TYPE_DECIMAL32:
- return _execute_number<ColumnDecimal32>(src_column, src_offsets,
dest_column,
- dest_offsets,
src_null_map, dest_null_map);
- case TYPE_DECIMAL64:
- return _execute_number<ColumnDecimal64>(src_column, src_offsets,
dest_column,
- dest_offsets,
src_null_map, dest_null_map);
- case TYPE_DECIMAL128I:
- return _execute_number<ColumnDecimal128V3>(src_column,
src_offsets, dest_column,
- dest_offsets,
src_null_map, dest_null_map);
- case TYPE_DECIMALV2:
- return _execute_number<ColumnDecimal128V2>(src_column,
src_offsets, dest_column,
- dest_offsets,
src_null_map, dest_null_map);
- case TYPE_DECIMAL256:
- return _execute_number<ColumnDecimal256>(src_column, src_offsets,
dest_column,
- dest_offsets,
src_null_map, dest_null_map);
- case TYPE_STRING:
- case TYPE_CHAR:
- case TYPE_VARCHAR:
+ if (is_string_type(nested_type->get_primitive_type())) {
return _execute_string(src_column, src_offsets, dest_column,
dest_offsets, src_null_map,
dest_null_map);
- case TYPE_IPV4:
- return _execute_number<ColumnIPv4>(src_column, src_offsets,
dest_column, dest_offsets,
- src_null_map, dest_null_map);
- case TYPE_IPV6:
- return _execute_number<ColumnIPv6>(src_column, src_offsets,
dest_column, dest_offsets,
- src_null_map, dest_null_map);
- default:
- LOG(ERROR) << "Unsupported array's element type: "
- << remove_nullable(nested_type)->get_name() << " for
function "
- << this->get_name();
- return false;
}
+ auto call = [&](const auto& type) -> bool {
+ using DispatchType = std::decay_t<decltype(type)>;
+ return _execute_number<typename
DispatchType::ColumnType>(src_column, src_offsets,
+
dest_column, dest_offsets,
+
src_null_map, dest_null_map);
+ };
+
+ return dispatch_switch_scalar(nested_type->get_primitive_type(), call);
}
};
diff --git a/be/src/exprs/function/array/function_array_element.h
b/be/src/exprs/function/array/function_array_element.h
index c55c7182c13..9d10034bb28 100644
--- a/be/src/exprs/function/array/function_array_element.h
+++ b/be/src/exprs/function/array/function_array_element.h
@@ -472,104 +472,21 @@ private:
// we should handle array index column by-self, and array index should
not be nullable.
auto idx_col = remove_nullable(arguments[1].column);
// we should dispatch branch according to data type rather than column
type
- switch (left_element_type->get_primitive_type()) {
- case TYPE_DATE: {
- res = _execute_number<ColumnDate>(offsets, *nested_column,
src_null_map, *idx_col,
- nested_null_map, dst_null_map);
- break;
- }
- case TYPE_DATETIME: {
- res = _execute_number<ColumnDateTime>(offsets, *nested_column,
src_null_map, *idx_col,
- nested_null_map,
dst_null_map);
- break;
- }
- case TYPE_DATEV2: {
- res = _execute_number<ColumnDateV2>(offsets, *nested_column,
src_null_map, *idx_col,
- nested_null_map, dst_null_map);
- break;
- }
- case TYPE_DATETIMEV2: {
- res = _execute_number<ColumnDateTimeV2>(offsets, *nested_column,
src_null_map, *idx_col,
- nested_null_map,
dst_null_map);
- break;
- }
- case TYPE_BOOLEAN: {
- res = _execute_number<ColumnUInt8>(offsets, *nested_column,
src_null_map, *idx_col,
- nested_null_map, dst_null_map);
- break;
- }
- case TYPE_TINYINT: {
- res = _execute_number<ColumnInt8>(offsets, *nested_column,
src_null_map, *idx_col,
- nested_null_map, dst_null_map);
- break;
- }
- case TYPE_SMALLINT: {
- res = _execute_number<ColumnInt16>(offsets, *nested_column,
src_null_map, *idx_col,
- nested_null_map, dst_null_map);
- break;
- }
- case TYPE_INT: {
- res = _execute_number<ColumnInt32>(offsets, *nested_column,
src_null_map, *idx_col,
- nested_null_map, dst_null_map);
- break;
- }
- case TYPE_BIGINT: {
- res = _execute_number<ColumnInt64>(offsets, *nested_column,
src_null_map, *idx_col,
- nested_null_map, dst_null_map);
- break;
- }
- case TYPE_LARGEINT: {
- res = _execute_number<ColumnInt128>(offsets, *nested_column,
src_null_map, *idx_col,
- nested_null_map, dst_null_map);
- break;
- }
- case TYPE_FLOAT: {
- res = _execute_number<ColumnFloat32>(offsets, *nested_column,
src_null_map, *idx_col,
- nested_null_map,
dst_null_map);
- break;
- }
- case TYPE_DOUBLE: {
- res = _execute_number<ColumnFloat64>(offsets, *nested_column,
src_null_map, *idx_col,
- nested_null_map,
dst_null_map);
- break;
- }
- case TYPE_DECIMAL32: {
- res = _execute_number<ColumnDecimal32>(offsets, *nested_column,
src_null_map, *idx_col,
- nested_null_map,
dst_null_map);
- break;
- }
- case TYPE_DECIMAL64: {
- res = _execute_number<ColumnDecimal64>(offsets, *nested_column,
src_null_map, *idx_col,
- nested_null_map,
dst_null_map);
- break;
- }
- case TYPE_DECIMAL256: {
- res = _execute_number<ColumnDecimal256>(offsets, *nested_column,
src_null_map, *idx_col,
- nested_null_map,
dst_null_map);
- break;
- }
- case TYPE_DECIMALV2: {
- res = _execute_number<ColumnDecimal128V2>(offsets, *nested_column,
src_null_map,
- *idx_col,
nested_null_map, dst_null_map);
- break;
- }
- case TYPE_DECIMAL128I: {
- res = _execute_number<ColumnDecimal128V3>(offsets, *nested_column,
src_null_map,
- *idx_col,
nested_null_map, dst_null_map);
- break;
- }
- case TYPE_CHAR:
- case TYPE_VARCHAR:
- case TYPE_STRING: {
+
+ auto call = [&](const auto& type) -> bool {
+ using DispatchType = std::decay_t<decltype(type)>;
+ res = _execute_number<typename DispatchType::ColumnType>(
+ offsets, *nested_column, src_null_map, *idx_col,
nested_null_map, dst_null_map);
+ return true;
+ };
+
+ if (is_string_type(left_element_type->get_primitive_type())) {
res = _execute_string(offsets, *nested_column, src_null_map,
*idx_col, nested_null_map,
dst_null_map);
- break;
- }
- default: {
+ } else if
(!dispatch_switch_scalar(left_element_type->get_primitive_type(), call)) {
res = _execute_common(offsets, *nested_column, src_null_map,
*idx_col, nested_null_map,
dst_null_map);
}
- }
return res;
}
};
diff --git a/be/src/exprs/function/array/function_array_enumerate_uniq.cpp
b/be/src/exprs/function/array/function_array_enumerate_uniq.cpp
index 3463868bbd8..71beccd28f5 100644
--- a/be/src/exprs/function/array/function_array_enumerate_uniq.cpp
+++ b/be/src/exprs/function/array/function_array_enumerate_uniq.cpp
@@ -168,71 +168,20 @@ public:
}
auto nested_type =
assert_cast<const
DataTypeArray&>(*src_column_type).get_nested_type();
- switch (nested_type->get_primitive_type()) {
- case TYPE_BOOLEAN:
- _execute_number<ColumnUInt8>(data_columns, *offsets, null_map,
dst_values);
- break;
- case TYPE_TINYINT:
- _execute_number<ColumnInt8>(data_columns, *offsets, null_map,
dst_values);
- break;
- case TYPE_SMALLINT:
- _execute_number<ColumnInt16>(data_columns, *offsets, null_map,
dst_values);
- break;
- case TYPE_INT:
- _execute_number<ColumnInt32>(data_columns, *offsets, null_map,
dst_values);
- break;
- case TYPE_BIGINT:
- _execute_number<ColumnInt64>(data_columns, *offsets, null_map,
dst_values);
- break;
- case TYPE_LARGEINT:
- _execute_number<ColumnInt128>(data_columns, *offsets,
null_map, dst_values);
- break;
- case TYPE_FLOAT:
- _execute_number<ColumnFloat32>(data_columns, *offsets,
null_map, dst_values);
- break;
- case TYPE_DOUBLE:
- _execute_number<ColumnFloat64>(data_columns, *offsets,
null_map, dst_values);
- break;
- case TYPE_DATE:
- _execute_number<ColumnDate>(data_columns, *offsets, null_map,
dst_values);
- break;
- case TYPE_DATEV2:
- _execute_number<ColumnDateV2>(data_columns, *offsets,
null_map, dst_values);
- break;
- case TYPE_DATETIME:
- _execute_number<ColumnDateTime>(data_columns, *offsets,
null_map, dst_values);
- break;
- case TYPE_DATETIMEV2:
- _execute_number<ColumnDateTimeV2>(data_columns, *offsets,
null_map, dst_values);
- break;
- case TYPE_DECIMAL32:
- _execute_number<ColumnDecimal32>(data_columns, *offsets,
null_map, dst_values);
- break;
- case TYPE_DECIMAL64:
- _execute_number<ColumnDecimal64>(data_columns, *offsets,
null_map, dst_values);
- break;
- case TYPE_DECIMAL128I:
- _execute_number<ColumnDecimal128V3>(data_columns, *offsets,
null_map, dst_values);
- break;
- case TYPE_DECIMALV2:
- _execute_number<ColumnDecimal128V2>(data_columns, *offsets,
null_map, dst_values);
- break;
- case TYPE_DECIMAL256:
- _execute_number<ColumnDecimal256>(data_columns, *offsets,
null_map, dst_values);
- break;
- case TYPE_IPV4:
- _execute_number<ColumnIPv4>(data_columns, *offsets, null_map,
dst_values);
- break;
- case TYPE_IPV6:
- _execute_number<ColumnIPv6>(data_columns, *offsets, null_map,
dst_values);
- break;
- case TYPE_CHAR:
- case TYPE_VARCHAR:
- case TYPE_STRING:
+
+ auto call = [&](const auto& type) -> bool {
+ using DispatchType = std::decay_t<decltype(type)>;
+ _execute_number<typename
DispatchType::ColumnType>(data_columns, *offsets, null_map,
+ dst_values);
+ return true;
+ };
+
+ if (is_string_type(nested_type->get_primitive_type())) {
_execute_string(data_columns, *offsets, null_map, dst_values);
- break;
- default:
- break;
+ } else if
(!dispatch_switch_scalar(nested_type->get_primitive_type(), call)) {
+ return Status::RuntimeError(fmt::format(
+ "execute failed or unsupported types for function
{}({})", get_name(),
+ block.get_by_position(arguments[0]).type->get_name()));
}
} else {
_execute_by_hash<MethodSerialized<PHHashMap<StringRef, Int64>>,
false>(
diff --git a/be/src/exprs/function/array/function_array_remove.h
b/be/src/exprs/function/array/function_array_remove.h
index 6f63af62058..09a43e7651c 100644
--- a/be/src/exprs/function/array/function_array_remove.h
+++ b/be/src/exprs/function/array/function_array_remove.h
@@ -375,74 +375,17 @@ private:
right_nested_null_map, array_null_map);
} else if (is_number(right_type->get_primitive_type()) &&
is_number(left_element_type->get_primitive_type())) {
- switch (left_element_type->get_primitive_type()) {
- case TYPE_BOOLEAN:
- res = _execute_number_expanded<ColumnUInt8>(offsets,
*nested_column, *right_column,
- nested_null_map,
right_nested_null_map,
- array_null_map);
- break;
- case TYPE_TINYINT:
- res = _execute_number_expanded<ColumnInt8>(offsets,
*nested_column, *right_column,
- nested_null_map,
right_nested_null_map,
- array_null_map);
- break;
- case TYPE_SMALLINT:
- res = _execute_number_expanded<ColumnInt16>(offsets,
*nested_column, *right_column,
- nested_null_map,
right_nested_null_map,
- array_null_map);
- break;
- case TYPE_INT:
- res = _execute_number_expanded<ColumnInt32>(offsets,
*nested_column, *right_column,
- nested_null_map,
right_nested_null_map,
- array_null_map);
- break;
- case TYPE_BIGINT:
- res = _execute_number_expanded<ColumnInt64>(offsets,
*nested_column, *right_column,
- nested_null_map,
right_nested_null_map,
- array_null_map);
- break;
- case TYPE_LARGEINT:
- res = _execute_number_expanded<ColumnInt128>(offsets,
*nested_column, *right_column,
- nested_null_map,
right_nested_null_map,
- array_null_map);
- break;
- case TYPE_FLOAT:
- res = _execute_number_expanded<ColumnFloat32>(
+ auto call = [&](const auto& type) -> bool {
+ using DispatchType = std::decay_t<decltype(type)>;
+ res = _execute_number_expanded<typename
DispatchType::ColumnType>(
offsets, *nested_column, *right_column,
nested_null_map,
right_nested_null_map, array_null_map);
- break;
- case TYPE_DOUBLE:
- res = _execute_number_expanded<ColumnFloat64>(
- offsets, *nested_column, *right_column,
nested_null_map,
- right_nested_null_map, array_null_map);
- break;
- case TYPE_DECIMAL32:
- res = _execute_number_expanded<ColumnDecimal32>(
- offsets, *nested_column, *right_column,
nested_null_map,
- right_nested_null_map, array_null_map);
- break;
- case TYPE_DECIMAL64:
- res = _execute_number_expanded<ColumnDecimal64>(
- offsets, *nested_column, *right_column,
nested_null_map,
- right_nested_null_map, array_null_map);
- break;
- case TYPE_DECIMAL128I:
- res = _execute_number_expanded<ColumnDecimal128V3>(
- offsets, *nested_column, *right_column,
nested_null_map,
- right_nested_null_map, array_null_map);
- break;
- case TYPE_DECIMALV2:
- res = _execute_number_expanded<ColumnDecimal128V2>(
- offsets, *nested_column, *right_column,
nested_null_map,
- right_nested_null_map, array_null_map);
- break;
- case TYPE_DECIMAL256:
- res = _execute_number_expanded<ColumnDecimal256>(
- offsets, *nested_column, *right_column,
nested_null_map,
- right_nested_null_map, array_null_map);
- break;
- default:
- break;
+ return true;
+ };
+
+ if
(!dispatch_switch_number(left_element_type->get_primitive_type(), call)) {
+ throw doris::Exception(doris::ErrorCode::INTERNAL_ERROR,
+ "not support left type " +
left_element_type->get_name());
}
} else if (is_date_v2_or_datetime_v2(right_type->get_primitive_type())
&&
is_date_v2_or_datetime_v2(left_element_type->get_primitive_type())) {
diff --git a/be/src/exprs/function/array/function_arrays_overlap.h
b/be/src/exprs/function/array/function_arrays_overlap.h
index b1eb8e22047..d71643945ca 100644
--- a/be/src/exprs/function/array/function_arrays_overlap.h
+++ b/be/src/exprs/function/array/function_arrays_overlap.h
@@ -308,112 +308,26 @@ public:
auto array_type =
remove_nullable(block.get_by_position(arguments[0]).type);
auto left_element_type = remove_nullable(
assert_cast<const
DataTypeArray*>(array_type.get())->get_nested_type());
- switch (left_element_type->get_primitive_type()) {
- case TYPE_STRING:
- case TYPE_CHAR:
- case TYPE_VARCHAR:
- ret = _execute_internal<ColumnString>(left_exec_data,
right_exec_data,
- dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
- case TYPE_DATE:
- ret = _execute_internal<ColumnDate>(left_exec_data,
right_exec_data, dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
- case TYPE_DATETIME:
- ret = _execute_internal<ColumnDateTime>(left_exec_data,
right_exec_data,
- dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
- case TYPE_DATEV2:
- ret = _execute_internal<ColumnDateV2>(left_exec_data,
right_exec_data,
- dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
- case TYPE_DATETIMEV2:
- ret = _execute_internal<ColumnDateTimeV2>(left_exec_data,
right_exec_data,
- dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
- case TYPE_BOOLEAN:
- ret = _execute_internal<ColumnUInt8>(left_exec_data,
right_exec_data, dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
- case TYPE_TINYINT:
- ret = _execute_internal<ColumnInt8>(left_exec_data,
right_exec_data, dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
- case TYPE_SMALLINT:
- ret = _execute_internal<ColumnInt16>(left_exec_data,
right_exec_data, dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
- case TYPE_INT:
- ret = _execute_internal<ColumnInt32>(left_exec_data,
right_exec_data, dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
- case TYPE_BIGINT:
- ret = _execute_internal<ColumnInt64>(left_exec_data,
right_exec_data, dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
- case TYPE_LARGEINT:
- ret = _execute_internal<ColumnInt128>(left_exec_data,
right_exec_data,
- dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
- case TYPE_FLOAT:
- ret = _execute_internal<ColumnFloat32>(left_exec_data,
right_exec_data,
- dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
- case TYPE_DOUBLE:
- ret = _execute_internal<ColumnFloat64>(left_exec_data,
right_exec_data,
- dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
- case TYPE_DECIMAL32:
- ret = _execute_internal<ColumnDecimal32>(left_exec_data,
right_exec_data,
- dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
- case TYPE_DECIMAL64:
- ret = _execute_internal<ColumnDecimal64>(left_exec_data,
right_exec_data,
- dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
- case TYPE_DECIMAL128I:
- ret = _execute_internal<ColumnDecimal128V3>(left_exec_data,
right_exec_data,
- dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
- case TYPE_DECIMALV2:
- ret = _execute_internal<ColumnDecimal128V2>(left_exec_data,
right_exec_data,
- dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
- case TYPE_DECIMAL256:
- ret = _execute_internal<ColumnDecimal256>(left_exec_data,
right_exec_data,
- dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
-
- case TYPE_IPV4:
- ret = _execute_internal<ColumnIPv4>(left_exec_data,
right_exec_data, dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
- case TYPE_IPV6:
- ret = _execute_internal<ColumnIPv6>(left_exec_data,
right_exec_data, dst_null_map_data,
-
dst_nested_col->get_data().data());
- break;
- default:
- break;
- }
- if (ret.ok()) {
- block.replace_by_position(result,
ColumnNullable::create(std::move(dst_nested_col),
-
std::move(dst_null_map)));
+ auto call = [&](const auto& type) -> bool {
+ using DispatchType = std::decay_t<decltype(type)>;
+ ret = _execute_internal<typename DispatchType::ColumnType>(
+ left_exec_data, right_exec_data, dst_null_map_data,
+ dst_nested_col->get_data().data());
+ return true;
+ };
+
+ if (!dispatch_switch_all(left_element_type->get_primitive_type(),
call)) {
+ ret = Status::InvalidArgument("execute failed, not support type {}
in function {}",
+ left_element_type->get_name(),
get_name());
}
- return ret;
+ RETURN_IF_ERROR(ret);
+
+ block.replace_by_position(
+ result, ColumnNullable::create(std::move(dst_nested_col),
std::move(dst_null_map)));
+
+ return Status::OK();
}
private:
diff --git a/be/src/exprs/function/function_map.cpp
b/be/src/exprs/function/function_map.cpp
index 54d01931b10..242a2d62c6b 100644
--- a/be/src/exprs/function/function_map.cpp
+++ b/be/src/exprs/function/function_map.cpp
@@ -55,7 +55,6 @@
#include "exprs/function/function.h"
#include "exprs/function/simple_function_factory.h"
#include "util/simd/vstring_function.h"
-
namespace doris {
class FunctionContext;
} // namespace doris
diff --git a/be/src/exprs/function/functions_comparison.h
b/be/src/exprs/function/functions_comparison.h
index 0e5b6678ed7..96ff5f10664 100644
--- a/be/src/exprs/function/functions_comparison.h
+++ b/be/src/exprs/function/functions_comparison.h
@@ -528,19 +528,20 @@ private:
Status execute_decimal(Block& block, uint32_t result, const
ColumnWithTypeAndName& col_left,
const ColumnWithTypeAndName& col_right) const {
- auto call = [&](const auto& types) -> bool {
- using Types = std::decay_t<decltype(types)>;
- using LeftDataType = typename Types::LeftType;
- using RightDataType = typename Types::RightType;
-
- DecimalComparison<LeftDataType::PType, RightDataType::PType, Op,
false>(
+ auto call = [&](const auto& type) -> bool {
+ using DispatchType = std::decay_t<decltype(type)>;
+ DecimalComparison<DispatchType::PType, DispatchType::PType, Op,
false>(
block, result, col_left, col_right);
return true;
};
- if (!call_on_basic_types<true, false, true,
false>(col_left.type->get_primitive_type(),
-
col_right.type->get_primitive_type(),
- call)) {
+ if (col_left.type->get_primitive_type() !=
col_right.type->get_primitive_type()) {
+ return Status::RuntimeError(
+ "type of left column {} is not equal to type of right
column {}",
+ col_left.type->get_name(), col_right.type->get_name());
+ }
+
+ if (!dispatch_switch_decimal(col_right.type->get_primitive_type(),
call)) {
return Status::RuntimeError("Wrong call for {} with {} and {}",
get_name(),
col_left.type->get_name(),
col_right.type->get_name());
}
diff --git a/be/src/exprs/function/if.cpp b/be/src/exprs/function/if.cpp
index aaa37057968..7e543499ada 100644
--- a/be/src/exprs/function/if.cpp
+++ b/be/src/exprs/function/if.cpp
@@ -529,23 +529,15 @@ public:
}
Status vec_exec;
- auto can_use_vec_exec = cast_type_to_either<
- // int
- DataTypeInt8, DataTypeInt16, DataTypeInt32, DataTypeInt64,
DataTypeInt128,
- DataTypeBool,
- // flaot
- DataTypeFloat32, DataTypeFloat64,
- // date time
- DataTypeDateTimeV2, DataTypeDateV2, DataTypeTimeV2,
- // decimal
- DataTypeDecimal32, DataTypeDecimal64, DataTypeDecimal128,
DataTypeDecimal256,
- // ip
- DataTypeIPv4, DataTypeIPv6>(arg_then.type.get(), [&](const
auto& type) -> bool {
+
+ auto call = [&](const auto& type) -> bool {
using DataType = std::decay_t<decltype(type)>;
vec_exec = execute_basic_type<DataType::PType>(block, cond_col,
arg_then, arg_else,
result, vec_exec);
return true;
- });
+ };
+
+ auto can_use_vec_exec =
dispatch_switch_scalar(arg_then.type->get_primitive_type(), call);
if (can_use_vec_exec) {
return vec_exec;
} else {
diff --git a/be/src/exprs/function/least_greast.cpp
b/be/src/exprs/function/least_greast.cpp
index ec6f561db41..13558035636 100644
--- a/be/src/exprs/function/least_greast.cpp
+++ b/be/src/exprs/function/least_greast.cpp
@@ -97,201 +97,25 @@ struct CompareMultiImpl {
} else {
result_column->insert_range_from(*(cols[0]), 0,
input_rows_count);
}
- switch (data_type->get_primitive_type()) {
- case PrimitiveType::TYPE_TINYINT: {
- for (int i = 1; i < arguments.size(); ++i) {
- if (col_const[i]) {
- insert_result_data<TYPE_TINYINT, true>(result_column,
cols[i],
-
input_rows_count);
- } else {
- insert_result_data<TYPE_TINYINT, false>(result_column,
cols[i],
-
input_rows_count);
- }
- }
- break;
- }
- case PrimitiveType::TYPE_SMALLINT: {
- for (int i = 1; i < arguments.size(); ++i) {
- if (col_const[i]) {
- insert_result_data<TYPE_SMALLINT, true>(result_column,
cols[i],
-
input_rows_count);
- } else {
- insert_result_data<TYPE_SMALLINT,
false>(result_column, cols[i],
-
input_rows_count);
- }
- }
- break;
- }
- case PrimitiveType::TYPE_INT: {
- for (int i = 1; i < arguments.size(); ++i) {
- if (col_const[i]) {
- insert_result_data<TYPE_INT, true>(result_column,
cols[i],
- input_rows_count);
- } else {
- insert_result_data<TYPE_INT, false>(result_column,
cols[i],
- input_rows_count);
- }
- }
- break;
- }
- case PrimitiveType::TYPE_BIGINT: {
- for (int i = 1; i < arguments.size(); ++i) {
- if (col_const[i]) {
- insert_result_data<TYPE_BIGINT, true>(result_column,
cols[i],
-
input_rows_count);
- } else {
- insert_result_data<TYPE_BIGINT, false>(result_column,
cols[i],
-
input_rows_count);
- }
- }
- break;
- }
- case PrimitiveType::TYPE_LARGEINT: {
- for (int i = 1; i < arguments.size(); ++i) {
- if (col_const[i]) {
- insert_result_data<TYPE_LARGEINT, true>(result_column,
cols[i],
-
input_rows_count);
- } else {
- insert_result_data<TYPE_LARGEINT,
false>(result_column, cols[i],
-
input_rows_count);
- }
- }
- break;
- }
- case PrimitiveType::TYPE_FLOAT: {
- for (int i = 1; i < arguments.size(); ++i) {
- if (col_const[i]) {
- insert_result_data<TYPE_FLOAT, true>(result_column,
cols[i],
- input_rows_count);
- } else {
- insert_result_data<TYPE_FLOAT, false>(result_column,
cols[i],
-
input_rows_count);
- }
- }
- break;
- }
- case PrimitiveType::TYPE_DOUBLE: {
- for (int i = 1; i < arguments.size(); ++i) {
- if (col_const[i]) {
- insert_result_data<TYPE_DOUBLE, true>(result_column,
cols[i],
-
input_rows_count);
- } else {
- insert_result_data<TYPE_DOUBLE, false>(result_column,
cols[i],
-
input_rows_count);
- }
- }
- break;
- }
- case PrimitiveType::TYPE_DECIMAL32: {
- for (int i = 1; i < arguments.size(); ++i) {
- if (col_const[i]) {
- insert_result_data<TYPE_DECIMAL32,
true>(result_column, cols[i],
-
input_rows_count);
- } else {
- insert_result_data<TYPE_DECIMAL32,
false>(result_column, cols[i],
-
input_rows_count);
- }
- }
- break;
- }
- case PrimitiveType::TYPE_DECIMAL64: {
- for (int i = 1; i < arguments.size(); ++i) {
- if (col_const[i]) {
- insert_result_data<TYPE_DECIMAL64,
true>(result_column, cols[i],
-
input_rows_count);
- } else {
- insert_result_data<TYPE_DECIMAL64,
false>(result_column, cols[i],
-
input_rows_count);
- }
- }
- break;
- }
- case PrimitiveType::TYPE_DECIMALV2: {
- for (int i = 1; i < arguments.size(); ++i) {
- if (col_const[i]) {
- insert_result_data<TYPE_DECIMALV2,
true>(result_column, cols[i],
-
input_rows_count);
- } else {
- insert_result_data<TYPE_DECIMALV2,
false>(result_column, cols[i],
-
input_rows_count);
- }
- }
- break;
- }
- case PrimitiveType::TYPE_DECIMAL128I: {
- for (int i = 1; i < arguments.size(); ++i) {
- if (col_const[i]) {
- insert_result_data<TYPE_DECIMAL128I,
true>(result_column, cols[i],
-
input_rows_count);
- } else {
- insert_result_data<TYPE_DECIMAL128I,
false>(result_column, cols[i],
-
input_rows_count);
- }
- }
- break;
- }
- case PrimitiveType::TYPE_DECIMAL256: {
- for (int i = 1; i < arguments.size(); ++i) {
- if (col_const[i]) {
- insert_result_data<TYPE_DECIMAL256,
true>(result_column, cols[i],
-
input_rows_count);
- } else {
- insert_result_data<TYPE_DECIMAL256,
false>(result_column, cols[i],
-
input_rows_count);
- }
- }
- break;
- }
- case PrimitiveType::TYPE_DATETIME: {
- for (int i = 1; i < arguments.size(); ++i) {
- if (col_const[i]) {
- insert_result_data<TYPE_DATETIME, true>(result_column,
cols[i],
-
input_rows_count);
- } else {
- insert_result_data<TYPE_DATETIME,
false>(result_column, cols[i],
-
input_rows_count);
- }
- }
- break;
- }
- case PrimitiveType::TYPE_DATE: {
- for (int i = 1; i < arguments.size(); ++i) {
- if (col_const[i]) {
- insert_result_data<TYPE_DATE, true>(result_column,
cols[i],
- input_rows_count);
- } else {
- insert_result_data<TYPE_DATE, false>(result_column,
cols[i],
- input_rows_count);
- }
- }
- break;
- }
- case PrimitiveType::TYPE_DATEV2: {
- for (int i = 1; i < arguments.size(); ++i) {
- if (col_const[i]) {
- insert_result_data<TYPE_DATEV2, true>(result_column,
cols[i],
-
input_rows_count);
- } else {
- insert_result_data<TYPE_DATEV2, false>(result_column,
cols[i],
-
input_rows_count);
- }
- }
- break;
- }
- case PrimitiveType::TYPE_DATETIMEV2: {
+
+ auto call = [&](const auto& type) -> bool {
+ using DispatchType = std::decay_t<decltype(type)>;
for (int i = 1; i < arguments.size(); ++i) {
if (col_const[i]) {
- insert_result_data<TYPE_DATETIMEV2,
true>(result_column, cols[i],
-
input_rows_count);
+ insert_result_data<DispatchType::PType,
true>(result_column, cols[i],
+
input_rows_count);
} else {
- insert_result_data<TYPE_DATETIMEV2,
false>(result_column, cols[i],
-
input_rows_count);
+ insert_result_data<DispatchType::PType,
false>(result_column, cols[i],
+
input_rows_count);
}
}
- break;
- }
- default:
- break;
+
+ return true;
+ };
+
+ if (!dispatch_switch_scalar(data_type->get_primitive_type(),
call)) {
+ throw doris::Exception(ErrorCode::INTERNAL_ERROR, "not support
type {}",
+ data_type->get_name());
}
}
return result_column;
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
