diff --git a/be/src/common/signal_handler.h b/be/src/common/signal_handler.h
index c7b655cbea..85da4e7096 100644
--- a/be/src/common/signal_handler.h
+++ b/be/src/common/signal_handler.h
@@ -235,7 +235,7 @@ void (*g_failure_writer)(const char* data, size_t size) = WriteToStderr;
 // Dumps time information.  We don't dump human-readable time information
 // as localtime() is not guaranteed to be async signal safe.
 void DumpTimeInfo() {
-    time_t time_in_sec = time(NULL);
+    time_t time_in_sec = time(nullptr);
     char buf[256]; // Big enough for time info.
     MinimalFormatter formatter(buf, sizeof(buf));
     formatter.AppendString("*** Query id: ");
@@ -258,7 +258,7 @@ void DumpTimeInfo() {
 // Dumps information about the signal to STDERR.
 void DumpSignalInfo(int signal_number, siginfo_t* siginfo) {
     // Get the signal name.
-    const char* signal_name = NULL;
+    const char* signal_name = nullptr;
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kFailureSignals); ++i) {
         if (signal_number == kFailureSignals[i].number) {
             signal_name = kFailureSignals[i].name;
@@ -322,7 +322,7 @@ void InvokeDefaultSignalHandler(int signal_number) {
     memset(&sig_action, 0, sizeof(sig_action));
     sigemptyset(&sig_action.sa_mask);
     sig_action.sa_handler = SIG_DFL;
-    sigaction(signal_number, &sig_action, NULL);
+    sigaction(signal_number, &sig_action, nullptr);
     kill(getpid(), signal_number);
 }
 
@@ -330,14 +330,14 @@ void InvokeDefaultSignalHandler(int signal_number) {
 // dumping stuff while another thread is doing it.  Our policy is to let
 // the first thread dump stuff and let other threads wait.
 // See also comments in FailureSignalHandler().
-static pthread_t* g_entered_thread_id_pointer = NULL;
+static pthread_t* g_entered_thread_id_pointer = nullptr;
 
 // Wrapper of __sync_val_compare_and_swap. If the GCC extension isn't
 // defined, we try the CPU specific logics (we only support x86 and
 // x86_64 for now) first, then use a naive implementation, which has a
 // race condition.
 template <typename T>
-inline T sync_val_compare_and_swap(T* ptr, T oldval, T newval) {
+T sync_val_compare_and_swap(T* ptr, T oldval, T newval) {
 #if defined(HAVE___SYNC_VAL_COMPARE_AND_SWAP)
     return __sync_val_compare_and_swap(ptr, oldval, newval);
 #elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
@@ -376,8 +376,8 @@ void FailureSignalHandler(int signal_number, siginfo_t* signal_info, void* ucont
     // old value (value returned from __sync_val_compare_and_swap) is
     // different from the original value (in this case NULL).
     pthread_t* old_thread_id_pointer = sync_val_compare_and_swap(
-            &g_entered_thread_id_pointer, static_cast<pthread_t*>(NULL), &my_thread_id);
-    if (old_thread_id_pointer != NULL) {
+            &g_entered_thread_id_pointer, static_cast<pthread_t*>(nullptr), &my_thread_id);
+    if (old_thread_id_pointer != nullptr) {
         // We've already entered the signal handler.  What should we do?
         if (pthread_equal(my_thread_id, *g_entered_thread_id_pointer)) {
             // It looks the current thread is reentering the signal handler.
@@ -431,7 +431,7 @@ inline void InstallFailureSignalHandler() {
     sig_action.sa_sigaction = &FailureSignalHandler;
 
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kFailureSignals); ++i) {
-        CHECK_ERR(sigaction(kFailureSignals[i].number, &sig_action, NULL));
+        CHECK_ERR(sigaction(kFailureSignals[i].number, &sig_action, nullptr));
     }
     kFailureSignalHandlerInstalled = true;
 }
diff --git a/be/src/common/status.h b/be/src/common/status.h
index 2c0da39b8e..254c25e528 100644
--- a/be/src/common/status.h
+++ b/be/src/common/status.h
@@ -259,7 +259,7 @@ E(INVERTED_INDEX_NO_TERMS, -6005);
 // clang-format off
 // whether to capture stacktrace
 template <int code>
-static constexpr bool capture_stacktrace() {
+constexpr bool capture_stacktrace() {
     return code != ErrorCode::OK
         && code != ErrorCode::END_OF_FILE
         && code != ErrorCode::MEM_LIMIT_EXCEEDED
diff --git a/be/src/common/utils.h b/be/src/common/utils.h
index 499b727f5b..b03e41260e 100644
--- a/be/src/common/utils.h
+++ b/be/src/common/utils.h
@@ -66,7 +66,7 @@ static_assert((RELEASE_CONTEXT_COUNTER & (RELEASE_CONTEXT_COUNTER - 1)) == 0,
               "should be power of 2");
 
 template <typename To, typename From>
-static inline To convert_to(From from) {
+To convert_to(From from) {
     union {
         From _from;
         To _to;
diff --git a/be/src/exec/es/es_scroll_parser.cpp b/be/src/exec/es/es_scroll_parser.cpp
index 06d0884db5..5c50aecede 100644
--- a/be/src/exec/es/es_scroll_parser.cpp
+++ b/be/src/exec/es/es_scroll_parser.cpp
@@ -140,8 +140,8 @@ static const std::string INVALID_NULL_VALUE =
     } while (false)
 
 template <typename T>
-static Status get_int_value(const rapidjson::Value& col, PrimitiveType type, void* slot,
-                            bool pure_doc_value) {
+Status get_int_value(const rapidjson::Value& col, PrimitiveType type, void* slot,
+                     bool pure_doc_value) {
     if (col.IsNumber()) {
         *reinterpret_cast<T*>(slot) = (T)(sizeof(T) < 8 ? col.GetInt() : col.GetInt64());
         return Status::OK();
@@ -173,8 +173,8 @@ static Status get_int_value(const rapidjson::Value& col, PrimitiveType type, voi
 }
 
 template <typename T, typename RT>
-static Status get_date_value_int(const rapidjson::Value& col, PrimitiveType type, bool is_date_str,
-                                 RT* slot) {
+Status get_date_value_int(const rapidjson::Value& col, PrimitiveType type, bool is_date_str,
+                          RT* slot) {
     constexpr bool is_datetime_v1 = std::is_same_v<T, vectorized::VecDateTimeValue>;
     T dt_val;
     if (is_date_str) {
@@ -238,8 +238,8 @@ static Status get_date_value_int(const rapidjson::Value& col, PrimitiveType type
 }
 
 template <typename T, typename RT>
-static Status get_date_int(const rapidjson::Value& col, PrimitiveType type, bool pure_doc_value,
-                           RT* slot) {
+Status get_date_int(const rapidjson::Value& col, PrimitiveType type, bool pure_doc_value,
+                    RT* slot) {
     // this would happend just only when `enable_docvalue_scan = false`, and field has timestamp format date from _source
     if (col.IsNumber()) {
         // ES process date/datetime field would use millisecond timestamp for index or docvalue
@@ -265,8 +265,8 @@ static Status get_date_int(const rapidjson::Value& col, PrimitiveType type, bool
     }
 }
 template <typename T, typename RT>
-static Status fill_date_int(const rapidjson::Value& col, PrimitiveType type, bool pure_doc_value,
-                            vectorized::IColumn* col_ptr) {
+Status fill_date_int(const rapidjson::Value& col, PrimitiveType type, bool pure_doc_value,
+                     vectorized::IColumn* col_ptr) {
     RT data;
     RETURN_IF_ERROR((get_date_int<T, RT>(col, type, pure_doc_value, &data)));
     col_ptr->insert_data(const_cast<const char*>(reinterpret_cast<char*>(&data)), 0);
@@ -274,8 +274,8 @@ static Status fill_date_int(const rapidjson::Value& col, PrimitiveType type, boo
 }
 
 template <typename T>
-static Status get_float_value(const rapidjson::Value& col, PrimitiveType type, void* slot,
-                              bool pure_doc_value) {
+Status get_float_value(const rapidjson::Value& col, PrimitiveType type, void* slot,
+                       bool pure_doc_value) {
     static_assert(sizeof(T) == 4 || sizeof(T) == 8);
     if (col.IsNumber()) {
         *reinterpret_cast<T*>(slot) = (T)(sizeof(T) == 4 ? col.GetFloat() : col.GetDouble());
@@ -301,8 +301,8 @@ static Status get_float_value(const rapidjson::Value& col, PrimitiveType type, v
 }
 
 template <typename T>
-static Status insert_float_value(const rapidjson::Value& col, PrimitiveType type,
-                                 vectorized::IColumn* col_ptr, bool pure_doc_value, bool nullable) {
+Status insert_float_value(const rapidjson::Value& col, PrimitiveType type,
+                          vectorized::IColumn* col_ptr, bool pure_doc_value, bool nullable) {
     static_assert(sizeof(T) == 4 || sizeof(T) == 8);
     if (col.IsNumber() && nullable) {
         T value = (T)(sizeof(T) == 4 ? col.GetFloat() : col.GetDouble());
@@ -331,8 +331,8 @@ static Status insert_float_value(const rapidjson::Value& col, PrimitiveType type
 }
 
 template <typename T>
-static Status insert_int_value(const rapidjson::Value& col, PrimitiveType type,
-                               vectorized::IColumn* col_ptr, bool pure_doc_value, bool nullable) {
+Status insert_int_value(const rapidjson::Value& col, PrimitiveType type,
+                        vectorized::IColumn* col_ptr, bool pure_doc_value, bool nullable) {
     if (col.IsNumber()) {
         T value = (T)(sizeof(T) < 8 ? col.GetInt() : col.GetInt64());
         col_ptr->insert_data(const_cast<const char*>(reinterpret_cast<char*>(&value)), 0);
diff --git a/be/src/exec/olap_utils.h b/be/src/exec/olap_utils.h
index e1af76f01d..610299cc0f 100644
--- a/be/src/exec/olap_utils.h
+++ b/be/src/exec/olap_utils.h
@@ -27,12 +27,12 @@
 
 namespace doris {
 
-typedef bool (*CompareLargeFunc)(const void*, const void*);
+using CompareLargeFunc = bool (*)(const void*, const void*);
 
 static const char* NEGATIVE_INFINITY = "-oo";
 static const char* POSITIVE_INFINITY = "+oo";
 
-typedef struct OlapScanRange {
+struct OlapScanRange {
 public:
     OlapScanRange() : begin_include(true), end_include(true) {
         begin_scan_range.add_value(NEGATIVE_INFINITY);
@@ -49,7 +49,7 @@ public:
     bool end_include;
     OlapTuple begin_scan_range;
     OlapTuple end_scan_range;
-} OlapScanRange;
+};
 
 static char encoding_table[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
                                 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
@@ -97,7 +97,7 @@ enum SQLFilterOp {
 };
 
 template <PrimitiveType>
-static constexpr bool always_false_v = false;
+constexpr bool always_false_v = false;
 
 inline SQLFilterOp to_olap_filter_type(TExprOpcode::type type, bool opposite) {
     switch (type) {
diff --git a/be/src/exprs/create_predicate_function.h b/be/src/exprs/create_predicate_function.h
index 33efebb325..cbb8a45a3b 100644
--- a/be/src/exprs/create_predicate_function.h
+++ b/be/src/exprs/create_predicate_function.h
@@ -155,9 +155,9 @@ inline auto create_bitmap_filter(PrimitiveType type) {
 }
 
 template <PrimitiveType PT>
-inline ColumnPredicate* create_olap_column_predicate(
-        uint32_t column_id, const std::shared_ptr<BloomFilterFuncBase>& filter, int be_exec_version,
-        const TabletColumn*) {
+ColumnPredicate* create_olap_column_predicate(uint32_t column_id,
+                                              const std::shared_ptr<BloomFilterFuncBase>& filter,
+                                              int be_exec_version, const TabletColumn*) {
     std::shared_ptr<BloomFilterFuncBase> filter_olap;
     filter_olap.reset(create_bloom_filter(PT));
     filter_olap->light_copy(filter.get());
@@ -165,9 +165,9 @@ inline ColumnPredicate* create_olap_column_predicate(
 }
 
 template <PrimitiveType PT>
-inline ColumnPredicate* create_olap_column_predicate(
-        uint32_t column_id, const std::shared_ptr<BitmapFilterFuncBase>& filter,
-        int be_exec_version, const TabletColumn*) {
+ColumnPredicate* create_olap_column_predicate(uint32_t column_id,
+                                              const std::shared_ptr<BitmapFilterFuncBase>& filter,
+                                              int be_exec_version, const TabletColumn*) {
     if constexpr (PT == TYPE_TINYINT || PT == TYPE_SMALLINT || PT == TYPE_INT ||
                   PT == TYPE_BIGINT) {
         std::shared_ptr<BitmapFilterFuncBase> filter_olap;
@@ -180,17 +180,16 @@ inline ColumnPredicate* create_olap_column_predicate(
 }
 
 template <PrimitiveType PT>
-inline ColumnPredicate* create_olap_column_predicate(uint32_t column_id,
-                                                     const std::shared_ptr<HybridSetBase>& filter,
-                                                     int, const TabletColumn* column = nullptr) {
+ColumnPredicate* create_olap_column_predicate(uint32_t column_id,
+                                              const std::shared_ptr<HybridSetBase>& filter, int,
+                                              const TabletColumn* column = nullptr) {
     return new InListPredicateBase<PT, PredicateType::IN_LIST>(column_id, filter, column->length());
 }
 
 template <typename T>
-inline ColumnPredicate* create_column_predicate(uint32_t column_id,
-                                                const std::shared_ptr<T>& filter, FieldType type,
-                                                int be_exec_version,
-                                                const TabletColumn* column = nullptr) {
+ColumnPredicate* create_column_predicate(uint32_t column_id, const std::shared_ptr<T>& filter,
+                                         FieldType type, int be_exec_version,
+                                         const TabletColumn* column = nullptr) {
     switch (type) {
 #define M(NAME)                                                                                \
     case OLAP_FIELD_##NAME: {                                                                  \
diff --git a/be/src/gutil/atomicops-internals-x86.h b/be/src/gutil/atomicops-internals-x86.h
index 92762f9be6..7d57b71a13 100644
--- a/be/src/gutil/atomicops-internals-x86.h
+++ b/be/src/gutil/atomicops-internals-x86.h
@@ -63,7 +63,7 @@ typedef int64_t Atomic64;
 // hard-to-track-down bugs, if the pointer isn't naturally aligned. Check alignment
 // in debug mode.
 template <class T>
-inline void CheckNaturalAlignment(const T* ptr) {
+void CheckNaturalAlignment(const T* ptr) {
     DCHECK_EQ(0, reinterpret_cast<const uintptr_t>(ptr) & (sizeof(T) - 1))
             << "unaligned pointer not allowed for atomics";
 }
diff --git a/be/src/gutil/basictypes.h b/be/src/gutil/basictypes.h
index f0cebc589d..ad191b5f3c 100644
--- a/be/src/gutil/basictypes.h
+++ b/be/src/gutil/basictypes.h
@@ -21,4 +21,4 @@ enum Ownership { DO_NOT_TAKE_OWNERSHIP, TAKE_OWNERSHIP };
 //     ignore_result(my_var.release());
 //
 template <typename T>
-inline void ignore_result(const T&) {}
+void ignore_result(const T&) {}
diff --git a/be/src/gutil/bits.h b/be/src/gutil/bits.h
index 4ffc7614bc..9db9ee867c 100644
--- a/be/src/gutil/bits.h
+++ b/be/src/gutil/bits.h
@@ -229,7 +229,7 @@ inline int Bits::FindLSBSetNonZero64_Portable(uint64 n) {
 }
 
 template <class T>
-inline bool Bits::BytesContainByteLessThan(T bytes, uint8 c) {
+ bool Bits::BytesContainByteLessThan(T bytes, uint8 c) {
     T l = BitPattern<T>::l;
     T h = BitPattern<T>::h;
     // The c <= 0x80 code is straight out of Knuth Volume 4.
@@ -239,13 +239,13 @@ inline bool Bits::BytesContainByteLessThan(T bytes, uint8 c) {
 }
 
 template <class T>
-inline bool Bits::BytesContainByte(T bytes, uint8 c) {
+ bool Bits::BytesContainByte(T bytes, uint8 c) {
     // Usually c will be manifestly constant.
     return Bits::BytesContainByteLessThan<T>(bytes ^ (c * BitPattern<T>::l), 1);
 }
 
 template <class T>
-inline bool Bits::BytesAllInRange(T bytes, uint8 lo, uint8 hi) {
+ bool Bits::BytesAllInRange(T bytes, uint8 lo, uint8 hi) {
     T l = BitPattern<T>::l;
     T h = BitPattern<T>::h;
     // In the common case, lo and hi are manifest constants.
diff --git a/be/src/gutil/casts.h b/be/src/gutil/casts.h
index 8e2a1a5cad..6decf8c0a5 100644
--- a/be/src/gutil/casts.h
+++ b/be/src/gutil/casts.h
@@ -34,14 +34,14 @@
 // base::identity_ is used to make a non-deduced context, which
 // forces all callers to explicitly specify the template argument.
 template <typename To>
-inline To implicit_cast(typename base::identity_<To>::type to) {
+ To implicit_cast(typename base::identity_<To>::type to) {
     return to;
 }
 
 // This version of implicit_cast is used when two template arguments
 // are specified. It's obsolete and should not be used.
 template <typename To, typename From>
-inline To implicit_cast(typename base::identity_<From>::type const& f) {
+ To implicit_cast(typename base::identity_<From>::type const& f) {
     return f;
 }
 
@@ -89,7 +89,7 @@ inline To down_cast(From* f) {        // so we only accept pointers
 // or the reference form. If you call down_cast with a const T&, the
 // compiler will just bind From to const T.
 template <typename To, typename From>
-inline To down_cast(From& f) {
+ To down_cast(From& f) {
     COMPILE_ASSERT(std::is_reference<To>::value, target_type_not_a_reference);
     using ToAsPointer = typename std::remove_reference<To>::type*;
     if (false) {
@@ -161,7 +161,7 @@ inline To down_cast(From& f) {
 // -- mec 2005-10-17
 
 template <class Dest, class Source>
-inline Dest bit_cast(const Source& source) {
+ Dest bit_cast(const Source& source) {
     // Compile time assertion: sizeof(Dest) == sizeof(Source)
     // A compile error here means your Dest and Source have different sizes.
     COMPILE_ASSERT(sizeof(Dest) == sizeof(Source), VerifySizesAreEqual);
@@ -279,7 +279,7 @@ public:
 // because of value propagation on the constant enumerator bounds.
 
 template <typename Enum>
-inline bool loose_enum_test(int e_val) {
+ bool loose_enum_test(int e_val) {
     COMPILE_ASSERT(enum_limits<Enum>::is_specialized, missing_MAKE_ENUM_LIMITS);
     const Enum e_min = enum_limits<Enum>::min_enumerator;
     const Enum e_max = enum_limits<Enum>::max_enumerator;
@@ -333,7 +333,7 @@ inline bool loose_enum_test(int e_val) {
 }
 
 template <typename Enum>
-inline bool tight_enum_test(int e_val) {
+ bool tight_enum_test(int e_val) {
     COMPILE_ASSERT(enum_limits<Enum>::is_specialized, missing_MAKE_ENUM_LIMITS);
     const Enum e_min = enum_limits<Enum>::min_enumerator;
     const Enum e_max = enum_limits<Enum>::max_enumerator;
@@ -341,7 +341,7 @@ inline bool tight_enum_test(int e_val) {
 }
 
 template <typename Enum>
-inline bool loose_enum_test_cast(int e_val, Enum* e_var) {
+ bool loose_enum_test_cast(int e_val, Enum* e_var) {
     if (loose_enum_test<Enum>(e_val)) {
         *e_var = static_cast<Enum>(e_val);
         return true;
@@ -351,7 +351,7 @@ inline bool loose_enum_test_cast(int e_val, Enum* e_var) {
 }
 
 template <typename Enum>
-inline bool tight_enum_test_cast(int e_val, Enum* e_var) {
+ bool tight_enum_test_cast(int e_val, Enum* e_var) {
     if (tight_enum_test<Enum>(e_val)) {
         *e_var = static_cast<Enum>(e_val);
         return true;
@@ -371,7 +371,7 @@ inline void WarnEnumCastError(int value_of_int) {
 } // namespace base
 
 template <typename Enum>
-inline Enum loose_enum_cast(int e_val) {
+ Enum loose_enum_cast(int e_val) {
     if (!loose_enum_test<Enum>(e_val)) {
         base::internal::WarnEnumCastError(e_val);
     }
@@ -379,7 +379,7 @@ inline Enum loose_enum_cast(int e_val) {
 }
 
 template <typename Enum>
-inline Enum tight_enum_cast(int e_val) {
+ Enum tight_enum_cast(int e_val) {
     if (!tight_enum_test<Enum>(e_val)) {
         base::internal::WarnEnumCastError(e_val);
     }
diff --git a/be/src/gutil/dynamic_annotations.h b/be/src/gutil/dynamic_annotations.h
index f0016d20ae..0001eef160 100644
--- a/be/src/gutil/dynamic_annotations.h
+++ b/be/src/gutil/dynamic_annotations.h
@@ -566,7 +566,7 @@ void __asan_set_death_callback(void (*callback)(void));
      one can use
         ... = ANNOTATE_UNPROTECTED_READ(x); */
 template <class T>
-inline T ANNOTATE_UNPROTECTED_READ(const volatile T& x) ANNOTALYSIS_UNPROTECTED_READ {
+ T ANNOTATE_UNPROTECTED_READ(const volatile T& x) ANNOTALYSIS_UNPROTECTED_READ {
     ANNOTATE_IGNORE_READS_BEGIN();
     T res = x;
     ANNOTATE_IGNORE_READS_END();
@@ -635,7 +635,7 @@ inline T ANNOTATE_UNPROTECTED_READ(const volatile T& x) ANNOTALYSIS_UNPROTECTED_
 #if defined(__cplusplus)
 #undef ANNOTATE_UNPROTECTED_READ
 template <class T>
-inline T ANNOTATE_UNPROTECTED_READ(const volatile T& x) ANNOTALYSIS_UNPROTECTED_READ {
+ T ANNOTATE_UNPROTECTED_READ(const volatile T& x) ANNOTALYSIS_UNPROTECTED_READ {
     ANNOTATE_IGNORE_READS_BEGIN();
     T res = x;
     ANNOTATE_IGNORE_READS_END();
@@ -675,7 +675,7 @@ inline T ANNOTATE_UNPROTECTED_READ(const volatile T& x) ANNOTALYSIS_UNPROTECTED_
 #if defined(__cplusplus)
 #undef ANNOTATE_UNPROTECTED_READ
 template <class T>
-inline T ANNOTATE_UNPROTECTED_READ(const volatile T& x) {
+ T ANNOTATE_UNPROTECTED_READ(const volatile T& x) {
     ANNOTATE_IGNORE_READS_BEGIN();
     T res = x;
     ANNOTATE_IGNORE_READS_END();
diff --git a/be/src/gutil/gscoped_ptr.h b/be/src/gutil/gscoped_ptr.h
index 01305b9294..c578501d56 100644
--- a/be/src/gutil/gscoped_ptr.h
+++ b/be/src/gutil/gscoped_ptr.h
@@ -786,17 +786,17 @@ private:
 };
 
 template <class C, class FP>
-inline void swap(gscoped_ptr_malloc<C, FP>& a, gscoped_ptr_malloc<C, FP>& b) {
+void swap(gscoped_ptr_malloc<C, FP>& a, gscoped_ptr_malloc<C, FP>& b) {
     a.swap(b);
 }
 
 template <class C, class FP>
-inline bool operator==(C* p, const gscoped_ptr_malloc<C, FP>& b) {
+bool operator==(C* p, const gscoped_ptr_malloc<C, FP>& b) {
     return p == b.get();
 }
 
 template <class C, class FP>
-inline bool operator!=(C* p, const gscoped_ptr_malloc<C, FP>& b) {
+bool operator!=(C* p, const gscoped_ptr_malloc<C, FP>& b) {
     return p != b.get();
 }
 
diff --git a/be/src/gutil/port.h b/be/src/gutil/port.h
index aadccba222..3f8a431d65 100644
--- a/be/src/gutil/port.h
+++ b/be/src/gutil/port.h
@@ -197,7 +197,7 @@ const char PATH_SEPARATOR = '/';
 // a compiler error here.
 //
 #include <stdarg.h>
-inline void va_copy(va_list& a, va_list& b) {
+void va_copy(va_list& a, va_list& b) {
     a = b;
 }
 
diff --git a/be/src/gutil/stl_util.h b/be/src/gutil/stl_util.h
index c528465ada..e3aa6dc57a 100644
--- a/be/src/gutil/stl_util.h
+++ b/be/src/gutil/stl_util.h
@@ -85,7 +85,7 @@ void STLClearObject(deque<T, A>* obj) {
 // Reduce memory usage on behalf of object if its capacity is greater
 // than or equal to "limit", which defaults to 2^20.
 template <class T>
-inline void STLClearIfBig(T* obj, size_t limit = 1 << 20) {
+ void STLClearIfBig(T* obj, size_t limit = 1 << 20) {
     if (obj->capacity() >= limit) {
         STLClearObject(obj);
     } else {
@@ -95,7 +95,7 @@ inline void STLClearIfBig(T* obj, size_t limit = 1 << 20) {
 
 // Specialization for deque, which doesn't implement capacity().
 template <class T, class A>
-inline void STLClearIfBig(deque<T, A>* obj, size_t limit = 1 << 20) {
+ void STLClearIfBig(deque<T, A>* obj, size_t limit = 1 << 20) {
     if (obj->size() >= limit) {
         STLClearObject(obj);
     } else {
@@ -123,7 +123,7 @@ inline void STLClearIfBig(deque<T, A>* obj, size_t limit = 1 << 20) {
 // operations cheap.  Note that the default number of buckets is 193
 // in the Gnu library implementation as of Jan '08.
 template <class T>
-inline void STLClearHashIfBig(T* obj, size_t limit) {
+ void STLClearHashIfBig(T* obj, size_t limit) {
     if (obj->bucket_count() >= limit) {
         T tmp;
         tmp.swap(*obj);
@@ -311,7 +311,7 @@ inline void STLAppendToString(string* str, const char* ptr, size_t n) {
 // change this as well.
 
 template <typename T, typename Allocator>
-inline T* vector_as_array(vector<T, Allocator>* v) {
+ T* vector_as_array(vector<T, Allocator>* v) {
 #ifdef NDEBUG
     return &*v->begin();
 #else
@@ -320,7 +320,7 @@ inline T* vector_as_array(vector<T, Allocator>* v) {
 }
 
 template <typename T, typename Allocator>
-inline const T* vector_as_array(const vector<T, Allocator>* v) {
+ const T* vector_as_array(const vector<T, Allocator>* v) {
 #ifdef NDEBUG
     return &*v->begin();
 #else
@@ -352,7 +352,7 @@ inline char* string_as_array(string* str) {
 // differed.
 
 template <class HashSet>
-inline bool HashSetEquality(const HashSet& set_a, const HashSet& set_b) {
+ bool HashSetEquality(const HashSet& set_a, const HashSet& set_b) {
     if (set_a.size() != set_b.size()) return false;
     for (typename HashSet::const_iterator i = set_a.begin(); i != set_a.end(); ++i)
         if (set_b.find(*i) == set_b.end()) return false;
@@ -360,7 +360,7 @@ inline bool HashSetEquality(const HashSet& set_a, const HashSet& set_b) {
 }
 
 template <class HashMap>
-inline bool HashMapEquality(const HashMap& map_a, const HashMap& map_b) {
+ bool HashMapEquality(const HashMap& map_a, const HashMap& map_b) {
     if (map_a.size() != map_b.size()) return false;
     for (typename HashMap::const_iterator i = map_a.begin(); i != map_a.end(); ++i) {
         typename HashMap::const_iterator j = map_b.find(i->first);
diff --git a/be/src/gutil/strings/escaping.cc b/be/src/gutil/strings/escaping.cc
index 68996f5a40..bf7fd212f6 100644
--- a/be/src/gutil/strings/escaping.cc
+++ b/be/src/gutil/strings/escaping.cc
@@ -1697,7 +1697,7 @@ static char hex_char[] = "0123456789abcdef";
 // or a string.  This works because we use the [] operator to access
 // individual characters at a time.
 template <typename T>
-static void a2b_hex_t(const char* a, T b, int num) {
+void a2b_hex_t(const char* a, T b, int num) {
     for (int i = 0; i < num; i++) {
         b[i] = (hex_value[a[i * 2] & 0xFF] << 4) + (hex_value[a[i * 2 + 1] & 0xFF]);
     }
@@ -1725,7 +1725,7 @@ string a2b_bin(const string& a, bool byte_order_msb) {
 // or a string.  This works because we use the [] operator to access
 // individual characters at a time.
 template <typename T>
-static void b2a_hex_t(const unsigned char* b, T a, int num) {
+void b2a_hex_t(const unsigned char* b, T a, int num) {
     for (int i = 0; i < num; i++) {
         a[i * 2 + 0] = hex_char[b[i] >> 4];
         a[i * 2 + 1] = hex_char[b[i] & 0xf];
diff --git a/be/src/gutil/strings/join.h b/be/src/gutil/strings/join.h
index 2a42104303..d2c1bbf408 100644
--- a/be/src/gutil/strings/join.h
+++ b/be/src/gutil/strings/join.h
@@ -152,12 +152,12 @@ string JoinStringsInArray(string const* components, int num_components, const ch
 // Definitions of above JoinStrings* methods
 // ----------------------------------------------------------------------
 template <class CONTAINER>
-inline void JoinStrings(const CONTAINER& components, const StringPiece& delim, string* result) {
+void JoinStrings(const CONTAINER& components, const StringPiece& delim, string* result) {
     JoinStringsIterator(components.begin(), components.end(), delim, result);
 }
 
 template <class CONTAINER>
-inline string JoinStrings(const CONTAINER& components, const StringPiece& delim) {
+string JoinStrings(const CONTAINER& components, const StringPiece& delim) {
     string result;
     JoinStrings(components, delim, &result);
     return result;
@@ -202,8 +202,7 @@ void JoinStringsIterator(const ITERATOR& start, const ITERATOR& end, const Strin
 }
 
 template <class ITERATOR>
-inline string JoinStringsIterator(const ITERATOR& start, const ITERATOR& end,
-                                  const StringPiece& delim) {
+string JoinStringsIterator(const ITERATOR& start, const ITERATOR& end, const StringPiece& delim) {
     string result;
     JoinStringsIterator(start, end, delim, &result);
     return result;
@@ -300,12 +299,12 @@ string JoinElementsIterator(ITERATOR first, ITERATOR last, StringPiece delim) {
 }
 
 template <class CONTAINER>
-inline void JoinElements(const CONTAINER& components, StringPiece delim, string* result) {
+void JoinElements(const CONTAINER& components, StringPiece delim, string* result) {
     JoinElementsIterator(components.begin(), components.end(), delim, result);
 }
 
 template <class CONTAINER>
-inline string JoinElements(const CONTAINER& components, StringPiece delim) {
+string JoinElements(const CONTAINER& components, StringPiece delim) {
     string result;
     JoinElements(components, delim, &result);
     return result;
@@ -317,6 +316,6 @@ void JoinInts(const CONTAINER& components, const char* delim, string* result) {
 }
 
 template <class CONTAINER>
-inline string JoinInts(const CONTAINER& components, const char* delim) {
+string JoinInts(const CONTAINER& components, const char* delim) {
     return JoinElements(components, delim);
 }
diff --git a/be/src/gutil/strings/split.cc b/be/src/gutil/strings/split.cc
index 610b1ee7ea..60939e7418 100644
--- a/be/src/gutil/strings/split.cc
+++ b/be/src/gutil/strings/split.cc
@@ -327,8 +327,7 @@ static int CalculateReserveForVector(const string& full, const char* delim) {
 // the characters in the string, not the entire string as a single delimiter.
 // ----------------------------------------------------------------------
 template <typename StringType, typename ITR>
-static inline void SplitStringToIteratorUsing(const StringType& full, const char* delim,
-                                              ITR& result) {
+void SplitStringToIteratorUsing(const StringType& full, const char* delim, ITR& result) {
     // Optimize the common case where delim is a single character.
     if (delim[0] != '\0' && delim[1] == '\0') {
         char c = delim[0];
@@ -471,9 +470,8 @@ string SplitOneStringToken(const char** source, const char* delim) {
 //   account. '\' is not allowed as a delimiter.
 // ----------------------------------------------------------------------
 template <typename ITR>
-static inline void SplitStringWithEscapingToIterator(const string& src,
-                                                     const strings::CharSet& delimiters,
-                                                     const bool allow_empty, ITR* result) {
+void SplitStringWithEscapingToIterator(const string& src, const strings::CharSet& delimiters,
+                                       const bool allow_empty, ITR* result) {
     CHECK(!delimiters.Test('\\')) << "\\ is not allowed as a delimiter.";
     CHECK(result);
     string part;
diff --git a/be/src/gutil/strings/split.h b/be/src/gutil/strings/split.h
index 7889a5a8a6..1ea3e71e73 100644
--- a/be/src/gutil/strings/split.h
+++ b/be/src/gutil/strings/split.h
@@ -292,12 +292,12 @@ namespace strings {
 
 // Definitions of the main Split() function.
 template <typename Delimiter>
-inline internal::Splitter<Delimiter> Split(StringPiece text, Delimiter d) {
+internal::Splitter<Delimiter> Split(StringPiece text, Delimiter d) {
     return internal::Splitter<Delimiter>(text, d);
 }
 
 template <typename Delimiter, typename Predicate>
-inline internal::Splitter<Delimiter, Predicate> Split(StringPiece text, Delimiter d, Predicate p) {
+internal::Splitter<Delimiter, Predicate> Split(StringPiece text, Delimiter d, Predicate p) {
     return internal::Splitter<Delimiter, Predicate>(text, d, p);
 }
 
@@ -415,7 +415,7 @@ private:
 // Literal as the default if string-like objects are passed as the delimiter
 // parameter. This is similar to the overloads for Split() below.
 template <typename Delimiter>
-inline LimitImpl<Delimiter> Limit(Delimiter delim, int limit) {
+LimitImpl<Delimiter> Limit(Delimiter delim, int limit) {
     return LimitImpl<Delimiter>(delim, limit);
 }
 
@@ -499,23 +499,22 @@ inline internal::Splitter<delimiter::Literal> Split(StringPiece text, StringPiec
 
 // Same overloads as above, but also including a Predicate argument.
 template <typename Predicate>
-inline internal::Splitter<delimiter::Literal, Predicate> Split(StringPiece text,
-                                                               const char* delimiter, Predicate p) {
+internal::Splitter<delimiter::Literal, Predicate> Split(StringPiece text, const char* delimiter,
+                                                        Predicate p) {
     return internal::Splitter<delimiter::Literal, Predicate>(text, delimiter::Literal(delimiter),
                                                              p);
 }
 
 template <typename Predicate>
-inline internal::Splitter<delimiter::Literal, Predicate> Split(StringPiece text,
-                                                               const string& delimiter,
-                                                               Predicate p) {
+internal::Splitter<delimiter::Literal, Predicate> Split(StringPiece text, const string& delimiter,
+                                                        Predicate p) {
     return internal::Splitter<delimiter::Literal, Predicate>(text, delimiter::Literal(delimiter),
                                                              p);
 }
 
 template <typename Predicate>
-inline internal::Splitter<delimiter::Literal, Predicate> Split(StringPiece text,
-                                                               StringPiece delimiter, Predicate p) {
+internal::Splitter<delimiter::Literal, Predicate> Split(StringPiece text, StringPiece delimiter,
+                                                        Predicate p) {
     return internal::Splitter<delimiter::Literal, Predicate>(text, delimiter::Literal(delimiter),
                                                              p);
 }
diff --git a/be/src/gutil/strings/strip.h b/be/src/gutil/strings/strip.h
index b9c8d59c42..b4221d7d45 100644
--- a/be/src/gutil/strings/strip.h
+++ b/be/src/gutil/strings/strip.h
@@ -115,7 +115,7 @@ void StripWhiteSpace(string* str);
 namespace strings {
 
 template <typename Collection>
-inline void StripWhiteSpaceInCollection(Collection* collection) {
+void StripWhiteSpaceInCollection(Collection* collection) {
     for (typename Collection::iterator it = collection->begin(); it != collection->end(); ++it)
         StripWhiteSpace(&(*it));
 }
diff --git a/be/src/gutil/strings/util.cc b/be/src/gutil/strings/util.cc
index 57751ce398..3225fe992b 100644
--- a/be/src/gutil/strings/util.cc
+++ b/be/src/gutil/strings/util.cc
@@ -776,8 +776,8 @@ static bool IsWildcard(Rune character) {
 
 // Move the strings pointers to the point where they start to differ.
 template <typename CHAR, typename NEXT>
-static void EatSameChars(const CHAR** pattern, const CHAR* pattern_end, const CHAR** string,
-                         const CHAR* string_end, NEXT next) {
+void EatSameChars(const CHAR** pattern, const CHAR* pattern_end, const CHAR** string,
+                  const CHAR* string_end, NEXT next) {
     const CHAR* escape = nullptr;
     while (*pattern != pattern_end && *string != string_end) {
         if (!escape && IsWildcard(**pattern)) {
@@ -818,7 +818,7 @@ static void EatSameChars(const CHAR** pattern, const CHAR* pattern_end, const CH
 }
 
 template <typename CHAR, typename NEXT>
-static void EatWildcard(const CHAR** pattern, const CHAR* end, NEXT next) {
+void EatWildcard(const CHAR** pattern, const CHAR* end, NEXT next) {
     while (*pattern != end) {
         if (!IsWildcard(**pattern)) return;
         next(pattern, end);
@@ -826,8 +826,8 @@ static void EatWildcard(const CHAR** pattern, const CHAR* end, NEXT next) {
 }
 
 template <typename CHAR, typename NEXT>
-static bool MatchPatternT(const CHAR* eval, const CHAR* eval_end, const CHAR* pattern,
-                          const CHAR* pattern_end, int depth, NEXT next) {
+bool MatchPatternT(const CHAR* eval, const CHAR* eval_end, const CHAR* pattern,
+                   const CHAR* pattern_end, int depth, NEXT next) {
     const int kMaxDepth = 16;
     if (depth > kMaxDepth) return false;
 
diff --git a/be/src/gutil/strings/util.h b/be/src/gutil/strings/util.h
index 5aaa058f48..941fd5e91b 100644
--- a/be/src/gutil/strings/util.h
+++ b/be/src/gutil/strings/util.h
@@ -142,7 +142,7 @@ const char* strncaseprefix(const char* haystack, int haystack_size, const char*
 // char* literals). Templated so searching a const char* returns a const char*,
 // and searching a non-const char* returns a non-const char*.
 template <class CharStar>
-inline CharStar var_strprefix(CharStar str, const char* prefix) {
+CharStar var_strprefix(CharStar str, const char* prefix) {
     const int len = strlen(prefix);
     return strncmp(str, prefix, len) == 0 ? str + len : NULL;
 }
@@ -150,7 +150,7 @@ inline CharStar var_strprefix(CharStar str, const char* prefix) {
 // Same as var_strprefix() (immediately above), but matches a case-insensitive
 // prefix.
 template <class CharStar>
-inline CharStar var_strcaseprefix(CharStar str, const char* prefix) {
+CharStar var_strcaseprefix(CharStar str, const char* prefix) {
     const int len = strlen(prefix);
     return strncasecmp(str, prefix, len) == 0 ? str + len : NULL;
 }
diff --git a/be/src/olap/predicate_creator.h b/be/src/olap/predicate_creator.h
index 931290021f..754a1ad503 100644
--- a/be/src/olap/predicate_creator.h
+++ b/be/src/olap/predicate_creator.h
@@ -152,7 +152,7 @@ private:
 };
 
 template <PredicateType PT, typename ConditionType>
-inline std::unique_ptr<PredicateCreator<ConditionType>> get_creator(const FieldType& type) {
+std::unique_ptr<PredicateCreator<ConditionType>> get_creator(const FieldType& type) {
     switch (type) {
     case OLAP_FIELD_TYPE_TINYINT: {
         return std::make_unique<IntegerPredicateCreator<TYPE_TINYINT, PT, ConditionType>>();
@@ -237,25 +237,24 @@ inline std::unique_ptr<PredicateCreator<ConditionType>> get_creator(const FieldT
 }
 
 template <PredicateType PT, typename ConditionType>
-inline ColumnPredicate* create_predicate(const TabletColumn& column, int index,
-                                         const ConditionType& conditions, bool opposite,
-                                         MemPool* pool) {
+ColumnPredicate* create_predicate(const TabletColumn& column, int index,
+                                  const ConditionType& conditions, bool opposite, MemPool* pool) {
     return get_creator<PT, ConditionType>(column.type())
             ->create(column, index, conditions, opposite, pool);
 }
 
 template <PredicateType PT>
-inline ColumnPredicate* create_comparison_predicate(const TabletColumn& column, int index,
-                                                    const std::string& condition, bool opposite,
-                                                    MemPool* pool) {
+ColumnPredicate* create_comparison_predicate(const TabletColumn& column, int index,
+                                             const std::string& condition, bool opposite,
+                                             MemPool* pool) {
     static_assert(PredicateTypeTraits::is_comparison(PT));
     return create_predicate<PT, std::string>(column, index, condition, opposite, pool);
 }
 
 template <PredicateType PT>
-inline ColumnPredicate* create_list_predicate(const TabletColumn& column, int index,
-                                              const std::vector<std::string>& conditions,
-                                              bool opposite, MemPool* pool) {
+ColumnPredicate* create_list_predicate(const TabletColumn& column, int index,
+                                       const std::vector<std::string>& conditions, bool opposite,
+                                       MemPool* pool) {
     static_assert(PredicateTypeTraits::is_list(PT));
     return create_predicate<PT, std::vector<std::string>>(column, index, conditions, opposite,
                                                           pool);
diff --git a/be/src/olap/skiplist.h b/be/src/olap/skiplist.h
index f960bb468e..771cca0e66 100644
--- a/be/src/olap/skiplist.h
+++ b/be/src/olap/skiplist.h
@@ -209,30 +209,30 @@ typename SkipList<Key, Comparator>::Node* SkipList<Key, Comparator>::NewNode(con
 }
 
 template <typename Key, class Comparator>
-inline SkipList<Key, Comparator>::Iterator::Iterator(const SkipList* list) {
+SkipList<Key, Comparator>::Iterator::Iterator(const SkipList* list) {
     list_ = list;
     node_ = nullptr;
 }
 
 template <typename Key, class Comparator>
-inline bool SkipList<Key, Comparator>::Iterator::Valid() const {
+bool SkipList<Key, Comparator>::Iterator::Valid() const {
     return node_ != nullptr;
 }
 
 template <typename Key, class Comparator>
-inline const Key& SkipList<Key, Comparator>::Iterator::key() const {
+const Key& SkipList<Key, Comparator>::Iterator::key() const {
     DCHECK(Valid());
     return node_->key;
 }
 
 template <typename Key, class Comparator>
-inline void SkipList<Key, Comparator>::Iterator::Next() {
+void SkipList<Key, Comparator>::Iterator::Next() {
     DCHECK(Valid());
     node_ = node_->Next(0);
 }
 
 template <typename Key, class Comparator>
-inline void SkipList<Key, Comparator>::Iterator::Prev() {
+void SkipList<Key, Comparator>::Iterator::Prev() {
     // Instead of using explicit "prev" links, we just search for the
     // last node that falls before key.
     DCHECK(Valid());
@@ -243,17 +243,17 @@ inline void SkipList<Key, Comparator>::Iterator::Prev() {
 }
 
 template <typename Key, class Comparator>
-inline void SkipList<Key, Comparator>::Iterator::Seek(const Key& target) {
+void SkipList<Key, Comparator>::Iterator::Seek(const Key& target) {
     node_ = list_->FindGreaterOrEqual(target, nullptr);
 }
 
 template <typename Key, class Comparator>
-inline void SkipList<Key, Comparator>::Iterator::SeekToFirst() {
+void SkipList<Key, Comparator>::Iterator::SeekToFirst() {
     node_ = list_->head_->Next(0);
 }
 
 template <typename Key, class Comparator>
-inline void SkipList<Key, Comparator>::Iterator::SeekToLast() {
+void SkipList<Key, Comparator>::Iterator::SeekToLast() {
     node_ = list_->FindLast();
     if (node_ == list_->head_) {
         node_ = nullptr;
diff --git a/be/src/olap/types.cpp b/be/src/olap/types.cpp
index f92c0c0da1..7d83e4ec30 100644
--- a/be/src/olap/types.cpp
+++ b/be/src/olap/types.cpp
@@ -106,7 +106,7 @@ const TypeInfo* get_scalar_type_info(FieldType field_type) {
     }
 
 template <FieldType field_type>
-inline const ArrayTypeInfo* get_init_array_type_info(int32_t iterations) {
+const ArrayTypeInfo* get_init_array_type_info(int32_t iterations) {
     static ArrayTypeInfo nested_type_info_0(
             create_static_type_info_ptr(get_scalar_type_info<field_type>()));
     static ArrayTypeInfo nested_type_info_1(create_static_type_info_ptr(&nested_type_info_0));
diff --git a/be/src/olap/types.h b/be/src/olap/types.h
index b26a89ba6f..c9e61456dd 100644
--- a/be/src/olap/types.h
+++ b/be/src/olap/types.h
@@ -1398,7 +1398,7 @@ struct TypeTraits : public FieldTypeTraits<field_type> {
 };
 
 template <FieldType field_type>
-inline const TypeInfo* get_scalar_type_info() {
+const TypeInfo* get_scalar_type_info() {
     static constexpr TypeTraits<field_type> traits;
     static ScalarTypeInfo scalar_type_info(traits);
     return &scalar_type_info;
diff --git a/be/src/olap/utils.h b/be/src/olap/utils.h
index e63d998cce..fd98df50df 100644
--- a/be/src/olap/utils.h
+++ b/be/src/olap/utils.h
@@ -52,16 +52,16 @@ const static int32_t g_power_table[] = {1,      10,      100,      1000,      10
 // 计时工具，用于确定一段代码执行的时间，用于性能调优
 class OlapStopWatch {
 public:
-    uint64_t get_elapse_time_us() {
+    uint64_t get_elapse_time_us() const {
         struct timeval now;
-        gettimeofday(&now, 0);
+        gettimeofday(&now, nullptr);
         return (uint64_t)((now.tv_sec - _begin_time.tv_sec) * 1e6 +
                           (now.tv_usec - _begin_time.tv_usec));
     }
 
-    double get_elapse_second() { return get_elapse_time_us() / 1000000.0; }
+    double get_elapse_second() const { return get_elapse_time_us() / 1000000.0; }
 
-    void reset() { gettimeofday(&_begin_time, 0); }
+    void reset() { gettimeofday(&_begin_time, nullptr); }
 
     OlapStopWatch() { reset(); }
 
diff --git a/be/src/runtime/exec_env.h b/be/src/runtime/exec_env.h
index ae402453be..7fb7251df6 100644
--- a/be/src/runtime/exec_env.h
+++ b/be/src/runtime/exec_env.h
@@ -114,7 +114,7 @@ public:
 
     // using template to simplify client cache management
     template <typename T>
-    ClientCache<T>* get_client_cache() {
+    inline ClientCache<T>* get_client_cache() {
         return nullptr;
     }
 
diff --git a/be/src/runtime/memory/thread_mem_tracker_mgr.h b/be/src/runtime/memory/thread_mem_tracker_mgr.h
index 5898f4c338..363d2e9361 100644
--- a/be/src/runtime/memory/thread_mem_tracker_mgr.h
+++ b/be/src/runtime/memory/thread_mem_tracker_mgr.h
@@ -203,7 +203,7 @@ inline bool ThreadMemTrackerMgr::try_consume(int64_t size) {
 }
 
 template <bool CheckLimit, bool Force>
-inline bool ThreadMemTrackerMgr::flush_untracked_mem() {
+bool ThreadMemTrackerMgr::flush_untracked_mem() {
     // Temporary memory may be allocated during the consumption of the mem tracker, which will lead to entering
     // the Memory Hook again, so suspend consumption to avoid falling into an infinite loop.
     _stop_consume = true;
diff --git a/be/src/service/point_query_executor.cpp b/be/src/service/point_query_executor.cpp
index e33a7a186b..1db2881007 100644
--- a/be/src/service/point_query_executor.cpp
+++ b/be/src/service/point_query_executor.cpp
@@ -278,8 +278,8 @@ Status PointQueryExecutor::_lookup_row_data() {
 }
 
 template <typename MysqlWriter>
-static Status _serialize_block(MysqlWriter& mysql_writer, vectorized::Block& block,
-                               PTabletKeyLookupResponse* response) {
+Status _serialize_block(MysqlWriter& mysql_writer, vectorized::Block& block,
+                        PTabletKeyLookupResponse* response) {
     RETURN_IF_ERROR(mysql_writer.append_block(block));
     assert(mysql_writer.results().size() == 1);
     uint8_t* buf = nullptr;
diff --git a/be/src/util/binary_cast.hpp b/be/src/util/binary_cast.hpp
index 17754a15e9..df9190a55c 100644
--- a/be/src/util/binary_cast.hpp
+++ b/be/src/util/binary_cast.hpp
@@ -37,7 +37,7 @@ union TypeConverter {
 };
 
 template <typename C0, typename C1, typename T0, typename T1>
-inline constexpr bool match_v = std::is_same_v<C0, C1> && std::is_same_v<T0, T1>;
+constexpr bool match_v = std::is_same_v<C0, C1> && std::is_same_v<T0, T1>;
 
 union DecimalInt128Union {
     DecimalV2Value decimal;
diff --git a/be/src/util/bit_packing.inline.h b/be/src/util/bit_packing.inline.h
index 118d4edaa2..ed578868bd 100644
--- a/be/src/util/bit_packing.inline.h
+++ b/be/src/util/bit_packing.inline.h
@@ -172,7 +172,7 @@ std::pair<const uint8_t*, int64_t> BitPacking::UnpackAndDecodeValues(
 // avoid buffer overflow (if we are unpacking 32 values, we can safely assume an input
 // buffer of length 32 * BIT_WIDTH).
 template <int BIT_WIDTH, int VALUE_IDX, bool FULL_BATCH>
-inline uint64_t ALWAYS_INLINE UnpackValue(const uint8_t* __restrict__ in_buf) {
+uint64_t UnpackValue(const uint8_t* __restrict__ in_buf) {
     if (BIT_WIDTH == 0) return 0;
 
     constexpr int FIRST_BIT_IDX = VALUE_IDX * BIT_WIDTH;
@@ -220,9 +220,8 @@ inline uint64_t ALWAYS_INLINE UnpackValue(const uint8_t* __restrict__ in_buf) {
 }
 
 template <typename OutType>
-inline void ALWAYS_INLINE DecodeValue(OutType* __restrict__ dict, int64_t dict_len, uint32_t idx,
-                                      OutType* __restrict__ out_val,
-                                      bool* __restrict__ decode_error) {
+void DecodeValue(OutType* __restrict__ dict, int64_t dict_len, uint32_t idx,
+                 OutType* __restrict__ out_val, bool* __restrict__ decode_error) {
     if (UNLIKELY(idx >= dict_len)) {
         *decode_error = true;
     } else {
diff --git a/be/src/util/bit_stream_utils.inline.h b/be/src/util/bit_stream_utils.inline.h
index fb62e9e3ae..24dabe9e67 100644
--- a/be/src/util/bit_stream_utils.inline.h
+++ b/be/src/util/bit_stream_utils.inline.h
@@ -80,7 +80,7 @@ inline uint8_t* BitWriter::GetNextBytePtr(int num_bytes) {
 }
 
 template <typename T>
-inline void BitWriter::PutAligned(T val, int num_bytes) {
+void BitWriter::PutAligned(T val, int num_bytes) {
     DCHECK_LE(num_bytes, sizeof(T));
     uint8_t* ptr = GetNextBytePtr(num_bytes);
     memcpy(ptr, &val, num_bytes);
@@ -114,7 +114,7 @@ inline void BitReader::BufferValues() {
 }
 
 template <typename T>
-inline bool BitReader::GetValue(int num_bits, T* v) {
+bool BitReader::GetValue(int num_bits, T* v) {
     DCHECK_LE(num_bits, 64);
     DCHECK_LE(num_bits, sizeof(T) * 8);
 
@@ -187,7 +187,7 @@ inline void BitReader::SeekToBit(unsigned int stream_position) {
 }
 
 template <typename T>
-inline bool BitReader::GetAligned(int num_bytes, T* v) {
+bool BitReader::GetAligned(int num_bytes, T* v) {
     DCHECK_LE(num_bytes, sizeof(T));
     int bytes_read = BitUtil::Ceil(bit_offset_, 8);
     if (PREDICT_FALSE(byte_offset_ + bytes_read + num_bytes > max_bytes_)) return false;
@@ -258,7 +258,7 @@ inline bool BitReader::GetZigZagVlqInt(int64_t* v) {
 }
 
 template <typename T>
-inline int BatchedBitReader::UnpackBatch(int bit_width, int num_values, T* v) {
+int BatchedBitReader::UnpackBatch(int bit_width, int num_values, T* v) {
     DCHECK(buffer_pos_ != nullptr);
     DCHECK_GE(bit_width, 0);
     DCHECK_LE(bit_width, MAX_BITWIDTH);
@@ -288,8 +288,8 @@ inline bool BatchedBitReader::SkipBatch(int bit_width, int num_values_to_skip) {
 }
 
 template <typename T>
-inline int BatchedBitReader::UnpackAndDecodeBatch(int bit_width, T* dict, int64_t dict_len,
-                                                  int num_values, T* v, int64_t stride) {
+int BatchedBitReader::UnpackAndDecodeBatch(int bit_width, T* dict, int64_t dict_len, int num_values,
+                                           T* v, int64_t stride) {
     DCHECK(buffer_pos_ != nullptr);
     DCHECK_GE(bit_width, 0);
     DCHECK_LE(bit_width, MAX_BITWIDTH);
@@ -309,7 +309,7 @@ inline int BatchedBitReader::UnpackAndDecodeBatch(int bit_width, T* dict, int64_
 }
 
 template <typename T>
-inline bool BatchedBitReader::GetBytes(int num_bytes, T* v) {
+bool BatchedBitReader::GetBytes(int num_bytes, T* v) {
     DCHECK(buffer_pos_ != nullptr);
     DCHECK_GE(num_bytes, 0);
     DCHECK_LE(num_bytes, sizeof(T));
@@ -321,7 +321,7 @@ inline bool BatchedBitReader::GetBytes(int num_bytes, T* v) {
 }
 
 template <typename UINT_T>
-inline bool BatchedBitReader::GetUleb128(UINT_T* v) {
+bool BatchedBitReader::GetUleb128(UINT_T* v) {
     static_assert(std::is_integral<UINT_T>::value, "Integral type required.");
     static_assert(std::is_unsigned<UINT_T>::value, "Unsigned type required.");
     static_assert(!std::is_same<UINT_T, bool>::value, "Bools are not supported.");
diff --git a/be/src/util/bitmap_intersect.h b/be/src/util/bitmap_intersect.h
index 5de40232c5..8258ee21eb 100644
--- a/be/src/util/bitmap_intersect.h
+++ b/be/src/util/bitmap_intersect.h
@@ -55,7 +55,7 @@ public:
 };
 
 template <>
-inline char* Helper::write_to<DateTimeValue>(const DateTimeValue& v, char* dest) {
+char* Helper::write_to<DateTimeValue>(const DateTimeValue& v, char* dest) {
     DateTimeVal value;
     v.to_datetime_val(&value);
     *(int64_t*)dest = value.packed_time;
@@ -66,7 +66,7 @@ inline char* Helper::write_to<DateTimeValue>(const DateTimeValue& v, char* dest)
 }
 
 template <>
-inline char* Helper::write_to<DecimalV2Value>(const DecimalV2Value& v, char* dest) {
+char* Helper::write_to<DecimalV2Value>(const DecimalV2Value& v, char* dest) {
     __int128 value = v.value();
     memcpy(dest, &value, DECIMAL_BYTE_SIZE);
     dest += DECIMAL_BYTE_SIZE;
@@ -74,7 +74,7 @@ inline char* Helper::write_to<DecimalV2Value>(const DecimalV2Value& v, char* des
 }
 
 template <>
-inline char* Helper::write_to<StringRef>(const StringRef& v, char* dest) {
+char* Helper::write_to<StringRef>(const StringRef& v, char* dest) {
     *(int32_t*)dest = v.size;
     dest += 4;
     memcpy(dest, v.data, v.size);
@@ -83,7 +83,7 @@ inline char* Helper::write_to<StringRef>(const StringRef& v, char* dest) {
 }
 
 template <>
-inline char* Helper::write_to<std::string>(const std::string& v, char* dest) {
+char* Helper::write_to<std::string>(const std::string& v, char* dest) {
     *(uint32_t*)dest = v.size();
     dest += 4;
     memcpy(dest, v.c_str(), v.size());
@@ -93,28 +93,28 @@ inline char* Helper::write_to<std::string>(const std::string& v, char* dest) {
 // write_to end
 
 template <>
-inline int32_t Helper::serialize_size<DateTimeValue>(const DateTimeValue& v) {
+int32_t Helper::serialize_size<DateTimeValue>(const DateTimeValue& v) {
     return Helper::DATETIME_PACKED_TIME_BYTE_SIZE + Helper::DATETIME_TYPE_BYTE_SIZE;
 }
 
 template <>
-inline int32_t Helper::serialize_size<DecimalV2Value>(const DecimalV2Value& v) {
+int32_t Helper::serialize_size<DecimalV2Value>(const DecimalV2Value& v) {
     return Helper::DECIMAL_BYTE_SIZE;
 }
 
 template <>
-inline int32_t Helper::serialize_size<StringRef>(const StringRef& v) {
+int32_t Helper::serialize_size<StringRef>(const StringRef& v) {
     return v.size + 4;
 }
 
 template <>
-inline int32_t Helper::serialize_size<std::string>(const std::string& v) {
+int32_t Helper::serialize_size<std::string>(const std::string& v) {
     return v.size() + 4;
 }
 // serialize_size end
 
 template <>
-inline void Helper::read_from<DateTimeValue>(const char** src, DateTimeValue* result) {
+void Helper::read_from<DateTimeValue>(const char** src, DateTimeValue* result) {
     DateTimeVal value;
     value.is_null = false;
     value.packed_time = *(int64_t*)(*src);
@@ -125,7 +125,7 @@ inline void Helper::read_from<DateTimeValue>(const char** src, DateTimeValue* re
 }
 
 template <>
-inline void Helper::read_from<DecimalV2Value>(const char** src, DecimalV2Value* result) {
+void Helper::read_from<DecimalV2Value>(const char** src, DecimalV2Value* result) {
     __int128 v = 0;
     memcpy(&v, *src, DECIMAL_BYTE_SIZE);
     *src += DECIMAL_BYTE_SIZE;
@@ -133,7 +133,7 @@ inline void Helper::read_from<DecimalV2Value>(const char** src, DecimalV2Value*
 }
 
 template <>
-inline void Helper::read_from<StringRef>(const char** src, StringRef* result) {
+void Helper::read_from<StringRef>(const char** src, StringRef* result) {
     int32_t length = *(int32_t*)(*src);
     *src += 4;
     *result = StringRef((char*)*src, length);
@@ -141,7 +141,7 @@ inline void Helper::read_from<StringRef>(const char** src, StringRef* result) {
 }
 
 template <>
-inline void Helper::read_from<std::string>(const char** src, std::string* result) {
+void Helper::read_from<std::string>(const char** src, std::string* result) {
     int32_t length = *(int32_t*)(*src);
     *src += 4;
     *result = std::string((char*)*src, length);
diff --git a/be/src/util/coding.h b/be/src/util/coding.h
index 3cfa8e76b4..16b89507b2 100644
--- a/be/src/util/coding.h
+++ b/be/src/util/coding.h
@@ -105,14 +105,14 @@ inline uint128_t decode_fixed128_le(const uint8_t* buf) {
 }
 
 template <typename T>
-inline void put_fixed32_le(T* dst, uint32_t val) {
+void put_fixed32_le(T* dst, uint32_t val) {
     uint8_t buf[sizeof(val)];
     encode_fixed32_le(buf, val);
     dst->append((char*)buf, sizeof(buf));
 }
 
 template <typename T>
-inline void put_fixed64_le(T* dst, uint64_t val) {
+void put_fixed64_le(T* dst, uint64_t val) {
     uint8_t buf[sizeof(val)];
     encode_fixed64_le(buf, val);
     dst->append((char*)buf, sizeof(buf));
@@ -129,7 +129,7 @@ inline int varint_length(uint64_t v) {
 }
 
 template <typename T>
-inline void put_fixed128_le(T* dst, uint128_t val) {
+void put_fixed128_le(T* dst, uint128_t val) {
     uint8_t buf[sizeof(val)];
     encode_fixed128_le(buf, val);
     dst->append((char*)buf, sizeof(buf));
@@ -169,27 +169,27 @@ inline const uint8_t* decode_varint32_ptr(const uint8_t* ptr, const uint8_t* lim
 extern const uint8_t* decode_varint64_ptr(const uint8_t* p, const uint8_t* limit, uint64_t* value);
 
 template <typename T>
-inline void put_varint32(T* dst, uint32_t v) {
+void put_varint32(T* dst, uint32_t v) {
     uint8_t buf[16];
     uint8_t* ptr = encode_varint32(buf, v);
     dst->append((char*)buf, static_cast<size_t>(ptr - buf));
 }
 
 template <typename T>
-inline void put_varint64(T* dst, uint64_t v) {
+void put_varint64(T* dst, uint64_t v) {
     uint8_t buf[16];
     uint8_t* ptr = encode_varint64(buf, v);
     dst->append((char*)buf, static_cast<size_t>(ptr - buf));
 }
 
 template <typename T>
-inline void put_length_prefixed_slice(T* dst, const Slice& value) {
+void put_length_prefixed_slice(T* dst, const Slice& value) {
     put_varint32(dst, value.get_size());
     dst->append(value.get_data(), value.get_size());
 }
 
 template <typename T>
-inline void put_varint64_varint32(T* dst, uint64_t v1, uint32_t v2) {
+void put_varint64_varint32(T* dst, uint64_t v1, uint32_t v2) {
     uint8_t buf[16];
     uint8_t* ptr = encode_varint64(buf, v1);
     ptr = encode_varint32(ptr, v2);
diff --git a/be/src/util/frame_of_reference_coding.h b/be/src/util/frame_of_reference_coding.h
index bab0dca0ef..da3d716e75 100644
--- a/be/src/util/frame_of_reference_coding.h
+++ b/be/src/util/frame_of_reference_coding.h
@@ -29,12 +29,12 @@
 
 namespace doris {
 
-static inline uint8_t bits_less_than_64(const uint64_t v) {
+inline uint8_t bits_less_than_64(const uint64_t v) {
     return v == 0 ? 0 : 64 - __builtin_clzll(v);
 }
 
 // See https://stackoverflow.com/questions/28423405/counting-the-number-of-leading-zeros-in-a-128-bit-integer
-static inline uint8_t bits_may_more_than_64(const uint128_t v) {
+inline uint8_t bits_may_more_than_64(const uint128_t v) {
     uint64_t hi = v >> 64;
     uint64_t lo = v;
     int z[3] = {__builtin_clzll(hi), __builtin_clzll(lo) + 64, 128};
@@ -43,7 +43,7 @@ static inline uint8_t bits_may_more_than_64(const uint128_t v) {
 }
 
 template <typename T>
-static inline uint8_t bits(const T v) {
+uint8_t bits(const T v) {
     if (sizeof(T) <= 8) {
         return bits_less_than_64(v);
     } else {
diff --git a/be/src/util/interval_tree-inl.h b/be/src/util/interval_tree-inl.h
index d322d260d5..f93dd788a6 100644
--- a/be/src/util/interval_tree-inl.h
+++ b/be/src/util/interval_tree-inl.h
@@ -70,7 +70,7 @@ void IntervalTree<Traits>::FindIntersectingInterval(const QueryPointType& lower_
 }
 
 template <class Traits>
-static bool LessThan(const typename Traits::point_type& a, const typename Traits::point_type& b) {
+bool LessThan(const typename Traits::point_type& a, const typename Traits::point_type& b) {
     return Traits::compare(a, b) < 0;
 }
 
diff --git a/be/src/util/mysql_row_buffer.cpp b/be/src/util/mysql_row_buffer.cpp
index 04f5519a6d..3473d525bd 100644
--- a/be/src/util/mysql_row_buffer.cpp
+++ b/be/src/util/mysql_row_buffer.cpp
@@ -146,7 +146,7 @@ int MysqlRowBuffer<is_binary_format>::reserve(int64_t size) {
 }
 
 template <typename T>
-static char* add_int(T data, char* pos, bool dynamic_mode) {
+char* add_int(T data, char* pos, bool dynamic_mode) {
     auto fi = fmt::format_int(data);
     int length = fi.size();
     if (!dynamic_mode) {
@@ -165,7 +165,7 @@ static char* add_largeint(int128_t data, char* pos, bool dynamic_mode) {
 }
 
 template <typename T>
-static char* add_float(T data, char* pos, bool dynamic_mode) {
+char* add_float(T data, char* pos, bool dynamic_mode) {
     int length = 0;
     if constexpr (std::is_same_v<T, float>) {
         length = FastFloatToBuffer(data, pos + !dynamic_mode);
diff --git a/be/src/util/proto_util.h b/be/src/util/proto_util.h
index f7d8e1ef09..79a1e0866c 100644
--- a/be/src/util/proto_util.h
+++ b/be/src/util/proto_util.h
@@ -39,7 +39,7 @@ constexpr size_t MIN_HTTP_BRPC_SIZE = (1ULL << 31);
 
 // Embed column_values and brpc request serialization string in controller attachment.
 template <typename Params, typename Closure>
-inline Status request_embed_attachment_contain_block(Params* brpc_request, Closure* closure) {
+Status request_embed_attachment_contain_block(Params* brpc_request, Closure* closure) {
     auto block = brpc_request->block();
     Status st = request_embed_attachment(brpc_request, block.column_values(), closure);
     block.set_column_values("");
@@ -62,15 +62,15 @@ inline bool enable_http_send_block(
 }
 
 template <typename Closure>
-inline void transmit_block(PBackendService_Stub& stub, Closure* closure,
-                           const PTransmitDataParams& params) {
+void transmit_block(PBackendService_Stub& stub, Closure* closure,
+                    const PTransmitDataParams& params) {
     closure->cntl.http_request().Clear();
     stub.transmit_block(&closure->cntl, &params, &closure->result, closure);
 }
 
 template <typename Closure>
-inline Status transmit_block_http(RuntimeState* state, Closure* closure,
-                                  PTransmitDataParams& params, TNetworkAddress brpc_dest_addr) {
+Status transmit_block_http(RuntimeState* state, Closure* closure, PTransmitDataParams& params,
+                           TNetworkAddress brpc_dest_addr) {
     RETURN_IF_ERROR(request_embed_attachment_contain_block(&params, closure));
 
     //format an ipv6 address
@@ -92,8 +92,8 @@ inline Status transmit_block_http(RuntimeState* state, Closure* closure,
 // This can avoid reaching the upper limit of the ProtoBuf Request length (2G),
 // and it is expected that performance can be improved.
 template <typename Params, typename Closure>
-inline void request_row_batch_transfer_attachment(Params* brpc_request,
-                                                  const std::string& tuple_data, Closure* closure) {
+void request_row_batch_transfer_attachment(Params* brpc_request, const std::string& tuple_data,
+                                           Closure* closure) {
     auto row_batch = brpc_request->mutable_row_batch();
     row_batch->set_tuple_data("");
     brpc_request->set_transfer_by_attachment(true);
@@ -107,8 +107,8 @@ inline void request_row_batch_transfer_attachment(Params* brpc_request,
 // This can avoid reaching the upper limit of the ProtoBuf Request length (2G),
 // and it is expected that performance can be improved.
 template <typename Params, typename Closure>
-inline void request_block_transfer_attachment(Params* brpc_request,
-                                              const std::string& column_values, Closure* closure) {
+void request_block_transfer_attachment(Params* brpc_request, const std::string& column_values,
+                                       Closure* closure) {
     auto block = brpc_request->mutable_block();
     block->set_column_values("");
     brpc_request->set_transfer_by_attachment(true);
@@ -120,8 +120,7 @@ inline void request_block_transfer_attachment(Params* brpc_request,
 // TODO(zxy) delete in v1.3 version
 // Controller Attachment transferred to RowBatch in ProtoBuf Request.
 template <typename Params>
-inline void attachment_transfer_request_row_batch(const Params* brpc_request,
-                                                  brpc::Controller* cntl) {
+void attachment_transfer_request_row_batch(const Params* brpc_request, brpc::Controller* cntl) {
     Params* req = const_cast<Params*>(brpc_request);
     if (req->has_row_batch() && req->transfer_by_attachment()) {
         auto rb = req->mutable_row_batch();
@@ -134,7 +133,7 @@ inline void attachment_transfer_request_row_batch(const Params* brpc_request,
 // TODO(zxy) delete in v1.3 version
 // Controller Attachment transferred to Block in ProtoBuf Request.
 template <typename Params>
-inline void attachment_transfer_request_block(const Params* brpc_request, brpc::Controller* cntl) {
+void attachment_transfer_request_block(const Params* brpc_request, brpc::Controller* cntl) {
     Params* req = const_cast<Params*>(brpc_request);
     if (req->has_block() && req->transfer_by_attachment()) {
         auto block = req->mutable_block();
@@ -145,8 +144,7 @@ inline void attachment_transfer_request_block(const Params* brpc_request, brpc::
 }
 
 template <typename Params, typename Closure>
-inline Status request_embed_attachment(Params* brpc_request, const std::string& data,
-                                       Closure* closure) {
+Status request_embed_attachment(Params* brpc_request, const std::string& data, Closure* closure) {
     butil::IOBuf attachment;
 
     // step1: serialize brpc_request to string, and append to attachment.
@@ -177,16 +175,16 @@ inline Status request_embed_attachment(Params* brpc_request, const std::string&
 // Extract the brpc request and block from the controller attachment,
 // and put the block into the request.
 template <typename Params>
-inline Status attachment_extract_request_contain_block(const Params* brpc_request,
-                                                       brpc::Controller* cntl) {
+Status attachment_extract_request_contain_block(const Params* brpc_request,
+                                                brpc::Controller* cntl) {
     Params* req = const_cast<Params*>(brpc_request);
     auto block = req->mutable_block();
     return attachment_extract_request(req, cntl, block->mutable_column_values());
 }
 
 template <typename Params>
-inline Status attachment_extract_request(const Params* brpc_request, brpc::Controller* cntl,
-                                         std::string* data) {
+Status attachment_extract_request(const Params* brpc_request, brpc::Controller* cntl,
+                                  std::string* data) {
     const butil::IOBuf& io_buf = cntl->request_attachment();
 
     // step1: deserialize request string to brpc_request from attachment.
diff --git a/be/src/util/rle_encoding.h b/be/src/util/rle_encoding.h
index 1e83599265..21f8ee428e 100644
--- a/be/src/util/rle_encoding.h
+++ b/be/src/util/rle_encoding.h
@@ -224,7 +224,7 @@ private:
 };
 
 template <typename T>
-inline bool RleDecoder<T>::ReadHeader() {
+bool RleDecoder<T>::ReadHeader() {
     DCHECK(bit_reader_.is_initialized());
     if (PREDICT_FALSE(literal_count_ == 0 && repeat_count_ == 0)) {
         // Read the next run's indicator int, it could be a literal or repeated run
@@ -252,7 +252,7 @@ inline bool RleDecoder<T>::ReadHeader() {
 }
 
 template <typename T>
-inline bool RleDecoder<T>::Get(T* val) {
+bool RleDecoder<T>::Get(T* val) {
     DCHECK(bit_reader_.is_initialized());
     if (PREDICT_FALSE(!ReadHeader())) {
         return false;
@@ -274,7 +274,7 @@ inline bool RleDecoder<T>::Get(T* val) {
 }
 
 template <typename T>
-inline void RleDecoder<T>::RewindOne() {
+void RleDecoder<T>::RewindOne() {
     DCHECK(bit_reader_.is_initialized());
 
     switch (rewind_state_) {
@@ -295,7 +295,7 @@ inline void RleDecoder<T>::RewindOne() {
 }
 
 template <typename T>
-inline size_t RleDecoder<T>::GetNextRun(T* val, size_t max_run) {
+size_t RleDecoder<T>::GetNextRun(T* val, size_t max_run) {
     DCHECK(bit_reader_.is_initialized());
     DCHECK_GT(max_run, 0);
     size_t ret = 0;
@@ -343,7 +343,7 @@ inline size_t RleDecoder<T>::GetNextRun(T* val, size_t max_run) {
 }
 
 template <typename T>
-inline size_t RleDecoder<T>::get_values(T* values, size_t num_values) {
+size_t RleDecoder<T>::get_values(T* values, size_t num_values) {
     size_t read_num = 0;
     while (read_num < num_values) {
         size_t read_this_time = num_values - read_num;
@@ -373,7 +373,7 @@ inline size_t RleDecoder<T>::get_values(T* values, size_t num_values) {
 }
 
 template <typename T>
-inline size_t RleDecoder<T>::repeated_count() {
+size_t RleDecoder<T>::repeated_count() {
     if (repeat_count_ > 0) {
         return repeat_count_;
     }
@@ -384,14 +384,14 @@ inline size_t RleDecoder<T>::repeated_count() {
 }
 
 template <typename T>
-inline T RleDecoder<T>::get_repeated_value(size_t count) {
+T RleDecoder<T>::get_repeated_value(size_t count) {
     DCHECK_GE(repeat_count_, count);
     repeat_count_ -= count;
     return current_value_;
 }
 
 template <typename T>
-inline size_t RleDecoder<T>::Skip(size_t to_skip) {
+size_t RleDecoder<T>::Skip(size_t to_skip) {
     DCHECK(bit_reader_.is_initialized());
 
     size_t set_count = 0;
@@ -427,7 +427,7 @@ inline size_t RleDecoder<T>::Skip(size_t to_skip) {
 // This function buffers input values 8 at a time.  After seeing all 8 values,
 // it decides whether they should be encoded as a literal or repeated run.
 template <typename T>
-inline void RleEncoder<T>::Put(T value, size_t run_length) {
+void RleEncoder<T>::Put(T value, size_t run_length) {
     DCHECK(bit_width_ == 64 || value < (1LL << bit_width_));
 
     // TODO(perf): remove the loop and use the repeat_count_
@@ -460,7 +460,7 @@ inline void RleEncoder<T>::Put(T value, size_t run_length) {
 }
 
 template <typename T>
-inline void RleEncoder<T>::FlushLiteralRun(bool update_indicator_byte) {
+void RleEncoder<T>::FlushLiteralRun(bool update_indicator_byte) {
     if (literal_indicator_byte_idx_ < 0) {
         // The literal indicator byte has not been reserved yet, get one now.
         literal_indicator_byte_idx_ = bit_writer_.GetByteIndexAndAdvance(1);
@@ -488,7 +488,7 @@ inline void RleEncoder<T>::FlushLiteralRun(bool update_indicator_byte) {
 }
 
 template <typename T>
-inline void RleEncoder<T>::FlushRepeatedRun() {
+void RleEncoder<T>::FlushRepeatedRun() {
     DCHECK_GT(repeat_count_, 0);
     // The lsb of 0 indicates this is a repeated run
     int32_t indicator_value = repeat_count_ << 1 | 0;
@@ -501,7 +501,7 @@ inline void RleEncoder<T>::FlushRepeatedRun() {
 // Flush the values that have been buffered.  At this point we decide whether
 // we need to switch between the run types or continue the current one.
 template <typename T>
-inline void RleEncoder<T>::FlushBufferedValues(bool done) {
+void RleEncoder<T>::FlushBufferedValues(bool done) {
     if (repeat_count_ >= 8) {
         // Clear the buffered values.  They are part of the repeated run now and we
         // don't want to flush them out as literals.
@@ -531,14 +531,14 @@ inline void RleEncoder<T>::FlushBufferedValues(bool done) {
 }
 
 template <typename T>
-inline void RleEncoder<T>::Reserve(int num_bytes, uint8_t val) {
+void RleEncoder<T>::Reserve(int num_bytes, uint8_t val) {
     for (int i = 0; i < num_bytes; ++i) {
         bit_writer_.PutValue(val, 8);
     }
 }
 
 template <typename T>
-inline int RleEncoder<T>::Flush() {
+int RleEncoder<T>::Flush() {
     if (literal_count_ > 0 || repeat_count_ > 0 || num_buffered_values_ > 0) {
         bool all_repeat = literal_count_ == 0 &&
                           (repeat_count_ == num_buffered_values_ || num_buffered_values_ == 0);
@@ -559,7 +559,7 @@ inline int RleEncoder<T>::Flush() {
 }
 
 template <typename T>
-inline void RleEncoder<T>::Clear() {
+void RleEncoder<T>::Clear() {
     current_value_ = 0;
     repeat_count_ = 0;
     num_buffered_values_ = 0;
@@ -720,7 +720,7 @@ private:
 };
 
 template <typename T>
-inline int32_t RleBatchDecoder<T>::OutputBufferedLiterals(int32_t max_to_output, T* values) {
+int32_t RleBatchDecoder<T>::OutputBufferedLiterals(int32_t max_to_output, T* values) {
     int32_t num_to_output =
             std::min<int32_t>(max_to_output, num_buffered_literals_ - literal_buffer_pos_);
     memcpy(values, &literal_buffer_[literal_buffer_pos_], sizeof(T) * num_to_output);
@@ -730,7 +730,7 @@ inline int32_t RleBatchDecoder<T>::OutputBufferedLiterals(int32_t max_to_output,
 }
 
 template <typename T>
-inline void RleBatchDecoder<T>::Reset(uint8_t* buffer, int buffer_len, int bit_width) {
+void RleBatchDecoder<T>::Reset(uint8_t* buffer, int buffer_len, int bit_width) {
     bit_reader_.Reset(buffer, buffer_len);
     bit_width_ = bit_width;
     repeat_count_ = 0;
@@ -740,14 +740,14 @@ inline void RleBatchDecoder<T>::Reset(uint8_t* buffer, int buffer_len, int bit_w
 }
 
 template <typename T>
-inline int32_t RleBatchDecoder<T>::NextNumRepeats() {
+int32_t RleBatchDecoder<T>::NextNumRepeats() {
     if (repeat_count_ > 0) return repeat_count_;
     if (literal_count_ == 0) NextCounts();
     return repeat_count_;
 }
 
 template <typename T>
-inline void RleBatchDecoder<T>::NextCounts() {
+void RleBatchDecoder<T>::NextCounts() {
     // Read the next run's indicator int, it could be a literal or repeated run.
     // The int is encoded as a ULEB128-encoded value.
     uint32_t indicator_value = 0;
@@ -775,20 +775,20 @@ inline void RleBatchDecoder<T>::NextCounts() {
 }
 
 template <typename T>
-inline T RleBatchDecoder<T>::GetRepeatedValue(int32_t num_repeats_to_consume) {
+T RleBatchDecoder<T>::GetRepeatedValue(int32_t num_repeats_to_consume) {
     repeat_count_ -= num_repeats_to_consume;
     return repeated_value_;
 }
 
 template <typename T>
-inline int32_t RleBatchDecoder<T>::NextNumLiterals() {
+int32_t RleBatchDecoder<T>::NextNumLiterals() {
     if (literal_count_ > 0) return literal_count_;
     if (repeat_count_ == 0) NextCounts();
     return literal_count_;
 }
 
 template <typename T>
-inline bool RleBatchDecoder<T>::GetLiteralValues(int32_t num_literals_to_consume, T* values) {
+bool RleBatchDecoder<T>::GetLiteralValues(int32_t num_literals_to_consume, T* values) {
     int32_t num_consumed = 0;
     // Copy any buffered literals left over from previous calls.
     if (HaveBufferedLiterals()) {
@@ -820,7 +820,7 @@ inline bool RleBatchDecoder<T>::GetLiteralValues(int32_t num_literals_to_consume
 }
 
 template <typename T>
-inline bool RleBatchDecoder<T>::FillLiteralBuffer() {
+bool RleBatchDecoder<T>::FillLiteralBuffer() {
     int32_t num_to_buffer = std::min<int32_t>(LITERAL_BUFFER_LEN, literal_count_);
     num_buffered_literals_ = bit_reader_.UnpackBatch(bit_width_, num_to_buffer, literal_buffer_);
     // If we couldn't read the expected number, that means the input was truncated.
@@ -830,7 +830,7 @@ inline bool RleBatchDecoder<T>::FillLiteralBuffer() {
 }
 
 template <typename T>
-inline int32_t RleBatchDecoder<T>::GetBatch(T* values, int32_t batch_num) {
+int32_t RleBatchDecoder<T>::GetBatch(T* values, int32_t batch_num) {
     int32_t num_consumed = 0;
     while (num_consumed < batch_num) {
         // Add RLE encoded values by repeating the current value this number of times.
diff --git a/be/src/util/simd/bits.h b/be/src/util/simd/bits.h
index 4f4fe65414..03d876b971 100644
--- a/be/src/util/simd/bits.h
+++ b/be/src/util/simd/bits.h
@@ -101,7 +101,7 @@ inline size_t count_zero_num(const int8_t* __restrict data, const uint8_t* __res
 
 // TODO: compare with different SIMD implements
 template <class T>
-inline static size_t find_byte(const std::vector<T>& vec, size_t start, T byte) {
+static size_t find_byte(const std::vector<T>& vec, size_t start, T byte) {
     if (start >= vec.size()) {
         return start;
     }
@@ -113,7 +113,7 @@ inline static size_t find_byte(const std::vector<T>& vec, size_t start, T byte)
 }
 
 template <typename T>
-inline bool contain_byte(const T* __restrict data, const size_t length, const signed char byte) {
+bool contain_byte(const T* __restrict data, const size_t length, const signed char byte) {
     return nullptr != std::memchr(reinterpret_cast<const void*>(data), byte, length);
 }
 
diff --git a/be/src/util/string_parser.hpp b/be/src/util/string_parser.hpp
index 7136f6bb94..ff473bf401 100644
--- a/be/src/util/string_parser.hpp
+++ b/be/src/util/string_parser.hpp
@@ -227,7 +227,7 @@ private:
 }; // end of class StringParser
 
 template <typename T>
-inline T StringParser::string_to_int_internal(const char* s, int len, ParseResult* result) {
+T StringParser::string_to_int_internal(const char* s, int len, ParseResult* result) {
     if (UNLIKELY(len <= 0)) {
         *result = PARSE_FAILURE;
         return 0;
@@ -283,8 +283,7 @@ inline T StringParser::string_to_int_internal(const char* s, int len, ParseResul
 }
 
 template <typename T>
-inline T StringParser::string_to_unsigned_int_internal(const char* s, int len,
-                                                       ParseResult* result) {
+T StringParser::string_to_unsigned_int_internal(const char* s, int len, ParseResult* result) {
     if (UNLIKELY(len <= 0)) {
         *result = PARSE_FAILURE;
         return 0;
@@ -331,8 +330,7 @@ inline T StringParser::string_to_unsigned_int_internal(const char* s, int len,
 }
 
 template <typename T>
-inline T StringParser::string_to_int_internal(const char* s, int len, int base,
-                                              ParseResult* result) {
+T StringParser::string_to_int_internal(const char* s, int len, int base, ParseResult* result) {
     typedef typename std::make_unsigned<T>::type UnsignedT;
     UnsignedT val = 0;
     UnsignedT max_val = StringParser::numeric_limits<T>(false);
@@ -391,7 +389,7 @@ inline T StringParser::string_to_int_internal(const char* s, int len, int base,
 }
 
 template <typename T>
-inline T StringParser::string_to_int_no_overflow(const char* s, int len, ParseResult* result) {
+T StringParser::string_to_int_no_overflow(const char* s, int len, ParseResult* result) {
     T val = 0;
     if (UNLIKELY(len == 0)) {
         *result = PARSE_SUCCESS;
@@ -422,7 +420,7 @@ inline T StringParser::string_to_int_no_overflow(const char* s, int len, ParseRe
 }
 
 template <typename T>
-inline T StringParser::string_to_float_internal(const char* s, int len, ParseResult* result) {
+T StringParser::string_to_float_internal(const char* s, int len, ParseResult* result) {
     int i = 0;
     // skip leading spaces
     for (; i < len; ++i) {
@@ -548,8 +546,8 @@ inline int StringParser::StringParseTraits<__int128>::max_ascii_len() {
 }
 
 template <typename T>
-inline T StringParser::string_to_decimal(const char* s, int len, int type_precision, int type_scale,
-                                         ParseResult* result) {
+T StringParser::string_to_decimal(const char* s, int len, int type_precision, int type_scale,
+                                  ParseResult* result) {
     // Special cases:
     //   1) '' == Fail, an empty string fails to parse.
     //   2) '   #   ' == #, leading and trailing white space is ignored.
diff --git a/be/src/util/string_util.h b/be/src/util/string_util.h
index ac19448164..b0bfdbd7e9 100644
--- a/be/src/util/string_util.h
+++ b/be/src/util/string_util.h
@@ -79,7 +79,7 @@ inline std::vector<std::string> split(const std::string& s, const std::string& d
 }
 
 template <typename T>
-inline std::string join(const std::vector<T>& elems, const std::string& delim) {
+std::string join(const std::vector<T>& elems, const std::string& delim) {
     std::stringstream ss;
     for (size_t i = 0; i < elems.size(); ++i) {
         if (i != 0) {
@@ -131,14 +131,14 @@ using StringCaseUnorderedMap =
         std::unordered_map<std::string, T, StringCaseHasher, StringCaseEqual>;
 
 template <typename T>
-inline auto get_json_token(T& path_string) {
+auto get_json_token(T& path_string) {
     return boost::tokenizer<boost::escaped_list_separator<char>>(
             path_string, boost::escaped_list_separator<char>("\\", ".", "\""));
 }
 
 #ifdef USE_LIBCPP
 template <>
-inline auto get_json_token(std::string_view& path_string) = delete;
+auto get_json_token(std::string_view& path_string) = delete;
 #endif
 
 } // namespace doris
diff --git a/be/src/util/type_traits.h b/be/src/util/type_traits.h
index dafa20f2d0..9f41234d7e 100644
--- a/be/src/util/type_traits.h
+++ b/be/src/util/type_traits.h
@@ -29,12 +29,12 @@ template <template <class...> class Primary, class... Args>
 struct is_specialization_of<Primary<Args...>, Primary> : std::true_type {};
 
 template <class T, template <class...> class Primary>
-inline constexpr bool is_specialization_of_v = is_specialization_of<T, Primary>::value;
+constexpr bool is_specialization_of_v = is_specialization_of<T, Primary>::value;
 
 template <class T>
 using is_complex = is_specialization_of<T, std::complex>;
 
 template <class T>
-inline constexpr bool is_complex_v = is_specialization_of_v<T, std::complex>;
+constexpr bool is_complex_v = is_specialization_of_v<T, std::complex>;
 
 } // namespace doris
diff --git a/be/src/util/uid_util.h b/be/src/util/uid_util.h
index 7a310f3cf1..498a1db503 100644
--- a/be/src/util/uid_util.h
+++ b/be/src/util/uid_util.h
@@ -28,7 +28,7 @@ namespace doris {
 
 // convert int to a hex format string, buf must enough to hold converted hex string
 template <typename T>
-inline void to_hex(T val, char* buf) {
+void to_hex(T val, char* buf) {
     static const char* digits = "0123456789abcdef";
     for (int i = 0; i < 2 * sizeof(T); ++i) {
         buf[2 * sizeof(T) - 1 - i] = digits[val & 0x0F];
@@ -37,7 +37,7 @@ inline void to_hex(T val, char* buf) {
 }
 
 template <typename T>
-inline void from_hex(T* ret, const std::string& buf) {
+void from_hex(T* ret, const std::string& buf) {
     T val = 0;
     for (int i = 0; i < buf.length(); ++i) {
         int buf_val = 0;
diff --git a/be/src/vec/aggregate_functions/aggregate_function_bitmap.cpp b/be/src/vec/aggregate_functions/aggregate_function_bitmap.cpp
index e2dd7e309d..546dbc56fa 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_bitmap.cpp
+++ b/be/src/vec/aggregate_functions/aggregate_function_bitmap.cpp
@@ -23,7 +23,7 @@
 namespace doris::vectorized {
 
 template <bool nullable, template <bool, typename> class AggregateFunctionTemplate>
-static IAggregateFunction* create_with_int_data_type(const DataTypes& argument_type) {
+IAggregateFunction* create_with_int_data_type(const DataTypes& argument_type) {
     auto type = remove_nullable(argument_type[0]);
     WhichDataType which(type);
 #define DISPATCH(TYPE)                                                                     \
diff --git a/be/src/vec/aggregate_functions/aggregate_function_min_max.cpp b/be/src/vec/aggregate_functions/aggregate_function_min_max.cpp
index 46606142b2..3f3b7dc727 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_min_max.cpp
+++ b/be/src/vec/aggregate_functions/aggregate_function_min_max.cpp
@@ -27,9 +27,9 @@
 namespace doris::vectorized {
 /// min, max, any
 template <template <typename> class AggregateFunctionTemplate, template <typename> class Data>
-static IAggregateFunction* create_aggregate_function_single_value(const String& name,
-                                                                  const DataTypes& argument_types,
-                                                                  const bool result_is_nullable) {
+IAggregateFunction* create_aggregate_function_single_value(const String& name,
+                                                           const DataTypes& argument_types,
+                                                           const bool result_is_nullable) {
     assert_unary(name, argument_types);
 
     IAggregateFunction* res(creator_with_numeric_type::create<AggregateFunctionTemplate, Data,
diff --git a/be/src/vec/aggregate_functions/aggregate_function_min_max_by.cpp b/be/src/vec/aggregate_functions/aggregate_function_min_max_by.cpp
index 2252da7721..1526975b9e 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_min_max_by.cpp
+++ b/be/src/vec/aggregate_functions/aggregate_function_min_max_by.cpp
@@ -28,8 +28,8 @@ namespace doris::vectorized {
 /// min_by, max_by
 template <template <typename> class AggregateFunctionTemplate,
           template <typename, typename> class Data, typename VT>
-static IAggregateFunction* create_aggregate_function_min_max_by_impl(
-        const DataTypes& argument_types, const bool result_is_nullable) {
+IAggregateFunction* create_aggregate_function_min_max_by_impl(const DataTypes& argument_types,
+                                                              const bool result_is_nullable) {
     WhichDataType which(remove_nullable(argument_types[1]));
 
 #define DISPATCH(TYPE)                                                            \
@@ -74,9 +74,9 @@ static IAggregateFunction* create_aggregate_function_min_max_by_impl(
 /// min_by, max_by
 template <template <typename> class AggregateFunctionTemplate,
           template <typename, typename> class Data>
-static IAggregateFunction* create_aggregate_function_min_max_by(const String& name,
-                                                                const DataTypes& argument_types,
-                                                                const bool result_is_nullable) {
+IAggregateFunction* create_aggregate_function_min_max_by(const String& name,
+                                                         const DataTypes& argument_types,
+                                                         const bool result_is_nullable) {
     assert_binary(name, argument_types);
 
     WhichDataType which(remove_nullable(argument_types[0]));
diff --git a/be/src/vec/aggregate_functions/aggregate_function_stddev.cpp b/be/src/vec/aggregate_functions/aggregate_function_stddev.cpp
index d549ad2ed0..9eca714d24 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_stddev.cpp
+++ b/be/src/vec/aggregate_functions/aggregate_function_stddev.cpp
@@ -26,10 +26,10 @@ namespace doris::vectorized {
 template <template <typename, bool> class AggregateFunctionTemplate,
           template <typename> class NameData, template <typename, typename> class Data,
           bool is_stddev, bool is_nullable = false>
-static IAggregateFunction* create_function_single_value(const String& name,
-                                                        const DataTypes& argument_types,
-                                                        const bool result_is_nullable,
-                                                        bool custom_nullable) {
+IAggregateFunction* create_function_single_value(const String& name,
+                                                 const DataTypes& argument_types,
+                                                 const bool result_is_nullable,
+                                                 bool custom_nullable) {
     IAggregateFunction* res = nullptr;
     WhichDataType which(remove_nullable(argument_types[0]));
 #define DISPATCH(TYPE)                                                          \
diff --git a/be/src/vec/aggregate_functions/aggregate_function_window.cpp b/be/src/vec/aggregate_functions/aggregate_function_window.cpp
index 97c8d18565..4ef03fb316 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_window.cpp
+++ b/be/src/vec/aggregate_functions/aggregate_function_window.cpp
@@ -59,8 +59,8 @@ AggregateFunctionPtr create_aggregate_function_ntile(const std::string& name,
 template <template <typename> class AggregateFunctionTemplate,
           template <typename ColVecType, bool, bool> class Data, template <typename> class Impl,
           bool result_is_nullable, bool arg_is_nullable>
-static IAggregateFunction* create_function_lead_lag_first_last(const String& name,
-                                                               const DataTypes& argument_types) {
+IAggregateFunction* create_function_lead_lag_first_last(const String& name,
+                                                        const DataTypes& argument_types) {
     auto type = remove_nullable(argument_types[0]);
     WhichDataType which(*type);
 
diff --git a/be/src/vec/aggregate_functions/factory_helpers.h b/be/src/vec/aggregate_functions/factory_helpers.h
index 76958d9bbf..0bbedce05a 100644
--- a/be/src/vec/aggregate_functions/factory_helpers.h
+++ b/be/src/vec/aggregate_functions/factory_helpers.h
@@ -37,7 +37,7 @@ inline void assert_binary(const std::string& name, const DataTypes& argument_typ
 }
 
 template <std::size_t maximal_arity>
-inline void assert_arity_at_most(const std::string& name, const DataTypes& argument_types) {
+void assert_arity_at_most(const std::string& name, const DataTypes& argument_types) {
     if (argument_types.size() <= maximal_arity) {
         return;
     }
diff --git a/be/src/vec/common/aggregation_common.h b/be/src/vec/common/aggregation_common.h
index ee3ef5ce5b..39beb8b25f 100644
--- a/be/src/vec/common/aggregation_common.h
+++ b/be/src/vec/common/aggregation_common.h
@@ -72,10 +72,9 @@ using KeysNullMap = std::array<UInt8, get_bitmap_size<T>()>;
 /// Pack into a binary blob of type T a set of fixed-size keys. Granted that all the keys fit into the
 /// binary blob, they are disposed in it consecutively.
 template <typename T, bool has_low_cardinality = false>
-static inline T ALWAYS_INLINE
-pack_fixed(size_t i, size_t keys_size, const ColumnRawPtrs& key_columns, const Sizes& key_sizes,
-           const ColumnRawPtrs* low_cardinality_positions [[maybe_unused]] = nullptr,
-           const Sizes* low_cardinality_sizes [[maybe_unused]] = nullptr) {
+T pack_fixed(size_t i, size_t keys_size, const ColumnRawPtrs& key_columns, const Sizes& key_sizes,
+             const ColumnRawPtrs* low_cardinality_positions [[maybe_unused]] = nullptr,
+             const Sizes* low_cardinality_sizes [[maybe_unused]] = nullptr) {
     union {
         T key;
         char bytes[sizeof(key)] = {};
@@ -149,9 +148,8 @@ pack_fixed(size_t i, size_t keys_size, const ColumnRawPtrs& key_columns, const S
 
 /// Similar as above but supports nullable values.
 template <typename T>
-static inline T ALWAYS_INLINE pack_fixed(size_t i, size_t keys_size,
-                                         const ColumnRawPtrs& key_columns, const Sizes& key_sizes,
-                                         const KeysNullMap<T>& bitmap) {
+T pack_fixed(size_t i, size_t keys_size, const ColumnRawPtrs& key_columns, const Sizes& key_sizes,
+             const KeysNullMap<T>& bitmap) {
     union {
         T key;
         char bytes[sizeof(key)] = {};
@@ -222,8 +220,7 @@ static inline T ALWAYS_INLINE pack_fixed(size_t i, size_t keys_size,
 }
 
 /// Hash a set of keys into a UInt128 value.
-static inline UInt128 ALWAYS_INLINE hash128(size_t i, size_t keys_size,
-                                            const ColumnRawPtrs& key_columns) {
+inline UInt128 hash128(size_t i, size_t keys_size, const ColumnRawPtrs& key_columns) {
     UInt128 key;
     SipHash hash;
 
@@ -235,8 +232,7 @@ static inline UInt128 ALWAYS_INLINE hash128(size_t i, size_t keys_size,
 }
 
 /// Copy keys to the pool. Then put into pool StringRefs to them and return the pointer to the first.
-static inline StringRef* ALWAYS_INLINE place_keys_in_pool(size_t keys_size, StringRefs& keys,
-                                                          Arena& pool) {
+inline StringRef* place_keys_in_pool(size_t keys_size, StringRefs& keys, Arena& pool) {
     for (size_t j = 0; j < keys_size; ++j) {
         char* place = pool.alloc(keys[j].size);
         memcpy_small_allow_read_write_overflow15(place, keys[j].data, keys[j].size);
@@ -252,8 +248,8 @@ static inline StringRef* ALWAYS_INLINE place_keys_in_pool(size_t keys_size, Stri
 
 /** Serialize keys into a continuous chunk of memory.
   */
-static inline StringRef ALWAYS_INLINE serialize_keys_to_pool_contiguous(
-        size_t i, size_t keys_size, const ColumnRawPtrs& key_columns, Arena& pool) {
+inline StringRef serialize_keys_to_pool_contiguous(size_t i, size_t keys_size,
+                                                   const ColumnRawPtrs& key_columns, Arena& pool) {
     const char* begin = nullptr;
 
     size_t sum_size = 0;
diff --git a/be/src/vec/common/bit_helpers.h b/be/src/vec/common/bit_helpers.h
index c2c480637a..640173f61d 100644
--- a/be/src/vec/common/bit_helpers.h
+++ b/be/src/vec/common/bit_helpers.h
@@ -49,7 +49,7 @@ inline size_t round_up_to_power_of_two_or_zero(size_t n) {
 }
 
 template <typename T>
-inline size_t get_leading_zero_bits(T x) {
+size_t get_leading_zero_bits(T x) {
     if (!x) return sizeof(x) * 8;
 
     if constexpr (sizeof(T) <= sizeof(unsigned int)) {
@@ -62,7 +62,7 @@ inline size_t get_leading_zero_bits(T x) {
 }
 
 template <typename T>
-inline size_t get_trailing_zero_bits(T x) {
+size_t get_trailing_zero_bits(T x) {
     if (!x) return sizeof(x) * 8;
 
     if constexpr (sizeof(T) <= sizeof(unsigned int)) {
@@ -78,7 +78,7 @@ inline size_t get_trailing_zero_bits(T x) {
  * mask_low_bits<UInt8>(3) => 00000111
  */
 template <typename T>
-inline T mask_low_bits(unsigned char bits) {
+T mask_low_bits(unsigned char bits) {
     if (bits == 0) {
         return 0;
     }
diff --git a/be/src/vec/common/hash_table/hash_table_key_holder.h b/be/src/vec/common/hash_table/hash_table_key_holder.h
index a422ad7eef..b3e317286e 100644
--- a/be/src/vec/common/hash_table/hash_table_key_holder.h
+++ b/be/src/vec/common/hash_table/hash_table_key_holder.h
@@ -69,7 +69,7 @@
   * After the call to key_holder_persist_key(), must return the persistent key.
   */
 template <typename Key>
-inline Key& ALWAYS_INLINE key_holder_get_key(Key&& key) {
+Key& key_holder_get_key(Key&& key) {
     return key;
 }
 
@@ -78,13 +78,13 @@ inline Key& ALWAYS_INLINE key_holder_get_key(Key&& key) {
   * after this call.
   */
 template <typename Key>
-inline void ALWAYS_INLINE key_holder_persist_key(Key&&) {}
+void key_holder_persist_key(Key&&) {}
 
 /**
   * Discard the key. Calling key_holder_get_key() is ill-defined after this.
   */
 template <typename Key>
-inline void ALWAYS_INLINE key_holder_discard_key(Key&&) {}
+void key_holder_discard_key(Key&&) {}
 
 namespace doris::vectorized {
 
diff --git a/be/src/vec/common/hex.h b/be/src/vec/common/hex.h
index 6d2d72bb42..b84aabad21 100644
--- a/be/src/vec/common/hex.h
+++ b/be/src/vec/common/hex.h
@@ -61,7 +61,7 @@ inline void write_bin_byte(UInt8 byte, void* out) {
 
 /// Produces hex representation of an unsigned int with leading zeros (for checksums)
 template <typename TUInt>
-inline void write_hex_uint_impl(TUInt uint_, char* out, const char* const table) {
+void write_hex_uint_impl(TUInt uint_, char* out, const char* const table) {
     union {
         TUInt value;
         UInt8 uint8[sizeof(TUInt)];
@@ -76,12 +76,12 @@ inline void write_hex_uint_impl(TUInt uint_, char* out, const char* const table)
 }
 
 template <typename TUInt>
-inline void write_hex_uint_uppercase(TUInt uint_, char* out) {
+void write_hex_uint_uppercase(TUInt uint_, char* out) {
     write_hex_uint_impl(uint_, out, hex_byte_to_char_uppercase_table);
 }
 
 template <typename TUInt>
-inline void write_hex_uint_lowercase(TUInt uint_, char* out) {
+void write_hex_uint_lowercase(TUInt uint_, char* out) {
     write_hex_uint_impl(uint_, out, hex_byte_to_char_lowercase_table);
 }
 
diff --git a/be/src/vec/common/memcmp_small.h b/be/src/vec/common/memcmp_small.h
index 3d43652a5b..4c04c7c532 100644
--- a/be/src/vec/common/memcmp_small.h
+++ b/be/src/vec/common/memcmp_small.h
@@ -26,7 +26,7 @@
 namespace detail {
 
 template <typename T>
-inline int cmp(T a, T b) {
+int cmp(T a, T b) {
     if (a < b) return -1;
     if (a > b) return 1;
     return 0;
@@ -53,8 +53,7 @@ inline int cmp(T a, T b) {
 /** Variant when memory regions may have different sizes.
   */
 template <typename Char>
-inline int memcmp_small_allow_overflow15(const Char* a, size_t a_size, const Char* b,
-                                         size_t b_size) {
+int memcmp_small_allow_overflow15(const Char* a, size_t a_size, const Char* b, size_t b_size) {
     size_t min_size = std::min(a_size, b_size);
 
     for (size_t offset = 0; offset < min_size; offset += 16) {
@@ -79,7 +78,7 @@ inline int memcmp_small_allow_overflow15(const Char* a, size_t a_size, const Cha
   * TODO Check if the compiler can optimize previous function when the caller pass identical sizes.
   */
 template <typename Char>
-inline int memcmp_small_allow_overflow15(const Char* a, const Char* b, size_t size) {
+int memcmp_small_allow_overflow15(const Char* a, const Char* b, size_t size) {
     for (size_t offset = 0; offset < size; offset += 16) {
         uint16_t mask = _mm_movemask_epi8(
                 _mm_cmpeq_epi8(_mm_loadu_si128(reinterpret_cast<const __m128i*>(a + offset)),
@@ -101,8 +100,7 @@ inline int memcmp_small_allow_overflow15(const Char* a, const Char* b, size_t si
 /** Compare memory regions for equality.
   */
 template <typename Char>
-inline bool memequal_small_allow_overflow15(const Char* a, size_t a_size, const Char* b,
-                                            size_t b_size) {
+bool memequal_small_allow_overflow15(const Char* a, size_t a_size, const Char* b, size_t b_size) {
     if (a_size != b_size) return false;
 
     for (size_t offset = 0; offset < a_size; offset += 16) {
@@ -123,7 +121,7 @@ inline bool memequal_small_allow_overflow15(const Char* a, size_t a_size, const
 /** Variant when the caller know in advance that the size is a multiple of 16.
   */
 template <typename Char>
-inline int memcmp_small_multiple_of16(const Char* a, const Char* b, size_t size) {
+int memcmp_small_multiple_of16(const Char* a, const Char* b, size_t size) {
     for (size_t offset = 0; offset < size; offset += 16) {
         uint16_t mask = _mm_movemask_epi8(
                 _mm_cmpeq_epi8(_mm_loadu_si128(reinterpret_cast<const __m128i*>(a + offset)),
@@ -142,7 +140,7 @@ inline int memcmp_small_multiple_of16(const Char* a, const Char* b, size_t size)
 /** Variant when the size is 16 exactly.
   */
 template <typename Char>
-inline int memcmp16(const Char* a, const Char* b) {
+int memcmp16(const Char* a, const Char* b) {
     uint16_t mask =
             _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_loadu_si128(reinterpret_cast<const __m128i*>(a)),
                                              _mm_loadu_si128(reinterpret_cast<const __m128i*>(b))));
@@ -188,8 +186,7 @@ inline bool memory_is_zero_small_allow_overflow15(const void* data, size_t size)
 #include <cstring>
 
 template <typename Char>
-inline int memcmp_small_allow_overflow15(const Char* a, size_t a_size, const Char* b,
-                                         size_t b_size) {
+int memcmp_small_allow_overflow15(const Char* a, size_t a_size, const Char* b, size_t b_size) {
     if (auto res = memcmp(a, b, std::min(a_size, b_size)))
         return res;
     else
@@ -197,23 +194,22 @@ inline int memcmp_small_allow_overflow15(const Char* a, size_t a_size, const Cha
 }
 
 template <typename Char>
-inline int memcmp_small_allow_overflow15(const Char* a, const Char* b, size_t size) {
+int memcmp_small_allow_overflow15(const Char* a, const Char* b, size_t size) {
     return memcmp(a, b, size);
 }
 
 template <typename Char>
-inline bool memequal_small_allow_overflow15(const Char* a, size_t a_size, const Char* b,
-                                            size_t b_size) {
+bool memequal_small_allow_overflow15(const Char* a, size_t a_size, const Char* b, size_t b_size) {
     return a_size == b_size && 0 == memcmp(a, b, a_size);
 }
 
 template <typename Char>
-inline int memcmp_small_multiple_of16(const Char* a, const Char* b, size_t size) {
+int memcmp_small_multiple_of16(const Char* a, const Char* b, size_t size) {
     return memcmp(a, b, size);
 }
 
 template <typename Char>
-inline int memcmp16(const Char* a, const Char* b) {
+int memcmp16(const Char* a, const Char* b) {
     return memcmp(a, b, 16);
 }
 
diff --git a/be/src/vec/common/nan_utils.h b/be/src/vec/common/nan_utils.h
index 9a4e5989e2..8cdf8d78a9 100644
--- a/be/src/vec/common/nan_utils.h
+++ b/be/src/vec/common/nan_utils.h
@@ -26,22 +26,22 @@
 
 /// To be sure, that this function is zero-cost for non-floating point types.
 template <typename T>
-inline std::enable_if_t<std::is_floating_point_v<T>, bool> is_nan(T x) {
+std::enable_if_t<std::is_floating_point_v<T>, bool> is_nan(T x) {
     return std::isnan(x);
 }
 
 template <typename T>
-inline std::enable_if_t<!std::is_floating_point_v<T>, bool> is_nan(T) {
+std::enable_if_t<!std::is_floating_point_v<T>, bool> is_nan(T) {
     return false;
 }
 
 template <typename T>
-inline std::enable_if_t<std::is_floating_point_v<T>, bool> is_finite(T x) {
+std::enable_if_t<std::is_floating_point_v<T>, bool> is_finite(T x) {
     return std::isfinite(x);
 }
 
 template <typename T>
-inline std::enable_if_t<!std::is_floating_point_v<T>, bool> is_finite(T) {
+std::enable_if_t<!std::is_floating_point_v<T>, bool> is_finite(T) {
     return true;
 }
 
diff --git a/be/src/vec/common/unaligned.h b/be/src/vec/common/unaligned.h
index 11b18535ce..d56eca59b2 100644
--- a/be/src/vec/common/unaligned.h
+++ b/be/src/vec/common/unaligned.h
@@ -25,7 +25,7 @@
 #include <type_traits>
 
 template <typename T>
-inline T unaligned_load(const void* address) {
+T unaligned_load(const void* address) {
     T res {};
     memcpy(&res, address, sizeof(res));
     return res;
@@ -36,7 +36,7 @@ inline T unaligned_load(const void* address) {
 /// To prevent this, make the caller specify the stored type explicitly.
 /// To disable deduction of T, wrap the argument type with std::enable_if.
 template <typename T>
-inline void unaligned_store(void* address, const typename std::enable_if<true, T>::type& src) {
+void unaligned_store(void* address, const typename std::enable_if<true, T>::type& src) {
     static_assert(std::is_trivially_copyable_v<T>);
     memcpy(address, &src, sizeof(src));
 }
diff --git a/be/src/vec/common/volnitsky.h b/be/src/vec/common/volnitsky.h
index 08413a45f9..91daeffc83 100644
--- a/be/src/vec/common/volnitsky.h
+++ b/be/src/vec/common/volnitsky.h
@@ -82,8 +82,7 @@ static inline Ngram toNGram(const UInt8* const pos) {
 }
 
 template <typename Callback>
-static inline bool putNGramASCIICaseInsensitive(const UInt8* pos, int offset,
-                                                Callback&& putNGramBase) {
+bool putNGramASCIICaseInsensitive(const UInt8* pos, int offset, Callback&& putNGramBase) {
     struct Chars {
         UInt8 c0;
         UInt8 c1;
@@ -126,8 +125,8 @@ static inline bool putNGramASCIICaseInsensitive(const UInt8* pos, int offset,
 }
 
 template <bool CaseSensitive, bool ASCII, typename Callback>
-static inline bool putNGram(const UInt8* pos, int offset, [[maybe_unused]] const UInt8* begin,
-                            size_t size, Callback&& putNGramBase) {
+bool putNGram(const UInt8* pos, int offset, [[maybe_unused]] const UInt8* begin, size_t size,
+              Callback&& putNGramBase) {
     if constexpr (CaseSensitive) {
         putNGramBase(toNGram(pos), offset);
         return true;
diff --git a/be/src/vec/core/call_on_type_index.h b/be/src/vec/core/call_on_type_index.h
index ff4bb9f693..88e8fca5bf 100644
--- a/be/src/vec/core/call_on_type_index.h
+++ b/be/src/vec/core/call_on_type_index.h
@@ -92,7 +92,7 @@ bool call_on_basic_type(TypeIndex number, F&& f) {
 
 /// Unroll template using TypeIndex
 template <bool _int, bool _float, bool _decimal, bool _datetime, typename F>
-inline bool call_on_basic_types(TypeIndex type_num1, TypeIndex type_num2, F&& f) {
+bool call_on_basic_types(TypeIndex type_num1, TypeIndex type_num2, F&& f) {
     if constexpr (_int) {
         switch (type_num1) {
         case TypeIndex::UInt8:
diff --git a/be/src/vec/core/field.cpp b/be/src/vec/core/field.cpp
index fb41677193..ca0e783064 100644
--- a/be/src/vec/core/field.cpp
+++ b/be/src/vec/core/field.cpp
@@ -134,19 +134,19 @@ Decimal128I DecimalField<Decimal128I>::get_scale_multiplier() const {
 }
 
 template <typename T>
-static bool dec_equal(T x, T y, UInt32 x_scale, UInt32 y_scale) {
+bool dec_equal(T x, T y, UInt32 x_scale, UInt32 y_scale) {
     using Comparator = DecimalComparison<T, T, EqualsOp>;
     return Comparator::compare(x, y, x_scale, y_scale);
 }
 
 template <typename T>
-static bool dec_less(T x, T y, UInt32 x_scale, UInt32 y_scale) {
+bool dec_less(T x, T y, UInt32 x_scale, UInt32 y_scale) {
     using Comparator = DecimalComparison<T, T, LessOp>;
     return Comparator::compare(x, y, x_scale, y_scale);
 }
 
 template <typename T>
-static bool dec_less_or_equal(T x, T y, UInt32 x_scale, UInt32 y_scale) {
+bool dec_less_or_equal(T x, T y, UInt32 x_scale, UInt32 y_scale) {
     using Comparator = DecimalComparison<T, T, LessOrEqualsOp>;
     return Comparator::compare(x, y, x_scale, y_scale);
 }
diff --git a/be/src/vec/data_types/data_type.h b/be/src/vec/data_types/data_type.h
index 76dfd3bd5c..e646d4d736 100644
--- a/be/src/vec/data_types/data_type.h
+++ b/be/src/vec/data_types/data_type.h
@@ -368,58 +368,58 @@ inline bool is_nothing(const DataTypePtr& data_type) {
 }
 
 template <typename T>
-inline bool is_uint8(const T& data_type) {
+bool is_uint8(const T& data_type) {
     return WhichDataType(data_type).is_uint8();
 }
 
 template <typename T>
-inline bool is_unsigned_integer(const T& data_type) {
+bool is_unsigned_integer(const T& data_type) {
     return WhichDataType(data_type).is_uint();
 }
 
 template <typename T>
-inline bool is_integer(const T& data_type) {
+bool is_integer(const T& data_type) {
     WhichDataType which(data_type);
     return which.is_int() || which.is_uint();
 }
 
 template <typename T>
-inline bool is_float(const T& data_type) {
+bool is_float(const T& data_type) {
     WhichDataType which(data_type);
     return which.is_float();
 }
 
 template <typename T>
-inline bool is_native_number(const T& data_type) {
+bool is_native_number(const T& data_type) {
     WhichDataType which(data_type);
     return which.is_native_int() || which.is_native_uint() || which.is_float();
 }
 
 template <typename T>
-inline bool is_number(const T& data_type) {
+bool is_number(const T& data_type) {
     WhichDataType which(data_type);
     return which.is_int() || which.is_uint() || which.is_float() || which.is_decimal();
 }
 
 template <typename T>
-inline bool is_columned_as_number(const T& data_type) {
+bool is_columned_as_number(const T& data_type) {
     WhichDataType which(data_type);
     return which.is_int() || which.is_uint() || which.is_float() || which.is_date_or_datetime() ||
            which.is_uuid() || which.is_date_v2_or_datetime_v2();
 }
 
 template <typename T>
-inline bool is_string(const T& data_type) {
+bool is_string(const T& data_type) {
     return WhichDataType(data_type).is_string();
 }
 
 template <typename T>
-inline bool is_fixed_string(const T& data_type) {
+bool is_fixed_string(const T& data_type) {
     return WhichDataType(data_type).is_fixed_string();
 }
 
 template <typename T>
-inline bool is_string_or_fixed_string(const T& data_type) {
+bool is_string_or_fixed_string(const T& data_type) {
     return WhichDataType(data_type).is_string_or_fixed_string();
 }
 
diff --git a/be/src/vec/data_types/data_type_decimal.h b/be/src/vec/data_types/data_type_decimal.h
index 5641b9b255..c330d0f386 100644
--- a/be/src/vec/data_types/data_type_decimal.h
+++ b/be/src/vec/data_types/data_type_decimal.h
@@ -30,11 +30,11 @@
 
 namespace doris::vectorized {
 
-static constexpr size_t min_decimal_precision() {
+constexpr size_t min_decimal_precision() {
     return 1;
 }
 template <typename T>
-static constexpr size_t max_decimal_precision() {
+constexpr size_t max_decimal_precision() {
     return 0;
 }
 template <>
@@ -55,7 +55,7 @@ constexpr size_t max_decimal_precision<Decimal128I>() {
 }
 
 template <typename T>
-static constexpr typename T::NativeType max_decimal_value() {
+constexpr typename T::NativeType max_decimal_value() {
     return 0;
 }
 template <>
@@ -251,7 +251,7 @@ DataTypePtr decimal_result_type(const DataTypeDecimal<T>& tx, const DataTypeDeci
 }
 
 template <typename T>
-inline const DataTypeDecimal<T>* check_decimal(const IDataType& data_type) {
+const DataTypeDecimal<T>* check_decimal(const IDataType& data_type) {
     return typeid_cast<const DataTypeDecimal<T>*>(&data_type);
 }
 
@@ -292,8 +292,8 @@ constexpr bool IsDataTypeDecimalOrNumber =
         IsDataTypeDecimal<DataType> || IsDataTypeNumber<DataType>;
 
 template <typename FromDataType, typename ToDataType>
-inline std::enable_if_t<IsDataTypeDecimal<FromDataType> && IsDataTypeDecimal<ToDataType>,
-                        typename ToDataType::FieldType>
+std::enable_if_t<IsDataTypeDecimal<FromDataType> && IsDataTypeDecimal<ToDataType>,
+                 typename ToDataType::FieldType>
 convert_decimals(const typename FromDataType::FieldType& value, UInt32 scale_from, UInt32 scale_to,
                  UInt8* overflow_flag = nullptr) {
     using FromFieldType = typename FromDataType::FieldType;
@@ -347,8 +347,8 @@ convert_decimals(const typename FromDataType::FieldType& value, UInt32 scale_fro
 }
 
 template <typename FromDataType, typename ToDataType>
-inline std::enable_if_t<IsDataTypeDecimal<FromDataType> && IsDataTypeNumber<ToDataType>,
-                        typename ToDataType::FieldType>
+std::enable_if_t<IsDataTypeDecimal<FromDataType> && IsDataTypeNumber<ToDataType>,
+                 typename ToDataType::FieldType>
 convert_from_decimal(const typename FromDataType::FieldType& value, UInt32 scale) {
     using FromFieldType = typename FromDataType::FieldType;
     using ToFieldType = typename ToDataType::FieldType;
@@ -391,8 +391,8 @@ convert_from_decimal(const typename FromDataType::FieldType& value, UInt32 scale
 }
 
 template <typename FromDataType, typename ToDataType>
-inline std::enable_if_t<IsDataTypeNumber<FromDataType> && IsDataTypeDecimal<ToDataType>,
-                        typename ToDataType::FieldType>
+std::enable_if_t<IsDataTypeNumber<FromDataType> && IsDataTypeDecimal<ToDataType>,
+                 typename ToDataType::FieldType>
 convert_to_decimal(const typename FromDataType::FieldType& value, UInt32 scale,
                    UInt8* overflow_flag) {
     using FromFieldType = typename FromDataType::FieldType;
diff --git a/be/src/vec/data_types/data_type_struct.cpp b/be/src/vec/data_types/data_type_struct.cpp
index 81bf774c12..80531af7ad 100644
--- a/be/src/vec/data_types/data_type_struct.cpp
+++ b/be/src/vec/data_types/data_type_struct.cpp
@@ -303,7 +303,7 @@ static inline IColumn& extract_element_column(IColumn& column, size_t idx) {
 }
 
 template <typename F>
-static void add_element_safe(const DataTypes& elems, IColumn& column, F&& impl) {
+void add_element_safe(const DataTypes& elems, IColumn& column, F&& impl) {
     /// We use the assumption that tuples of zero size do not exist.
     size_t old_size = column.size();
 
diff --git a/be/src/vec/exec/format/orc/vorc_reader.cpp b/be/src/vec/exec/format/orc/vorc_reader.cpp
index 6df70e0f16..df1d4ee1e3 100644
--- a/be/src/vec/exec/format/orc/vorc_reader.cpp
+++ b/be/src/vec/exec/format/orc/vorc_reader.cpp
@@ -277,9 +277,8 @@ static std::unordered_map<orc::TypeKind, orc::PredicateDataType> TYPEKIND_TO_PRE
         {orc::TypeKind::BOOLEAN, orc::PredicateDataType::BOOLEAN}};
 
 template <typename CppType>
-static std::tuple<bool, orc::Literal> convert_to_orc_literal(const orc::Type* type,
-                                                             const void* value, int precision,
-                                                             int scale) {
+std::tuple<bool, orc::Literal> convert_to_orc_literal(const orc::Type* type, const void* value,
+                                                      int precision, int scale) {
     try {
         switch (type->getKind()) {
         case orc::TypeKind::BOOLEAN:
@@ -375,7 +374,7 @@ static std::tuple<bool, orc::Literal> convert_to_orc_literal(const orc::Type* ty
 }
 
 template <PrimitiveType primitive_type>
-static std::vector<OrcPredicate> value_range_to_predicate(
+std::vector<OrcPredicate> value_range_to_predicate(
         const ColumnValueRange<primitive_type>& col_val_range, const orc::Type* type) {
     using CppType = typename PrimitiveTypeTraits<primitive_type>::CppType;
     std::vector<OrcPredicate> predicates;
diff --git a/be/src/vec/functions/function_encryption.cpp b/be/src/vec/functions/function_encryption.cpp
index 339850f61d..e0d9edfce1 100644
--- a/be/src/vec/functions/function_encryption.cpp
+++ b/be/src/vec/functions/function_encryption.cpp
@@ -116,11 +116,11 @@ public:
 };
 
 template <typename Impl, bool is_encrypt>
-static void exectue_result(std::vector<const ColumnString::Offsets*>& offsets_list,
-                           std::vector<const ColumnString::Chars*>& chars_list, size_t i,
-                           EncryptionMode& encryption_mode, const char* iv_raw, int iv_length,
-                           ColumnString::Chars& result_data, ColumnString::Offsets& result_offset,
-                           NullMap& null_map) {
+void exectue_result(std::vector<const ColumnString::Offsets*>& offsets_list,
+                    std::vector<const ColumnString::Chars*>& chars_list, size_t i,
+                    EncryptionMode& encryption_mode, const char* iv_raw, int iv_length,
+                    ColumnString::Chars& result_data, ColumnString::Offsets& result_offset,
+                    NullMap& null_map) {
     int src_size = (*offsets_list[0])[i] - (*offsets_list[0])[i - 1];
     const auto src_raw =
             reinterpret_cast<const char*>(&(*chars_list[0])[(*offsets_list[0])[i - 1]]);
diff --git a/be/src/vec/functions/function_helpers.h b/be/src/vec/functions/function_helpers.h
index 474ac435bf..85b4fcea48 100644
--- a/be/src/vec/functions/function_helpers.h
+++ b/be/src/vec/functions/function_helpers.h
@@ -75,12 +75,12 @@ const ColumnConst* check_and_get_column_const_string_or_fixedstring(const IColum
 
 /// Transform anything to Field.
 template <typename T>
-inline std::enable_if_t<!IsDecimalNumber<T>, Field> to_field(const T& x) {
+std::enable_if_t<!IsDecimalNumber<T>, Field> to_field(const T& x) {
     return Field(NearestFieldType<T>(x));
 }
 
 template <typename T>
-inline std::enable_if_t<IsDecimalNumber<T>, Field> to_field(const T& x, UInt32 scale) {
+std::enable_if_t<IsDecimalNumber<T>, Field> to_field(const T& x, UInt32 scale) {
     return Field(NearestFieldType<T>(x, scale));
 }
 
diff --git a/be/src/vec/functions/function_string.h b/be/src/vec/functions/function_string.h
index fcd2b9ea41..2a5b698ef7 100644
--- a/be/src/vec/functions/function_string.h
+++ b/be/src/vec/functions/function_string.h
@@ -2020,8 +2020,8 @@ public:
 namespace MoneyFormat {
 
 template <typename T, size_t N>
-static StringRef do_money_format(FunctionContext* context, const T int_value,
-                                 const int32_t frac_value = 0) {
+StringRef do_money_format(FunctionContext* context, const T int_value,
+                          const int32_t frac_value = 0) {
     char local[N];
     char* p = SimpleItoaWithCommas(int_value, local, sizeof(local));
     int32_t string_val_len = local + sizeof(local) - p + 3;
diff --git a/be/src/vec/functions/functions_logical.cpp b/be/src/vec/functions/functions_logical.cpp
index c810c82b8a..f5a1f0af09 100644
--- a/be/src/vec/functions/functions_logical.cpp
+++ b/be/src/vec/functions/functions_logical.cpp
@@ -40,7 +40,7 @@ namespace {
 using namespace FunctionsLogicalDetail;
 
 template <class Op>
-static void vector_const(const IColumn* left, const ColumnConst* right, IColumn* res, size_t rows) {
+void vector_const(const IColumn* left, const ColumnConst* right, IColumn* res, size_t rows) {
     const auto* __restrict l_datas = assert_cast<const ColumnUInt8*>(left)->get_data().data();
     auto r_data = (uint8)right->get_uint(0);
     auto* __restrict res_datas = assert_cast<ColumnUInt8*>(res)->get_data().data();
@@ -51,7 +51,7 @@ static void vector_const(const IColumn* left, const ColumnConst* right, IColumn*
 }
 
 template <class Op>
-static void vector_vector(const IColumn* left, const IColumn* right, IColumn* res, size_t rows) {
+void vector_vector(const IColumn* left, const IColumn* right, IColumn* res, size_t rows) {
     const auto* __restrict l_datas = assert_cast<const ColumnUInt8*>(left)->get_data().data();
     const auto* __restrict r_datas = assert_cast<const ColumnUInt8*>(right)->get_data().data();
     auto* __restrict res_datas = assert_cast<ColumnUInt8*>(res)->get_data().data();
@@ -71,8 +71,8 @@ std::pair<const IColumn*, ColumnPtr> get_nested_and_null_column(const IColumn* c
 }
 
 template <class Op>
-static void vector_const_null(const IColumn* left, const ColumnConst* right, IColumn* res,
-                              IColumn* nulls, size_t rows) {
+void vector_const_null(const IColumn* left, const ColumnConst* right, IColumn* res, IColumn* nulls,
+                       size_t rows) {
     auto [data_column, null_column_ptr] = get_nested_and_null_column(left);
     const auto* __restrict l_datas =
             assert_cast<const ColumnUInt8*>(data_column)->get_data().data();
@@ -99,8 +99,8 @@ static void vector_const_null(const IColumn* left, const ColumnConst* right, ICo
 }
 
 template <class Op>
-static void vector_vector_null(const IColumn* left, const IColumn* right, IColumn* res,
-                               IColumn* nulls, size_t rows) {
+void vector_vector_null(const IColumn* left, const IColumn* right, IColumn* res, IColumn* nulls,
+                        size_t rows) {
     auto [l_datas_ptr, l_nulls_ptr] = get_nested_and_null_column(left);
     auto [r_datas_ptr, r_nulls_ptr] = get_nested_and_null_column(right);
 
@@ -123,8 +123,8 @@ static void vector_vector_null(const IColumn* left, const IColumn* right, IColum
 }
 
 template <class Op>
-static void basic_execute_impl(ColumnRawPtrs arguments, ColumnWithTypeAndName& result_info,
-                               size_t input_rows_count) {
+void basic_execute_impl(ColumnRawPtrs arguments, ColumnWithTypeAndName& result_info,
+                        size_t input_rows_count) {
     auto col_res = ColumnUInt8::create(input_rows_count);
     if (auto l = check_and_get_column<ColumnConst>(arguments[0])) {
         vector_const<Op>(arguments[1], l, col_res, input_rows_count);
@@ -137,8 +137,8 @@ static void basic_execute_impl(ColumnRawPtrs arguments, ColumnWithTypeAndName& r
 }
 
 template <class Op>
-static void null_execute_impl(ColumnRawPtrs arguments, ColumnWithTypeAndName& result_info,
-                              size_t input_rows_count) {
+void null_execute_impl(ColumnRawPtrs arguments, ColumnWithTypeAndName& result_info,
+                       size_t input_rows_count) {
     auto col_nulls = ColumnUInt8::create(input_rows_count);
     auto col_res = ColumnUInt8::create(input_rows_count);
     if (auto l = check_and_get_column<ColumnConst>(arguments[0])) {
diff --git a/be/src/vec/functions/functions_logical.h b/be/src/vec/functions/functions_logical.h
index 9e1f8368b3..93e4f47599 100644
--- a/be/src/vec/functions/functions_logical.h
+++ b/be/src/vec/functions/functions_logical.h
@@ -46,12 +46,12 @@ static constexpr UInt8 True = -1;
 static constexpr UInt8 Null = 1;
 
 template <typename T>
-inline ResultType make_value(T value) {
+ResultType make_value(T value) {
     return value != 0 ? Ternary::True : Ternary::False;
 }
 
 template <typename T>
-inline ResultType make_value(T value, bool is_null) {
+ResultType make_value(T value, bool is_null) {
     if (is_null) return Ternary::Null;
     return make_value<T>(value);
 }
diff --git a/be/src/vec/functions/regexps.h b/be/src/vec/functions/regexps.h
index ffa9d88173..378dd3ec68 100644
--- a/be/src/vec/functions/regexps.h
+++ b/be/src/vec/functions/regexps.h
@@ -89,8 +89,8 @@ private:
 using DeferredConstructedRegexpsPtr = std::shared_ptr<DeferredConstructedRegexps>;
 
 template <bool save_indices, bool WithEditDistance>
-inline Regexps constructRegexps(const std::vector<String>& str_patterns,
-                                [[maybe_unused]] std::optional<UInt32> edit_distance) {
+Regexps constructRegexps(const std::vector<String>& str_patterns,
+                         [[maybe_unused]] std::optional<UInt32> edit_distance) {
     /// Common pointers
     std::vector<const char*> patterns;
     std::vector<unsigned int> flags;
@@ -205,8 +205,8 @@ struct GlobalCacheTable {
 /// If WithEditDistance is False, edit_distance must be nullopt. Also, we use templates here because each instantiation of function template
 /// has its own copy of local static variables which must not be the same for different hyperscan compilations.
 template <bool save_indices, bool WithEditDistance>
-inline DeferredConstructedRegexpsPtr getOrSet(const std::vector<StringRef>& patterns,
-                                              std::optional<UInt32> edit_distance) {
+DeferredConstructedRegexpsPtr getOrSet(const std::vector<StringRef>& patterns,
+                                       std::optional<UInt32> edit_distance) {
     static GlobalCacheTable
             pool; /// Different variables for different pattern parameters, thread-safe in C++11
 
diff --git a/be/src/vec/io/io_helper.h b/be/src/vec/io/io_helper.h
index 457ae26d50..59512a9e1f 100644
--- a/be/src/vec/io/io_helper.h
+++ b/be/src/vec/io/io_helper.h
@@ -94,17 +94,17 @@ void write_text(Decimal<T> value, UInt32 scale, std::ostream& ostr) {
 
 /// Write POD-type in native format. It's recommended to use only with packed (dense) data types.
 template <typename Type>
-inline void write_pod_binary(const Type& x, BufferWritable& buf) {
+void write_pod_binary(const Type& x, BufferWritable& buf) {
     buf.write(reinterpret_cast<const char*>(&x), sizeof(x));
 }
 
 template <typename Type>
-inline void write_int_binary(const Type& x, BufferWritable& buf) {
+void write_int_binary(const Type& x, BufferWritable& buf) {
     write_pod_binary(x, buf);
 }
 
 template <typename Type>
-inline void write_float_binary(const Type& x, BufferWritable& buf) {
+void write_float_binary(const Type& x, BufferWritable& buf) {
     write_pod_binary(x, buf);
 }
 
@@ -143,23 +143,23 @@ inline void write_binary(const StringRef& x, BufferWritable& buf) {
 }
 
 template <typename Type>
-inline void write_binary(const Type& x, BufferWritable& buf) {
+void write_binary(const Type& x, BufferWritable& buf) {
     write_pod_binary(x, buf);
 }
 
 /// Read POD-type in native format
 template <typename Type>
-inline void read_pod_binary(Type& x, BufferReadable& buf) {
+void read_pod_binary(Type& x, BufferReadable& buf) {
     buf.read(reinterpret_cast<char*>(&x), sizeof(x));
 }
 
 template <typename Type>
-inline void read_int_binary(Type& x, BufferReadable& buf) {
+void read_int_binary(Type& x, BufferReadable& buf) {
     read_pod_binary(x, buf);
 }
 
 template <typename Type>
-inline void read_float_binary(Type& x, BufferReadable& buf) {
+void read_float_binary(Type& x, BufferReadable& buf) {
     read_pod_binary(x, buf);
 }
 
@@ -227,7 +227,7 @@ inline void read_binary(StringRef& x, BufferReadable& buf) {
 }
 
 template <typename Type>
-inline void read_binary(Type& x, BufferReadable& buf) {
+void read_binary(Type& x, BufferReadable& buf) {
     read_pod_binary(x, buf);
 }
 
@@ -360,7 +360,7 @@ bool try_read_int_text(T& x, ReadBuffer& buf) {
 }
 
 template <typename T>
-static inline const char* try_read_first_int_text(T& x, const char* pos, const char* end) {
+const char* try_read_first_int_text(T& x, const char* pos, const char* end) {
     const int len = end - pos;
     int i = 0;
     while (i < len) {
diff --git a/be/src/vec/io/var_int.h b/be/src/vec/io/var_int.h
index af979194e8..eda4b6b387 100644
--- a/be/src/vec/io/var_int.h
+++ b/be/src/vec/io/var_int.h
@@ -39,7 +39,7 @@ size_t get_length_of_var_int(Int64 x);
 
 /** Write Int64 in variable length format (base128) */
 template <typename OUT>
-inline void write_var_int(Int64 x, OUT& ostr) {
+void write_var_int(Int64 x, OUT& ostr) {
     write_var_uint(static_cast<UInt64>((x << 1) ^ (x >> 63)), ostr);
 }
 
@@ -49,7 +49,7 @@ inline char* write_var_int(Int64 x, char* ostr) {
 
 /** Read Int64, written in variable length format (base128) */
 template <typename IN>
-inline void read_var_int(Int64& x, IN& istr) {
+void read_var_int(Int64& x, IN& istr) {
     read_var_uint(*reinterpret_cast<UInt64*>(&x), istr);
     x = (static_cast<UInt64>(x) >> 1) ^ -(x & 1);
 }
diff --git a/be/src/vec/utils/arrow_column_to_doris_column.cpp b/be/src/vec/utils/arrow_column_to_doris_column.cpp
index b808daae7a..35d5d4956a 100644
--- a/be/src/vec/utils/arrow_column_to_doris_column.cpp
+++ b/be/src/vec/utils/arrow_column_to_doris_column.cpp
@@ -140,8 +140,8 @@ static Status convert_column_with_fixed_size_data(const arrow::Array* array, siz
 
 /// Inserts numeric data right into internal column data to reduce an overhead
 template <typename NumericType, typename VectorType = ColumnVector<NumericType>>
-static Status convert_column_with_numeric_data(const arrow::Array* array, size_t array_idx,
-                                               MutableColumnPtr& data_column, size_t num_elements) {
+Status convert_column_with_numeric_data(const arrow::Array* array, size_t array_idx,
+                                        MutableColumnPtr& data_column, size_t num_elements) {
     auto& column_data = static_cast<VectorType&>(*data_column).get_data();
     /// buffers[0] is a null bitmap and buffers[1] are actual values
     std::shared_ptr<arrow::Buffer> buffer = array->data()->buffers[1];
@@ -181,9 +181,9 @@ static int64_t time_unit_divisor(arrow::TimeUnit::type unit) {
 }
 
 template <typename ArrowType>
-static Status convert_column_with_timestamp_data(const arrow::Array* array, size_t array_idx,
-                                                 MutableColumnPtr& data_column, size_t num_elements,
-                                                 const cctz::time_zone& ctz) {
+Status convert_column_with_timestamp_data(const arrow::Array* array, size_t array_idx,
+                                          MutableColumnPtr& data_column, size_t num_elements,
+                                          const cctz::time_zone& ctz) {
     auto& column_data = static_cast<ColumnVector<Int64>&>(*data_column).get_data();
     auto concrete_array = down_cast<const ArrowType*>(array);
     int64_t divisor = 1;
@@ -213,9 +213,9 @@ static Status convert_column_with_timestamp_data(const arrow::Array* array, size
 }
 
 template <typename ArrowType>
-static Status convert_column_with_date_v2_data(const arrow::Array* array, size_t array_idx,
-                                               MutableColumnPtr& data_column, size_t num_elements,
-                                               const cctz::time_zone& ctz) {
+Status convert_column_with_date_v2_data(const arrow::Array* array, size_t array_idx,
+                                        MutableColumnPtr& data_column, size_t num_elements,
+                                        const cctz::time_zone& ctz) {
     auto& column_data = static_cast<ColumnVector<UInt32>&>(*data_column).get_data();
     auto concrete_array = down_cast<const ArrowType*>(array);
     int64_t divisor = 1;
@@ -242,10 +242,9 @@ static Status convert_column_with_date_v2_data(const arrow::Array* array, size_t
 }
 
 template <typename ArrowType>
-static Status convert_column_with_datetime_v2_data(const arrow::Array* array, size_t array_idx,
-                                                   MutableColumnPtr& data_column,
-                                                   size_t num_elements,
-                                                   const cctz::time_zone& ctz) {
+Status convert_column_with_datetime_v2_data(const arrow::Array* array, size_t array_idx,
+                                            MutableColumnPtr& data_column, size_t num_elements,
+                                            const cctz::time_zone& ctz) {
     auto& column_data = static_cast<ColumnVector<UInt64>&>(*data_column).get_data();
     auto concrete_array = down_cast<const ArrowType*>(array);
     int64_t divisor = 1;
diff --git a/be/src/vec/utils/histogram_helpers.hpp b/be/src/vec/utils/histogram_helpers.hpp
index 9a6ca5a444..4cba13ed97 100644
--- a/be/src/vec/utils/histogram_helpers.hpp
+++ b/be/src/vec/utils/histogram_helpers.hpp
@@ -53,8 +53,8 @@ public:
  * @return true if the values can be assigned to the buckets, false otherwise.
  */
 template <typename T>
-static bool can_assign_into_buckets(const std::map<T, size_t>& value_map,
-                                    const size_t max_bucket_size, const size_t num_buckets) {
+bool can_assign_into_buckets(const std::map<T, size_t>& value_map, const size_t max_bucket_size,
+                             const size_t num_buckets) {
     if (value_map.empty()) {
         return false;
     };
@@ -91,8 +91,7 @@ static bool can_assign_into_buckets(const std::map<T, size_t>& value_map,
  * @return the maximum number of values that can fit into each bucket
  */
 template <typename T>
-static size_t calculate_bucket_max_values(const std::map<T, size_t>& value_map,
-                                          const size_t num_buckets) {
+size_t calculate_bucket_max_values(const std::map<T, size_t>& value_map, const size_t num_buckets) {
     // Ensure that the value map is not empty
     assert(!value_map.empty());
 
@@ -172,8 +171,8 @@ static size_t calculate_bucket_max_values(const std::map<T, size_t>& value_map,
  * @return True if the buckets were successfully built, false otherwise.
  */
 template <typename T>
-static bool build_histogram(std::vector<Bucket<T>>& buckets, const std::map<T, size_t>& ordered_map,
-                            const size_t max_num_buckets) {
+bool build_histogram(std::vector<Bucket<T>>& buckets, const std::map<T, size_t>& ordered_map,
+                     const size_t max_num_buckets) {
     // If the input map is empty, there is nothing to build.
     if (ordered_map.empty()) {
         return false;
@@ -242,8 +241,8 @@ static bool build_histogram(std::vector<Bucket<T>>& buckets, const std::map<T, s
 }
 
 template <typename T>
-static bool histogram_to_json(rapidjson::StringBuffer& buffer,
-                              const std::vector<Bucket<T>>& buckets, const DataTypePtr& data_type) {
+bool histogram_to_json(rapidjson::StringBuffer& buffer, const std::vector<Bucket<T>>& buckets,
+                       const DataTypePtr& data_type) {
     rapidjson::Document doc;
     doc.SetObject();
     rapidjson::Document::AllocatorType& allocator = doc.GetAllocator();
diff --git a/be/test/vec/utils/arrow_column_to_doris_column_test.cpp b/be/test/vec/utils/arrow_column_to_doris_column_test.cpp
index 57c63fafe1..f16558ae86 100644
--- a/be/test/vec/utils/arrow_column_to_doris_column_test.cpp
+++ b/be/test/vec/utils/arrow_column_to_doris_column_test.cpp
@@ -419,9 +419,9 @@ TEST(ArrowColumnToDorisColumnTest, test_decimalv2) {
 }
 
 template <int bytes_width, bool is_nullable = false>
-static inline std::shared_ptr<arrow::Array> create_fixed_size_binary_array(int64_t num_elements,
-                                                                           const std::string& value,
-                                                                           size_t& counter) {
+std::shared_ptr<arrow::Array> create_fixed_size_binary_array(int64_t num_elements,
+                                                             const std::string& value,
+                                                             size_t& counter) {
     auto data_buf_size = bytes_width * num_elements;
     auto data_buf_tmp = arrow::AllocateBuffer(data_buf_size);
     std::shared_ptr<arrow::Buffer> data_buf = std::move(data_buf_tmp.ValueOrDie());
@@ -513,9 +513,8 @@ TEST(ArrowColumnToDorisColumnTest, test_fixed_binary) {
 }
 
 template <typename ArrowType, bool is_nullable = false>
-static inline std::shared_ptr<arrow::Array> create_binary_array(int64_t num_elements,
-                                                                const std::string& value,
-                                                                size_t& counter) {
+std::shared_ptr<arrow::Array> create_binary_array(int64_t num_elements, const std::string& value,
+                                                  size_t& counter) {
     using offset_type = typename ArrowType::offset_type;
     size_t offsets_bytes = (num_elements + 1) * sizeof(offset_type);
     auto offsets_buf_tmp = arrow::AllocateBuffer(offsets_bytes);
@@ -612,10 +611,11 @@ TEST(ArrowColumnToDorisColumnTest, test_binary) {
 }
 
 template <typename ArrowValueType, bool is_nullable = false>
-static inline std::shared_ptr<arrow::Array> create_array_array(
-        std::vector<ColumnArray::Offset64>& vec_offsets, std::vector<bool>& null_map,
-        std::shared_ptr<arrow::DataType> value_type, std::shared_ptr<arrow::Array> values,
-        size_t& counter) {
+std::shared_ptr<arrow::Array> create_array_array(std::vector<ColumnArray::Offset64>& vec_offsets,
+                                                 std::vector<bool>& null_map,
+                                                 std::shared_ptr<arrow::DataType> value_type,
+                                                 std::shared_ptr<arrow::Array> values,
+                                                 size_t& counter) {
     using offset_type = typename arrow::ListType::offset_type;
     size_t num_rows = vec_offsets.size() - 1;
     DCHECK(null_map.size() == num_rows);