This is an automated email from the ASF dual-hosted git repository.
panxiaolei pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/master by this push:
new 16fc3a0e22 [Chore](compile) remove some unused static on inline
function to reduce compile time (#17603)
16fc3a0e22 is described below
commit 16fc3a0e221bb7157b2b3f5656c827bc0322c267
Author: Pxl <[email protected]>
AuthorDate: Mon Mar 13 11:11:59 2023 +0800
[Chore](compile) remove some unused static on inline function to reduce
compile time (#17603)
remove some unused static on inline function to reduce compile time
---
be/src/common/signal_handler.h | 16 ++++----
be/src/common/status.h | 2 +-
be/src/common/utils.h | 2 +-
be/src/exec/es/es_scroll_parser.cpp | 28 ++++++-------
be/src/exec/olap_utils.h | 8 ++--
be/src/exprs/create_predicate_function.h | 25 ++++++-----
be/src/gutil/atomicops-internals-x86.h | 2 +-
be/src/gutil/basictypes.h | 2 +-
be/src/gutil/bits.h | 6 +--
be/src/gutil/casts.h | 20 ++++-----
be/src/gutil/dynamic_annotations.h | 6 +--
be/src/gutil/gscoped_ptr.h | 6 +--
be/src/gutil/port.h | 2 +-
be/src/gutil/stl_util.h | 14 +++----
be/src/gutil/strings/escaping.cc | 4 +-
be/src/gutil/strings/join.h | 13 +++---
be/src/gutil/strings/split.cc | 8 ++--
be/src/gutil/strings/split.h | 19 ++++-----
be/src/gutil/strings/strip.h | 2 +-
be/src/gutil/strings/util.cc | 10 ++---
be/src/gutil/strings/util.h | 4 +-
be/src/olap/predicate_creator.h | 19 ++++-----
be/src/olap/skiplist.h | 16 ++++----
be/src/olap/types.cpp | 2 +-
be/src/olap/types.h | 2 +-
be/src/olap/utils.h | 8 ++--
be/src/runtime/exec_env.h | 2 +-
be/src/runtime/memory/thread_mem_tracker_mgr.h | 2 +-
be/src/service/point_query_executor.cpp | 4 +-
be/src/util/binary_cast.hpp | 2 +-
be/src/util/bit_packing.inline.h | 7 ++--
be/src/util/bit_stream_utils.inline.h | 16 ++++----
be/src/util/bitmap_intersect.h | 24 +++++------
be/src/util/coding.h | 14 +++----
be/src/util/frame_of_reference_coding.h | 6 +--
be/src/util/interval_tree-inl.h | 2 +-
be/src/util/mysql_row_buffer.cpp | 4 +-
be/src/util/proto_util.h | 34 ++++++++-------
be/src/util/rle_encoding.h | 48 +++++++++++-----------
be/src/util/simd/bits.h | 4 +-
be/src/util/string_parser.hpp | 16 ++++----
be/src/util/string_util.h | 6 +--
be/src/util/type_traits.h | 4 +-
be/src/util/uid_util.h | 4 +-
.../aggregate_function_bitmap.cpp | 2 +-
.../aggregate_function_min_max.cpp | 6 +--
.../aggregate_function_min_max_by.cpp | 10 ++---
.../aggregate_function_stddev.cpp | 8 ++--
.../aggregate_function_window.cpp | 4 +-
be/src/vec/aggregate_functions/factory_helpers.h | 2 +-
be/src/vec/common/aggregation_common.h | 22 ++++------
be/src/vec/common/bit_helpers.h | 6 +--
.../vec/common/hash_table/hash_table_key_holder.h | 6 +--
be/src/vec/common/hex.h | 6 +--
be/src/vec/common/memcmp_small.h | 26 +++++-------
be/src/vec/common/nan_utils.h | 8 ++--
be/src/vec/common/unaligned.h | 4 +-
be/src/vec/common/volnitsky.h | 7 ++--
be/src/vec/core/call_on_type_index.h | 2 +-
be/src/vec/core/field.cpp | 6 +--
be/src/vec/data_types/data_type.h | 20 ++++-----
be/src/vec/data_types/data_type_decimal.h | 20 ++++-----
be/src/vec/data_types/data_type_struct.cpp | 2 +-
be/src/vec/exec/format/orc/vorc_reader.cpp | 7 ++--
be/src/vec/functions/function_encryption.cpp | 10 ++---
be/src/vec/functions/function_helpers.h | 4 +-
be/src/vec/functions/function_string.h | 4 +-
be/src/vec/functions/functions_logical.cpp | 20 ++++-----
be/src/vec/functions/functions_logical.h | 4 +-
be/src/vec/functions/regexps.h | 8 ++--
be/src/vec/io/io_helper.h | 18 ++++----
be/src/vec/io/var_int.h | 4 +-
be/src/vec/utils/arrow_column_to_doris_column.cpp | 23 +++++------
be/src/vec/utils/histogram_helpers.hpp | 15 ++++---
.../utils/arrow_column_to_doris_column_test.cpp | 20 ++++-----
75 files changed, 363 insertions(+), 386 deletions(-)
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, ¶ms, &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(¶ms, 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);
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
