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 8063aa1cab5427..cd675d1296c22d 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 @@ class FunctionArrayContainsAll : public IFunction {
                 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 @@ class FunctionArrayContainsAll : public IFunction {
         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 8961b638827460..edd0d82a45bea8 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 @@ class FunctionArrayDistinct : public IFunction {
                           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 c55c7182c13c16..9d10034bb28549 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 @@ class FunctionArrayElement : public IFunction {
         // 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 3463868bbd8c30..71beccd28f57ea 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 @@ class FunctionArrayEnumerateUniq : public IFunction {
             }
             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 6f63af620585ca..09a43e7651c3c9 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 @@ class FunctionArrayRemove : public IFunction {
                                   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 b1eb8e22047de7..d71643945ca796 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 @@ class FunctionArraysOverlap : public IFunction {
         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 54d01931b10a71..242a2d62c6bf5a 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 0e5b6678ed7b3f..96ff5f106640d2 100644
--- a/be/src/exprs/function/functions_comparison.h
+++ b/be/src/exprs/function/functions_comparison.h
@@ -528,19 +528,20 @@ class FunctionComparison : public IFunction {
 
     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 aaa370579683c7..7e543499ada6a1 100644
--- a/be/src/exprs/function/if.cpp
+++ b/be/src/exprs/function/if.cpp
@@ -529,23 +529,15 @@ class FunctionIf : public IFunction {
         }
 
         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 ec6f561db41f39..13558035636154 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;