[refactor](type) type checking in field

be/src/olap/comparison_predicate.h

@@ -171,13 +171,13 @@ class ComparisonPredicateBase final : public ColumnPredicate {
         T min_value;
         T max_value;
         if constexpr (is_string_type(Type)) {
-            auto& tmp_min = min_field.template get<std::string>();
-            auto& tmp_max = max_field.template get<std::string>();
+            auto& tmp_min = min_field.template get<Type>();
+            auto& tmp_max = max_field.template get<Type>();
             min_value = StringRef(tmp_min.data(), tmp_min.size());
             max_value = StringRef(tmp_max.data(), tmp_max.size());
         } else {
-            min_value = min_field.template get<T>();
-            max_value = max_field.template get<T>();
+            min_value = min_field.template get<Type>();
+            max_value = max_field.template get<Type>();
         }
 
         if constexpr (PT == PredicateType::EQ) {

be/src/olap/in_list_predicate.h

@@ -258,13 +258,13 @@ class InListPredicateBase final : public ColumnPredicate {
         T min_value;
         T max_value;
         if constexpr (is_string_type(Type)) {
-            auto& tmp_min = min_field.template get<std::string>();
-            auto& tmp_max = max_field.template get<std::string>();
+            auto& tmp_min = min_field.template get<Type>();
+            auto& tmp_max = max_field.template get<Type>();
             min_value = StringRef(tmp_min.data(), tmp_min.size());
             max_value = StringRef(tmp_max.data(), tmp_max.size());
         } else {
-            min_value = min_field.template get<T>();
-            max_value = max_field.template get<T>();
+            min_value = min_field.template get<Type>();
+            max_value = max_field.template get<Type>();
         }
 
         if constexpr (PT == PredicateType::IN_LIST) {

be/src/olap/rowset/segment_v2/column_reader.cpp

@@ -345,7 +345,7 @@ void ColumnReader::check_data_by_zone_map_for_test(const vectorized::MutableColu
         vectorized::Field field;
         dst->get(i, field);
         DCHECK(!field.is_null());
-        const auto v = field.get<int32_t>();
+        const auto v = field.get<TYPE_INT>();
         DCHECK_GE(v, min_v);
         DCHECK_LE(v, max_v);
     }

be/src/olap/rowset/segment_v2/inverted_index_reader.h

@@ -393,7 +393,7 @@ class InvertedIndexQueryParamFactory {
 
         if constexpr (is_string_type(PT)) {
             if constexpr (std::is_same_v<ValueType, doris::vectorized::Field>) {
-                const auto& str = doris::vectorized::get<vectorized::String>(*value);
+                const auto& str = value->template get<PT>();
                 param->set_value(str);
             } else if constexpr (std::is_same_v<ValueType, StringRef>) {
                 param->set_value(value);
@@ -405,7 +405,7 @@ class InvertedIndexQueryParamFactory {
         } else {
             CPP_TYPE cpp_val;
             if constexpr (std::is_same_v<ValueType, doris::vectorized::Field>) {
-                auto field_val = value->template get<typename PrimitiveTypeTraits<PT>::CppType>();
+                auto field_val = value->template get<PT>();
                 cpp_val = static_cast<CPP_TYPE>(field_val);
             } else {
                 cpp_val = static_cast<CPP_TYPE>(*value);

be/src/runtime/decimalv2_value.h

@@ -28,6 +28,7 @@
 #include <string>
 #include <string_view>
 
+#include "runtime/define_primitive_type.h"
 #include "util/hash_util.hpp"
 #include "vec/core/extended_types.h"
 
@@ -52,6 +53,7 @@ enum DecimalRoundMode { HALF_UP = 1, HALF_EVEN = 2, CEILING = 3, FLOOR = 4, TRUN
 
 class DecimalV2Value {
 public:
+    static constexpr PrimitiveType PType = TYPE_DECIMALV2;
     using NativeType = __int128_t;
     friend DecimalV2Value operator+(const DecimalV2Value& v1, const DecimalV2Value& v2);
     friend DecimalV2Value operator-(const DecimalV2Value& v1, const DecimalV2Value& v2);
@@ -76,6 +78,7 @@ class DecimalV2Value {
 
     static const int128_t MAX_DECIMAL_VALUE =
             static_cast<int128_t>(MAX_INT64) * ONE_BILLION + MAX_FRAC_VALUE;
+    static constexpr int max_string_length() { return PRECISION + 1; }
 
     DecimalV2Value() = default;
     const int128_t& value() const { return _value; }

be/src/runtime/primitive_type.h

@@ -275,7 +275,7 @@ template <>
 struct PrimitiveTypeTraits<TYPE_BOOLEAN> {
     using CppType = bool;
     using StorageFieldType = CppType;
-    using CppNativeType = bool;
+    using CppNativeType = CppType;
     using ColumnItemType = vectorized::UInt8;
     using DataType = vectorized::DataTypeBool;
     using ColumnType = vectorized::ColumnUInt8;
@@ -424,7 +424,7 @@ struct PrimitiveTypeTraits<TYPE_DECIMALV2> {
     /// Different with compute layer, the DecimalV1 was stored as decimal12_t(12 bytes).
     using StorageFieldType = decimal12_t;
     using CppNativeType = vectorized::Int128;
-    using ColumnItemType = vectorized::Decimal128V2;
+    using ColumnItemType = CppType;
     using DataType = vectorized::DataTypeDecimalV2;
     using ColumnType = vectorized::ColumnDecimal128V2;
 };

be/src/runtime/runtime_predicate.cpp

@@ -77,33 +77,33 @@ Status RuntimePredicate::init_target(
 StringRef RuntimePredicate::_get_string_ref(const Field& field, const PrimitiveType type) {
     switch (type) {
     case PrimitiveType::TYPE_BOOLEAN: {
-        const auto& v = field.get<typename PrimitiveTypeTraits<TYPE_BOOLEAN>::CppType>();
+        const auto& v = field.get<TYPE_BOOLEAN>();
         return StringRef((char*)&v, sizeof(v));
     }
     case PrimitiveType::TYPE_TINYINT: {
-        const auto& v = field.get<typename PrimitiveTypeTraits<TYPE_TINYINT>::CppType>();
+        const auto& v = field.get<TYPE_TINYINT>();
         return StringRef((char*)&v, sizeof(v));
     }
     case PrimitiveType::TYPE_SMALLINT: {
-        const auto& v = field.get<typename PrimitiveTypeTraits<TYPE_SMALLINT>::CppType>();
+        const auto& v = field.get<TYPE_SMALLINT>();
         return StringRef((char*)&v, sizeof(v));
     }
     case PrimitiveType::TYPE_INT: {
-        const auto& v = field.get<typename PrimitiveTypeTraits<TYPE_INT>::CppType>();
+        const auto& v = field.get<TYPE_INT>();
         return StringRef((char*)&v, sizeof(v));
     }
     case PrimitiveType::TYPE_BIGINT: {
-        const auto& v = field.get<typename PrimitiveTypeTraits<TYPE_BIGINT>::CppType>();
+        const auto& v = field.get<TYPE_BIGINT>();
         return StringRef((char*)&v, sizeof(v));
     }
     case PrimitiveType::TYPE_LARGEINT: {
-        const auto& v = field.get<typename PrimitiveTypeTraits<TYPE_LARGEINT>::CppType>();
+        const auto& v = field.get<TYPE_LARGEINT>();
         return StringRef((char*)&v, sizeof(v));
     }
     case PrimitiveType::TYPE_CHAR:
     case PrimitiveType::TYPE_VARCHAR:
     case PrimitiveType::TYPE_STRING: {
-        const auto& v = field.get<String>();
+        const auto& v = field.get<TYPE_STRING>();
         auto length = v.size();
         char* buffer = _predicate_arena.alloc(length);
         memset(buffer, 0, length);
@@ -112,61 +112,61 @@ StringRef RuntimePredicate::_get_string_ref(const Field& field, const PrimitiveT
         return {buffer, length};
     }
     case PrimitiveType::TYPE_DATEV2: {
-        const auto& v = field.get<typename PrimitiveTypeTraits<TYPE_DATEV2>::CppType>();
+        const auto& v = field.get<TYPE_DATEV2>();
         return StringRef((char*)&v, sizeof(v));
     }
     case PrimitiveType::TYPE_DATETIMEV2: {
-        const auto& v = field.get<typename PrimitiveTypeTraits<TYPE_DATETIMEV2>::CppType>();
+        const auto& v = field.get<TYPE_DATETIMEV2>();
         return StringRef((char*)&v, sizeof(v));
     }
     case PrimitiveType::TYPE_TIMESTAMPTZ: {
-        const auto& v = field.get<typename PrimitiveTypeTraits<TYPE_TIMESTAMPTZ>::CppType>();
+        const auto& v = field.get<TYPE_TIMESTAMPTZ>();
         return StringRef((char*)&v, sizeof(v));
         break;
     }
     case PrimitiveType::TYPE_DATE: {
-        const auto& v = field.get<typename PrimitiveTypeTraits<TYPE_DATE>::CppType>();
+        const auto& v = field.get<TYPE_DATE>();
         return StringRef((char*)&v, sizeof(v));
     }
     case PrimitiveType::TYPE_DATETIME: {
-        const auto& v = field.get<typename PrimitiveTypeTraits<TYPE_DATETIME>::CppType>();
+        const auto& v = field.get<TYPE_DATETIME>();
         return StringRef((char*)&v, sizeof(v));
     }
     case PrimitiveType::TYPE_TIMEV2: {
-        const auto& v = field.get<typename PrimitiveTypeTraits<TYPE_TIMEV2>::CppType>();
+        const auto& v = field.get<TYPE_TIMEV2>();
         return StringRef((char*)&v, sizeof(v));
     }
     case PrimitiveType::TYPE_DECIMAL32: {
-        const auto& v = field.get<typename PrimitiveTypeTraits<TYPE_DECIMAL32>::CppType>();
+        const auto& v = field.get<TYPE_DECIMAL32>();
         return StringRef((char*)&v, sizeof(v));
     }
     case PrimitiveType::TYPE_DECIMAL64: {
-        const auto& v = field.get<typename PrimitiveTypeTraits<TYPE_DECIMAL64>::CppType>();
+        const auto& v = field.get<TYPE_DECIMAL64>();
         return StringRef((char*)&v, sizeof(v));
     }
     case PrimitiveType::TYPE_DECIMALV2: {
-        const auto& v = field.get<typename PrimitiveTypeTraits<TYPE_DECIMALV2>::CppType>();
+        const auto& v = field.get<TYPE_DECIMALV2>();
         return StringRef((char*)&v, sizeof(v));
     }
     case PrimitiveType::TYPE_DECIMAL128I: {
-        const auto& v = field.get<typename PrimitiveTypeTraits<TYPE_DECIMAL128I>::CppType>();
+        const auto& v = field.get<TYPE_DECIMAL128I>();
         return StringRef((char*)&v, sizeof(v));
     }
     case PrimitiveType::TYPE_DECIMAL256: {
-        const auto& v = field.get<typename PrimitiveTypeTraits<TYPE_DECIMAL256>::CppType>();
+        const auto& v = field.get<TYPE_DECIMAL256>();
         return StringRef((char*)&v, sizeof(v));
     }
     case PrimitiveType::TYPE_IPV4: {
-        const auto& v = field.get<typename PrimitiveTypeTraits<TYPE_IPV4>::CppType>();
+        const auto& v = field.get<TYPE_IPV4>();
         return StringRef((char*)&v, sizeof(v));
     }
     case PrimitiveType::TYPE_IPV6: {
-        const auto& v = field.get<typename PrimitiveTypeTraits<TYPE_IPV6>::CppType>();
+        const auto& v = field.get<TYPE_IPV6>();
         return StringRef((char*)&v, sizeof(v));
     }
     case doris::PrimitiveType::TYPE_VARBINARY: {
         // For VARBINARY type, use StringViewField to store binary data
-        const auto& v = field.get<StringViewField>();
+        const auto& v = field.get<TYPE_VARBINARY>();
         auto length = v.size();
         char* buffer = _predicate_arena.alloc(length);
         memset(buffer, 0, length);

be/src/vec/aggregate_functions/aggregate_function_avg.h

@@ -72,8 +72,7 @@ struct AggregateFunctionAvgData {
             DecimalV2Value decimal_val_count(count, 0);
             DecimalV2Value decimal_val_sum(sum * multiplier);
             DecimalV2Value cal_ret = decimal_val_sum / decimal_val_count;
-            Decimal128V2 ret(cal_ret.value());
-            return ret;
+            return cal_ret;
         } else {
             if constexpr (T == TYPE_DECIMAL256) {
                 return static_cast<ResultT>(sum * multiplier /
@@ -127,10 +126,10 @@ class AggregateFunctionAvg<T, TResult, Data> final
           UnaryExpression,
           NullableAggregateFunction {
 public:
-    using ResultType = PrimitiveTypeTraits<TResult>::ColumnItemType;
-    using ResultDataType = PrimitiveTypeTraits<TResult>::DataType;
-    using ColVecType = PrimitiveTypeTraits<T>::ColumnType;
-    using ColVecResult = PrimitiveTypeTraits<TResult>::ColumnType;
+    using ResultType = typename PrimitiveTypeTraits<TResult>::ColumnItemType;
+    using ResultDataType = typename PrimitiveTypeTraits<TResult>::DataType;
+    using ColVecType = typename PrimitiveTypeTraits<T>::ColumnType;
+    using ColVecResult = typename PrimitiveTypeTraits<TResult>::ColumnType;
     // The result calculated by PercentileApprox is an approximate value,
     // so the underlying storage uses float. The following calls will involve
     // an implicit cast to float.
@@ -175,14 +174,18 @@ class AggregateFunctionAvg<T, TResult, Data> final
         const auto& column =
                 assert_cast<const ColVecType&, TypeCheckOnRelease::DISABLE>(*columns[0]);
         if constexpr (is_add) {
-            if constexpr (is_decimal(T)) {
+            if constexpr (T == TYPE_DECIMALV2) {
+                this->data(place).sum += column.get_data()[row_num];
+            } else if constexpr (is_decimal(T)) {
                 this->data(place).sum += column.get_data()[row_num].value;
             } else {
                 this->data(place).sum += (DataType)column.get_data()[row_num];
             }
             ++this->data(place).count;
         } else {
-            if constexpr (is_decimal(T)) {
+            if constexpr (T == TYPE_DECIMALV2) {
+                this->data(place).sum += -column.get_data()[row_num];
+            } else if constexpr (is_decimal(T)) {
                 this->data(place).sum -= column.get_data()[row_num].value;
             } else {
                 this->data(place).sum -= (DataType)column.get_data()[row_num];
@@ -203,7 +206,9 @@ class AggregateFunctionAvg<T, TResult, Data> final
 
     NO_SANITIZE_UNDEFINED void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs,
                                      Arena&) const override {
-        if constexpr (is_decimal(T)) {
+        if constexpr (T == TYPE_DECIMALV2) {
+            this->data(place).sum += this->data(rhs).sum;
+        } else if constexpr (is_decimal(T)) {
             this->data(place).sum += this->data(rhs).sum.value;
         } else {
             this->data(place).sum += this->data(rhs).sum;

be/src/vec/aggregate_functions/aggregate_function_map.h

@@ -67,20 +67,20 @@ struct AggregateFunctionMapAggData {
 
     void add(const Field& key_, const Field& value) {
         DCHECK(!key_.is_null());
-        auto key_array = vectorized::get<Array>(key_);
-        auto value_array = vectorized::get<Array>(value);
+        auto key_array = key_.get<TYPE_ARRAY>();
+        auto value_array = value.get<TYPE_ARRAY>();
 
         const auto count = key_array.size();
         DCHECK_EQ(count, value_array.size());
 
         for (size_t i = 0; i != count; ++i) {
             StringRef key;
             if constexpr (is_string_type(K)) {
-                auto& string = key_array[i].get<String>();
+                auto& string = key_array[i].get<K>();
                 key.data = string.data();
                 key.size = string.size();
             } else {
-                auto& k = key_array[i].get<KeyType>();
+                auto& k = key_array[i].get<K>();
                 key.data = reinterpret_cast<const char*>(&k);
                 key.size = sizeof(k);
             }
@@ -266,7 +266,7 @@ class AggregateFunctionMapAgg final
         const auto& col = assert_cast<const ColumnMap&>(column);
         auto* data = &(this->data(places));
         for (size_t i = 0; i != num_rows; ++i) {
-            auto map = doris::vectorized::get<Map>(col[i]);
+            auto map = col[i].get<TYPE_MAP>();
             data->add(map[0], map[1]);
         }
     }
@@ -284,7 +284,7 @@ class AggregateFunctionMapAgg final
         auto& col = assert_cast<const ColumnMap&>(column);
         const size_t num_rows = column.size();
         for (size_t i = 0; i != num_rows; ++i) {
-            auto map = doris::vectorized::get<Map>(col[i]);
+            auto map = col[i].get<TYPE_MAP>();
             this->data(place).add(map[0], map[1]);
         }
     }
@@ -296,7 +296,7 @@ class AggregateFunctionMapAgg final
                 << ", begin:" << begin << ", end:" << end << ", column.size():" << column.size();
         const auto& col = assert_cast<const ColumnMap&>(column);
         for (size_t i = begin; i <= end; ++i) {
-            auto map = doris::vectorized::get<Map>(col[i]);
+            auto map = col[i].get<TYPE_MAP>();
             this->data(place).add(map[0], map[1]);
         }
     }
@@ -306,7 +306,7 @@ class AggregateFunctionMapAgg final
                                    const size_t num_rows) const override {
         const auto& col = assert_cast<const ColumnMap&>(*column);
         for (size_t i = 0; i != num_rows; ++i) {
-            auto map = doris::vectorized::get<Map>(col[i]);
+            auto map = col[i].get<TYPE_MAP>();
             this->data(places[i] + offset).add(map[0], map[1]);
         }
     }
@@ -317,7 +317,7 @@ class AggregateFunctionMapAgg final
         const auto& col = assert_cast<const ColumnMap&>(*column);
         for (size_t i = 0; i != num_rows; ++i) {
             if (places[i]) {
-                auto map = doris::vectorized::get<Map>(col[i]);
+                auto map = col[i].get<TYPE_MAP>();
                 this->data(places[i] + offset).add(map[0], map[1]);
             }
         }