diff --git a/be/src/vec/data_types/data_type_decimal.h b/be/src/vec/data_types/data_type_decimal.h
index c1321fd791..74f1df9230 100644
--- a/be/src/vec/data_types/data_type_decimal.h
+++ b/be/src/vec/data_types/data_type_decimal.h
@@ -376,9 +376,11 @@ convert_decimals(const typename FromDataType::FieldType& value, UInt32 scale_fro
 
 template <typename FromDataType, typename ToDataType>
 void convert_decimal_cols(
-        const typename ColumnDecimal<typename FromDataType::FieldType>::Container& vec_from,
-        typename ColumnDecimal<typename ToDataType::FieldType>::Container& vec_to,
-        UInt32 scale_from, UInt32 scale_to, UInt8* overflow_flag = nullptr) {
+        const typename ColumnDecimal<
+                typename FromDataType::FieldType>::Container::value_type* __restrict vec_from,
+        typename ColumnDecimal<typename ToDataType::FieldType>::Container::value_type* vec_to,
+        const UInt32 scale_from, const UInt32 scale_to, const size_t sz,
+        UInt8* overflow_flag = nullptr) {
     using FromFieldType = typename FromDataType::FieldType;
     using ToFieldType = typename ToDataType::FieldType;
     using MaxFieldType =
@@ -391,31 +393,37 @@ void convert_decimal_cols(
     using MaxNativeType = typename MaxFieldType::NativeType;
 
     if (scale_to > scale_from) {
-        MaxNativeType multiplier =
+        const MaxNativeType multiplier =
                 DataTypeDecimal<MaxFieldType>::get_scale_multiplier(scale_to - scale_from);
         MaxNativeType res;
-        for (size_t i = 0; i < vec_from.size(); i++) {
-            if (common::mul_overflow(static_cast<MaxNativeType>(vec_from[i]), multiplier, res)) {
-                if (overflow_flag) {
-                    overflow_flag[i] = 1;
-                }
-                VLOG_DEBUG << "Decimal convert overflow";
-                vec_to[i] = res < 0 ? std::numeric_limits<typename ToFieldType::NativeType>::min()
+        for (size_t i = 0; i < sz; i++) {
+            if (std::is_same_v<MaxNativeType, Int128>) {
+                if (common::mul_overflow(static_cast<MaxNativeType>(vec_from[i]), multiplier,
+                                         res)) {
+                    if (overflow_flag) {
+                        overflow_flag[i] = 1;
+                    }
+                    VLOG_DEBUG << "Decimal convert overflow";
+                    vec_to[i] =
+                            res < 0 ? std::numeric_limits<typename ToFieldType::NativeType>::min()
                                     : std::numeric_limits<typename ToFieldType::NativeType>::max();
+                } else {
+                    vec_to[i] = res;
+                }
             } else {
-                vec_to[i] = res;
+                vec_to[i] = vec_from[i] * multiplier;
             }
         }
     } else {
         MaxNativeType multiplier =
                 DataTypeDecimal<MaxFieldType>::get_scale_multiplier(scale_from - scale_to);
-        for (size_t i = 0; i < vec_from.size(); i++) {
+        for (size_t i = 0; i < sz; i++) {
             vec_to[i] = vec_from[i] / multiplier;
         }
     }
 
     if constexpr (sizeof(FromFieldType) > sizeof(ToFieldType)) {
-        for (size_t i = 0; i < vec_from.size(); i++) {
+        for (size_t i = 0; i < sz; i++) {
             if (vec_to[i] < std::numeric_limits<typename ToFieldType::NativeType>::min()) {
                 if (overflow_flag) {
                     *overflow_flag = 1;
diff --git a/be/src/vec/functions/function_binary_arithmetic.h b/be/src/vec/functions/function_binary_arithmetic.h
index c29132b637..e95a6adc1f 100644
--- a/be/src/vec/functions/function_binary_arithmetic.h
+++ b/be/src/vec/functions/function_binary_arithmetic.h
@@ -231,13 +231,12 @@ struct DecimalBinaryOperation {
     using Traits = NumberTraits::BinaryOperatorTraits<A, B>;
     using ArrayC = typename ColumnDecimal<ResultType>::Container;
 
-    static void vector_vector(const typename Traits::ArrayA& a, const typename Traits::ArrayB& b,
-                              ArrayC& c) {
-        size_t size = a.size();
-
+    static void vector_vector(const typename Traits::ArrayA::value_type* __restrict a,
+                              const typename Traits::ArrayB::value_type* __restrict b,
+                              typename ArrayC::value_type* c, size_t size) {
         if constexpr (OpTraits::is_multiply && IsDecimalV2<A> && IsDecimalV2<B> &&
                       IsDecimalV2<ResultType>) {
-            Op::vector_vector(a, b, c);
+            Op::vector_vector(a, b, c, size);
         } else {
             for (size_t i = 0; i < size; i++) {
                 c[i] = apply(a[i], b[i]);
@@ -246,9 +245,9 @@ struct DecimalBinaryOperation {
     }
 
     /// null_map for divide and mod
-    static void vector_vector(const typename Traits::ArrayA& a, const typename Traits::ArrayB& b,
-                              ArrayC& c, NullMap& null_map) {
-        size_t size = a.size();
+    static void vector_vector(const typename Traits::ArrayA::value_type* __restrict a,
+                              const typename Traits::ArrayB::value_type* __restrict b,
+                              typename ArrayC::value_type* c, NullMap& null_map, size_t size) {
         if constexpr (IsDecimalV2<B> || IsDecimalV2<A>) {
             /// default: use it if no return before
             for (size_t i = 0; i < size; ++i) {
@@ -266,8 +265,8 @@ struct DecimalBinaryOperation {
         }
     }
 
-    static void vector_constant(const typename Traits::ArrayA& a, B b, ArrayC& c) {
-        size_t size = a.size();
+    static void vector_constant(const typename Traits::ArrayA::value_type* __restrict a, B b,
+                                typename ArrayC::value_type* c, size_t size) {
         if constexpr (OpTraits::is_division && IsDecimalNumber<B>) {
             for (size_t i = 0; i < size; ++i) {
                 c[i] = apply_scaled_div(a[i], b);
@@ -281,9 +280,8 @@ struct DecimalBinaryOperation {
         }
     }
 
-    static void vector_constant(const typename Traits::ArrayA& a, B b, ArrayC& c,
-                                NullMap& null_map) {
-        size_t size = a.size();
+    static void vector_constant(const typename Traits::ArrayA::value_type* __restrict a, B b,
+                                typename ArrayC::value_type* c, NullMap& null_map, size_t size) {
         if constexpr (OpTraits::is_division && IsDecimalNumber<B>) {
             for (size_t i = 0; i < size; ++i) {
                 c[i] = apply_scaled_div(a[i], b, null_map[i]);
@@ -300,8 +298,8 @@ struct DecimalBinaryOperation {
         }
     }
 
-    static void constant_vector(A a, const typename Traits::ArrayB& b, ArrayC& c) {
-        size_t size = b.size();
+    static void constant_vector(A a, const typename Traits::ArrayB::value_type* __restrict b,
+                                typename ArrayC::value_type* c, size_t size) {
         if constexpr (IsDecimalV2<A> || IsDecimalV2<B>) {
             DecimalV2Value da(a);
             for (size_t i = 0; i < size; ++i) {
@@ -314,9 +312,8 @@ struct DecimalBinaryOperation {
         }
     }
 
-    static void constant_vector(A a, const typename Traits::ArrayB& b, ArrayC& c,
-                                NullMap& null_map) {
-        size_t size = b.size();
+    static void constant_vector(A a, const typename Traits::ArrayB::value_type* __restrict b,
+                                typename ArrayC::value_type* c, NullMap& null_map, size_t size) {
         if constexpr (OpTraits::is_division && IsDecimalNumber<B>) {
             for (size_t i = 0; i < size; ++i) {
                 c[i] = apply_scaled_div(a, b[i], null_map[i]);
@@ -382,11 +379,12 @@ struct DecimalBinaryOperation {
             return column_result;
         } else if constexpr (return_nullable_type || is_to_null_type) {
             auto null_map = ColumnUInt8::create(column_left->size(), 0);
-            vector_constant(column_left_ptr->get_data(), b, column_result->get_data(),
-                            null_map->get_data());
+            vector_constant(column_left_ptr->get_data().data(), b, column_result->get_data().data(),
+                            null_map->get_data(), column_left->size());
             return ColumnNullable::create(std::move(column_result), std::move(null_map));
         } else {
-            vector_constant(column_left_ptr->get_data(), b, column_result->get_data());
+            vector_constant(column_left_ptr->get_data().data(), b, column_result->get_data().data(),
+                            column_left->size());
             return column_result;
         }
     }
@@ -406,11 +404,13 @@ struct DecimalBinaryOperation {
             return column_result;
         } else if constexpr (return_nullable_type || is_to_null_type) {
             auto null_map = ColumnUInt8::create(column_right->size(), 0);
-            constant_vector(a, column_right_ptr->get_data(), column_result->get_data(),
-                            null_map->get_data());
+            constant_vector(a, column_right_ptr->get_data().data(),
+                            column_result->get_data().data(), null_map->get_data(),
+                            column_right->size());
             return ColumnNullable::create(std::move(column_result), std::move(null_map));
         } else {
-            constant_vector(a, column_right_ptr->get_data(), column_result->get_data());
+            constant_vector(a, column_right_ptr->get_data().data(),
+                            column_result->get_data().data(), column_right->size());
             return column_result;
         }
     }
@@ -432,19 +432,20 @@ struct DecimalBinaryOperation {
             return column_result;
         } else if constexpr (return_nullable_type || is_to_null_type) {
             auto null_map = ColumnUInt8::create(column_result->size(), 0);
-            vector_vector(column_left_ptr->get_data(), column_right_ptr->get_data(),
-                          column_result->get_data(), null_map->get_data());
+            vector_vector(column_left_ptr->get_data().data(), column_right_ptr->get_data().data(),
+                          column_result->get_data().data(), null_map->get_data(),
+                          column_left->size());
             return ColumnNullable::create(std::move(column_result), std::move(null_map));
         } else {
-            vector_vector(column_left_ptr->get_data(), column_right_ptr->get_data(),
-                          column_result->get_data());
+            vector_vector(column_left_ptr->get_data().data(), column_right_ptr->get_data().data(),
+                          column_result->get_data().data(), column_left->size());
             return column_result;
         }
     }
 
 private:
     /// there's implicit type conversion here
-    static NativeResultType apply(NativeResultType a, NativeResultType b) {
+    static ALWAYS_INLINE NativeResultType apply(NativeResultType a, NativeResultType b) {
         if constexpr (IsDecimalV2<B> || IsDecimalV2<A>) {
             // Now, Doris only support decimal +-*/ decimal.
             // overflow in consider in operator
@@ -465,7 +466,8 @@ private:
     }
 
     /// null_map for divide and mod
-    static NativeResultType apply(NativeResultType a, NativeResultType b, UInt8& is_null) {
+    static ALWAYS_INLINE NativeResultType apply(NativeResultType a, NativeResultType b,
+                                                UInt8& is_null) {
         if constexpr (IsDecimalV2<B> || IsDecimalV2<A>) {
             DecimalV2Value l(a);
             DecimalV2Value r(b);
@@ -516,7 +518,8 @@ private:
         return apply(a, b, is_null);
     }
 
-    static UInt8 apply_op_safely(NativeResultType a, NativeResultType b, NativeResultType& c) {
+    static ALWAYS_INLINE UInt8 apply_op_safely(NativeResultType a, NativeResultType b,
+                                               NativeResultType& c) {
         if constexpr (OpTraits::is_multiply || OpTraits::is_plus_minus) {
             return Op::template apply(a, b, c);
         }
diff --git a/be/src/vec/functions/function_cast.h b/be/src/vec/functions/function_cast.h
index 77be12e144..f0d620f2df 100644
--- a/be/src/vec/functions/function_cast.h
+++ b/be/src/vec/functions/function_cast.h
@@ -115,8 +115,8 @@ struct ConvertImpl {
                 }
                 if constexpr (IsDataTypeDecimal<FromDataType> && IsDataTypeDecimal<ToDataType>) {
                     convert_decimal_cols<FromDataType, ToDataType>(
-                            vec_from, vec_to, vec_from.get_scale(), vec_to.get_scale(),
-                            vec_null_map_to);
+                            vec_from.data(), vec_to.data(), vec_from.get_scale(),
+                            vec_to.get_scale(), vec_from.size(), vec_null_map_to);
                 } else {
                     for (size_t i = 0; i < size; ++i) {
                         if constexpr (IsDataTypeDecimal<FromDataType> &&
diff --git a/be/src/vec/functions/multiply.cpp b/be/src/vec/functions/multiply.cpp
index e55a8549e5..0a350392e7 100644
--- a/be/src/vec/functions/multiply.cpp
+++ b/be/src/vec/functions/multiply.cpp
@@ -41,10 +41,9 @@ struct MultiplyImpl {
         return a * b;
     }
 
-    static void vector_vector(const ColumnDecimal128::Container& a,
-                              const ColumnDecimal128::Container& b,
-                              ColumnDecimal128::Container& c) {
-        size_t size = c.size();
+    static void vector_vector(const ColumnDecimal128::Container::value_type* __restrict a,
+                              const ColumnDecimal128::Container::value_type* __restrict b,
+                              ColumnDecimal128::Container::value_type* c, size_t size) {
         int8 sgn[size];
 
         for (int i = 0; i < size; i++) {