diff --git a/be/src/udf/udf.h b/be/src/udf/udf.h index 5b429b85d1..a1413a5ab8 100644 --- a/be/src/udf/udf.h +++ b/be/src/udf/udf.h @@ -26,6 +26,7 @@ #include #include "runtime/types.h" +#include "vec/common/arena.h" namespace doris { @@ -127,6 +128,8 @@ public: ~FunctionContext() = default; + vectorized::Arena& get_arena() { return arena; } + private: FunctionContext() = default; @@ -160,6 +163,8 @@ private: bool _check_overflow_for_decimal = false; std::string _string_result; + + vectorized::Arena arena; }; using doris::FunctionContext; diff --git a/be/src/vec/functions/array/function_array_apply.cpp b/be/src/vec/functions/array/function_array_apply.cpp index bc16ec6516..d05ba904f3 100644 --- a/be/src/vec/functions/array/function_array_apply.cpp +++ b/be/src/vec/functions/array/function_array_apply.cpp @@ -72,7 +72,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { ColumnPtr src_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); const auto& src_column_array = check_and_get_column(*src_column); @@ -111,7 +111,7 @@ private: GE = 6, }; template - bool apply(T data, T comp) { + bool apply(T data, T comp) const { if constexpr (op == ApplyOp::EQ) { return data == comp; } @@ -137,7 +137,7 @@ private: // need exception safety template ColumnPtr _apply_internal(const IColumn& src_column, const ColumnArray::Offsets64& src_offsets, - const ColumnConst& cmp) { + const ColumnConst& cmp) const { T rhs_val = *reinterpret_cast(cmp.get_data_at(0).data); auto column_filter = ColumnUInt8::create(src_column.size(), 0); auto& column_filter_data = column_filter->get_data(); @@ -218,7 +218,7 @@ private: // need exception safety Status _execute(const IColumn& nested_src, DataTypePtr nested_type, const ColumnArray::Offsets64& offsets, const std::string& condition, - const ColumnConst& rhs_value_column, ColumnPtr* dst) { + const ColumnConst& rhs_value_column, ColumnPtr* dst) const { if (condition == "=") { APPLY_ALL_TYPES(nested_src, offsets, ApplyOp::EQ, rhs_value_column, dst); } else if (condition == "!=") { diff --git a/be/src/vec/functions/array/function_array_binary.h b/be/src/vec/functions/array/function_array_binary.h index 27b5fd594d..a41a82b8a7 100644 --- a/be/src/vec/functions/array/function_array_binary.h +++ b/be/src/vec/functions/array/function_array_binary.h @@ -50,7 +50,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const auto& [left_column, left_const] = unpack_if_const(block.get_by_position(arguments[0]).column); const auto& [right_column, right_const] = diff --git a/be/src/vec/functions/array/function_array_compact.h b/be/src/vec/functions/array/function_array_compact.h index 57c07b38d8..c3acde4959 100644 --- a/be/src/vec/functions/array/function_array_compact.h +++ b/be/src/vec/functions/array/function_array_compact.h @@ -66,7 +66,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { ColumnPtr src_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); const auto& src_column_array = check_and_get_column(*src_column); @@ -100,7 +100,7 @@ public: private: bool _execute(const IColumn& src_column, const ColumnArray::Offsets64& src_offsets, - IColumn& dest_column, ColumnArray::Offsets64& dest_offsets) { + IColumn& dest_column, ColumnArray::Offsets64& dest_offsets) const { ColumnArray::Offset64 src_offsets_size = src_offsets.size(); ColumnArray::Offset64 src_pos = 0; ColumnArray::Offset64 dest_pos = 0; diff --git a/be/src/vec/functions/array/function_array_concat.cpp b/be/src/vec/functions/array/function_array_concat.cpp index fe7cfa8eca..a4f1bfd29c 100644 --- a/be/src/vec/functions/array/function_array_concat.cpp +++ b/be/src/vec/functions/array/function_array_concat.cpp @@ -68,7 +68,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - const size_t result, size_t input_rows_count) override { + const size_t result, size_t input_rows_count) const override { DataTypePtr column_type = block.get_by_position(arguments[0]).type; auto nested_type = assert_cast(*column_type).get_nested_type(); auto result_column = ColumnArray::create(nested_type->create_column(), diff --git a/be/src/vec/functions/array/function_array_constructor.cpp b/be/src/vec/functions/array/function_array_constructor.cpp index b7133ec0db..d19d29ec25 100644 --- a/be/src/vec/functions/array/function_array_constructor.cpp +++ b/be/src/vec/functions/array/function_array_constructor.cpp @@ -68,7 +68,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { size_t num_element = arguments.size(); auto result_col = block.get_by_position(result).type->create_column(); auto result_array_col = static_cast(result_col.get()); diff --git a/be/src/vec/functions/array/function_array_count.cpp b/be/src/vec/functions/array/function_array_count.cpp index 25c15c0912..2d8eca3c17 100644 --- a/be/src/vec/functions/array/function_array_count.cpp +++ b/be/src/vec/functions/array/function_array_count.cpp @@ -48,7 +48,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const auto& [src_column, src_const] = unpack_if_const(block.get_by_position(arguments[0]).column); const ColumnArray* array_column = nullptr; diff --git a/be/src/vec/functions/array/function_array_cum_sum.cpp b/be/src/vec/functions/array/function_array_cum_sum.cpp index 4201fe4f27..b3ddd0a6fe 100644 --- a/be/src/vec/functions/array/function_array_cum_sum.cpp +++ b/be/src/vec/functions/array/function_array_cum_sum.cpp @@ -90,7 +90,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - const size_t result, size_t input_rows_count) override { + const size_t result, size_t input_rows_count) const override { auto src_arg = block.get_by_position(arguments[0]); ColumnPtr src_column = src_arg.column->convert_to_full_column_if_const(); @@ -133,7 +133,7 @@ public: private: bool _execute_by_type(DataTypePtr src_nested_type, const IColumn& src_column, const ColumnArray::Offsets64& src_offsets, - const NullMapType& src_null_map, ColumnPtr& res_nested_ptr) { + const NullMapType& src_null_map, ColumnPtr& res_nested_ptr) const { bool res = false; WhichDataType which(remove_nullable(src_nested_type)); if (which.is_uint8()) { @@ -179,7 +179,7 @@ private: template bool _execute_number(const IColumn& src_column, const ColumnArray::Offsets64& src_offsets, - const NullMapType& src_null_map, ColumnPtr& res_nested_ptr) { + const NullMapType& src_null_map, ColumnPtr& res_nested_ptr) const { using ColVecType = ColumnVectorOrDecimal; using ColVecResult = ColumnVectorOrDecimal; @@ -217,7 +217,8 @@ private: template void _compute_cum_sum(const PaddedPODArray& src_datas, const ColumnArray::Offsets64& src_offsets, - const NullMapType& src_null_map, PaddedPODArray& res_datas) { + const NullMapType& src_null_map, + PaddedPODArray& res_datas) const { size_t prev_offset = 0; for (auto cur_offset : src_offsets) { // [1, null, 2, 3] -> [1, null, 3, 6] diff --git a/be/src/vec/functions/array/function_array_difference.h b/be/src/vec/functions/array/function_array_difference.h index 242d62adbf..492d7cdcb7 100644 --- a/be/src/vec/functions/array/function_array_difference.h +++ b/be/src/vec/functions/array/function_array_difference.h @@ -103,7 +103,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const ColumnWithTypeAndName& arg = block.get_by_position(arguments[0]); auto res_column = _execute_non_nullable(arg, input_rows_count); if (!res_column) { @@ -137,7 +137,8 @@ private: template ColumnPtr _execute_number_expanded(const ColumnArray::Offsets64& offsets, - const IColumn& nested_column, ColumnPtr nested_null_map) { + const IColumn& nested_column, + ColumnPtr nested_null_map) const { using ColVecType = ColumnVectorOrDecimal; using ColVecResult = ColumnVectorOrDecimal; typename ColVecResult::MutablePtr res_nested = nullptr; @@ -178,7 +179,8 @@ private: } } - ColumnPtr _execute_non_nullable(const ColumnWithTypeAndName& arg, size_t input_rows_count) { + ColumnPtr _execute_non_nullable(const ColumnWithTypeAndName& arg, + size_t input_rows_count) const { // check array nested column type and get data auto left_column = arg.column->convert_to_full_column_if_const(); const auto& array_column = reinterpret_cast(*left_column); diff --git a/be/src/vec/functions/array/function_array_distance.h b/be/src/vec/functions/array/function_array_distance.h index ed1a1b0163..ef511436d8 100644 --- a/be/src/vec/functions/array/function_array_distance.h +++ b/be/src/vec/functions/array/function_array_distance.h @@ -93,7 +93,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const auto& arg1 = block.get_by_position(arguments[0]); const auto& arg2 = block.get_by_position(arguments[1]); if (!_check_input_type(arg1.type) || !_check_input_type(arg2.type)) { @@ -170,7 +170,7 @@ public: } private: - bool _check_input_type(const DataTypePtr& type) { + bool _check_input_type(const DataTypePtr& type) const { auto array_type = remove_nullable(type); if (!is_array(array_type)) { return false; diff --git a/be/src/vec/functions/array/function_array_distinct.h b/be/src/vec/functions/array/function_array_distinct.h index ae8e3ac600..dff894d115 100644 --- a/be/src/vec/functions/array/function_array_distinct.h +++ b/be/src/vec/functions/array/function_array_distinct.h @@ -78,7 +78,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { ColumnPtr src_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); const auto& src_column_array = check_and_get_column(*src_column); @@ -136,7 +136,7 @@ private: template bool _execute_number(const IColumn& src_column, const ColumnArray::Offsets64& src_offsets, IColumn& dest_column, ColumnArray::Offsets64& dest_offsets, - const NullMapType* src_null_map, NullMapType* dest_null_map) { + const NullMapType* src_null_map, NullMapType* dest_null_map) const { using NestType = typename ColumnType::value_type; using ElementNativeType = typename NativeType::Type; @@ -193,7 +193,7 @@ private: bool _execute_string(const IColumn& src_column, const ColumnArray::Offsets64& src_offsets, IColumn& dest_column, ColumnArray::Offsets64& dest_offsets, - const NullMapType* src_null_map, NullMapType* dest_null_map) { + const NullMapType* src_null_map, NullMapType* dest_null_map) const { const ColumnString* src_data_concrete = reinterpret_cast(&src_column); if (!src_data_concrete) { return false; @@ -256,7 +256,7 @@ private: bool _execute_by_type(const IColumn& src_column, const ColumnArray::Offsets64& src_offsets, IColumn& dest_column, ColumnArray::Offsets64& dest_offsets, const NullMapType* src_null_map, NullMapType* dest_null_map, - DataTypePtr& nested_type) { + DataTypePtr& nested_type) const { bool res = false; WhichDataType which(remove_nullable(nested_type)); if (which.is_uint8()) { diff --git a/be/src/vec/functions/array/function_array_element.h b/be/src/vec/functions/array/function_array_element.h index c6cc27fbaf..fcd54c6dfa 100644 --- a/be/src/vec/functions/array/function_array_element.h +++ b/be/src/vec/functions/array/function_array_element.h @@ -95,7 +95,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto dst_null_column = ColumnUInt8::create(input_rows_count); UInt8* dst_null_map = dst_null_column->get_data().data(); const UInt8* src_null_map = nullptr; @@ -129,7 +129,8 @@ public: private: //=========================== map element===========================// - ColumnPtr _get_mapped_idx(const ColumnArray& column, const ColumnWithTypeAndName& argument) { + ColumnPtr _get_mapped_idx(const ColumnArray& column, + const ColumnWithTypeAndName& argument) const { auto right_column = make_nullable(argument.column->convert_to_full_column_if_const()); const ColumnArray::Offsets64& offsets = column.get_offsets(); ColumnPtr nested_ptr = make_nullable(column.get_data_ptr()); @@ -161,7 +162,7 @@ private: template ColumnPtr _execute_number(const ColumnArray::Offsets64& offsets, const IColumn& nested_column, const UInt8* arr_null_map, const IColumn& indices, - const UInt8* nested_null_map, UInt8* dst_null_map) { + const UInt8* nested_null_map, UInt8* dst_null_map) const { const auto& nested_data = reinterpret_cast(nested_column).get_data(); auto dst_column = nested_column.clone_empty(); @@ -202,7 +203,7 @@ private: ColumnPtr _execute_string(const ColumnArray::Offsets64& offsets, const IColumn& nested_column, const UInt8* arr_null_map, const IColumn& indices, - const UInt8* nested_null_map, UInt8* dst_null_map) { + const UInt8* nested_null_map, UInt8* dst_null_map) const { const auto& src_str_offs = reinterpret_cast(nested_column).get_offsets(); const auto& src_str_chars = @@ -254,7 +255,7 @@ private: } ColumnPtr _execute_map(const ColumnsWithTypeAndName& arguments, size_t input_rows_count, - const UInt8* src_null_map, UInt8* dst_null_map) { + const UInt8* src_null_map, UInt8* dst_null_map) const { auto left_column = arguments[0].column->convert_to_full_column_if_const(); DataTypePtr val_type = reinterpret_cast(*arguments[0].type).get_value_type(); @@ -286,7 +287,7 @@ private: ColumnPtr _execute_common(const ColumnArray::Offsets64& offsets, const IColumn& nested_column, const UInt8* arr_null_map, const IColumn& indices, - const UInt8* nested_null_map, UInt8* dst_null_map) { + const UInt8* nested_null_map, UInt8* dst_null_map) const { // prepare return data auto dst_column = nested_column.clone_empty(); dst_column->reserve(offsets.size()); @@ -323,7 +324,7 @@ private: } ColumnPtr _execute_nullable(const ColumnsWithTypeAndName& arguments, size_t input_rows_count, - const UInt8* src_null_map, UInt8* dst_null_map) { + const UInt8* src_null_map, UInt8* dst_null_map) const { // check array nested column type and get data auto left_column = arguments[0].column->convert_to_full_column_if_const(); const auto& array_column = reinterpret_cast(*left_column); diff --git a/be/src/vec/functions/array/function_array_enumerate.cpp b/be/src/vec/functions/array/function_array_enumerate.cpp index 9594f87ba8..3530e1ceca 100644 --- a/be/src/vec/functions/array/function_array_enumerate.cpp +++ b/be/src/vec/functions/array/function_array_enumerate.cpp @@ -79,7 +79,7 @@ public: return return_type; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto left_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); const ColumnArray* array = diff --git a/be/src/vec/functions/array/function_array_enumerate_uniq.cpp b/be/src/vec/functions/array/function_array_enumerate_uniq.cpp index e3b8aa4bf6..d1a160ddac 100644 --- a/be/src/vec/functions/array/function_array_enumerate_uniq.cpp +++ b/be/src/vec/functions/array/function_array_enumerate_uniq.cpp @@ -116,7 +116,7 @@ public: #endif // __GNUC__ Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { ColumnRawPtrs data_columns(arguments.size()); const ColumnArray::Offsets64* offsets = nullptr; ColumnPtr src_offsets; @@ -234,7 +234,7 @@ private: template void _execute_by_hash(const ColumnRawPtrs& columns, const ColumnArray::Offsets64& offsets, [[maybe_unused]] const NullMap* null_map, - ColumnInt64::Container& dst_values) { + ColumnInt64::Container& dst_values) const { HashMapContainer hash_map; HashMethod hash_method(columns, {}, nullptr); @@ -262,7 +262,7 @@ private: template void _execute_number(const ColumnRawPtrs& columns, const ColumnArray::Offsets64& offsets, - const NullMapType* null_map, ColumnInt64::Container& dst_values) { + const NullMapType* null_map, ColumnInt64::Container& dst_values) const { using NestType = typename ColumnType::value_type; using ElementNativeType = typename NativeType::Type; @@ -281,7 +281,7 @@ private: } void _execute_string(const ColumnRawPtrs& columns, const ColumnArray::Offsets64& offsets, - const NullMapType* null_map, ColumnInt64::Container& dst_values) { + const NullMapType* null_map, ColumnInt64::Container& dst_values) const { using HashMapContainer = HashMapWithStackMemory, INITIAL_SIZE_DEGREE>; using HashMethod = ColumnsHashing::HashMethodString; diff --git a/be/src/vec/functions/array/function_array_exists.cpp b/be/src/vec/functions/array/function_array_exists.cpp index 2e0288f869..daef5faf84 100644 --- a/be/src/vec/functions/array/function_array_exists.cpp +++ b/be/src/vec/functions/array/function_array_exists.cpp @@ -64,7 +64,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { // 1. get first array column const auto first_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); diff --git a/be/src/vec/functions/array/function_array_filter.cpp b/be/src/vec/functions/array/function_array_filter.cpp index d6395ed37b..af7e7a4cb3 100644 --- a/be/src/vec/functions/array/function_array_filter.cpp +++ b/be/src/vec/functions/array/function_array_filter.cpp @@ -63,7 +63,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { //TODO: maybe need optimize not convert auto first_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); diff --git a/be/src/vec/functions/array/function_array_first_or_last_index.cpp b/be/src/vec/functions/array/function_array_first_or_last_index.cpp index 1e0fa67e4f..3d1e88c49f 100644 --- a/be/src/vec/functions/array/function_array_first_or_last_index.cpp +++ b/be/src/vec/functions/array/function_array_first_or_last_index.cpp @@ -67,7 +67,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto src_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); const ColumnArray* array_column = nullptr; diff --git a/be/src/vec/functions/array/function_array_index.h b/be/src/vec/functions/array/function_array_index.h index c7cf7bcc99..b66e25b5f7 100644 --- a/be/src/vec/functions/array/function_array_index.h +++ b/be/src/vec/functions/array/function_array_index.h @@ -93,14 +93,15 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { return _execute_non_nullable(block, arguments, result, input_rows_count); } private: ColumnPtr _execute_string(const ColumnArray::Offsets64& offsets, const UInt8* nested_null_map, const IColumn& nested_column, const IColumn& right_column, - const UInt8* right_nested_null_map, const UInt8* outer_null_map) { + const UInt8* right_nested_null_map, + const UInt8* outer_null_map) const { // check array nested column type and get data const auto& str_offs = reinterpret_cast(nested_column).get_offsets(); const auto& str_chars = reinterpret_cast(nested_column).get_chars(); @@ -165,7 +166,8 @@ private: template ColumnPtr _execute_number(const ColumnArray::Offsets64& offsets, const UInt8* nested_null_map, const IColumn& nested_column, const IColumn& right_column, - const UInt8* right_nested_null_map, const UInt8* outer_null_map) { + const UInt8* right_nested_null_map, + const UInt8* outer_null_map) const { // check array nested column type and get data const auto& nested_data = reinterpret_cast(nested_column).get_data(); @@ -223,7 +225,7 @@ private: const UInt8* nested_null_map, const IColumn& nested_column, const IColumn& right_column, const UInt8* right_nested_null_map, - const UInt8* outer_null_map) { + const UInt8* outer_null_map) const { if (check_column(right_column)) { return _execute_number( offsets, nested_null_map, nested_column, right_column, right_nested_null_map, @@ -233,7 +235,7 @@ private: } Status _execute_non_nullable(Block& block, const ColumnNumbers& arguments, size_t result, - size_t input_rows_count) { + size_t input_rows_count) const { // extract array offsets and nested data auto left_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); diff --git a/be/src/vec/functions/array/function_array_mapped.h b/be/src/vec/functions/array/function_array_mapped.h index 9f9bcf9e21..19ffb8ce9c 100644 --- a/be/src/vec/functions/array/function_array_mapped.h +++ b/be/src/vec/functions/array/function_array_mapped.h @@ -48,7 +48,7 @@ public: String get_name() const override { return name; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const auto& typed_column = block.get_by_position(arguments[0]); auto ptr = typed_column.column->convert_to_full_column_if_const(); const typename Impl::column_type* column_array; diff --git a/be/src/vec/functions/array/function_array_nary.h b/be/src/vec/functions/array/function_array_nary.h index 719890b7ba..9d14a68560 100644 --- a/be/src/vec/functions/array/function_array_nary.h +++ b/be/src/vec/functions/array/function_array_nary.h @@ -59,7 +59,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { ColumnPtr res_ptr; ColumnArrayExecutionDatas datas(arguments.size()); std::vector col_const(arguments.size()); diff --git a/be/src/vec/functions/array/function_array_popback.cpp b/be/src/vec/functions/array/function_array_popback.cpp index 89be7b2263..08c0b2f40b 100644 --- a/be/src/vec/functions/array/function_array_popback.cpp +++ b/be/src/vec/functions/array/function_array_popback.cpp @@ -63,7 +63,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto array_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); // extract src array column diff --git a/be/src/vec/functions/array/function_array_popfront.cpp b/be/src/vec/functions/array/function_array_popfront.cpp index c156c8dca6..3c87999905 100644 --- a/be/src/vec/functions/array/function_array_popfront.cpp +++ b/be/src/vec/functions/array/function_array_popfront.cpp @@ -63,7 +63,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto array_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); // extract src array column diff --git a/be/src/vec/functions/array/function_array_pushback.cpp b/be/src/vec/functions/array/function_array_pushback.cpp index b7b83f7f6d..8dedd3e9a6 100644 --- a/be/src/vec/functions/array/function_array_pushback.cpp +++ b/be/src/vec/functions/array/function_array_pushback.cpp @@ -61,7 +61,7 @@ public: }; Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const auto& [src_column, src_const] = unpack_if_const(block.get_by_position(arguments[0]).column); const auto& [right_column, right_const] = diff --git a/be/src/vec/functions/array/function_array_pushfront.cpp b/be/src/vec/functions/array/function_array_pushfront.cpp index 4e19ad8c33..28ba7ac6c3 100644 --- a/be/src/vec/functions/array/function_array_pushfront.cpp +++ b/be/src/vec/functions/array/function_array_pushfront.cpp @@ -64,7 +64,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto src_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); // extract src array column diff --git a/be/src/vec/functions/array/function_array_range.cpp b/be/src/vec/functions/array/function_array_range.cpp index 356941e261..2431e76c88 100644 --- a/be/src/vec/functions/array/function_array_range.cpp +++ b/be/src/vec/functions/array/function_array_range.cpp @@ -79,7 +79,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { return Impl::execute_impl(context, block, arguments, result, input_rows_count); } }; diff --git a/be/src/vec/functions/array/function_array_remove.h b/be/src/vec/functions/array/function_array_remove.h index fdda43de43..eb33952a2d 100644 --- a/be/src/vec/functions/array/function_array_remove.h +++ b/be/src/vec/functions/array/function_array_remove.h @@ -73,7 +73,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { // For default implementation of nulls args ColumnsWithTypeAndName args = {block.get_by_position(arguments[0]), block.get_by_position(arguments[1])}; @@ -93,7 +93,7 @@ public: private: template ColumnPtr _execute_number(const ColumnArray::Offsets64& offsets, const IColumn& nested_column, - const IColumn& right_column, const UInt8* nested_null_map) { + const IColumn& right_column, const UInt8* nested_null_map) const { // check array nested column type and get data const auto& src_data = reinterpret_cast(nested_column).get_data(); @@ -163,7 +163,7 @@ private: } ColumnPtr _execute_string(const ColumnArray::Offsets64& offsets, const IColumn& nested_column, - const IColumn& right_column, const UInt8* nested_null_map) { + const IColumn& right_column, const UInt8* nested_null_map) const { // check array nested column type and get data const auto& src_offs = reinterpret_cast(nested_column).get_offsets(); const auto& src_chars = reinterpret_cast(nested_column).get_chars(); @@ -253,7 +253,7 @@ private: template ColumnPtr _execute_number_expanded(const ColumnArray::Offsets64& offsets, const IColumn& nested_column, const IColumn& right_column, - const UInt8* nested_null_map) { + const UInt8* nested_null_map) const { if (check_column(right_column)) { return _execute_number( offsets, nested_column, right_column, nested_null_map); @@ -262,7 +262,7 @@ private: } ColumnPtr _execute_non_nullable(const ColumnsWithTypeAndName& arguments, - size_t input_rows_count) { + size_t input_rows_count) const { // check array nested column type and get data auto left_column = arguments[0].column->convert_to_full_column_if_const(); const auto& array_column = reinterpret_cast(*left_column); diff --git a/be/src/vec/functions/array/function_array_shuffle.cpp b/be/src/vec/functions/array/function_array_shuffle.cpp index 6f080b0cb9..cb3fc8ab7e 100644 --- a/be/src/vec/functions/array/function_array_shuffle.cpp +++ b/be/src/vec/functions/array/function_array_shuffle.cpp @@ -65,7 +65,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { ColumnPtr src_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); const auto& src_column_array = assert_cast(*src_column); @@ -90,7 +90,7 @@ public: } private: - ColumnPtr _execute(const ColumnArray& src_column_array, std::mt19937& g) { + ColumnPtr _execute(const ColumnArray& src_column_array, std::mt19937& g) const { const auto& src_offsets = src_column_array.get_offsets(); const auto src_nested_column = src_column_array.get_data_ptr(); diff --git a/be/src/vec/functions/array/function_array_slice.h b/be/src/vec/functions/array/function_array_slice.h index 43a84d4653..6cc5ece48a 100644 --- a/be/src/vec/functions/array/function_array_slice.h +++ b/be/src/vec/functions/array/function_array_slice.h @@ -69,7 +69,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto array_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); auto offset_column = diff --git a/be/src/vec/functions/array/function_array_sort.h b/be/src/vec/functions/array/function_array_sort.h index 5178780d82..800a137742 100644 --- a/be/src/vec/functions/array/function_array_sort.h +++ b/be/src/vec/functions/array/function_array_sort.h @@ -63,7 +63,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { ColumnPtr src_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); const auto& src_column_array = check_and_get_column(*src_column); @@ -80,7 +80,7 @@ public: } private: - ColumnPtr _execute(const ColumnArray& src_column_array) { + ColumnPtr _execute(const ColumnArray& src_column_array) const { const auto& src_offsets = src_column_array.get_offsets(); const auto& src_nested_column = src_column_array.get_data(); diff --git a/be/src/vec/functions/array/function_array_sortby.cpp b/be/src/vec/functions/array/function_array_sortby.cpp index a493a4ed88..15e296acb2 100644 --- a/be/src/vec/functions/array/function_array_sortby.cpp +++ b/be/src/vec/functions/array/function_array_sortby.cpp @@ -66,7 +66,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { ColumnPtr argument_columns[2] = {nullptr, nullptr}; ColumnPtr argument_nullmap[2] = {nullptr, nullptr}; for (int i = 0; i < 2; ++i) { diff --git a/be/src/vec/functions/array/function_array_with_constant.cpp b/be/src/vec/functions/array/function_array_with_constant.cpp index 9e3885b1c3..fcec2a89d5 100644 --- a/be/src/vec/functions/array/function_array_with_constant.cpp +++ b/be/src/vec/functions/array/function_array_with_constant.cpp @@ -76,7 +76,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto num = block.get_by_position(arguments[FunctionType::param_num_idx]) .column->convert_to_full_column_if_const(); num = num->is_nullable() diff --git a/be/src/vec/functions/array/function_array_zip.cpp b/be/src/vec/functions/array/function_array_zip.cpp index af925c1718..2f9b94454e 100644 --- a/be/src/vec/functions/array/function_array_zip.cpp +++ b/be/src/vec/functions/array/function_array_zip.cpp @@ -91,7 +91,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { size_t num_element = arguments.size(); // all the columns must have the same size as the first column diff --git a/be/src/vec/functions/array/function_arrays_overlap.h b/be/src/vec/functions/array/function_arrays_overlap.h index d4b9c8245e..7af722e10a 100644 --- a/be/src/vec/functions/array/function_arrays_overlap.h +++ b/be/src/vec/functions/array/function_arrays_overlap.h @@ -131,7 +131,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto left_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); auto right_column = @@ -242,7 +242,7 @@ public: } private: - Status _execute_nullable(const ColumnArrayExecutionData& data, UInt8* dst_nullmap_data) { + Status _execute_nullable(const ColumnArrayExecutionData& data, UInt8* dst_nullmap_data) const { for (ssize_t row = 0; row < data.offsets_ptr->size(); ++row) { if (dst_nullmap_data[row]) { continue; @@ -271,7 +271,7 @@ private: template Status _execute_internal(const ColumnArrayExecutionData& left_data, const ColumnArrayExecutionData& right_data, - const UInt8* dst_nullmap_data, UInt8* dst_data) { + const UInt8* dst_nullmap_data, UInt8* dst_data) const { using ExecutorImpl = OverlapSetImpl; for (ssize_t row = 0; row < left_data.offsets_ptr->size(); ++row) { if (dst_nullmap_data[row]) { diff --git a/be/src/vec/functions/comparison_equal_for_null.cpp b/be/src/vec/functions/comparison_equal_for_null.cpp index 20f7e8859a..80e0bd40d9 100644 --- a/be/src/vec/functions/comparison_equal_for_null.cpp +++ b/be/src/vec/functions/comparison_equal_for_null.cpp @@ -63,7 +63,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { ColumnWithTypeAndName& col_left = block.get_by_position(arguments[0]); ColumnWithTypeAndName& col_right = block.get_by_position(arguments[1]); diff --git a/be/src/vec/functions/function.h b/be/src/vec/functions/function.h index e1b9016be6..f3dc818db8 100644 --- a/be/src/vec/functions/function.h +++ b/be/src/vec/functions/function.h @@ -106,7 +106,7 @@ protected: virtual Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, - size_t input_rows_count) = 0; + size_t input_rows_count) const = 0; /** Default implementation in presence of Nullable arguments or NULL constants as arguments is the following: * if some of arguments are NULL constants then return NULL constant, @@ -430,9 +430,9 @@ public: bool is_stateful() const override { return false; } - /// TODO: make const - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override = 0; + virtual Status execute_impl(FunctionContext* context, Block& block, + const ColumnNumbers& arguments, size_t result, + size_t input_rows_count) const override = 0; /// Override this functions to change default implementation behavior. See details in IMyFunction. bool use_default_implementation_for_nulls() const override { return true; } @@ -497,7 +497,7 @@ public: protected: Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) final { + size_t result, size_t input_rows_count) const final { return function->execute_impl(context, block, arguments, result, input_rows_count); } Status execute_impl_dry_run(FunctionContext* context, Block& block, diff --git a/be/src/vec/functions/function_agg_state.h b/be/src/vec/functions/function_agg_state.h index 4340fe31d9..8d28e0da1e 100644 --- a/be/src/vec/functions/function_agg_state.h +++ b/be/src/vec/functions/function_agg_state.h @@ -62,7 +62,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto col = _agg_function->create_serialize_column(); std::vector agg_columns; std::vector save_columns; @@ -86,7 +86,7 @@ public: agg_columns.push_back(column); } _agg_function->streaming_agg_serialize_to_column(agg_columns.data(), col, input_rows_count, - &arena); + &(context->get_arena())); block.replace_by_position(result, std::move(col)); return Status::OK(); } @@ -95,7 +95,6 @@ private: DataTypes _argument_types; DataTypePtr _return_type; AggregateFunctionPtr _agg_function; - Arena arena; }; } // namespace doris::vectorized diff --git a/be/src/vec/functions/function_always_not_nullable.h b/be/src/vec/functions/function_always_not_nullable.h index 72c0048bf4..b6f18490bb 100644 --- a/be/src/vec/functions/function_always_not_nullable.h +++ b/be/src/vec/functions/function_always_not_nullable.h @@ -42,7 +42,7 @@ public: template Status execute_internal(const ColumnPtr& column, const DataTypePtr& data_type, - MutableColumnPtr& column_result) { + MutableColumnPtr& column_result) const { auto type_error = [&]() { return Status::RuntimeError("Illegal column {} of argument of function {}", column->get_name(), get_name()); @@ -76,7 +76,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const ColumnPtr& column = block.get_by_position(arguments[0]).column; const DataTypePtr& data_type = block.get_by_position(arguments[0]).type; WhichDataType which(data_type); diff --git a/be/src/vec/functions/function_binary_arithmetic.h b/be/src/vec/functions/function_binary_arithmetic.h index 1725ef30a2..122d5b01e9 100644 --- a/be/src/vec/functions/function_binary_arithmetic.h +++ b/be/src/vec/functions/function_binary_arithmetic.h @@ -808,7 +808,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto* left_generic = block.get_by_position(arguments[0]).type.get(); auto* right_generic = block.get_by_position(arguments[1]).type.get(); auto* result_generic = block.get_by_position(result).type.get(); diff --git a/be/src/vec/functions/function_bitmap.cpp b/be/src/vec/functions/function_bitmap.cpp index 7f90db70ab..15bb2d057a 100644 --- a/be/src/vec/functions/function_bitmap.cpp +++ b/be/src/vec/functions/function_bitmap.cpp @@ -357,7 +357,7 @@ public: bool use_default_implementation_for_nulls() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto res_null_map = ColumnUInt8::create(input_rows_count, 0); auto res_data_column = ColumnBitmap::create(); auto& null_map = res_null_map->get_data(); @@ -502,7 +502,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto res_data_column = ColumnInt64::create(); auto& res = res_data_column->get_data(); auto data_null_map = ColumnUInt8::create(input_rows_count, 0); @@ -755,21 +755,19 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { DCHECK_EQ(arguments.size(), 2); - - return execute_bitmap_op_count_null_to_zero( - context, block, arguments, result, input_rows_count, - std::bind((Status(FunctionBitmapAndNotCount::*)( - FunctionContext*, Block&, const ColumnNumbers&, size_t, size_t)) & - FunctionBitmapAndNotCount::execute_impl_internal, - this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, - std::placeholders::_4, std::placeholders::_5)); + auto impl_func = [&](FunctionContext* context, Block& block, const ColumnNumbers& arguments, + size_t result, size_t input_rows_count) { + return execute_impl_internal(context, block, arguments, result, input_rows_count); + }; + return execute_bitmap_op_count_null_to_zero(context, block, arguments, result, + input_rows_count, impl_func); } Status execute_impl_internal(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, - size_t input_rows_count) { + size_t input_rows_count) const { using ResultType = typename ResultDataType::FieldType; using ColVecResult = ColumnVector; @@ -1161,7 +1159,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { DCHECK_EQ(arguments.size(), 3); auto res_null_map = ColumnUInt8::create(input_rows_count, 0); auto res_data_column = ColumnBitmap::create(input_rows_count); @@ -1220,7 +1218,7 @@ public: bool use_default_implementation_for_nulls() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto return_nested_type = make_nullable(std::make_shared()); auto dest_array_column_ptr = ColumnArray::create(return_nested_type->create_column(), ColumnArray::ColumnOffsets::create()); diff --git a/be/src/vec/functions/function_bitmap_min_or_max.h b/be/src/vec/functions/function_bitmap_min_or_max.h index a467a65647..726fdb3b42 100644 --- a/be/src/vec/functions/function_bitmap_min_or_max.h +++ b/be/src/vec/functions/function_bitmap_min_or_max.h @@ -50,7 +50,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto result_column = ColumnInt64::create(); auto result_null_map_column = ColumnUInt8::create(input_rows_count, 0); @@ -76,7 +76,7 @@ public: private: void execute_straight(const ColumnBitmap* date_column, ColumnInt64* result_column, - NullMap& result_null_map, size_t input_rows_count) { + NullMap& result_null_map, size_t input_rows_count) const { for (size_t i = 0; i < input_rows_count; i++) { if (result_null_map[i]) { result_column->insert_default(); diff --git a/be/src/vec/functions/function_bitmap_variadic.cpp b/be/src/vec/functions/function_bitmap_variadic.cpp index e128bf4a40..b2a09bb6a9 100644 --- a/be/src/vec/functions/function_bitmap_variadic.cpp +++ b/be/src/vec/functions/function_bitmap_variadic.cpp @@ -206,16 +206,15 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { if (std::is_same_v || std::is_same_v) { - return execute_bitmap_op_count_null_to_zero( - context, block, arguments, result, input_rows_count, - std::bind((Status(FunctionBitMapVariadic::*)(FunctionContext*, Block&, - const ColumnNumbers&, size_t, - size_t)) & - FunctionBitMapVariadic::execute_impl_internal, - this, std::placeholders::_1, std::placeholders::_2, - std::placeholders::_3, std::placeholders::_4, std::placeholders::_5)); + auto impl_func = [&](FunctionContext* context, Block& block, + const ColumnNumbers& arguments, size_t result, + size_t input_rows_count) { + return execute_impl_internal(context, block, arguments, result, input_rows_count); + }; + return execute_bitmap_op_count_null_to_zero(context, block, arguments, result, + input_rows_count, impl_func); } else { return execute_impl_internal(context, block, arguments, result, input_rows_count); } @@ -223,7 +222,7 @@ public: Status execute_impl_internal(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, - size_t input_rows_count) { + size_t input_rows_count) const { size_t argument_size = arguments.size(); ColumnPtr argument_columns[argument_size]; diff --git a/be/src/vec/functions/function_case.h b/be/src/vec/functions/function_case.h index c3592e5ef3..86a3322d20 100644 --- a/be/src/vec/functions/function_case.h +++ b/be/src/vec/functions/function_case.h @@ -153,7 +153,7 @@ public: template Status execute_short_circuit(const DataTypePtr& data_type, Block& block, size_t result, - CaseWhenColumnHolder column_holder) { + CaseWhenColumnHolder column_holder) const { auto case_column_ptr = column_holder.when_ptrs[0].value_or(nullptr); int rows_count = column_holder.rows_count; @@ -196,7 +196,7 @@ public: template Status execute_impl(const DataTypePtr& data_type, Block& block, size_t result, - CaseWhenColumnHolder column_holder) { + CaseWhenColumnHolder column_holder) const { if (column_holder.pair_count > UINT8_MAX) { return execute_short_circuit(data_type, block, result, column_holder); @@ -250,7 +250,7 @@ public: template Status execute_update_result(const DataTypePtr& data_type, size_t result, Block& block, - uint8* then_idx, CaseWhenColumnHolder& column_holder) { + uint8* then_idx, CaseWhenColumnHolder& column_holder) const { auto result_column_ptr = data_type->create_column(); if constexpr (std::is_same_v || @@ -278,7 +278,7 @@ public: template void update_result_normal(MutableColumnPtr& result_column_ptr, IndexType* then_idx, - CaseWhenColumnHolder& column_holder) { + CaseWhenColumnHolder& column_holder) const { std::vector is_consts(column_holder.then_ptrs.size()); std::vector raw_columns(column_holder.then_ptrs.size()); for (size_t i = 0; i < column_holder.then_ptrs.size(); i++) { @@ -309,7 +309,7 @@ public: template void update_result_auto_simd(MutableColumnPtr& result_column_ptr, const uint8* __restrict then_idx, - CaseWhenColumnHolder& column_holder) { + CaseWhenColumnHolder& column_holder) const { for (size_t i = 0; i < column_holder.then_ptrs.size(); i++) { column_holder.then_ptrs[i]->reset( column_holder.then_ptrs[i].value()->convert_to_full_column_if_const()); @@ -342,7 +342,7 @@ public: template Status execute_get_then_null(const DataTypePtr& data_type, Block& block, const ColumnNumbers& arguments, size_t result, - size_t input_rows_count) { + size_t input_rows_count) const { bool then_null = false; for (int i = 1 + has_case; i < arguments.size() - has_else; i += 2) { if (block.get_by_position(arguments[i]).type->is_nullable()) { @@ -372,7 +372,7 @@ public: template Status execute_get_when_null(const DataTypePtr& data_type, Block& block, const ColumnNumbers& arguments, size_t result, - size_t input_rows_count) { + size_t input_rows_count) const { bool when_null = false; if constexpr (has_case) { block.replace_by_position_if_const(arguments[0]); @@ -398,7 +398,7 @@ public: Status execute_get_type(const DataTypePtr& data_type, Block& block, const ColumnNumbers& arguments, size_t result, - size_t input_rows_count) { + size_t input_rows_count) const { WhichDataType which( data_type->is_nullable() ? assert_cast(data_type.get())->get_nested_type() @@ -413,7 +413,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { return execute_get_type(block.get_by_position(result).type, block, arguments, result, input_rows_count); } diff --git a/be/src/vec/functions/function_cast.h b/be/src/vec/functions/function_cast.h index 1cfa86d540..5f0c7d2a3d 100644 --- a/be/src/vec/functions/function_cast.h +++ b/be/src/vec/functions/function_cast.h @@ -1115,7 +1115,7 @@ public: ColumnNumbers get_arguments_that_are_always_constant() const override { return {1}; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { if (!arguments.size()) { return Status::RuntimeError("Function {} expects at least 1 arguments", get_name()); } @@ -1304,7 +1304,7 @@ public: protected: Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { /// drop second argument, pass others ColumnNumbers new_arguments {arguments.front()}; if (arguments.size() > 2) @@ -1458,7 +1458,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const IDataType* from_type = block.get_by_position(arguments[0]).type.get(); if (check_and_get_data_type(from_type)) { @@ -1494,7 +1494,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { Status ret_status = Status::OK(); const IDataType* from_type = block.get_by_position(arguments[0]).type.get(); auto call = [&](const auto& types) -> bool { diff --git a/be/src/vec/functions/function_coalesce.cpp b/be/src/vec/functions/function_coalesce.cpp index 2a53f03d9a..8296e04c19 100644 --- a/be/src/vec/functions/function_coalesce.cpp +++ b/be/src/vec/functions/function_coalesce.cpp @@ -87,7 +87,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { DCHECK_GE(arguments.size(), 1); DataTypePtr result_type = block.get_by_position(result).type; ColumnNumbers filtered_args; @@ -226,7 +226,7 @@ public: template Status insert_result_data(MutableColumnPtr& result_column, ColumnPtr& argument_column, const UInt8* __restrict null_map_data, UInt8* __restrict filled_flag, - const size_t input_rows_count) { + const size_t input_rows_count) const { auto* __restrict result_raw_data = reinterpret_cast(result_column.get())->get_data().data(); auto* __restrict column_raw_data = @@ -245,7 +245,8 @@ public: Status insert_result_data_bitmap(MutableColumnPtr& result_column, ColumnPtr& argument_column, const UInt8* __restrict null_map_data, - UInt8* __restrict filled_flag, const size_t input_rows_count) { + UInt8* __restrict filled_flag, + const size_t input_rows_count) const { auto* __restrict result_raw_data = reinterpret_cast(result_column.get())->get_data().data(); auto* __restrict column_raw_data = @@ -268,7 +269,7 @@ public: ColumnPtr& argument_column, UInt8* __restrict null_map_data, UInt8* __restrict filled_flag, - const size_t input_rows_count) { + const size_t input_rows_count) const { WhichDataType which(data_type->is_nullable() ? reinterpret_cast(data_type.get()) ->get_nested_type() diff --git a/be/src/vec/functions/function_const.h b/be/src/vec/functions/function_const.h index 30f3852781..0ce24c85dc 100644 --- a/be/src/vec/functions/function_const.h +++ b/be/src/vec/functions/function_const.h @@ -44,7 +44,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { block.get_by_position(result).column = block.get_by_position(result).type->create_column_const(input_rows_count, Impl::init_value()); @@ -66,7 +66,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto column = Impl::ReturnColVec::create(); column->get_data().emplace_back(Impl::init_value()); block.replace_by_position(result, ColumnConst::create(std::move(column), input_rows_count)); @@ -90,7 +90,7 @@ private: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { block.get_by_position(result).column = block.get_by_position(result).type->create_column_const( input_rows_count == 0 ? 1 : input_rows_count, Impl::value); diff --git a/be/src/vec/functions/function_conv.cpp b/be/src/vec/functions/function_conv.cpp index b0a7ef7df9..c168c89900 100644 --- a/be/src/vec/functions/function_conv.cpp +++ b/be/src/vec/functions/function_conv.cpp @@ -75,7 +75,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto result_column = ColumnString::create(); auto result_null_map_column = ColumnUInt8::create(input_rows_count, 0); diff --git a/be/src/vec/functions/function_convert_tz.h b/be/src/vec/functions/function_convert_tz.h index 12b8c04913..32cb32578d 100644 --- a/be/src/vec/functions/function_convert_tz.h +++ b/be/src/vec/functions/function_convert_tz.h @@ -189,7 +189,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto result_null_map_column = ColumnUInt8::create(input_rows_count, 0); bool col_const[3]; diff --git a/be/src/vec/functions/function_date_or_datetime_computation.h b/be/src/vec/functions/function_date_or_datetime_computation.h index 2d7c190f89..cf0304e188 100644 --- a/be/src/vec/functions/function_date_or_datetime_computation.h +++ b/be/src/vec/functions/function_date_or_datetime_computation.h @@ -736,7 +736,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const auto& first_arg_type = block.get_by_position(arguments[0]).type; const auto& second_arg_type = block.get_by_position(arguments[1]).type; WhichDataType which1(remove_nullable(first_arg_type)); @@ -869,7 +869,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { return FunctionImpl::execute(context, block, arguments, result, input_rows_count); } }; @@ -1140,7 +1140,7 @@ struct TimestampToDateTime : IFunction { static FunctionPtr create() { return std::make_shared>(); } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const auto& arg_col = block.get_by_position(arguments[0]).column; const auto& column_data = assert_cast(*arg_col); auto res_col = ColumnUInt64::create(); diff --git a/be/src/vec/functions/function_date_or_datetime_to_something.h b/be/src/vec/functions/function_date_or_datetime_to_something.h index a822df9fed..200cd606c2 100644 --- a/be/src/vec/functions/function_date_or_datetime_to_something.h +++ b/be/src/vec/functions/function_date_or_datetime_to_something.h @@ -92,7 +92,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { return DateTimeTransformImpl::execute(block, arguments, result, input_rows_count); diff --git a/be/src/vec/functions/function_date_or_datetime_to_string.h b/be/src/vec/functions/function_date_or_datetime_to_string.h index 85ad246621..fc4ee46bbf 100644 --- a/be/src/vec/functions/function_date_or_datetime_to_string.h +++ b/be/src/vec/functions/function_date_or_datetime_to_string.h @@ -80,7 +80,7 @@ public: ColumnNumbers get_arguments_that_are_always_constant() const override { return {1}; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const ColumnPtr source_col = block.get_by_position(arguments[0]).column; const auto is_nullable = block.get_by_position(result).type->is_nullable(); const auto* sources = check_and_get_column>( diff --git a/be/src/vec/functions/function_datetime_floor_ceil.cpp b/be/src/vec/functions/function_datetime_floor_ceil.cpp index 8d256c409b..967a39c2a3 100644 --- a/be/src/vec/functions/function_datetime_floor_ceil.cpp +++ b/be/src/vec/functions/function_datetime_floor_ceil.cpp @@ -139,7 +139,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const ColumnPtr source_col = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); if (const auto* sources = diff --git a/be/src/vec/functions/function_datetime_string_to_string.h b/be/src/vec/functions/function_datetime_string_to_string.h index 68b8290a59..93eb84c84f 100644 --- a/be/src/vec/functions/function_datetime_string_to_string.h +++ b/be/src/vec/functions/function_datetime_string_to_string.h @@ -73,7 +73,7 @@ public: ColumnNumbers get_arguments_that_are_always_constant() const override { return {1}; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const ColumnPtr source_col = block.get_by_position(arguments[0]).column; const auto* nullable_column = check_and_get_column(source_col.get()); diff --git a/be/src/vec/functions/function_encryption.cpp b/be/src/vec/functions/function_encryption.cpp index a2758fcb15..ce01e2afa0 100644 --- a/be/src/vec/functions/function_encryption.cpp +++ b/be/src/vec/functions/function_encryption.cpp @@ -109,7 +109,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { size_t argument_size = arguments.size(); ColumnPtr argument_columns[argument_size]; std::vector offsets_list(argument_size); diff --git a/be/src/vec/functions/function_fake.h b/be/src/vec/functions/function_fake.h index 0efca39c9a..2f32fd146b 100644 --- a/be/src/vec/functions/function_fake.h +++ b/be/src/vec/functions/function_fake.h @@ -57,7 +57,7 @@ public: bool use_default_implementation_for_constants() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { return Status::NotSupported(Impl::get_error_msg()); } }; diff --git a/be/src/vec/functions/function_grouping.h b/be/src/vec/functions/function_grouping.h index 6eb220286d..0dbd50c8b9 100644 --- a/be/src/vec/functions/function_grouping.h +++ b/be/src/vec/functions/function_grouping.h @@ -53,7 +53,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const ColumnWithTypeAndName& src_column = block.get_by_position(arguments[0]); DCHECK(src_column.column->size() == input_rows_count); // result of functions grouping and grouping_id is always not nullable, diff --git a/be/src/vec/functions/function_hex.cpp b/be/src/vec/functions/function_hex.cpp index 9db623bbd2..494f58e61d 100644 --- a/be/src/vec/functions/function_hex.cpp +++ b/be/src/vec/functions/function_hex.cpp @@ -70,7 +70,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { ColumnPtr& argument_column = block.get_by_position(arguments[0]).column; auto result_data_column = ColumnString::create(); diff --git a/be/src/vec/functions/function_ifnull.h b/be/src/vec/functions/function_ifnull.h index a64d79bc51..3459663a3f 100644 --- a/be/src/vec/functions/function_ifnull.h +++ b/be/src/vec/functions/function_ifnull.h @@ -77,7 +77,7 @@ public: // ifnull(col_left, col_right) == if(isnull(col_left), col_right, col_left) Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { ColumnWithTypeAndName& col_left = block.get_by_position(arguments[0]); if (col_left.column->only_null()) { block.get_by_position(result).column = block.get_by_position(arguments[1]).column; diff --git a/be/src/vec/functions/function_ip.h b/be/src/vec/functions/function_ip.h index 9cce426c34..4dbbaf47eb 100644 --- a/be/src/vec/functions/function_ip.h +++ b/be/src/vec/functions/function_ip.h @@ -95,7 +95,7 @@ public: bool use_default_implementation_for_nulls() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { ColumnWithTypeAndName& argument = block.get_by_position(arguments[0]); switch (argument.type->get_type_id()) { diff --git a/be/src/vec/functions/function_java_udf.h b/be/src/vec/functions/function_java_udf.h index 875e3426df..410c65e817 100644 --- a/be/src/vec/functions/function_java_udf.h +++ b/be/src/vec/functions/function_java_udf.h @@ -55,7 +55,7 @@ public: protected: Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { return callback_function(context, block, arguments, result, input_rows_count); } diff --git a/be/src/vec/functions/function_json.cpp b/be/src/vec/functions/function_json.cpp index 124015818a..05c199e354 100644 --- a/be/src/vec/functions/function_json.cpp +++ b/be/src/vec/functions/function_json.cpp @@ -706,7 +706,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto result_column = ColumnString::create(); std::vector column_ptrs; // prevent converted column destruct @@ -855,7 +855,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto result_column = ColumnString::create(); std::vector column_ptrs; // prevent converted column destruct @@ -894,7 +894,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const IColumn& col_from = *(block.get_by_position(arguments[0]).column); auto null_map = ColumnUInt8::create(input_rows_count, 0); @@ -960,7 +960,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } bool json_contains_object(const rapidjson::Value& target, - const rapidjson::Value& search_value) { + const rapidjson::Value& search_value) const { if (!target.IsObject() || !search_value.IsObject()) { return false; } @@ -974,7 +974,8 @@ public: return true; } - bool json_contains_array(const rapidjson::Value& target, const rapidjson::Value& search_value) { + bool json_contains_array(const rapidjson::Value& target, + const rapidjson::Value& search_value) const { if (!target.IsArray() || !search_value.IsArray()) { return false; } @@ -995,7 +996,7 @@ public: return true; } - bool json_contains(const rapidjson::Value& target, const rapidjson::Value& search_value) { + bool json_contains(const rapidjson::Value& target, const rapidjson::Value& search_value) const { if (target == search_value) { return true; } @@ -1012,7 +1013,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const IColumn& col_json = *(block.get_by_position(arguments[0]).column); const IColumn& col_search = *(block.get_by_position(arguments[1]).column); const IColumn& col_path = *(block.get_by_position(arguments[2]).column); @@ -1085,7 +1086,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const IColumn& col_from = *(block.get_by_position(arguments[0]).column); auto null_map = ColumnUInt8::create(input_rows_count, 0); @@ -1164,7 +1165,8 @@ private: // if path is not a valid path expression or contains // a * wildcard, return runtime error. template - Status get_parsed_paths_with_status(const T& path_exprs, std::vector* parsed_paths) { + Status get_parsed_paths_with_status(const T& path_exprs, + std::vector* parsed_paths) const { if (UNLIKELY(path_exprs.empty())) { return Status::RuntimeError("json path empty function {}", get_name()); } @@ -1202,7 +1204,7 @@ private: Status get_parsed_path_columns(std::vector>>& json_paths, const std::vector& data_columns, - size_t input_rows_count) { + size_t input_rows_count) const { for (auto col = 1; col + 1 < data_columns.size() - 1; col += 2) { json_paths.emplace_back(std::vector>()); for (auto row = 0; row < input_rows_count; row++) { @@ -1251,7 +1253,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto result_column = ColumnString::create(); bool is_nullable = false; auto ret_null_map = ColumnUInt8::create(0, 0); @@ -1297,7 +1299,7 @@ public: Status execute_process(const std::vector& data_columns, ColumnString& result_column, size_t input_rows_count, const std::vector nullmaps, bool is_nullable, - ColumnUInt8& ret_null_map) { + ColumnUInt8& ret_null_map) const { std::string type_flags = data_columns.back()->get_data_at(0).to_string(); std::vector objects; diff --git a/be/src/vec/functions/function_jsonb.cpp b/be/src/vec/functions/function_jsonb.cpp index b9d61772f0..14f31c33b5 100644 --- a/be/src/vec/functions/function_jsonb.cpp +++ b/be/src/vec/functions/function_jsonb.cpp @@ -185,7 +185,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const IColumn& col_from = *(block.get_by_position(arguments[0]).column); auto null_map = ColumnUInt8::create(0, 0); @@ -354,7 +354,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto null_map = ColumnUInt8::create(input_rows_count, 0); DCHECK_GE(arguments.size(), 2); @@ -1022,7 +1022,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { return Impl::execute_impl(context, block, arguments, result, input_rows_count); } }; @@ -1146,7 +1146,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { return Impl::execute_impl(context, block, arguments, result, input_rows_count); } }; diff --git a/be/src/vec/functions/function_map.cpp b/be/src/vec/functions/function_map.cpp index eb21b6f839..dd342a0786 100644 --- a/be/src/vec/functions/function_map.cpp +++ b/be/src/vec/functions/function_map.cpp @@ -93,7 +93,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { DCHECK(arguments.size() % 2 == 0) << "function: " << get_name() << ", arguments should not be even number"; @@ -174,7 +174,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { // backup original argument 0 auto orig_arg0 = block.get_by_position(arguments[0]); auto left_column = @@ -269,7 +269,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto left_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); const ColumnMap* map_column = nullptr; diff --git a/be/src/vec/functions/function_math_unary.h b/be/src/vec/functions/function_math_unary.h index 29bcbcf419..c6496f57c5 100644 --- a/be/src/vec/functions/function_math_unary.h +++ b/be/src/vec/functions/function_math_unary.h @@ -128,7 +128,7 @@ private: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const ColumnWithTypeAndName& col = block.get_by_position(arguments[0]); auto call = [&](const auto& types) -> bool { diff --git a/be/src/vec/functions/function_math_unary_to_null_type.h b/be/src/vec/functions/function_math_unary_to_null_type.h index 3e64001dc8..02640aafb2 100644 --- a/be/src/vec/functions/function_math_unary_to_null_type.h +++ b/be/src/vec/functions/function_math_unary_to_null_type.h @@ -101,7 +101,7 @@ private: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const ColumnWithTypeAndName& col = block.get_by_position(arguments[0]); auto call = [&](const auto& types) -> bool { diff --git a/be/src/vec/functions/function_multi_same_args.h b/be/src/vec/functions/function_multi_same_args.h index 3da03beffd..aaac717331 100644 --- a/be/src/vec/functions/function_multi_same_args.h +++ b/be/src/vec/functions/function_multi_same_args.h @@ -46,7 +46,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { DCHECK_GE(arguments.size(), 1); block.replace_by_position(result, Impl::execute(block, arguments, input_rows_count)); return Status::OK(); diff --git a/be/src/vec/functions/function_nonnullable.cpp b/be/src/vec/functions/function_nonnullable.cpp index 22d9c688b4..fa7b5623b7 100644 --- a/be/src/vec/functions/function_nonnullable.cpp +++ b/be/src/vec/functions/function_nonnullable.cpp @@ -58,7 +58,7 @@ public: // trans nullable column to non-nullable column. If argument is already non-nullable, raise error. Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto& data = block.get_by_position(arguments[0]); const ColumnNullable* column = check_and_get_column(data.column); diff --git a/be/src/vec/functions/function_quantile_state.cpp b/be/src/vec/functions/function_quantile_state.cpp index b963a07a7a..b75abbc308 100644 --- a/be/src/vec/functions/function_quantile_state.cpp +++ b/be/src/vec/functions/function_quantile_state.cpp @@ -86,7 +86,7 @@ public: template Status execute_internal(const ColumnPtr& column, const DataTypePtr& data_type, - MutableColumnPtr& column_result) { + MutableColumnPtr& column_result, float compression) const { auto type_error = [&]() { return Status::RuntimeError("Illegal column {} of argument of function {}", column->get_name(), get_name()); @@ -127,16 +127,17 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const ColumnPtr& column = block.get_by_position(arguments[0]).column; const DataTypePtr& data_type = block.get_by_position(arguments[0]).type; auto compression_arg = check_and_get_column_const( block.get_by_position(arguments.back()).column); + float compression = 2048; if (compression_arg) { auto compression_arg_val = compression_arg->get_value(); if (compression_arg_val && compression_arg_val >= QUANTILE_STATE_COMPRESSION_MIN && compression_arg_val <= QUANTILE_STATE_COMPRESSION_MAX) { - this->compression = compression_arg_val; + compression = compression_arg_val; } } WhichDataType which(data_type); @@ -148,18 +149,15 @@ public: const DataTypePtr& nested_data_type = static_cast(data_type.get())->get_nested_type(); WhichDataType nested_which(nested_data_type); - execute_internal(column, data_type, column_result); + execute_internal(column, data_type, column_result, compression); } else { - execute_internal(column, data_type, column_result); + execute_internal(column, data_type, column_result, compression); } if (status.ok()) { block.replace_by_position(result, std::move(column_result)); } return status; } - -private: - float compression = 2048; }; class FunctionQuantileStatePercent : public IFunction { @@ -178,7 +176,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto res_data_column = ColumnFloat64::create(); auto& res = res_data_column->get_data(); auto data_null_map = ColumnUInt8::create(input_rows_count, 0); diff --git a/be/src/vec/functions/function_regexp.cpp b/be/src/vec/functions/function_regexp.cpp index 31ad61cc18..1a38fe741e 100644 --- a/be/src/vec/functions/function_regexp.cpp +++ b/be/src/vec/functions/function_regexp.cpp @@ -424,7 +424,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { size_t argument_size = arguments.size(); auto result_null_map = ColumnUInt8::create(input_rows_count, 0); diff --git a/be/src/vec/functions/function_reverse.h b/be/src/vec/functions/function_reverse.h index 074fa59880..e899b44aeb 100644 --- a/be/src/vec/functions/function_reverse.h +++ b/be/src/vec/functions/function_reverse.h @@ -42,7 +42,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { ColumnPtr& src_column = block.get_by_position(arguments[0]).column; if (const ColumnString* col_string = check_and_get_column(src_column.get())) { auto col_res = ColumnString::create(); diff --git a/be/src/vec/functions/function_running_difference.cpp b/be/src/vec/functions/function_running_difference.cpp deleted file mode 100644 index b4abda6b1d..0000000000 --- a/be/src/vec/functions/function_running_difference.cpp +++ /dev/null @@ -1,26 +0,0 @@ -// Licensed to the Apache Software Foundation (ASF) under one -// or more contributor license agreements. See the NOTICE file -// distributed with this work for additional information -// regarding copyright ownership. The ASF licenses this file -// to you under the Apache License, Version 2.0 (the -// "License"); you may not use this file except in compliance -// with the License. You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, -// software distributed under the License is distributed on an -// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -// KIND, either express or implied. See the License for the -// specific language governing permissions and limitations -// under the License. - -#include "vec/functions/function_running_difference.h" - -namespace doris::vectorized { - -void register_function_running_difference(SimpleFunctionFactory& factory) { - factory.register_function(); -} - -} // namespace doris::vectorized diff --git a/be/src/vec/functions/function_running_difference.h b/be/src/vec/functions/function_running_difference.h deleted file mode 100644 index 576b707057..0000000000 --- a/be/src/vec/functions/function_running_difference.h +++ /dev/null @@ -1,148 +0,0 @@ -// Licensed to the Apache Software Foundation (ASF) under one -// or more contributor license agreements. See the NOTICE file -// distributed with this work for additional information -// regarding copyright ownership. The ASF licenses this file -// to you under the Apache License, Version 2.0 (the -// "License"); you may not use this file except in compliance -// with the License. You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, -// software distributed under the License is distributed on an -// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -// KIND, either express or implied. See the License for the -// specific language governing permissions and limitations -// under the License. - -#pragma once - -#include - -#include -#include -#include -#include -#include - -#include "common/status.h" -#include "vec/aggregate_functions/aggregate_function.h" -#include "vec/columns/column.h" -#include "vec/common/string_ref.h" -#include "vec/core/block.h" -#include "vec/core/column_numbers.h" -#include "vec/core/column_with_type_and_name.h" -#include "vec/core/columns_with_type_and_name.h" -#include "vec/core/types.h" -#include "vec/data_types/data_type.h" -#include "vec/data_types/data_type_nullable.h" -#include "vec/data_types/data_type_number.h" -#include "vec/data_types/data_type_time.h" -#include "vec/data_types/number_traits.h" -#include "vec/functions/function.h" -#include "vec/functions/simple_function_factory.h" - -namespace doris { -class FunctionContext; -} // namespace doris - -namespace doris::vectorized { - -class FunctionRunningDifference : public IFunction { -public: - static constexpr auto name = "running_difference"; - - static FunctionPtr create() { return std::make_shared(); } - - String get_name() const override { return name; } - - size_t get_number_of_arguments() const override { return 1; } - - bool use_default_implementation_for_nulls() const override { return false; } - - template - using DstFieldType = - typename NumberTraits::ResultOfSubtraction::Type; - DataTypePtr get_return_type_impl(const DataTypes& arguments) const override { - bool is_nullable = arguments[0]->is_nullable(); - auto nested_type = remove_nullable(arguments[0]); - WhichDataType which(nested_type); - //return type is promoted to prevent result overflow - //like: input is int32 ---> return type will be int64 - DataTypePtr return_type = nullptr; - if (which.is_uint8() || which.is_int8()) { - return_type = std::make_shared(); - } else if (which.is_uint16() || which.is_int16()) { - return_type = std::make_shared(); - } else if (which.is_uint32() || which.is_uint64() || which.is_int32() || which.is_int64()) { - return_type = std::make_shared(); - } else if (which.is_int128()) { - return_type = std::make_shared(); - } else if (which.is_float32() || which.is_float64()) { - return_type = std::make_shared(); - } else if (which.is_decimal()) { - return_type = nested_type; - } else if (which.is_date_time()) { - return_type = std::make_shared(); - } else if (which.is_date_time_v2()) { - return_type = std::make_shared(); - } else if (which.is_date() || which.is_date_v2()) { - return_type = std::make_shared(); - } - - return_type = is_nullable ? make_nullable(return_type) : return_type; - const ColumnsWithTypeAndName subtract_cols {{nullptr, arguments[0], "first_arg"}, - {nullptr, arguments[0], "second_arg"}}; - if (which.is_date_time() || which.is_date_time_v2()) { - func_subtract = SimpleFunctionFactory::instance().get_function( - "timediff", subtract_cols, return_type); - } else if (which.is_date() || which.is_date_v2()) { - func_subtract = SimpleFunctionFactory::instance().get_function( - "datediff", subtract_cols, return_type); - } else { - func_subtract = SimpleFunctionFactory::instance().get_function( - "subtract", subtract_cols, return_type); - } - func_return_type = return_type; - return return_type; - } - - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { - if (is_column_const(*block.get_by_position(arguments[0]).column)) { - auto res = func_return_type->create_column_const_with_default_value(input_rows_count); - block.replace_by_position(result, std::move(res)); - return Status::OK(); - } - - auto arg_first = block.get_by_position(arguments[0]).column; - auto arg_type = block.get_by_position(arguments[0]).type; - auto arg_second = arg_type->create_column(); - - if (is_first_block) { - arg_second->insert_from(*arg_first, 0); - is_first_block = false; - } else { - arg_second->insert_data(last_value.c_str(), last_value.length()); - } - arg_second->insert_range_from(*arg_first, 0, input_rows_count - 1); - last_value = arg_first->get_data_at(input_rows_count - 1).to_string(); - - Block temporary_block { - ColumnsWithTypeAndName {block.get_by_position(arguments[0]), - {std::move(arg_second), arg_type, "second_arg"}, - block.get_by_position(result)}}; - - func_subtract->execute(context, temporary_block, {0, 1}, 2, input_rows_count); - block.get_by_position(result).column = temporary_block.get_by_position(2).column; - return Status::OK(); - } - -private: - mutable FunctionBasePtr func_subtract; - mutable DataTypePtr func_return_type; - bool is_first_block = true; - std::string last_value; -}; - -} // namespace doris::vectorized \ No newline at end of file diff --git a/be/src/vec/functions/function_size.cpp b/be/src/vec/functions/function_size.cpp index 988f909443..803d6d283d 100644 --- a/be/src/vec/functions/function_size.cpp +++ b/be/src/vec/functions/function_size.cpp @@ -46,7 +46,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const auto& [left_column, left_const] = unpack_if_const(block.get_by_position(arguments[0]).column); const auto type = block.get_by_position(arguments[0]).type; diff --git a/be/src/vec/functions/function_string.cpp b/be/src/vec/functions/function_string.cpp index df9f28a579..0573eca2dc 100644 --- a/be/src/vec/functions/function_string.cpp +++ b/be/src/vec/functions/function_string.cpp @@ -575,7 +575,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { return impl::execute(context, block, arguments, result, input_rows_count); } }; diff --git a/be/src/vec/functions/function_string.h b/be/src/vec/functions/function_string.h index 37a21a3ea5..5bfa44b387 100644 --- a/be/src/vec/functions/function_string.h +++ b/be/src/vec/functions/function_string.h @@ -317,7 +317,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { return Impl::execute_impl(context, block, arguments, result, input_rows_count); } }; @@ -395,7 +395,7 @@ public: bool use_default_implementation_for_nulls() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { DCHECK_GE(arguments.size(), 1); DCHECK_LE(arguments.size(), 4); @@ -494,7 +494,7 @@ public: bool use_default_implementation_for_nulls() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { DCHECK_GE(arguments.size(), 1); DCHECK_LE(arguments.size(), 2); @@ -573,7 +573,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto int_type = std::make_shared(); size_t num_columns_without_result = block.columns(); block.insert({int_type->create_column_const(input_rows_count, to_field(1)), int_type, @@ -600,7 +600,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto int_type = std::make_shared(); auto params1 = ColumnInt32::create(input_rows_count); auto params2 = ColumnInt32::create(input_rows_count); @@ -693,7 +693,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { NullOrEmptyImpl::execute(context, block, arguments, result, input_rows_count, false); return Status::OK(); } @@ -713,7 +713,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { NullOrEmptyImpl::execute(context, block, arguments, result, input_rows_count, true); return Status::OK(); } @@ -733,7 +733,7 @@ public: bool use_default_implementation_for_nulls() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { DCHECK_GE(arguments.size(), 1); if (arguments.size() == 1) { @@ -816,7 +816,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { int arguent_size = arguments.size(); int num_children = arguent_size - 1; auto res = ColumnString::create(); @@ -928,7 +928,7 @@ public: bool use_default_implementation_for_constants() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { int arguent_size = arguments.size(); auto pos_col = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); @@ -979,7 +979,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { DCHECK_GE(arguments.size(), 2); auto null_map = ColumnUInt8::create(input_rows_count, 0); // we create a zero column to simply implement @@ -1061,7 +1061,7 @@ private: const std::vector& offsets_list, const std::vector& chars_list, const std::vector& null_list, - Chars& res_data, Offsets& res_offset) { + Chars& res_data, Offsets& res_offset) const { // Get array nested column const UInt8* array_nested_null_map = nullptr; ColumnPtr array_nested_column = nullptr; @@ -1130,7 +1130,7 @@ private: const std::vector& offsets_list, const std::vector& chars_list, const std::vector& null_list, - Chars& res_data, Offsets& res_offset) { + Chars& res_data, Offsets& res_offset) const { // Concat string for (size_t i = 0; i < input_rows_count; ++i) { auto& sep_offsets = *offsets_list[0]; @@ -1176,7 +1176,7 @@ public: return make_nullable(std::make_shared()); } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { DCHECK_EQ(arguments.size(), 2); auto res = ColumnString::create(); auto null_map = ColumnUInt8::create(); @@ -1223,7 +1223,7 @@ public: void vector_vector(const ColumnString::Chars& data, const ColumnString::Offsets& offsets, const ColumnInt32::Container& repeats, ColumnString::Chars& res_data, ColumnString::Offsets& res_offsets, ColumnUInt8::Container& null_map, - const int repeat_max_num) { + const int repeat_max_num) const { size_t input_row_size = offsets.size(); fmt::memory_buffer buffer; @@ -1258,7 +1258,7 @@ public: // 3. rethink we should use `DEFAULT_MAX_STRING_SIZE` to bigger here void vector_const(const ColumnString::Chars& data, const ColumnString::Offsets& offsets, int repeat, ColumnString::Chars& res_data, ColumnString::Offsets& res_offsets, - ColumnUInt8::Container& null_map) { + ColumnUInt8::Container& null_map) const { size_t input_row_size = offsets.size(); fmt::memory_buffer buffer; @@ -1296,7 +1296,7 @@ public: bool use_default_implementation_for_nulls() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { DCHECK_GE(arguments.size(), 3); auto null_map = ColumnUInt8::create(input_rows_count, 0); // we create a zero column to simply implement @@ -1439,7 +1439,7 @@ public: bool use_default_implementation_for_nulls() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { DCHECK_EQ(arguments.size(), 3); auto null_map = ColumnUInt8::create(input_rows_count, 0); @@ -1613,7 +1613,7 @@ public: bool use_default_implementation_for_constants() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { DCHECK_EQ(arguments.size(), 3); auto null_map = ColumnUInt8::create(input_rows_count, 0); @@ -1795,7 +1795,7 @@ public: } Status execute_impl(FunctionContext* /*context*/, Block& block, const ColumnNumbers& arguments, - size_t result, size_t /*input_rows_count*/) override { + size_t result, size_t /*input_rows_count*/) const override { DCHECK_EQ(arguments.size(), 2); const auto& [src_column, left_const] = @@ -1838,7 +1838,7 @@ public: private: void _execute_constant(const ColumnString& src_column_string, const StringRef& delimiter_ref, IColumn& dest_nested_column, ColumnArray::Offsets64& dest_offsets, - NullMapType* dest_nested_null_map) { + NullMapType* dest_nested_null_map) const { ColumnString& dest_column_string = reinterpret_cast(dest_nested_column); ColumnString::Chars& column_string_chars = dest_column_string.get_chars(); ColumnString::Offsets& column_string_offsets = dest_column_string.get_offsets(); @@ -1904,7 +1904,8 @@ private: void _execute_vector(const ColumnString& src_column_string, const ColumnString& delimiter_column, IColumn& dest_nested_column, - ColumnArray::Offsets64& dest_offsets, NullMapType* dest_nested_null_map) { + ColumnArray::Offsets64& dest_offsets, + NullMapType* dest_nested_null_map) const { ColumnString& dest_column_string = reinterpret_cast(dest_nested_column); ColumnString::Chars& column_string_chars = dest_column_string.get_chars(); ColumnString::Offsets& column_string_offsets = dest_column_string.get_offsets(); @@ -1958,7 +1959,7 @@ private: } } - size_t split_str(size_t& pos, const StringRef str_ref, StringRef delimiter_ref) { + size_t split_str(size_t& pos, const StringRef str_ref, StringRef delimiter_ref) const { size_t old_size = pos; size_t str_size = str_ref.size; while (pos < str_size && @@ -1994,7 +1995,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { DCHECK_GE(arguments.size(), 1); int argument_size = arguments.size(); @@ -2058,7 +2059,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { DCHECK_EQ(arguments.size(), 1); ColumnPtr str_col = block.get_by_position(arguments[0]).column; @@ -2097,7 +2098,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { DCHECK(!is_column_const(*block.get_by_position(arguments[0]).column)); ColumnPtr str_col = block.get_by_position(arguments[0]).column; @@ -2134,7 +2135,7 @@ private: template void execute_base(const ColumnString::Chars& data, const ColumnString::Offsets& offset, int input_rows_count, ColumnString::Chars& res_data, - ColumnString::Offsets& res_offset) { + ColumnString::Offsets& res_offset) const { T digest; for (size_t i = 0; i < input_rows_count; ++i) { int size = offset[i] - offset[i - 1]; @@ -2158,7 +2159,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto col_url = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); auto col_parameter = @@ -2181,7 +2182,7 @@ public: } private: - StringRef extract_url(StringRef url, StringRef parameter) { + StringRef extract_url(StringRef url, StringRef parameter) const { if (url.size == 0 || parameter.size == 0) { return StringRef("", 0); } @@ -2203,7 +2204,7 @@ public: bool use_default_implementation_for_nulls() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto null_map = ColumnUInt8::create(input_rows_count, 0); auto& null_map_data = null_map->get_data(); @@ -2297,7 +2298,7 @@ public: size_t get_number_of_arguments() const override { return 1; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto res_column = ColumnString::create(); ColumnPtr argument_column = block.get_by_position(arguments[0]).column; @@ -2497,7 +2498,7 @@ public: bool is_variadic() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { DCHECK_EQ(arguments.size(), 3); bool col_const[3]; ColumnPtr argument_columns[3]; @@ -2534,7 +2535,7 @@ public: private: template void scalar_search(const StringRef& ldata, const ColumnString* col_right, - const PaddedPODArray& posdata, PaddedPODArray& res) { + const PaddedPODArray& posdata, PaddedPODArray& res) const { const ColumnString::Chars& rdata = col_right->get_chars(); const ColumnString::Offsets& roffsets = col_right->get_offsets(); @@ -2558,7 +2559,7 @@ private: template void vector_search(const ColumnString* col_left, const ColumnString* col_right, - const PaddedPODArray& posdata, PaddedPODArray& res) { + const PaddedPODArray& posdata, PaddedPODArray& res) const { const ColumnString::Chars& rdata = col_right->get_chars(); const ColumnString::Offsets& roffsets = col_right->get_offsets(); @@ -2586,7 +2587,7 @@ private: } int locate_pos(StringRef substr, StringRef str, std::shared_ptr search_ptr, - int start_pos) { + int start_pos) const { if (substr.size == 0) { if (start_pos <= 0) { return 0; @@ -2639,7 +2640,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto col_origin = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); auto col_old = @@ -2665,7 +2666,7 @@ public: } private: - std::string replace(std::string str, std::string_view old_str, std::string_view new_str) { + std::string replace(std::string str, std::string_view old_str, std::string_view new_str) const { if (old_str.empty()) { return str; } @@ -2726,7 +2727,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { return Impl::execute_impl(context, block, arguments, result, input_rows_count); } }; @@ -2866,7 +2867,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { ColumnPtr argument_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); const ColumnString* str_col = static_cast(argument_column.get()); @@ -2892,7 +2893,7 @@ public: return Status::OK(); } - void _utf8_to_pinyin(const char* in, size_t in_len, char* out, size_t* out_len) { + void _utf8_to_pinyin(const char* in, size_t in_len, char* out, size_t* out_len) const { auto do_memcpy = [](char*& dest, const char*& from, size_t size) { memcpy_small_allow_read_write_overflow15(dest, from, size); dest += size; @@ -3056,7 +3057,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { DCHECK_GE(arguments.size(), 2); int argument_size = arguments.size(); @@ -3209,7 +3210,7 @@ public: private: void integer_to_char_(int line_num, const int* num, ColumnString::Chars& chars, - IColumn::Offsets& offsets) { + IColumn::Offsets& offsets) const { if (0 == *num) { chars.push_back(' '); offsets[line_num] = offsets[line_num - 1] + 1; diff --git a/be/src/vec/functions/function_string_to_string.h b/be/src/vec/functions/function_string_to_string.h index 742e1687f3..1317506805 100644 --- a/be/src/vec/functions/function_string_to_string.h +++ b/be/src/vec/functions/function_string_to_string.h @@ -59,7 +59,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const ColumnPtr column = block.get_by_position(arguments[0]).column; if (const ColumnString* col = check_and_get_column(column.get())) { auto col_res = ColumnString::create(); diff --git a/be/src/vec/functions/function_struct.cpp b/be/src/vec/functions/function_struct.cpp index 0343d3b616..c3a5eb6dc5 100644 --- a/be/src/vec/functions/function_struct.cpp +++ b/be/src/vec/functions/function_struct.cpp @@ -74,7 +74,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto result_col = block.get_by_position(result).type->create_column(); auto struct_column = typeid_cast(result_col.get()); if (!struct_column) { diff --git a/be/src/vec/functions/function_struct_element.cpp b/be/src/vec/functions/function_struct_element.cpp index d3bf0fa164..0a9e71a348 100644 --- a/be/src/vec/functions/function_struct_element.cpp +++ b/be/src/vec/functions/function_struct_element.cpp @@ -69,7 +69,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto struct_type = check_and_get_data_type( block.get_by_position(arguments[0]).type.get()); auto struct_col = check_and_get_column( diff --git a/be/src/vec/functions/function_timestamp.cpp b/be/src/vec/functions/function_timestamp.cpp index 5222b529a0..7d36c7c504 100644 --- a/be/src/vec/functions/function_timestamp.cpp +++ b/be/src/vec/functions/function_timestamp.cpp @@ -488,7 +488,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto null_map = ColumnUInt8::create(input_rows_count, 0); ColumnPtr& argument_column = block.get_by_position(arguments[0]).column; @@ -519,7 +519,7 @@ private: template void execute_straight(size_t input_rows_count, NullMap& null_map, const PaddedPODArray& data_col, - PaddedPODArray& res_data) { + PaddedPODArray& res_data) const { for (int i = 0; i < input_rows_count; i++) { if constexpr (std::is_same_v) { const auto& cur_data = data_col[i]; @@ -773,7 +773,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { return Impl::execute_impl(context, block, arguments, result, input_rows_count); } }; @@ -807,7 +807,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const auto& arg_col = block.get_by_position(arguments[0]).column; const auto& column_data = assert_cast(*arg_col); auto res_col = ColumnInt64::create(); @@ -886,7 +886,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { return Impl::execute_impl(context, block, arguments, result, input_rows_count); } }; @@ -1258,7 +1258,7 @@ public: //ColumnNumbers get_arguments_that_are_always_constant() const override { return {1}; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { return Impl::execute(context, block, arguments, result, input_rows_count); } }; diff --git a/be/src/vec/functions/function_tokenize.cpp b/be/src/vec/functions/function_tokenize.cpp index 11760a30f5..648f79db30 100644 --- a/be/src/vec/functions/function_tokenize.cpp +++ b/be/src/vec/functions/function_tokenize.cpp @@ -59,7 +59,7 @@ void FunctionTokenize::_do_tokenize(const ColumnString& src_column_string, InvertedIndexCtx& inverted_index_ctx, IColumn& dest_nested_column, ColumnArray::Offsets64& dest_offsets, - NullMapType* dest_nested_null_map) { + NullMapType* dest_nested_null_map) const { ColumnString& dest_column_string = reinterpret_cast(dest_nested_column); ColumnString::Chars& column_string_chars = dest_column_string.get_chars(); ColumnString::Offsets& column_string_offsets = dest_column_string.get_offsets(); @@ -105,7 +105,7 @@ void FunctionTokenize::_do_tokenize(const ColumnString& src_column_string, Status FunctionTokenize::execute_impl(FunctionContext* /*context*/, Block& block, const ColumnNumbers& arguments, size_t result, - size_t /*input_rows_count*/) { + size_t /*input_rows_count*/) const { DCHECK_EQ(arguments.size(), 2); const auto& [src_column, left_const] = unpack_if_const(block.get_by_position(arguments[0]).column); diff --git a/be/src/vec/functions/function_tokenize.h b/be/src/vec/functions/function_tokenize.h index 20b4f74284..f632d8fd4c 100644 --- a/be/src/vec/functions/function_tokenize.h +++ b/be/src/vec/functions/function_tokenize.h @@ -67,9 +67,9 @@ public: } void _do_tokenize(const ColumnString& src_column_string, InvertedIndexCtx& inverted_index_ctx, IColumn& dest_nested_column, ColumnArray::Offsets64& dest_offsets, - NullMapType* dest_nested_null_map); + NullMapType* dest_nested_null_map) const; Status execute_impl(FunctionContext* /*context*/, Block& block, const ColumnNumbers& arguments, - size_t result, size_t /*input_rows_count*/) override; + size_t result, size_t /*input_rows_count*/) const override; Status open(FunctionContext* context, FunctionContext::FunctionStateScope scope) override { return Status::OK(); diff --git a/be/src/vec/functions/function_totype.h b/be/src/vec/functions/function_totype.h index 2dc72cbec6..f2f0934ead 100644 --- a/be/src/vec/functions/function_totype.h +++ b/be/src/vec/functions/function_totype.h @@ -52,7 +52,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { return execute_impl(block, arguments, result, input_rows_count); } @@ -68,7 +68,7 @@ private: template requires std::is_same_v Status execute_impl(Block& block, const ColumnNumbers& arguments, size_t result, - size_t input_rows_count) { + size_t input_rows_count) const { const ColumnPtr column = block.get_by_position(arguments[0]).column; if constexpr (typeindex_is_int(Impl::TYPE_INDEX)) { if (auto* col = check_and_get_column>(column.get())) { @@ -96,7 +96,7 @@ private: template requires(!std::is_same_v) Status execute_impl(Block& block, const ColumnNumbers& arguments, size_t result, - size_t input_rows_count) { + size_t input_rows_count) const { const ColumnPtr column = block.get_by_position(arguments[0]).column; if constexpr (Impl::TYPE_INDEX == TypeIndex::String) { if (const ColumnString* col = check_and_get_column(column.get())) { @@ -143,7 +143,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t /*input_rows_count*/) override { + size_t result, size_t /*input_rows_count*/) const override { DCHECK_EQ(arguments.size(), 2); const auto& [lcol, left_const] = unpack_if_const(block.get_by_position(arguments[0]).column); @@ -218,7 +218,7 @@ public: bool is_variadic() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t /*input_rows_count*/) override { + size_t result, size_t /*input_rows_count*/) const override { const auto& left = block.get_by_position(arguments[0]); const auto& right = block.get_by_position(arguments[1]); return execute_inner_impl(left, right, block, arguments, result); @@ -228,7 +228,7 @@ private: template requires(!std::is_same_v) Status execute_inner_impl(const ColumnWithTypeAndName& left, const ColumnWithTypeAndName& right, - Block& block, const ColumnNumbers& arguments, size_t result) { + Block& block, const ColumnNumbers& arguments, size_t result) const { const auto& [lcol, left_const] = unpack_if_const(left.column); const auto& [rcol, right_const] = unpack_if_const(right.column); @@ -313,7 +313,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto null_map = ColumnUInt8::create(input_rows_count, 0); DCHECK_EQ(arguments.size(), 2); @@ -386,7 +386,7 @@ public: return make_nullable(std::make_shared()); } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto null_map = ColumnUInt8::create(input_rows_count, 0); ColumnPtr argument_columns[2]; bool col_const[2]; @@ -459,7 +459,7 @@ public: bool use_default_implementation_for_nulls() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto null_map = ColumnUInt8::create(input_rows_count, 0); auto& col_ptr = block.get_by_position(arguments[0]).column; diff --git a/be/src/vec/functions/function_unary_arithmetic.h b/be/src/vec/functions/function_unary_arithmetic.h index 7081298de5..63376f93d7 100644 --- a/be/src/vec/functions/function_unary_arithmetic.h +++ b/be/src/vec/functions/function_unary_arithmetic.h @@ -107,7 +107,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { bool valid = cast_type(block.get_by_position(arguments[0]).type.get(), [&](const auto& type) { using DataType = std::decay_t; diff --git a/be/src/vec/functions/function_utility.cpp b/be/src/vec/functions/function_utility.cpp index 9637c7a21a..454e5afb8c 100644 --- a/be/src/vec/functions/function_utility.cpp +++ b/be/src/vec/functions/function_utility.cpp @@ -71,7 +71,7 @@ public: bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { ColumnPtr& argument_column = block.get_by_position(arguments[0]).column; auto res_column = ColumnUInt8::create(); @@ -128,7 +128,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { auto res_column = ColumnString::create(); res_column->insert_data(version.c_str(), version.length()); auto col_const = ColumnConst::create(std::move(res_column), input_rows_count); diff --git a/be/src/vec/functions/function_variadic_arguments.h b/be/src/vec/functions/function_variadic_arguments.h index 0ba9bf81b3..c13f911f11 100644 --- a/be/src/vec/functions/function_variadic_arguments.h +++ b/be/src/vec/functions/function_variadic_arguments.h @@ -51,7 +51,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { ToDataType to_type; auto column = to_type.create_column(); column->reserve(input_rows_count); diff --git a/be/src/vec/functions/function_width_bucket.cpp b/be/src/vec/functions/function_width_bucket.cpp index cf93e2c8e5..1daf3ed5ea 100644 --- a/be/src/vec/functions/function_width_bucket.cpp +++ b/be/src/vec/functions/function_width_bucket.cpp @@ -60,7 +60,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { ColumnPtr expr_ptr = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); ColumnPtr min_value_ptr = @@ -85,7 +85,7 @@ private: template void _execute(const IColumn& expr_column, const IColumn& min_value_column, const IColumn& max_value_column, const int64_t num_buckets, - IColumn& nested_column) { + IColumn& nested_column) const { const ColumnType& expr_column_concrete = reinterpret_cast(expr_column); const ColumnType& min_value_column_concrete = reinterpret_cast(min_value_column); @@ -116,7 +116,7 @@ private: void _execute_by_type(const IColumn& expr_column, const IColumn& min_value_column, const IColumn& max_value_column, const int64_t num_buckets, - IColumn& nested_column_column, DataTypePtr& expr_type) { + IColumn& nested_column_column, DataTypePtr& expr_type) const { WhichDataType which(remove_nullable(expr_type)); if (which.is_int8()) { _execute(expr_column, min_value_column, max_value_column, num_buckets, diff --git a/be/src/vec/functions/functions_comparison.h b/be/src/vec/functions/functions_comparison.h index e182722d7f..0bf03310b9 100644 --- a/be/src/vec/functions/functions_comparison.h +++ b/be/src/vec/functions/functions_comparison.h @@ -273,7 +273,7 @@ public: private: template bool execute_num_right_type(Block& block, size_t result, const ColumnVector* col_left, - const IColumn* col_right_untyped) { + const IColumn* col_right_untyped) const { if (const ColumnVector* col_right = check_and_get_column>(col_right_untyped)) { auto col_res = ColumnUInt8::create(); @@ -303,7 +303,7 @@ private: template bool execute_num_const_right_type(Block& block, size_t result, const ColumnConst* col_left, - const IColumn* col_right_untyped) { + const IColumn* col_right_untyped) const { if (const ColumnVector* col_right = check_and_get_column>(col_right_untyped)) { auto col_res = ColumnUInt8::create(); @@ -332,7 +332,7 @@ private: template bool execute_num_left_type(Block& block, size_t result, const IColumn* col_left_untyped, - const IColumn* col_right_untyped) { + const IColumn* col_right_untyped) const { if (const ColumnVector* col_left = check_and_get_column>(col_left_untyped)) { if (execute_num_right_type(block, result, col_left, col_right_untyped) || @@ -387,7 +387,7 @@ private: } Status execute_decimal(Block& block, size_t result, const ColumnWithTypeAndName& col_left, - const ColumnWithTypeAndName& col_right) { + const ColumnWithTypeAndName& col_right) const { TypeIndex left_number = col_left.type->get_type_id(); TypeIndex right_number = col_right.type->get_type_id(); @@ -408,7 +408,7 @@ private: return Status::OK(); } - Status execute_string(Block& block, size_t result, const IColumn* c0, const IColumn* c1) { + Status execute_string(Block& block, size_t result, const IColumn* c0, const IColumn* c1) const { const ColumnString* c0_string = check_and_get_column(c0); const ColumnString* c1_string = check_and_get_column(c1); const ColumnConst* c0_const = check_and_get_column_const_string_or_fixedstring(c0); @@ -480,7 +480,7 @@ private: } void execute_generic_identical_types(Block& block, size_t result, const IColumn* c0, - const IColumn* c1) { + const IColumn* c1) const { bool c0_const = is_column_const(*c0); bool c1_const = is_column_const(*c1); @@ -507,7 +507,7 @@ private: } Status execute_generic(Block& block, size_t result, const ColumnWithTypeAndName& c0, - const ColumnWithTypeAndName& c1) { + const ColumnWithTypeAndName& c1) const { execute_generic_identical_types(block, result, c0.column.get(), c1.column.get()); return Status::OK(); } @@ -523,7 +523,7 @@ public: } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { const auto& col_with_type_and_name_left = block.get_by_position(arguments[0]); const auto& col_with_type_and_name_right = block.get_by_position(arguments[1]); const IColumn* col_left_untyped = col_with_type_and_name_left.column.get(); diff --git a/be/src/vec/functions/functions_geo.h b/be/src/vec/functions/functions_geo.h index 48a048e534..11d2cd7f88 100644 --- a/be/src/vec/functions/functions_geo.h +++ b/be/src/vec/functions/functions_geo.h @@ -71,7 +71,7 @@ public: bool use_default_implementation_for_nulls() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) override { + size_t result, size_t input_rows_count) const override { if constexpr (Impl::NEED_CONTEXT) { return Impl::execute(context, block, arguments, result); } else { diff --git a/be/src/vec/functions/functions_logical.cpp b/be/src/vec/functions/functions_logical.cpp index af9deba563..b24fcf9139 100644 --- a/be/src/vec/functions/functions_logical.cpp +++ b/be/src/vec/functions/functions_logical.cpp @@ -204,7 +204,7 @@ template Status FunctionAnyArityLogical::execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result_index, - size_t input_rows_count) { + size_t input_rows_count) const { ColumnRawPtrs args_in; for (const auto arg_index : arguments) args_in.push_back(block.get_by_position(arg_index).column.get()); @@ -260,7 +260,7 @@ bool functionUnaryExecuteType(Block& block, const ColumnNumbers& arguments, size template