diff --git a/be/src/exprs/bitmapfilter_predicate.h b/be/src/exprs/bitmapfilter_predicate.h index 376453c06817b0..5cb2b812220b10 100644 --- a/be/src/exprs/bitmapfilter_predicate.h +++ b/be/src/exprs/bitmapfilter_predicate.h @@ -37,7 +37,7 @@ class BitmapFilterFuncBase : public RuntimeFilterFuncBase { virtual void light_copy(BitmapFilterFuncBase* other) { _not_in = other->_not_in; } virtual uint16_t find_fixed_len_olap_engine(const char* data, const uint8* nullmap, uint16_t* offsets, int number) = 0; - virtual void find_batch(const char* data, const uint8* nullmap, int number, + virtual void find_batch(const char* data, const uint8* nullmap, size_t number, uint8* results) const = 0; virtual size_t size() const = 0; bool is_not_in() const { return _not_in; } @@ -65,7 +65,7 @@ class BitmapFilterFunc : public BitmapFilterFuncBase { uint16_t find_fixed_len_olap_engine(const char* data, const uint8* nullmap, uint16_t* offsets, int number) override; - void find_batch(const char* data, const uint8* nullmap, int number, + void find_batch(const char* data, const uint8* nullmap, size_t number, uint8* results) const override; bool empty() override { return _bitmap_value->empty(); } @@ -133,9 +133,9 @@ uint16_t BitmapFilterFunc::find_fixed_len_olap_engine(const char* data, co } template -void BitmapFilterFunc::find_batch(const char* data, const uint8* nullmap, int number, +void BitmapFilterFunc::find_batch(const char* data, const uint8* nullmap, size_t number, uint8* results) const { - for (int i = 0; i < number; i++) { + for (size_t i = 0; i < number; i++) { results[i] = false; if (nullmap != nullptr && nullmap[i]) { continue; diff --git a/be/src/olap/column_predicate.h b/be/src/olap/column_predicate.h index 764521818f5b1f..64fc40184478d6 100644 --- a/be/src/olap/column_predicate.h +++ b/be/src/olap/column_predicate.h @@ -325,7 +325,7 @@ class ColumnPredicate { _judge_filter_rows = 0; } - void do_judge_selectivity(int64_t filter_rows, int64_t input_rows) const { + void do_judge_selectivity(uint64_t filter_rows, uint64_t input_rows) const { if ((_judge_counter--) == 0) { reset_judge_selectivity(); } @@ -352,8 +352,8 @@ class ColumnPredicate { // without recalculating. At the beginning of the next period, // reset_judge_selectivity is used to reset these variables. mutable int _judge_counter = 0; - mutable int _judge_input_rows = 0; - mutable int _judge_filter_rows = 0; + mutable uint64_t _judge_input_rows = 0; + mutable uint64_t _judge_filter_rows = 0; mutable bool _always_true = false; }; diff --git a/be/src/olap/push_handler.cpp b/be/src/olap/push_handler.cpp index 575b002b2f6086..56d167459f5be7 100644 --- a/be/src/olap/push_handler.cpp +++ b/be/src/olap/push_handler.cpp @@ -471,7 +471,7 @@ Status PushBrokerReader::_init_src_block() { } Status PushBrokerReader::_cast_to_input_block() { - size_t idx = 0; + uint32_t idx = 0; for (auto& slot_desc : _src_slot_descs) { if (_name_to_col_type.find(slot_desc->col_name()) == _name_to_col_type.end()) { continue; diff --git a/be/src/pipeline/exec/aggregation_sink_operator.cpp b/be/src/pipeline/exec/aggregation_sink_operator.cpp index 1d1bfbe7d173ab..27400fba474eef 100644 --- a/be/src/pipeline/exec/aggregation_sink_operator.cpp +++ b/be/src/pipeline/exec/aggregation_sink_operator.cpp @@ -20,6 +20,7 @@ #include #include +#include "common/cast_set.h" #include "common/status.h" #include "pipeline/exec/operator.h" #include "runtime/primitive_type.h" @@ -814,7 +815,8 @@ Status AggSinkOperatorX::open(RuntimeState* state) { // check output type if (_needs_finalize) { RETURN_IF_ERROR(vectorized::AggFnEvaluator::check_agg_fn_output( - _probe_expr_ctxs.size(), _aggregate_evaluators, _agg_fn_output_row_descriptor)); + cast_set(_probe_expr_ctxs.size()), _aggregate_evaluators, + _agg_fn_output_row_descriptor)); } RETURN_IF_ERROR(vectorized::VExpr::open(_probe_expr_ctxs, state)); diff --git a/be/src/pipeline/exec/scan_operator.cpp b/be/src/pipeline/exec/scan_operator.cpp index 6200f3b12ce5a0..f55ef7da36981c 100644 --- a/be/src/pipeline/exec/scan_operator.cpp +++ b/be/src/pipeline/exec/scan_operator.cpp @@ -375,7 +375,7 @@ Status ScanLocalState::_normalize_bloom_filter(vectorized::VExpr* expr, vectorized::VExprContext* expr_ctx, SlotDescriptor* slot, PushDownType* pdt) { if (TExprNodeType::BLOOM_PRED == expr->node_type()) { - DCHECK(expr->children().size() == 1); + DCHECK(expr->get_num_children() == 1); PushDownType temp_pdt = _should_push_down_bloom_filter(); if (temp_pdt != PushDownType::UNACCEPTABLE) { _filter_predicates.bloom_filters.emplace_back(slot->col_name(), @@ -391,7 +391,7 @@ Status ScanLocalState::_normalize_bitmap_filter(vectorized::VExpr* expr vectorized::VExprContext* expr_ctx, SlotDescriptor* slot, PushDownType* pdt) { if (TExprNodeType::BITMAP_PRED == expr->node_type()) { - DCHECK(expr->children().size() == 1); + DCHECK(expr->get_num_children() == 1); PushDownType temp_pdt = _should_push_down_bitmap_filter(); if (temp_pdt != PushDownType::UNACCEPTABLE) { _filter_predicates.bitmap_filters.emplace_back(slot->col_name(), @@ -620,7 +620,7 @@ Status ScanLocalState::_normalize_in_and_eq_predicate(vectorized::VExpr range.intersection(temp_range); *pdt = PushDownType::ACCEPTABLE; } else if (TExprNodeType::BINARY_PRED == expr->node_type()) { - DCHECK(expr->children().size() == 2); + DCHECK(expr->get_num_children() == 2); auto eq_checker = [](const std::string& fn_name) { return fn_name == "eq"; }; StringRef value; @@ -769,7 +769,7 @@ Status ScanLocalState::_normalize_not_in_and_not_eq_predicate( iter->next(); } } else if (TExprNodeType::BINARY_PRED == expr->node_type()) { - DCHECK(expr->children().size() == 2); + DCHECK(expr->get_num_children() == 2); auto ne_checker = [](const std::string& fn_name) { return fn_name == "ne"; }; StringRef value; @@ -924,7 +924,7 @@ Status ScanLocalState::_normalize_noneq_binary_predicate( vectorized::VExpr* expr, vectorized::VExprContext* expr_ctx, SlotDescriptor* slot, ColumnValueRange& range, PushDownType* pdt) { if (TExprNodeType::BINARY_PRED == expr->node_type()) { - DCHECK(expr->children().size() == 2); + DCHECK(expr->get_num_children() == 2); auto noneq_checker = [](const std::string& fn_name) { return fn_name != "ne" && fn_name != "eq" && fn_name != "eq_for_null"; diff --git a/be/src/pipeline/exec/streaming_aggregation_operator.cpp b/be/src/pipeline/exec/streaming_aggregation_operator.cpp index bc1e7fa8ae451f..cf5071d62e4737 100644 --- a/be/src/pipeline/exec/streaming_aggregation_operator.cpp +++ b/be/src/pipeline/exec/streaming_aggregation_operator.cpp @@ -22,6 +22,7 @@ #include #include +#include "common/cast_set.h" #include "common/compiler_util.h" // IWYU pragma: keep #include "pipeline/exec/operator.h" #include "vec/exprs/vectorized_agg_fn.h" @@ -1217,7 +1218,8 @@ Status StreamingAggOperatorX::open(RuntimeState* state) { // check output type if (_needs_finalize) { RETURN_IF_ERROR(vectorized::AggFnEvaluator::check_agg_fn_output( - _probe_expr_ctxs.size(), _aggregate_evaluators, _agg_fn_output_row_descriptor)); + cast_set(_probe_expr_ctxs.size()), _aggregate_evaluators, + _agg_fn_output_row_descriptor)); } RETURN_IF_ERROR(vectorized::VExpr::open(_probe_expr_ctxs, state)); diff --git a/be/src/util/simd/bits.h b/be/src/util/simd/bits.h index 7e2e7c8202569d..5953c651dc6f78 100644 --- a/be/src/util/simd/bits.h +++ b/be/src/util/simd/bits.h @@ -19,6 +19,7 @@ #include #include +#include #include #if defined(__ARM_NEON) && defined(__aarch64__) @@ -27,8 +28,7 @@ #include "util/sse_util.hpp" -namespace doris { -namespace simd { +namespace doris::simd { consteval auto bits_mask_length() { #if defined(__ARM_NEON) && defined(__aarch64__) @@ -70,7 +70,7 @@ inline uint64_t bytes16_mask_to_bits64_mask(const uint8_t* data) { inline uint32_t bytes32_mask_to_bits32_mask(const uint8_t* data) { #ifdef __AVX2__ auto zero32 = _mm256_setzero_si256(); - uint32_t mask = static_cast(_mm256_movemask_epi8( + auto mask = static_cast(_mm256_movemask_epi8( _mm256_cmpgt_epi8(_mm256_loadu_si256(reinterpret_cast(data)), zero32))); #elif defined(__SSE2__) auto zero16 = _mm_setzero_si128(); @@ -125,8 +125,10 @@ void iterate_through_bits_mask(Func func, decltype(bytes_mask_to_bits_mask(nullp #endif } -inline size_t count_zero_num(const int8_t* __restrict data, size_t size) { - size_t num = 0; +template + requires requires { std::is_unsigned_v; } +inline T count_zero_num(const int8_t* __restrict data, T size) { + T num = 0; const int8_t* end = data + size; #if defined(__SSE2__) && defined(__POPCNT__) const __m128i zero16 = _mm_setzero_si128(); @@ -138,13 +140,13 @@ inline size_t count_zero_num(const int8_t* __restrict data, size_t size) { _mm_loadu_si128(reinterpret_cast(data)), zero16))) | (static_cast(_mm_movemask_epi8(_mm_cmpeq_epi8( _mm_loadu_si128(reinterpret_cast(data + 16)), zero16))) - << 16u) | + << 16U) | (static_cast(_mm_movemask_epi8(_mm_cmpeq_epi8( _mm_loadu_si128(reinterpret_cast(data + 32)), zero16))) - << 32u) | + << 32U) | (static_cast(_mm_movemask_epi8(_mm_cmpeq_epi8( _mm_loadu_si128(reinterpret_cast(data + 48)), zero16))) - << 48u)); + << 48U)); } #endif for (; data < end; ++data) { @@ -153,9 +155,10 @@ inline size_t count_zero_num(const int8_t* __restrict data, size_t size) { return num; } -inline size_t count_zero_num(const int8_t* __restrict data, const uint8_t* __restrict null_map, - size_t size) { - size_t num = 0; +template + requires requires { std::is_unsigned_v; } +inline T count_zero_num(const int8_t* __restrict data, const uint8_t* __restrict null_map, T size) { + T num = 0; const int8_t* end = data + size; #if defined(__SSE2__) && defined(__POPCNT__) const __m128i zero16 = _mm_setzero_si128(); @@ -172,19 +175,19 @@ inline size_t count_zero_num(const int8_t* __restrict data, const uint8_t* __res _mm_loadu_si128(reinterpret_cast(data + 16)), zero16), _mm_loadu_si128(reinterpret_cast(null_map + 16))))) - << 16u) | + << 16U) | (static_cast(_mm_movemask_epi8(_mm_or_si128( _mm_cmpeq_epi8( _mm_loadu_si128(reinterpret_cast(data + 32)), zero16), _mm_loadu_si128(reinterpret_cast(null_map + 32))))) - << 32u) | + << 32U) | (static_cast(_mm_movemask_epi8(_mm_or_si128( _mm_cmpeq_epi8( _mm_loadu_si128(reinterpret_cast(data + 48)), zero16), _mm_loadu_si128(reinterpret_cast(null_map + 48))))) - << 48u)); + << 48U)); } #endif for (; data < end; ++data, ++null_map) { @@ -235,5 +238,4 @@ inline size_t find_zero(const std::vector& vec, size_t start) { return find_byte(vec, start, 0); } -} // namespace simd -} // namespace doris +} // namespace doris::simd diff --git a/be/src/vec/core/block.h b/be/src/vec/core/block.h index d1af45e1297d4f..2242db3f9058c2 100644 --- a/be/src/vec/core/block.h +++ b/be/src/vec/core/block.h @@ -194,7 +194,9 @@ class Block { // Skip the rows in block, use in OFFSET, LIMIT operation void skip_num_rows(int64_t& offset); - size_t columns() const { return data.size(); } + /// As the assumption we used around, the number of columns won't exceed int16 range. so no need to worry when we + /// assign it to int32. + uint32_t columns() const { return static_cast(data.size()); } /// Checks that every column in block is not nullptr and has same number of elements. void check_number_of_rows(bool allow_null_columns = false) const; diff --git a/be/src/vec/core/column_numbers.h b/be/src/vec/core/column_numbers.h index 25c8912f73c2ba..32a0dd5804ab22 100644 --- a/be/src/vec/core/column_numbers.h +++ b/be/src/vec/core/column_numbers.h @@ -20,11 +20,10 @@ #pragma once -#include +#include #include namespace doris::vectorized { -using ColumnNumbers = std::vector; - +using ColumnNumbers = std::vector; } diff --git a/be/src/vec/core/decimal_comparison.h b/be/src/vec/core/decimal_comparison.h index c5c1e40e2ff4df..9e9d9ad399ae04 100644 --- a/be/src/vec/core/decimal_comparison.h +++ b/be/src/vec/core/decimal_comparison.h @@ -79,7 +79,7 @@ class DecimalComparison { using ArrayA = typename ColVecA::Container; using ArrayB = typename ColVecB::Container; - DecimalComparison(Block& block, size_t result, const ColumnWithTypeAndName& col_left, + DecimalComparison(Block& block, uint32_t result, const ColumnWithTypeAndName& col_left, const ColumnWithTypeAndName& col_right) { if (!apply(block, result, col_left, col_right)) { LOG(FATAL) << fmt::format("Wrong decimal comparison with {} and {}", @@ -87,7 +87,7 @@ class DecimalComparison { } } - static bool apply(Block& block, size_t result [[maybe_unused]], + static bool apply(Block& block, uint32_t result [[maybe_unused]], const ColumnWithTypeAndName& col_left, const ColumnWithTypeAndName& col_right) { if constexpr (_actual) { diff --git a/be/src/vec/exec/format/orc/vorc_reader.cpp b/be/src/vec/exec/format/orc/vorc_reader.cpp index 6b6639f2feb244..6242d65a793626 100644 --- a/be/src/vec/exec/format/orc/vorc_reader.cpp +++ b/be/src/vec/exec/format/orc/vorc_reader.cpp @@ -773,7 +773,7 @@ Status OrcReader::set_fill_columns( visit_slot(child.get()); } } else if (VInPredicate* in_predicate = typeid_cast(filter_impl)) { - if (in_predicate->children().size() > 0) { + if (in_predicate->get_num_children() > 0) { visit_slot(in_predicate->children()[0].get()); } } else { diff --git a/be/src/vec/exec/format/parquet/vparquet_reader.cpp b/be/src/vec/exec/format/parquet/vparquet_reader.cpp index 6c4e4983c70a43..1a3ae2f885e4a0 100644 --- a/be/src/vec/exec/format/parquet/vparquet_reader.cpp +++ b/be/src/vec/exec/format/parquet/vparquet_reader.cpp @@ -412,7 +412,7 @@ Status ParquetReader::set_fill_columns( visit_slot(child.get()); } } else if (VInPredicate* in_predicate = typeid_cast(filter_impl)) { - if (in_predicate->children().size() > 0) { + if (in_predicate->get_num_children() > 0) { visit_slot(in_predicate->children()[0].get()); } } else { diff --git a/be/src/vec/exec/scan/vfile_scanner.cpp b/be/src/vec/exec/scan/vfile_scanner.cpp index 2ecf72687f758b..9353887799207d 100644 --- a/be/src/vec/exec/scan/vfile_scanner.cpp +++ b/be/src/vec/exec/scan/vfile_scanner.cpp @@ -428,7 +428,7 @@ Status VFileScanner::_cast_to_input_block(Block* block) { } SCOPED_TIMER(_cast_to_input_block_timer); // cast primitive type(PT0) to primitive type(PT1) - size_t idx = 0; + uint32_t idx = 0; for (auto& slot_desc : _input_tuple_desc->slots()) { if (_name_to_col_type.find(slot_desc->col_name()) == _name_to_col_type.end()) { // skip columns which does not exist in file diff --git a/be/src/vec/exec/vjdbc_connector.cpp b/be/src/vec/exec/vjdbc_connector.cpp index 0fa33bfaad917d..28baac567cc5d1 100644 --- a/be/src/vec/exec/vjdbc_connector.cpp +++ b/be/src/vec/exec/vjdbc_connector.cpp @@ -259,8 +259,8 @@ Status JdbcConnector::get_next(bool* eos, Block* block, int batch_size) { RETURN_IF_ERROR(JniUtil::GetJniExceptionMsg(env)); env->DeleteLocalRef(map); - std::vector all_columns; - for (size_t i = 0; i < column_size; ++i) { + std::vector all_columns; + for (uint32_t i = 0; i < column_size; ++i) { all_columns.push_back(i); } SCOPED_RAW_TIMER(&_jdbc_statistic._fill_block_timer); diff --git a/be/src/vec/exprs/lambda_function/varray_filter_function.cpp b/be/src/vec/exprs/lambda_function/varray_filter_function.cpp index 0a77ebd673790a..f698df0c52d92c 100644 --- a/be/src/vec/exprs/lambda_function/varray_filter_function.cpp +++ b/be/src/vec/exprs/lambda_function/varray_filter_function.cpp @@ -20,7 +20,6 @@ #include #include #include -#include #include "common/status.h" #include "vec/aggregate_functions/aggregate_function.h" @@ -36,16 +35,11 @@ #include "vec/data_types/data_type.h" #include "vec/exprs/lambda_function/lambda_function.h" #include "vec/exprs/lambda_function/lambda_function_factory.h" -#include "vec/exprs/vexpr.h" #include "vec/utils/util.hpp" -namespace doris { -namespace vectorized { -class VExprContext; -} // namespace vectorized -} // namespace doris - namespace doris::vectorized { +#include "common/compile_check_begin.h" +class VExprContext; class ArrayFilterFunction : public LambdaFunction { ENABLE_FACTORY_CREATOR(ArrayFilterFunction); @@ -78,7 +72,7 @@ class ArrayFilterFunction : public LambdaFunction { auto second_column = block->get_by_position(arguments[1]).column->convert_to_full_column_if_const(); - int input_rows = first_column->size(); + auto input_rows = first_column->size(); auto first_outside_null_map = ColumnUInt8::create(input_rows, 0); auto first_arg_column = first_column; if (first_arg_column->is_nullable()) { @@ -89,7 +83,7 @@ class ArrayFilterFunction : public LambdaFunction { VectorizedUtils::update_null_map(first_outside_null_map->get_data(), column_array_nullmap.get_data()); } - const ColumnArray& first_col_array = assert_cast(*first_arg_column); + const auto& first_col_array = assert_cast(*first_arg_column); const auto& first_off_data = assert_cast(first_col_array.get_offsets_column()) .get_data(); @@ -113,7 +107,7 @@ class ArrayFilterFunction : public LambdaFunction { VectorizedUtils::update_null_map(second_outside_null_map->get_data(), column_array_nullmap.get_data()); } - const ColumnArray& second_col_array = assert_cast(*second_arg_column); + const auto& second_col_array = assert_cast(*second_arg_column); const auto& second_off_data = assert_cast( second_col_array.get_offsets_column()) .get_data(); @@ -180,4 +174,6 @@ class ArrayFilterFunction : public LambdaFunction { void register_function_array_filter(doris::vectorized::LambdaFunctionFactory& factory) { factory.register_function(); } + +#include "common/compile_check_end.h" } // namespace doris::vectorized diff --git a/be/src/vec/exprs/lambda_function/varray_map_function.cpp b/be/src/vec/exprs/lambda_function/varray_map_function.cpp index 609f5dcebdac85..f80cffa166eac4 100644 --- a/be/src/vec/exprs/lambda_function/varray_map_function.cpp +++ b/be/src/vec/exprs/lambda_function/varray_map_function.cpp @@ -18,7 +18,6 @@ #include #include #include -#include #include "common/status.h" #include "vec/aggregate_functions/aggregate_function.h" @@ -36,16 +35,12 @@ #include "vec/data_types/data_type_nullable.h" #include "vec/exprs/lambda_function/lambda_function.h" #include "vec/exprs/lambda_function/lambda_function_factory.h" -#include "vec/exprs/vexpr.h" #include "vec/utils/util.hpp" -namespace doris { -namespace vectorized { -class VExprContext; -} // namespace vectorized -} // namespace doris - namespace doris::vectorized { +#include "common/compile_check_begin.h" + +class VExprContext; class ArrayMapFunction : public LambdaFunction { ENABLE_FACTORY_CREATOR(ArrayMapFunction); @@ -80,7 +75,7 @@ class ArrayMapFunction : public LambdaFunction { 0); // offset column MutableColumnPtr array_column_offset; - int nested_array_column_rows = 0; + size_t nested_array_column_rows = 0; ColumnPtr first_array_offsets = nullptr; //2. get the result column from executed expr, and the needed is nested column of array @@ -109,23 +104,23 @@ class ArrayMapFunction : public LambdaFunction { } // here is the array column - const ColumnArray& col_array = assert_cast(*column_array); + const auto& col_array = assert_cast(*column_array); const auto& col_type = assert_cast(*type_array); if (i == 0) { nested_array_column_rows = col_array.get_data_ptr()->size(); first_array_offsets = col_array.get_offsets_ptr(); - auto& off_data = assert_cast( + const auto& off_data = assert_cast( col_array.get_offsets_column()); array_column_offset = off_data.clone_resized(col_array.get_offsets_column().size()); } else { // select array_map((x,y)->x+y,c_array1,[0,1,2,3]) from array_test2; // c_array1: [0,1,2,3,4,5,6,7,8,9] - auto& array_offsets = + const auto& array_offsets = assert_cast(*first_array_offsets) .get_data(); if (nested_array_column_rows != col_array.get_data_ptr()->size() || - (array_offsets.size() > 0 && + (!array_offsets.empty() && memcmp(array_offsets.data(), col_array.get_offsets().data(), sizeof(array_offsets[0]) * array_offsets.size()) != 0)) { return Status::InvalidArgument( @@ -192,4 +187,6 @@ class ArrayMapFunction : public LambdaFunction { void register_function_array_map(doris::vectorized::LambdaFunctionFactory& factory) { factory.register_function(); } + +#include "common/compile_check_end.h" } // namespace doris::vectorized diff --git a/be/src/vec/exprs/table_function/udf_table_function.cpp b/be/src/vec/exprs/table_function/udf_table_function.cpp index 35357f7c9357e1..9aa850d68b7d20 100644 --- a/be/src/vec/exprs/table_function/udf_table_function.cpp +++ b/be/src/vec/exprs/table_function/udf_table_function.cpp @@ -24,6 +24,7 @@ #include "vec/columns/column_nullable.h" #include "vec/common/assert_cast.h" #include "vec/core/block.h" +#include "vec/core/column_numbers.h" #include "vec/core/types.h" #include "vec/data_types/data_type_array.h" #include "vec/data_types/data_type_factory.hpp" @@ -95,7 +96,7 @@ Status UDFTableFunction::open() { Status UDFTableFunction::process_init(Block* block, RuntimeState* state) { auto child_size = _expr_context->root()->children().size(); - std::vector child_column_idxs; + ColumnNumbers child_column_idxs; child_column_idxs.resize(child_size); for (int i = 0; i < child_size; ++i) { int result_id = -1; diff --git a/be/src/vec/exprs/table_function/udf_table_function.h b/be/src/vec/exprs/table_function/udf_table_function.h index b09371984675df..b9707bf069398d 100644 --- a/be/src/vec/exprs/table_function/udf_table_function.h +++ b/be/src/vec/exprs/table_function/udf_table_function.h @@ -90,8 +90,8 @@ class UDFTableFunction final : public TableFunction { DataTypePtr _return_type = nullptr; ColumnPtr _array_result_column = nullptr; ColumnArrayExecutionData _array_column_detail; - size_t _result_column_idx = 0; // _array_result_column pos in block - size_t _array_offset = 0; // start offset of array[row_idx] + uint32_t _result_column_idx = 0; // _array_result_column pos in block + size_t _array_offset = 0; // start offset of array[row_idx] }; } // namespace doris::vectorized diff --git a/be/src/vec/exprs/vbitmap_predicate.cpp b/be/src/vec/exprs/vbitmap_predicate.cpp index 8116311247b5b9..d801f8691fe3b8 100644 --- a/be/src/vec/exprs/vbitmap_predicate.cpp +++ b/be/src/vec/exprs/vbitmap_predicate.cpp @@ -17,11 +17,8 @@ #include "vec/exprs/vbitmap_predicate.h" -#include - -#include +#include #include -#include #include "exprs/bitmapfilter_predicate.h" #include "gutil/integral_types.h" @@ -41,12 +38,12 @@ class RowDescriptor; class RuntimeState; class TExprNode; -namespace vectorized { -class VExprContext; -} // namespace vectorized } // namespace doris namespace doris::vectorized { +#include "common/compile_check_begin.h" + +class VExprContext; vectorized::VBitmapPredicate::VBitmapPredicate(const TExprNode& node) : VExpr(node), _filter(nullptr), _expr_name("bitmap_predicate") {} @@ -90,14 +87,14 @@ doris::Status vectorized::VBitmapPredicate::execute(vectorized::VExprContext* co arguments[i] = column_id; } // call function - size_t num_columns_without_result = block->columns(); + uint32_t num_columns_without_result = block->columns(); auto res_data_column = ColumnVector::create(block->rows()); ColumnPtr argument_column = block->get_by_position(arguments[0]).column->convert_to_full_column_if_const(); size_t sz = argument_column->size(); res_data_column->resize(sz); - auto ptr = ((ColumnVector*)res_data_column.get())->get_data().data(); + auto* ptr = res_data_column->get_data().data(); if (argument_column->is_nullable()) { auto column_nested = reinterpret_cast(argument_column.get()) @@ -134,4 +131,5 @@ void vectorized::VBitmapPredicate::set_filter(std::shared_ptr - +#include #include -#include #include "common/status.h" #include "exprs/bloom_filter_func.h" -#include "gutil/integral_types.h" #include "runtime/runtime_state.h" #include "vec/columns/column.h" #include "vec/columns/column_nullable.h" #include "vec/columns/column_vector.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" @@ -41,12 +37,12 @@ namespace doris { class RowDescriptor; class TExprNode; -namespace vectorized { -class VExprContext; -} // namespace vectorized } // namespace doris namespace doris::vectorized { +#include "common/compile_check_begin.h" + +class VExprContext; VBloomPredicate::VBloomPredicate(const TExprNode& node) : VExpr(node), _filter(nullptr), _expr_name("bloom_predicate") {} @@ -85,7 +81,7 @@ Status VBloomPredicate::execute(VExprContext* context, Block* block, int* result arguments[i] = column_id; } // call function - size_t num_columns_without_result = block->columns(); + auto num_columns_without_result = block->columns(); auto res_data_column = ColumnVector::create(block->rows()); ColumnPtr argument_column = @@ -112,4 +108,6 @@ const std::string& VBloomPredicate::expr_name() const { void VBloomPredicate::set_filter(std::shared_ptr& filter) { _filter = filter; } + +#include "common/compile_check_end.h" } // namespace doris::vectorized \ No newline at end of file diff --git a/be/src/vec/exprs/vcase_expr.cpp b/be/src/vec/exprs/vcase_expr.cpp index 222a8f5629af77..7e65a5bbb486c9 100644 --- a/be/src/vec/exprs/vcase_expr.cpp +++ b/be/src/vec/exprs/vcase_expr.cpp @@ -19,12 +19,8 @@ #include #include -#include -#include -#include #include -#include #include "common/status.h" #include "runtime/runtime_state.h" @@ -43,6 +39,7 @@ class RuntimeState; } // namespace doris namespace doris::vectorized { +#include "common/compile_check_begin.h" VCaseExpr::VCaseExpr(const TExprNode& node) : VExpr(node), @@ -61,8 +58,7 @@ Status VCaseExpr::prepare(RuntimeState* state, const RowDescriptor& desc, VExprC ColumnsWithTypeAndName argument_template; DataTypes arguments; - for (int i = 0; i < _children.size(); i++) { - auto child = _children[i]; + for (auto child : _children) { argument_template.emplace_back(nullptr, child->data_type(), child->expr_name()); arguments.emplace_back(child->data_type()); } @@ -113,7 +109,7 @@ Status VCaseExpr::execute(VExprContext* context, Block* block, int* result_colum } RETURN_IF_ERROR(check_constant(*block, arguments)); - size_t num_columns_without_result = block->columns(); + uint32_t num_columns_without_result = block->columns(); block->insert({nullptr, _data_type, _expr_name}); RETURN_IF_ERROR(_function->execute(context->fn_context(_fn_context_index), *block, arguments, @@ -132,7 +128,7 @@ std::string VCaseExpr::debug_string() const { out << "CaseExpr(has_case_expr=" << _has_case_expr << " has_else_expr=" << _has_else_expr << " function=" << _function_name << "){"; bool first = true; - for (auto& input_expr : children()) { + for (const auto& input_expr : children()) { if (first) { first = false; } else { @@ -143,4 +139,6 @@ std::string VCaseExpr::debug_string() const { out << "}"; return out.str(); } + +#include "common/compile_check_end.h" } // namespace doris::vectorized diff --git a/be/src/vec/exprs/vcast_expr.cpp b/be/src/vec/exprs/vcast_expr.cpp index 0e0241c76ff04f..6e3a49cfc13e63 100644 --- a/be/src/vec/exprs/vcast_expr.cpp +++ b/be/src/vec/exprs/vcast_expr.cpp @@ -41,6 +41,7 @@ class RuntimeState; } // namespace doris namespace doris::vectorized { +#include "common/compile_check_begin.h" doris::Status VCastExpr::prepare(doris::RuntimeState* state, const doris::RowDescriptor& desc, VExprContext* context) { @@ -108,14 +109,14 @@ doris::Status VCastExpr::execute(VExprContext* context, doris::vectorized::Block RETURN_IF_ERROR(_children[0]->execute(context, block, &column_id)); // call function - size_t num_columns_without_result = block->columns(); + uint32_t num_columns_without_result = block->columns(); // prepare a column to save result block->insert({nullptr, _data_type, _expr_name}); auto state = Status::OK(); try { state = _function->execute(context->fn_context(_fn_context_index), *block, - {static_cast(column_id)}, num_columns_without_result, + {static_cast(column_id)}, num_columns_without_result, block->rows(), false); *result_column_id = num_columns_without_result; } catch (const Exception& e) { @@ -133,7 +134,7 @@ std::string VCastExpr::debug_string() const { out << "CastExpr(CAST " << get_child(0)->data_type()->get_name() << " to " << _target_data_type->get_name() << "){"; bool first = true; - for (auto& input_expr : children()) { + for (const auto& input_expr : children()) { if (first) { first = false; } else { @@ -144,4 +145,6 @@ std::string VCastExpr::debug_string() const { out << "}"; return out.str(); } + +#include "common/compile_check_end.h" } // namespace doris::vectorized diff --git a/be/src/vec/exprs/vcompound_pred.h b/be/src/vec/exprs/vcompound_pred.h index faed6788ba34ac..8c65e6c8adbfef 100644 --- a/be/src/vec/exprs/vcompound_pred.h +++ b/be/src/vec/exprs/vcompound_pred.h @@ -18,18 +18,21 @@ #pragma once #include +#include +#include + #include "common/status.h" #include "gutil/integral_types.h" #include "util/simd/bits.h" #include "vec/columns/column.h" #include "vec/columns/columns_number.h" #include "vec/common/assert_cast.h" -#include "vec/data_types/data_type_number.h" #include "vec/exprs/vectorized_fn_call.h" -#include "vec/exprs/vexpr.h" #include "vec/exprs/vexpr_context.h" +#include "vec/exprs/vexpr_fwd.h" namespace doris::vectorized { +#include "common/compile_check_begin.h" inline std::string compound_operator_to_string(TExprOpcode::type op) { if (op == TExprOpcode::COMPOUND_AND) { @@ -155,7 +158,7 @@ class VCompoundPred : public VectorizedFnCall { if (_can_fast_execute && fast_execute(context, block, result_column_id)) { return Status::OK(); } - if (children().size() == 1 || !_all_child_is_compound_and_not_const()) { + if (get_num_children() == 1 || !_all_child_is_compound_and_not_const()) { return VectorizedFnCall::execute(context, block, result_column_id); } @@ -168,7 +171,7 @@ class VCompoundPred : public VectorizedFnCall { bool lhs_is_nullable = lhs_column->is_nullable(); auto [lhs_data_column, lhs_null_map] = _get_raw_data_and_null_map(lhs_column, lhs_is_nullable); - int filted = simd::count_zero_num((int8_t*)lhs_data_column, size); + size_t filted = simd::count_zero_num((int8_t*)lhs_data_column, size); bool lhs_all_true = (filted == 0); bool lhs_all_false = (filted == size); @@ -196,7 +199,7 @@ class VCompoundPred : public VectorizedFnCall { auto rhs_nullable_column = _get_raw_data_and_null_map(rhs_column, rhs_is_nullable); rhs_data_column = rhs_nullable_column.first; rhs_null_map = rhs_nullable_column.second; - int filted = simd::count_zero_num((int8_t*)rhs_data_column, size); + size_t filted = simd::count_zero_num((int8_t*)rhs_data_column, size); rhs_all_true = (filted == 0); rhs_all_false = (filted == size); if (rhs_is_nullable) { @@ -340,13 +343,9 @@ class VCompoundPred : public VectorizedFnCall { } bool _all_child_is_compound_and_not_const() const { - for (auto child : _children) { - // we can make sure non const compound predicate's return column is allow modifyied locally. - if (child->is_constant() || !child->is_compound_predicate()) { - return false; - } - } - return true; + return std::ranges::all_of(_children, [](const VExprSPtr& arg) -> bool { + return arg->is_compound_predicate() && !arg->is_constant(); + }); } std::pair _get_raw_data_and_null_map(ColumnPtr column, @@ -371,4 +370,6 @@ class VCompoundPred : public VectorizedFnCall { TExprOpcode::type _op; }; + +#include "common/compile_check_end.h" } // namespace doris::vectorized diff --git a/be/src/vec/exprs/vdirect_in_predicate.h b/be/src/vec/exprs/vdirect_in_predicate.h index 7abd43a5e02903..c86a1e10b1da28 100644 --- a/be/src/vec/exprs/vdirect_in_predicate.h +++ b/be/src/vec/exprs/vdirect_in_predicate.h @@ -22,6 +22,8 @@ #include "vec/exprs/vexpr.h" namespace doris::vectorized { +#include "common/compile_check_begin.h" + class VDirectInPredicate final : public VExpr { ENABLE_FACTORY_CREATOR(VDirectInPredicate); @@ -52,7 +54,7 @@ class VDirectInPredicate final : public VExpr { Status execute_runtime_fitler(doris::vectorized::VExprContext* context, doris::vectorized::Block* block, int* result_column_id, - std::vector& args) override { + ColumnNumbers& args) override { return _do_execute(context, block, result_column_id, args); } @@ -62,7 +64,7 @@ class VDirectInPredicate final : public VExpr { private: Status _do_execute(VExprContext* context, Block* block, int* result_column_id, - std::vector& arguments) { + ColumnNumbers& arguments) { DCHECK(_open_finished || _getting_const_col); arguments.resize(_children.size()); for (int i = 0; i < _children.size(); ++i) { @@ -71,7 +73,7 @@ class VDirectInPredicate final : public VExpr { arguments[i] = column_id; } - size_t num_columns_without_result = block->columns(); + uint32_t num_columns_without_result = block->columns(); auto res_data_column = ColumnVector::create(block->rows()); ColumnPtr argument_column = block->get_by_position(arguments[0]).column->convert_to_full_column_if_const(); @@ -99,4 +101,6 @@ class VDirectInPredicate final : public VExpr { std::shared_ptr _filter; std::string _expr_name; }; + +#include "common/compile_check_end.h" } // namespace doris::vectorized \ No newline at end of file diff --git a/be/src/vec/exprs/vectorized_agg_fn.cpp b/be/src/vec/exprs/vectorized_agg_fn.cpp index ef2bbcb29964aa..b5e5aa4738a041 100644 --- a/be/src/vec/exprs/vectorized_agg_fn.cpp +++ b/be/src/vec/exprs/vectorized_agg_fn.cpp @@ -56,6 +56,7 @@ class IColumn; } // namespace doris namespace doris::vectorized { +#include "common/compile_check_begin.h" template AggregateFunctionPtr get_agg_state_function(const DataTypes& argument_types, @@ -362,11 +363,11 @@ AggFnEvaluator::AggFnEvaluator(AggFnEvaluator& evaluator, RuntimeState* state) } } -Status AggFnEvaluator::check_agg_fn_output(int64_t key_size, +Status AggFnEvaluator::check_agg_fn_output(uint32_t key_size, const std::vector& agg_fn, const RowDescriptor& output_row_desc) { auto name_and_types = VectorizedUtils::create_name_and_data_types(output_row_desc); - for (int i = key_size, j = 0; i < name_and_types.size(); i++, j++) { + for (uint32_t i = key_size, j = 0; i < name_and_types.size(); i++, j++) { auto&& [name, column_type] = name_and_types[i]; auto agg_return_type = agg_fn[j]->function()->get_return_type(); if (!column_type->equals(*agg_return_type)) { @@ -381,4 +382,6 @@ Status AggFnEvaluator::check_agg_fn_output(int64_t key_size, } return Status::OK(); } + +#include "common/compile_check_end.h" } // namespace doris::vectorized diff --git a/be/src/vec/exprs/vectorized_agg_fn.h b/be/src/vec/exprs/vectorized_agg_fn.h index a3f7030d958870..e47d3638646eb0 100644 --- a/be/src/vec/exprs/vectorized_agg_fn.h +++ b/be/src/vec/exprs/vectorized_agg_fn.h @@ -17,8 +17,8 @@ #pragma once #include -#include +#include #include #include @@ -31,6 +31,8 @@ #include "vec/exprs/vexpr_fwd.h" namespace doris { +#include "common/compile_check_begin.h" + class RuntimeState; class SlotDescriptor; class ObjectPool; @@ -97,7 +99,7 @@ class AggFnEvaluator { bool is_merge() const { return _is_merge; } const VExprContextSPtrs& input_exprs_ctxs() const { return _input_exprs_ctxs; } - static Status check_agg_fn_output(int64_t key_size, + static Status check_agg_fn_output(uint32_t key_size, const std::vector& agg_fn, const RowDescriptor& output_row_desc); @@ -145,4 +147,5 @@ class AggFnEvaluator { }; } // namespace vectorized +#include "common/compile_check_end.h" } // namespace doris diff --git a/be/src/vec/exprs/vectorized_fn_call.cpp b/be/src/vec/exprs/vectorized_fn_call.cpp index 3192653a816f2c..fc69b4047ceb5f 100644 --- a/be/src/vec/exprs/vectorized_fn_call.cpp +++ b/be/src/vec/exprs/vectorized_fn_call.cpp @@ -22,10 +22,8 @@ #include #include -#include #include "common/config.h" -#include "common/consts.h" #include "common/status.h" #include "pipeline/pipeline_task.h" #include "runtime/runtime_state.h" @@ -49,6 +47,7 @@ class TExprNode; } // namespace doris namespace doris::vectorized { +#include "common/compile_check_begin.h" const std::string AGG_STATE_SUFFIX = "_state"; @@ -146,7 +145,7 @@ Status VectorizedFnCall::evaluate_inverted_index(VExprContext* context, uint32_t Status VectorizedFnCall::_do_execute(doris::vectorized::VExprContext* context, doris::vectorized::Block* block, int* result_column_id, - std::vector& args) { + ColumnNumbers& args) { if (is_const_and_have_executed()) { // const have executed in open function return get_result_from_const(block, _expr_name, result_column_id); } @@ -182,7 +181,7 @@ Status VectorizedFnCall::_do_execute(doris::vectorized::VExprContext* context, RETURN_IF_ERROR(check_constant(*block, args)); // call function - size_t num_columns_without_result = block->columns(); + uint32_t num_columns_without_result = block->columns(); // prepare a column to save result block->insert({nullptr, _data_type, _expr_name}); RETURN_IF_ERROR(_function->execute(context->fn_context(_fn_context_index), *block, args, @@ -193,13 +192,13 @@ Status VectorizedFnCall::_do_execute(doris::vectorized::VExprContext* context, Status VectorizedFnCall::execute_runtime_fitler(doris::vectorized::VExprContext* context, doris::vectorized::Block* block, - int* result_column_id, std::vector& args) { + int* result_column_id, ColumnNumbers& args) { return _do_execute(context, block, result_column_id, args); } Status VectorizedFnCall::execute(VExprContext* context, vectorized::Block* block, int* result_column_id) { - std::vector arguments; + ColumnNumbers arguments; return _do_execute(context, block, result_column_id, arguments); } @@ -247,10 +246,10 @@ bool VectorizedFnCall::equals(const VExpr& other) { if (this->_function_name != other_ptr->_function_name) { return false; } - if (this->children().size() != other_ptr->children().size()) { + if (get_num_children() != other_ptr->get_num_children()) { return false; } - for (size_t i = 0; i < this->children().size(); i++) { + for (uint16_t i = 0; i < get_num_children(); i++) { if (!this->get_child(i)->equals(*other_ptr->get_child(i))) { return false; } @@ -258,4 +257,5 @@ bool VectorizedFnCall::equals(const VExpr& other) { return true; } +#include "common/compile_check_end.h" } // namespace doris::vectorized diff --git a/be/src/vec/exprs/vectorized_fn_call.h b/be/src/vec/exprs/vectorized_fn_call.h index bae996136ddc31..cea328f413b620 100644 --- a/be/src/vec/exprs/vectorized_fn_call.h +++ b/be/src/vec/exprs/vectorized_fn_call.h @@ -17,12 +17,10 @@ #pragma once #include -#include #include #include -#include "common/object_pool.h" #include "common/status.h" #include "udf/udf.h" #include "vec/core/column_numbers.h" @@ -35,14 +33,14 @@ namespace doris { class RowDescriptor; class RuntimeState; class TExprNode; +} // namespace doris + +namespace doris::vectorized { +#include "common/compile_check_begin.h" -namespace vectorized { class Block; class VExprContext; -} // namespace vectorized -} // namespace doris -namespace doris::vectorized { class VectorizedFnCall : public VExpr { ENABLE_FACTORY_CREATOR(VectorizedFnCall); @@ -51,7 +49,7 @@ class VectorizedFnCall : public VExpr { Status execute(VExprContext* context, Block* block, int* result_column_id) override; Status execute_runtime_fitler(doris::vectorized::VExprContext* context, doris::vectorized::Block* block, int* result_column_id, - std::vector& args) override; + ColumnNumbers& args) override; Status evaluate_inverted_index(VExprContext* context, uint32_t segment_num_rows) override; Status prepare(RuntimeState* state, const RowDescriptor& desc, VExprContext* context) override; Status open(RuntimeState* state, VExprContext* context, @@ -79,7 +77,8 @@ class VectorizedFnCall : public VExpr { private: Status _do_execute(doris::vectorized::VExprContext* context, doris::vectorized::Block* block, - int* result_column_id, std::vector& args); + int* result_column_id, ColumnNumbers& args); }; +#include "common/compile_check_end.h" } // namespace doris::vectorized diff --git a/be/src/vec/exprs/vexpr.cpp b/be/src/vec/exprs/vexpr.cpp index ba440231f4ee51..c40bcbcab57f23 100644 --- a/be/src/vec/exprs/vexpr.cpp +++ b/be/src/vec/exprs/vexpr.cpp @@ -25,6 +25,7 @@ #include #include #include +#include #include #include @@ -59,6 +60,8 @@ #include "vec/utils/util.hpp" namespace doris { +#include "common/compile_check_begin.h" + class RowDescriptor; class RuntimeState; @@ -628,7 +631,7 @@ Status VExpr::_evaluate_inverted_index(VExprContext* context, const FunctionBase VExprSPtrs children_exprs; // Reserve space to avoid multiple reallocations - const size_t estimated_size = children().size(); + const size_t estimated_size = get_num_children(); iterators.reserve(estimated_size); data_type_with_names.reserve(estimated_size); column_ids.reserve(estimated_size); @@ -642,7 +645,7 @@ Status VExpr::_evaluate_inverted_index(VExprContext* context, const FunctionBase for (const auto& child : children()) { if (child->node_type() == TExprNodeType::CAST_EXPR) { auto* cast_expr = assert_cast(child.get()); - DCHECK_EQ(cast_expr->children().size(), 1); + DCHECK_EQ(cast_expr->get_num_children(), 1); if (cast_expr->get_child(0)->is_slot_ref()) { auto* column_slot_ref = assert_cast(cast_expr->get_child(0).get()); auto column_id = column_slot_ref->column_id(); @@ -742,7 +745,7 @@ bool VExpr::fast_execute(doris::vectorized::VExprContext* context, doris::vector int* result_column_id) { if (context->get_inverted_index_context() && context->get_inverted_index_context()->get_inverted_index_result_column().contains(this)) { - size_t num_columns_without_result = block->columns(); + uint32_t num_columns_without_result = block->columns(); // prepare a column to save result auto result_column = context->get_inverted_index_context()->get_inverted_index_result_column()[this]; @@ -763,4 +766,5 @@ bool VExpr::equals(const VExpr& other) { return false; } +#include "common/compile_check_end.h" } // namespace doris::vectorized diff --git a/be/src/vec/exprs/vexpr.h b/be/src/vec/exprs/vexpr.h index b608f876456e54..3456fb431a48cb 100644 --- a/be/src/vec/exprs/vexpr.h +++ b/be/src/vec/exprs/vexpr.h @@ -23,6 +23,7 @@ #include #include +#include #include #include #include @@ -55,6 +56,7 @@ class RowDescriptor; class RuntimeState; namespace vectorized { +#include "common/compile_check_begin.h" #define RETURN_IF_ERROR_OR_PREPARED(stmt) \ if (_prepared) { \ @@ -68,12 +70,13 @@ namespace vectorized { // the relatioinship between threads and classes. class VExpr { public: - // resize inserted param column to make sure column size equal to block.rows() - // and return param column index - static size_t insert_param(Block* block, ColumnWithTypeAndName&& elem, size_t size) { + // resize inserted param column to make sure column size equal to block.rows() and return param column index + // keep return type same with block::columns() + static uint32_t insert_param(Block* block, ColumnWithTypeAndName&& elem, size_t size) { // usually elem.column always is const column, so we just clone it. elem.column = elem.column->clone_resized(size); block->insert(std::move(elem)); + // just inserted. so no need to check underflow. return block->columns() - 1; } @@ -129,7 +132,7 @@ class VExpr { // Only the 4th parameter is used in the runtime filter. In and MinMax need overwrite the // interface virtual Status execute_runtime_fitler(VExprContext* context, Block* block, - int* result_column_id, std::vector& args) { + int* result_column_id, ColumnNumbers& args) { return execute(context, block, result_column_id); }; @@ -152,15 +155,17 @@ class VExpr { TExprOpcode::type op() const { return _opcode; } void add_child(const VExprSPtr& expr) { _children.push_back(expr); } - VExprSPtr get_child(int i) const { return _children[i]; } - int get_num_children() const { return _children.size(); } + VExprSPtr get_child(uint16_t i) const { return _children[i]; } + // Expr's children number is restricted by org.apache.doris.common.Config#expr_children_limit, 10000 default. and strongly not recommend to change. + // There's little to worry about it. uint16 is enough. + uint16_t get_num_children() const { return static_cast(_children.size()); } virtual bool is_rf_wrapper() const { return std::ranges::any_of(_children.begin(), _children.end(), [](VExprSPtr child) { return child->is_rf_wrapper(); }); } - virtual void do_judge_selectivity(int64_t filter_rows, int64_t input_rows) { + virtual void do_judge_selectivity(uint64_t filter_rows, uint64_t input_rows) { for (auto child : _children) { child->do_judge_selectivity(filter_rows, input_rows); } @@ -217,7 +222,7 @@ class VExpr { int fn_context_index() const { return _fn_context_index; } - static const VExprSPtr expr_without_cast(const VExprSPtr& expr) { + static VExprSPtr expr_without_cast(const VExprSPtr& expr) { if (expr->node_type() == TExprNodeType::CAST_EXPR) { return expr_without_cast(expr->_children[0]); } @@ -225,7 +230,7 @@ class VExpr { } // If this expr is a RuntimeFilterWrapper, this method will return an underlying rf expression - virtual const VExprSPtr get_impl() const { return {}; } + virtual VExprSPtr get_impl() const { return {}; } // If this expr is a BloomPredicate, this method will return a BloomFilterFunc virtual std::shared_ptr get_bloom_filter_func() const { @@ -300,7 +305,7 @@ class VExpr { TExprOpcode::type _opcode; TypeDescriptor _type; DataTypePtr _data_type; - VExprSPtrs _children; + VExprSPtrs _children; // in few hundreds TFunction _fn; /// Index to pass to ExprContext::fn_context() to retrieve this expr's FunctionContext. @@ -492,4 +497,5 @@ Status create_texpr_literal_node(const void* data, TExprNode* node, int precisio TExprNode create_texpr_node_from(const void* data, const PrimitiveType& type, int precision = 0, int scale = 0); +#include "common/compile_check_end.h" } // namespace doris diff --git a/be/src/vec/exprs/vexpr_context.cpp b/be/src/vec/exprs/vexpr_context.cpp index ff2238548ec55e..b01ce2fade3660 100644 --- a/be/src/vec/exprs/vexpr_context.cpp +++ b/be/src/vec/exprs/vexpr_context.cpp @@ -17,9 +17,11 @@ #include "vec/exprs/vexpr_context.h" +#include #include #include +#include "common/cast_set.h" #include "common/compiler_util.h" // IWYU pragma: keep #include "common/exception.h" #include "runtime/runtime_state.h" @@ -27,6 +29,7 @@ #include "udf/udf.h" #include "util/simd/bits.h" #include "vec/columns/column_const.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/exprs/vexpr.h" @@ -36,6 +39,8 @@ class RowDescriptor; } // namespace doris namespace doris::vectorized { +#include "common/compile_check_begin.h" + VExprContext::~VExprContext() { // In runtime filter, only create expr context to get expr root, will not call // prepare or open, so that it is not need to call close. And call close may core @@ -118,7 +123,7 @@ int VExprContext::register_function_context(RuntimeState* state, const TypeDescr const std::vector& arg_types) { _fn_contexts.push_back(FunctionContext::create_context(state, return_type, arg_types)); _fn_contexts.back()->set_check_overflow_for_decimal(state->check_overflow_for_decimal()); - return _fn_contexts.size() - 1; + return static_cast(_fn_contexts.size()) - 1; } Status VExprContext::evaluate_inverted_index(uint32_t segment_num_rows) { @@ -146,11 +151,11 @@ Status VExprContext::filter_block(const VExprContextSPtrs& expr_contexts, Block* return Status::OK(); } - std::vector columns_to_filter(column_to_keep); + ColumnNumbers columns_to_filter(column_to_keep); std::iota(columns_to_filter.begin(), columns_to_filter.end(), 0); return execute_conjuncts_and_filter_block(expr_contexts, block, columns_to_filter, - column_to_keep); + static_cast(column_to_keep)); } Status VExprContext::execute_conjuncts(const VExprContextSPtrs& ctxs, @@ -164,7 +169,7 @@ Status VExprContext::execute_conjuncts(const VExprContextSPtrs& ctxs, const std::vector* filters, bool accept_null, Block* block, IColumn::Filter* result_filter, bool* can_filter_all) { - int rows = block->rows(); + size_t rows = block->rows(); DCHECK_EQ(result_filter->size(), rows); *can_filter_all = false; auto* __restrict result_filter_data = result_filter->data(); @@ -186,7 +191,7 @@ Status VExprContext::execute_conjuncts(const VExprContextSPtrs& ctxs, const auto* __restrict filter_data = filter.data(); const auto* __restrict null_map_data = nullable_column->get_null_map_data().data(); - int input_rows = + size_t input_rows = rows - (is_rf_wrapper ? simd::count_zero_num((int8*)result_filter_data, rows) : 0); @@ -200,7 +205,7 @@ Status VExprContext::execute_conjuncts(const VExprContextSPtrs& ctxs, } } - int output_rows = + size_t output_rows = rows - (is_rf_wrapper ? simd::count_zero_num((int8*)result_filter_data, rows) : 0); @@ -226,7 +231,7 @@ Status VExprContext::execute_conjuncts(const VExprContextSPtrs& ctxs, assert_cast(*filter_column).get_data(); const auto* __restrict filter_data = filter.data(); - int input_rows = + size_t input_rows = rows - (is_rf_wrapper ? simd::count_zero_num((int8*)result_filter_data, rows) : 0); @@ -234,7 +239,7 @@ Status VExprContext::execute_conjuncts(const VExprContextSPtrs& ctxs, result_filter_data[i] &= filter_data[i]; } - int output_rows = + size_t output_rows = rows - (is_rf_wrapper ? simd::count_zero_num((int8*)result_filter_data, rows) : 0); @@ -281,14 +286,14 @@ Status VExprContext::execute_conjuncts(const VExprContextSPtrs& conjuncts, Block for (const auto& conjunct : conjuncts) { int result_column_id = -1; RETURN_IF_ERROR(conjunct->execute(block, &result_column_id)); - auto& filter_column = + const auto& filter_column = unpack_if_const(block->get_by_position(result_column_id).column).first; - if (auto* nullable_column = check_and_get_column(*filter_column)) { + if (const auto* nullable_column = check_and_get_column(*filter_column)) { const ColumnPtr& nested_column = nullable_column->get_nested_column_ptr(); const IColumn::Filter& result = assert_cast(*nested_column).get_data(); - auto* __restrict filter_data = result.data(); - auto* __restrict null_map_data = nullable_column->get_null_map_data().data(); + const auto* __restrict filter_data = result.data(); + const auto* __restrict null_map_data = nullable_column->get_null_map_data().data(); DCHECK_EQ(rows, nullable_column->size()); for (size_t i = 0; i != rows; ++i) { @@ -300,7 +305,8 @@ Status VExprContext::execute_conjuncts(const VExprContextSPtrs& conjuncts, Block final_filter_ptr[i] = final_filter_ptr[i] & filter_data[i]; } } else { - auto* filter_data = assert_cast(*filter_column).get_data().data(); + const auto* filter_data = + assert_cast(*filter_column).get_data().data(); for (size_t i = 0; i != rows; ++i) { final_filter_ptr[i] = final_filter_ptr[i] & filter_data[i]; } @@ -320,6 +326,7 @@ Status VExprContext::execute_conjuncts_and_filter_block(const VExprContextSPtrs& execute_conjuncts(ctxs, nullptr, false, block, &result_filter, &can_filter_all)); if (can_filter_all) { for (auto& col : columns_to_filter) { + // NOLINTNEXTLINE(performance-move-const-arg) std::move(*block->get_by_position(col).column).assume_mutable()->clear(); } } else { @@ -352,6 +359,7 @@ Status VExprContext::execute_conjuncts_and_filter_block(const VExprContextSPtrs& RETURN_IF_ERROR(execute_conjuncts(ctxs, nullptr, false, block, &filter, &can_filter_all)); if (can_filter_all) { for (auto& col : columns_to_filter) { + // NOLINTNEXTLINE(performance-move-const-arg) std::move(*block->get_by_position(col).column).assume_mutable()->clear(); } } else { @@ -388,4 +396,5 @@ Status VExprContext::get_output_block_after_execute_exprs( return Status::OK(); } +#include "common/compile_check_end.h" } // namespace doris::vectorized diff --git a/be/src/vec/exprs/vin_predicate.cpp b/be/src/vec/exprs/vin_predicate.cpp index efd757ddd8b4d3..ce6270c2e62dea 100644 --- a/be/src/vec/exprs/vin_predicate.cpp +++ b/be/src/vec/exprs/vin_predicate.cpp @@ -20,12 +20,10 @@ #include #include #include -#include #include -#include +#include #include -#include #include "common/status.h" #include "runtime/runtime_state.h" @@ -44,6 +42,7 @@ class RuntimeState; } // namespace doris namespace doris::vectorized { +#include "common/compile_check_begin.h" VInPredicate::VInPredicate(const TExprNode& node) : VExpr(node), _is_not_in(node.in_predicate.is_not_in) {} @@ -52,16 +51,15 @@ Status VInPredicate::prepare(RuntimeState* state, const RowDescriptor& desc, VExprContext* context) { RETURN_IF_ERROR_OR_PREPARED(VExpr::prepare(state, desc, context)); - if (_children.size() < 1) { + if (_children.empty()) { return Status::InternalError("no Function operator in."); } _expr_name = fmt::format("({} {} set)", _children[0]->expr_name(), _is_not_in ? "not_in" : "in"); - DCHECK(_children.size() >= 1); ColumnsWithTypeAndName argument_template; - argument_template.reserve(_children.size()); + argument_template.reserve(get_num_children()); for (auto child : _children) { argument_template.emplace_back(nullptr, child->data_type(), child->expr_name()); } @@ -146,7 +144,7 @@ Status VInPredicate::execute(VExprContext* context, Block* block, int* result_co arguments[i] = column_id; } // call function - size_t num_columns_without_result = block->columns(); + uint32_t num_columns_without_result = block->columns(); // prepare a column to save result block->insert({nullptr, _data_type, _expr_name}); @@ -163,7 +161,7 @@ const std::string& VInPredicate::expr_name() const { std::string VInPredicate::debug_string() const { std::stringstream out; out << "InPredicate(" << children()[0]->debug_string() << " " << _is_not_in << ",["; - int num_children = children().size(); + int num_children = get_num_children(); for (int i = 1; i < num_children; ++i) { out << (i == 1 ? "" : " ") << children()[i]->debug_string(); @@ -173,4 +171,5 @@ std::string VInPredicate::debug_string() const { return out.str(); } +#include "common/compile_check_end.h" } // namespace doris::vectorized diff --git a/be/src/vec/exprs/vinfo_func.cpp b/be/src/vec/exprs/vinfo_func.cpp index c262882b317e90..59140c4c267ca6 100644 --- a/be/src/vec/exprs/vinfo_func.cpp +++ b/be/src/vec/exprs/vinfo_func.cpp @@ -19,11 +19,8 @@ #include #include -#include #include -#include -#include #include "runtime/define_primitive_type.h" #include "runtime/types.h" @@ -32,13 +29,10 @@ #include "vec/core/types.h" #include "vec/data_types/data_type.h" -namespace doris { -namespace vectorized { -class VExprContext; -} // namespace vectorized -} // namespace doris - namespace doris::vectorized { +#include "common/compile_check_begin.h" + +class VExprContext; VInfoFunc::VInfoFunc(const TExprNode& node) : VExpr(node) { Field field; @@ -63,9 +57,10 @@ VInfoFunc::VInfoFunc(const TExprNode& node) : VExpr(node) { Status VInfoFunc::execute(VExprContext* context, vectorized::Block* block, int* result_column_id) { // Info function should return least one row, e.g. select current_user(). - size_t row_size = std::max(block->rows(), size_t(1)); + size_t row_size = std::max(block->rows(), 1UL); *result_column_id = VExpr::insert_param(block, {_column_ptr, _data_type, _expr_name}, row_size); return Status::OK(); } +#include "common/compile_check_end.h" } // namespace doris::vectorized diff --git a/be/src/vec/exprs/vliteral.cpp b/be/src/vec/exprs/vliteral.cpp index bb95788bb336a2..b1e3113b45af92 100644 --- a/be/src/vec/exprs/vliteral.cpp +++ b/be/src/vec/exprs/vliteral.cpp @@ -21,33 +21,21 @@ #include #include #include -#include -#include #include #include #include -#include -#include "common/exception.h" -#include "olap/olap_common.h" -#include "runtime/decimalv2_value.h" -#include "runtime/define_primitive_type.h" -#include "runtime/jsonb_value.h" -#include "runtime/large_int_value.h" -#include "runtime/types.h" -#include "util/string_parser.hpp" #include "vec/aggregate_functions/aggregate_function.h" #include "vec/columns/column.h" -#include "vec/common/string_ref.h" -#include "vec/common/typeid_cast.h" #include "vec/core/block.h" #include "vec/core/field.h" #include "vec/core/types.h" #include "vec/data_types/data_type_decimal.h" -#include "vec/runtime/vdatetime_value.h" namespace doris::vectorized { +#include "common/compile_check_begin.h" + class VExprContext; void VLiteral::init(const TExprNode& node) { @@ -104,4 +92,5 @@ bool VLiteral::equals(const VExpr& other) { return true; } +#include "common/compile_check_end.h" } // namespace doris::vectorized diff --git a/be/src/vec/exprs/vmatch_predicate.cpp b/be/src/vec/exprs/vmatch_predicate.cpp index c80933df13c0bd..333d0ef389f724 100644 --- a/be/src/vec/exprs/vmatch_predicate.cpp +++ b/be/src/vec/exprs/vmatch_predicate.cpp @@ -17,6 +17,8 @@ #include "vec/exprs/vmatch_predicate.h" +#include + #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wshadow-field" @@ -26,8 +28,8 @@ #include // IWYU pragma: keep #include #include -#include +#include #include #include #include @@ -50,6 +52,8 @@ class RuntimeState; } // namespace doris namespace doris::vectorized { +#include "common/compile_check_begin.h" + using namespace doris::segment_v2; VMatchPredicate::VMatchPredicate(const TExprNode& node) : VExpr(node) { @@ -106,8 +110,8 @@ Status VMatchPredicate::prepare(RuntimeState* state, const RowDescriptor& desc, Status VMatchPredicate::open(RuntimeState* state, VExprContext* context, FunctionContext::FunctionStateScope scope) { DCHECK(_prepare_finished); - for (int i = 0; i < _children.size(); ++i) { - RETURN_IF_ERROR(_children[i]->open(state, context, scope)); + for (auto& i : _children) { + RETURN_IF_ERROR(i->open(state, context, scope)); } RETURN_IF_ERROR(VExpr::init_function_context(state, context, scope, _function)); if (scope == FunctionContext::THREAD_LOCAL || scope == FunctionContext::FRAGMENT_LOCAL) { @@ -161,7 +165,7 @@ Status VMatchPredicate::execute(VExprContext* context, Block* block, int* result arguments[i] = column_id; } // call function - size_t num_columns_without_result = block->columns(); + uint32_t num_columns_without_result = block->columns(); // prepare a column to save result block->insert({nullptr, _data_type, _expr_name}); RETURN_IF_ERROR(_function->execute(context->fn_context(_fn_context_index), *block, arguments, @@ -181,9 +185,9 @@ const std::string& VMatchPredicate::function_name() const { std::string VMatchPredicate::debug_string() const { std::stringstream out; out << "MatchPredicate(" << children()[0]->debug_string() << ",["; - int num_children = children().size(); + uint16_t num_children = get_num_children(); - for (int i = 1; i < num_children; ++i) { + for (uint16_t i = 1; i < num_children; ++i) { out << (i == 1 ? "" : " ") << children()[i]->debug_string(); } @@ -191,4 +195,5 @@ std::string VMatchPredicate::debug_string() const { return out.str(); } +#include "common/compile_check_end.h" } // namespace doris::vectorized \ No newline at end of file diff --git a/be/src/vec/exprs/vruntimefilter_wrapper.cpp b/be/src/vec/exprs/vruntimefilter_wrapper.cpp index bbd466327819f6..40910ab7a6b9fa 100644 --- a/be/src/vec/exprs/vruntimefilter_wrapper.cpp +++ b/be/src/vec/exprs/vruntimefilter_wrapper.cpp @@ -18,26 +18,22 @@ #include "vec/exprs/vruntimefilter_wrapper.h" #include -#include -#include -#include -#include +#include -#include "util/defer_op.h" #include "util/runtime_profile.h" -#include "util/simd/bits.h" #include "vec/columns/column.h" #include "vec/columns/column_const.h" -#include "vec/columns/column_nullable.h" -#include "vec/columns/column_vector.h" #include "vec/core/block.h" +#include "vec/core/column_numbers.h" #include "vec/core/column_with_type_and_name.h" #include "vec/core/types.h" #include "vec/data_types/data_type.h" #include "vec/utils/util.hpp" namespace doris { +#include "common/compile_check_begin.h" + class RowDescriptor; class RuntimeState; class TExprNode; @@ -53,17 +49,18 @@ double get_comparison_ignore_thredhold() { double get_bloom_filter_ignore_thredhold() { return 0.4; } - -namespace vectorized { -class VExprContext; -} // namespace vectorized } // namespace doris namespace doris::vectorized { -VRuntimeFilterWrapper::VRuntimeFilterWrapper(const TExprNode& node, const VExprSPtr& impl, +class VExprContext; + +VRuntimeFilterWrapper::VRuntimeFilterWrapper(const TExprNode& node, VExprSPtr impl, double ignore_thredhold, bool null_aware) - : VExpr(node), _impl(impl), _ignore_thredhold(ignore_thredhold), _null_aware(null_aware) { + : VExpr(node), + _impl(std::move(impl)), + _ignore_thredhold(ignore_thredhold), + _null_aware(null_aware) { reset_judge_selectivity(); } @@ -108,7 +105,7 @@ Status VRuntimeFilterWrapper::execute(VExprContext* context, Block* block, int* if (_getting_const_col) { _impl->set_getting_const_col(true); } - std::vector args; + ColumnNumbers args; RETURN_IF_ERROR(_impl->execute_runtime_fitler(context, block, result_column_id, args)); if (_getting_const_col) { _impl->set_getting_const_col(false); @@ -128,4 +125,5 @@ const std::string& VRuntimeFilterWrapper::expr_name() const { return _expr_name; } -} // namespace doris::vectorized \ No newline at end of file +#include "common/compile_check_end.h" +} // namespace doris::vectorized diff --git a/be/src/vec/exprs/vruntimefilter_wrapper.h b/be/src/vec/exprs/vruntimefilter_wrapper.h index 477d0dc8b1b486..79e9361e854719 100644 --- a/be/src/vec/exprs/vruntimefilter_wrapper.h +++ b/be/src/vec/exprs/vruntimefilter_wrapper.h @@ -20,10 +20,8 @@ #include #include #include -#include #include "common/config.h" -#include "common/object_pool.h" #include "common/status.h" #include "udf/udf.h" #include "util/runtime_profile.h" @@ -37,20 +35,19 @@ class TExprNode; double get_in_list_ignore_thredhold(size_t list_size); double get_comparison_ignore_thredhold(); double get_bloom_filter_ignore_thredhold(); - -namespace vectorized { -class Block; -class VExprContext; -} // namespace vectorized } // namespace doris namespace doris::vectorized { +#include "common/compile_check_begin.h" + +class Block; +class VExprContext; class VRuntimeFilterWrapper final : public VExpr { ENABLE_FACTORY_CREATOR(VRuntimeFilterWrapper); public: - VRuntimeFilterWrapper(const TExprNode& node, const VExprSPtr& impl, double ignore_thredhold, + VRuntimeFilterWrapper(const TExprNode& node, VExprSPtr impl, double ignore_thredhold, bool null_aware = false); ~VRuntimeFilterWrapper() override = default; Status execute(VExprContext* context, Block* block, int* result_column_id) override; @@ -62,7 +59,7 @@ class VRuntimeFilterWrapper final : public VExpr { const std::string& expr_name() const override; const VExprSPtrs& children() const override { return _impl->children(); } - const VExprSPtr get_impl() const override { return _impl; } + VExprSPtr get_impl() const override { return _impl; } void attach_profile_counter(RuntimeProfile::Counter* expr_filtered_rows_counter, RuntimeProfile::Counter* expr_input_rows_counter, @@ -80,12 +77,12 @@ class VRuntimeFilterWrapper final : public VExpr { template static void judge_selectivity(double ignore_threshold, int64_t filter_rows, int64_t input_rows, T& always_true) { - always_true = filter_rows / (input_rows * 1.0) < ignore_threshold; + always_true = filter_rows / (input_rows * 1.0L) < ignore_threshold; } bool is_rf_wrapper() const override { return true; } - void do_judge_selectivity(int64_t filter_rows, int64_t input_rows) override { + void do_judge_selectivity(uint64_t filter_rows, uint64_t input_rows) override { update_counters(filter_rows, input_rows); if (!_always_true) { @@ -114,8 +111,8 @@ class VRuntimeFilterWrapper final : public VExpr { // without recalculating. At the beginning of the next period, // reset_judge_selectivity is used to reset these variables. std::atomic_int _judge_counter = 0; - std::atomic_int _judge_input_rows = 0; - std::atomic_int _judge_filter_rows = 0; + std::atomic_uint64_t _judge_input_rows = 0; + std::atomic_uint64_t _judge_filter_rows = 0; std::atomic_int _always_true = false; RuntimeProfile::Counter* _expr_filtered_rows_counter = nullptr; @@ -129,4 +126,5 @@ class VRuntimeFilterWrapper final : public VExpr { using VRuntimeFilterPtr = std::shared_ptr; +#include "common/compile_check_end.h" } // namespace doris::vectorized \ No newline at end of file diff --git a/be/src/vec/exprs/vtopn_pred.h b/be/src/vec/exprs/vtopn_pred.h index 044bc28b2618ab..ce756273d92018 100644 --- a/be/src/vec/exprs/vtopn_pred.h +++ b/be/src/vec/exprs/vtopn_pred.h @@ -24,7 +24,7 @@ #include "runtime/query_context.h" #include "runtime/runtime_predicate.h" #include "runtime/runtime_state.h" -#include "vec/columns/columns_number.h" +#include "vec/core/column_numbers.h" #include "vec/data_types/data_type.h" #include "vec/exprs/vexpr.h" #include "vec/exprs/vslot_ref.h" @@ -32,6 +32,7 @@ #include "vec/utils/util.hpp" namespace doris::vectorized { +#include "common/compile_check_begin.h" // only used for dynamic topn filter class VTopNPred : public VExpr { @@ -94,10 +95,11 @@ class VTopNPred : public VExpr { int slot_id = -1; RETURN_IF_ERROR(_children[0]->execute(context, block, &slot_id)); + // if error(slot_id == -1), will return. + ColumnNumbers arguments = {static_cast(slot_id), + static_cast(topn_value_id)}; - std::vector arguments = {(size_t)slot_id, (size_t)topn_value_id}; - - size_t num_columns_without_result = block->columns(); + uint32_t num_columns_without_result = block->columns(); block->insert({nullptr, _data_type, _expr_name}); RETURN_IF_ERROR(_function->execute(nullptr, *block, arguments, num_columns_without_result, block->rows(), false)); @@ -119,4 +121,6 @@ class VTopNPred : public VExpr { FunctionBasePtr _function; VExprContextSPtr _target_ctx; }; + +#include "common/compile_check_end.h" } // namespace doris::vectorized diff --git a/be/src/vec/functions/array/function_array_aggregation.cpp b/be/src/vec/functions/array/function_array_aggregation.cpp index 24d82f7894a3eb..24ded2c7b41952 100644 --- a/be/src/vec/functions/array/function_array_aggregation.cpp +++ b/be/src/vec/functions/array/function_array_aggregation.cpp @@ -205,7 +205,7 @@ struct ArrayAggregateImpl { } } - static Status execute(Block& block, const ColumnNumbers& arguments, size_t result, + static Status execute(Block& block, const ColumnNumbers& arguments, uint32_t result, const DataTypeArray* data_type_array, const ColumnArray& array) { ColumnPtr res; DataTypePtr type = data_type_array->get_nested_type(); diff --git a/be/src/vec/functions/array/function_array_apply.cpp b/be/src/vec/functions/array/function_array_apply.cpp index 426347c449b3b6..75425389dd975c 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 @@ class FunctionArrayApply : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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); diff --git a/be/src/vec/functions/array/function_array_binary.h b/be/src/vec/functions/array/function_array_binary.h index a41a82b8a78453..3a134e7392a40c 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 @@ class FunctionArrayBinary : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 c3acde4959a47d..ef4ae5a76ad892 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 @@ class FunctionArrayCompact : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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); diff --git a/be/src/vec/functions/array/function_array_concat.cpp b/be/src/vec/functions/array/function_array_concat.cpp index a4f1bfd29ccd78..18d0b7b48c14dc 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 @@ class FunctionArrayConcat : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - const size_t result, size_t input_rows_count) const override { + const uint32_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 6a26725ac9d00d..50c53697d2600d 100644 --- a/be/src/vec/functions/array/function_array_constructor.cpp +++ b/be/src/vec/functions/array/function_array_constructor.cpp @@ -72,7 +72,7 @@ class FunctionArrayConstructor : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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_contains_all.cpp b/be/src/vec/functions/array/function_array_contains_all.cpp index de74b648aab047..298289278bfa5f 100644 --- a/be/src/vec/functions/array/function_array_contains_all.cpp +++ b/be/src/vec/functions/array/function_array_contains_all.cpp @@ -57,7 +57,7 @@ class FunctionArrayContainsAll : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { const auto& [left_column, left_is_const] = unpack_if_const(block.get_by_position(arguments[0]).column); const auto& [right_column, right_is_const] = diff --git a/be/src/vec/functions/array/function_array_count.cpp b/be/src/vec/functions/array/function_array_count.cpp index 2d8eca3c178f90..21520de0744ea1 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 @@ class FunctionArrayCount : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 24750b55f6c8c2..2f93a2a83b1a89 100644 --- a/be/src/vec/functions/array/function_array_cum_sum.cpp +++ b/be/src/vec/functions/array/function_array_cum_sum.cpp @@ -97,7 +97,7 @@ class FunctionArrayCumSum : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - const size_t result, size_t input_rows_count) const override { + const uint32_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(); diff --git a/be/src/vec/functions/array/function_array_difference.h b/be/src/vec/functions/array/function_array_difference.h index 9eca677f0336ce..283ac206ce69b7 100644 --- a/be/src/vec/functions/array/function_array_difference.h +++ b/be/src/vec/functions/array/function_array_difference.h @@ -104,7 +104,7 @@ class FunctionArrayDifference : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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) { diff --git a/be/src/vec/functions/array/function_array_distance.h b/be/src/vec/functions/array/function_array_distance.h index 5284a3838adfce..e03e52a0ce191f 100644 --- a/be/src/vec/functions/array/function_array_distance.h +++ b/be/src/vec/functions/array/function_array_distance.h @@ -95,7 +95,7 @@ class FunctionArrayDistance : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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)) { diff --git a/be/src/vec/functions/array/function_array_distinct.h b/be/src/vec/functions/array/function_array_distinct.h index a3b70aa60d7385..6f477f3b671dec 100644 --- a/be/src/vec/functions/array/function_array_distinct.h +++ b/be/src/vec/functions/array/function_array_distinct.h @@ -76,7 +76,7 @@ class FunctionArrayDistinct : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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); diff --git a/be/src/vec/functions/array/function_array_element.h b/be/src/vec/functions/array/function_array_element.h index 60a353b9eb0b7b..7a4807608c3ef9 100644 --- a/be/src/vec/functions/array/function_array_element.h +++ b/be/src/vec/functions/array/function_array_element.h @@ -17,6 +17,7 @@ // This file is copied from // https://github.com/ClickHouse/ClickHouse/blob/master/src/Functions/array/arrayElement.cpp // and modified by Doris + #pragma once #include @@ -96,7 +97,7 @@ class FunctionArrayElement : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { auto dst_null_column = ColumnUInt8::create(input_rows_count, 0); UInt8* dst_null_map = dst_null_column->get_data().data(); const UInt8* src_null_map = nullptr; diff --git a/be/src/vec/functions/array/function_array_enumerate.cpp b/be/src/vec/functions/array/function_array_enumerate.cpp index 0ce927db897870..0e8bca3e5cd3b1 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 @@ class FunctionArrayEnumerate : public IFunction { return return_type; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 167d008a7339d7..a10124354be3ae 100644 --- a/be/src/vec/functions/array/function_array_enumerate_uniq.cpp +++ b/be/src/vec/functions/array/function_array_enumerate_uniq.cpp @@ -117,7 +117,7 @@ class FunctionArrayEnumerateUniq : public IFunction { #endif // __GNUC__ Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { ColumnRawPtrs data_columns(arguments.size()); const ColumnArray::Offsets64* offsets = nullptr; ColumnPtr src_offsets; diff --git a/be/src/vec/functions/array/function_array_exists.cpp b/be/src/vec/functions/array/function_array_exists.cpp index daef5faf849475..8621ecd35c0280 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 @@ class FunctionArrayExists : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 af7e7a4cb316b8..1a9cc5105b0f58 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 @@ class FunctionArrayFilter : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 144c7a9194fa73..773fc7b81998be 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 @@ class FunctionArrayFirstOrLastIndex : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 25a4397309557a..e602d67a73b01c 100644 --- a/be/src/vec/functions/array/function_array_index.h +++ b/be/src/vec/functions/array/function_array_index.h @@ -191,7 +191,7 @@ class FunctionArrayIndex : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { DBUG_EXECUTE_IF("array_func.array_contains", { auto req_id = DebugPoints::instance()->get_debug_param_or_default( "array_func.array_contains", "req_id", 0); @@ -348,7 +348,7 @@ class FunctionArrayIndex : public IFunction { return nullptr; } - Status _execute_dispatch(Block& block, const ColumnNumbers& arguments, size_t result, + Status _execute_dispatch(Block& block, const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) const { // extract array offsets and nested data auto left_column = diff --git a/be/src/vec/functions/array/function_array_join.h b/be/src/vec/functions/array/function_array_join.h index d184765edf65af..f7ffd4dfca3449 100644 --- a/be/src/vec/functions/array/function_array_join.h +++ b/be/src/vec/functions/array/function_array_join.h @@ -54,7 +54,7 @@ struct ArrayJoinImpl { return std::make_shared(); } - static Status execute(Block& block, const ColumnNumbers& arguments, size_t result, + static Status execute(Block& block, const ColumnNumbers& arguments, uint32_t result, const DataTypeArray* data_type_array, const ColumnArray& array) { ColumnPtr src_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 19ffb8ce9c722f..93f7d068e4b01d 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 @@ class FunctionArrayMapped : public IFunction { 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) const override { + uint32_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 9d14a68560cef4..923b64473a8d1d 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 @@ class FunctionArrayNary : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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_pop.cpp b/be/src/vec/functions/array/function_array_pop.cpp index f9b5c161ae124e..2182699e0205b5 100644 --- a/be/src/vec/functions/array/function_array_pop.cpp +++ b/be/src/vec/functions/array/function_array_pop.cpp @@ -63,7 +63,7 @@ class FunctionArrayPop : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 8dedd3e9a66e8b..d1152ca9739b98 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 @@ class FunctionArrayPushback : public IFunction { }; Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 28ba7ac6c36ff5..c592999b108a35 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 @@ class FunctionArrayPushfront : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 1b71693f6407bc..b6b814a26e339a 100644 --- a/be/src/vec/functions/array/function_array_range.cpp +++ b/be/src/vec/functions/array/function_array_range.cpp @@ -80,7 +80,7 @@ class FunctionArrayRange : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { return Impl::execute_impl(context, block, arguments, result, input_rows_count); } }; @@ -127,7 +127,7 @@ struct RangeImplUtil { static constexpr auto name = get_function_name(); - static Status range_execute(Block& block, const ColumnNumbers& arguments, size_t result, + static Status range_execute(Block& block, const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { DCHECK_EQ(arguments.size(), 3); auto return_nested_type = make_nullable(std::make_shared()); @@ -248,7 +248,7 @@ struct RangeOneImpl : public RangeImplUtil { } static Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { using ColumnType = std::conditional_t, ColumnInt32, ColumnDateTimeV2>; @@ -272,7 +272,7 @@ struct RangeTwoImpl : public RangeImplUtil { } static Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { auto step_column = ColumnInt32::create(input_rows_count, 1); block.insert({std::move(step_column), std::make_shared(), "step_column"}); @@ -291,7 +291,7 @@ struct RangeThreeImpl : public RangeImplUtil { } static Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { return (RangeImplUtil::range_execute)( 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 2645f87320fabb..197b032b0f8a4b 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 @@ class FunctionArrayRemove : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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])}; diff --git a/be/src/vec/functions/array/function_array_reverse.h b/be/src/vec/functions/array/function_array_reverse.h index 07145426145b3c..8567bc61158bab 100644 --- a/be/src/vec/functions/array/function_array_reverse.h +++ b/be/src/vec/functions/array/function_array_reverse.h @@ -28,7 +28,7 @@ namespace doris::vectorized { struct ArrayReverseImpl { - static Status _execute(Block& block, const ColumnNumbers& arguments, size_t result, + static Status _execute(Block& block, const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { ColumnPtr src_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); diff --git a/be/src/vec/functions/array/function_array_shuffle.cpp b/be/src/vec/functions/array/function_array_shuffle.cpp index 8d46aaa69333fa..648b06318df3dc 100644 --- a/be/src/vec/functions/array/function_array_shuffle.cpp +++ b/be/src/vec/functions/array/function_array_shuffle.cpp @@ -66,7 +66,7 @@ class FunctionArrayShuffle : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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); diff --git a/be/src/vec/functions/array/function_array_slice.h b/be/src/vec/functions/array/function_array_slice.h index 6cc5ece48ab57b..2acd1d3fbe1fd4 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 @@ class FunctionArraySlice : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 800a137742478b..7b66336836ea12 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 @@ class FunctionArraySort : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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); diff --git a/be/src/vec/functions/array/function_array_sortby.cpp b/be/src/vec/functions/array/function_array_sortby.cpp index 15e296acb2440e..499a5e37ab9380 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 @@ class FunctionArraySortBy : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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_split.cpp b/be/src/vec/functions/array/function_array_split.cpp index 30e46d18c8fae0..7f7a847abc71f4 100644 --- a/be/src/vec/functions/array/function_array_split.cpp +++ b/be/src/vec/functions/array/function_array_split.cpp @@ -61,7 +61,7 @@ class FunctionArraySplit : public IFunction { }; Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { // (Array((Int))) auto src_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); 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 16e3947714cb62..6f38e83e209705 100644 --- a/be/src/vec/functions/array/function_array_with_constant.cpp +++ b/be/src/vec/functions/array/function_array_with_constant.cpp @@ -75,7 +75,7 @@ class FunctionArrayWithConstant : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 2f9b94454e1f5e..217a8039421a1c 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 @@ class FunctionArrayZip : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 23c0ed1f8cc261..7c851f5c16088b 100644 --- a/be/src/vec/functions/array/function_arrays_overlap.h +++ b/be/src/vec/functions/array/function_arrays_overlap.h @@ -207,7 +207,7 @@ class FunctionArraysOverlap : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { DBUG_EXECUTE_IF("array_func.arrays_overlap", { auto req_id = DebugPoints::instance()->get_debug_param_or_default( "array_func.arrays_overlap", "req_id", 0); diff --git a/be/src/vec/functions/array/varray_match_function.cpp b/be/src/vec/functions/array/varray_match_function.cpp index c322fea7566303..e0081f3c39fc52 100644 --- a/be/src/vec/functions/array/varray_match_function.cpp +++ b/be/src/vec/functions/array/varray_match_function.cpp @@ -59,7 +59,7 @@ class ArrayMatchFunction : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { // here is executed by array_map filtered and arg[0] is bool result column const auto& [src_column, src_const] = unpack_if_const(block.get_by_position(arguments[0]).column); diff --git a/be/src/vec/functions/comparison_equal_for_null.cpp b/be/src/vec/functions/comparison_equal_for_null.cpp index 24c669094a515e..919f9ebed65a7c 100644 --- a/be/src/vec/functions/comparison_equal_for_null.cpp +++ b/be/src/vec/functions/comparison_equal_for_null.cpp @@ -66,7 +66,7 @@ class FunctionEqForNull : public IFunction { 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) const override { + uint32_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/date_time_transforms.h b/be/src/vec/functions/date_time_transforms.h index 73155afae3a996..d2c30d9d706332 100644 --- a/be/src/vec/functions/date_time_transforms.h +++ b/be/src/vec/functions/date_time_transforms.h @@ -429,7 +429,7 @@ struct Transformer> { template struct DateTimeTransformImpl { - static Status execute(Block& block, const ColumnNumbers& arguments, size_t result, + static Status execute(Block& block, const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { using Op = Transformer; diff --git a/be/src/vec/functions/function.cpp b/be/src/vec/functions/function.cpp index 1fea4c70fc1753..5b935444710e25 100644 --- a/be/src/vec/functions/function.cpp +++ b/be/src/vec/functions/function.cpp @@ -23,7 +23,6 @@ #include #include #include -#include #include "vec/aggregate_functions/aggregate_function.h" #include "vec/columns/column.h" @@ -42,7 +41,7 @@ namespace doris::vectorized { ColumnPtr wrap_in_nullable(const ColumnPtr& src, const Block& block, const ColumnNumbers& args, - size_t result, size_t input_rows_count) { + uint32_t result, size_t input_rows_count) { ColumnPtr result_null_map_column; /// If result is already nullable. ColumnPtr src_not_nullable = src; @@ -105,7 +104,7 @@ bool have_null_column(const ColumnsWithTypeAndName& args) { } inline Status PreparedFunctionImpl::_execute_skipped_constant_deal( - FunctionContext* context, Block& block, const ColumnNumbers& args, size_t result, + FunctionContext* context, Block& block, const ColumnNumbers& args, uint32_t result, size_t input_rows_count, bool dry_run) const { bool executed = false; RETURN_IF_ERROR(default_implementation_for_nulls(context, block, args, result, input_rows_count, @@ -122,7 +121,7 @@ inline Status PreparedFunctionImpl::_execute_skipped_constant_deal( } Status PreparedFunctionImpl::default_implementation_for_constant_arguments( - FunctionContext* context, Block& block, const ColumnNumbers& args, size_t result, + FunctionContext* context, Block& block, const ColumnNumbers& args, uint32_t result, size_t input_rows_count, bool dry_run, bool* executed) const { *executed = false; ColumnNumbers args_expect_const = get_arguments_that_are_always_constant(); @@ -186,7 +185,7 @@ Status PreparedFunctionImpl::default_implementation_for_constant_arguments( } Status PreparedFunctionImpl::default_implementation_for_nulls( - FunctionContext* context, Block& block, const ColumnNumbers& args, size_t result, + FunctionContext* context, Block& block, const ColumnNumbers& args, uint32_t result, size_t input_rows_count, bool dry_run, bool* executed) const { *executed = false; if (args.empty() || !use_default_implementation_for_nulls()) { @@ -232,7 +231,7 @@ Status PreparedFunctionImpl::default_implementation_for_nulls( } Status PreparedFunctionImpl::execute_without_low_cardinality_columns( - FunctionContext* context, Block& block, const ColumnNumbers& args, size_t result, + FunctionContext* context, Block& block, const ColumnNumbers& args, uint32_t result, size_t input_rows_count, bool dry_run) const { bool executed = false; @@ -246,7 +245,7 @@ Status PreparedFunctionImpl::execute_without_low_cardinality_columns( } Status PreparedFunctionImpl::execute(FunctionContext* context, Block& block, - const ColumnNumbers& args, size_t result, + const ColumnNumbers& args, uint32_t result, size_t input_rows_count, bool dry_run) const { return execute_without_low_cardinality_columns(context, block, args, result, input_rows_count, dry_run); diff --git a/be/src/vec/functions/function.h b/be/src/vec/functions/function.h index 4702a4b7af0bbf..5dab13012a2784 100644 --- a/be/src/vec/functions/function.h +++ b/be/src/vec/functions/function.h @@ -22,10 +22,9 @@ #include #include -#include +#include #include -#include #include #include @@ -95,7 +94,7 @@ class IPreparedFunction { virtual String get_name() const = 0; virtual Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count, bool dry_run) const = 0; + uint32_t result, size_t input_rows_count, bool dry_run) const = 0; }; using PreparedFunctionPtr = std::shared_ptr; @@ -103,7 +102,7 @@ using PreparedFunctionPtr = std::shared_ptr; class PreparedFunctionImpl : public IPreparedFunction { public: Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count, bool dry_run = false) const final; + uint32_t result, size_t input_rows_count, bool dry_run = false) const final; /** If the function have non-zero number of arguments, * and if all arguments are constant, that we could automatically provide default implementation: @@ -120,13 +119,13 @@ class PreparedFunctionImpl : public IPreparedFunction { protected: virtual Status execute_impl_dry_run(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) const { return execute_impl(context, block, arguments, result, input_rows_count); } virtual Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) const = 0; /** Default implementation in presence of Nullable arguments or NULL constants as arguments is the following: @@ -150,18 +149,18 @@ class PreparedFunctionImpl : public IPreparedFunction { private: Status default_implementation_for_nulls(FunctionContext* context, Block& block, - const ColumnNumbers& args, size_t result, + const ColumnNumbers& args, uint32_t result, size_t input_rows_count, bool dry_run, bool* executed) const; Status default_implementation_for_constant_arguments(FunctionContext* context, Block& block, - const ColumnNumbers& args, size_t result, + const ColumnNumbers& args, uint32_t result, size_t input_rows_count, bool dry_run, bool* executed) const; Status execute_without_low_cardinality_columns(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count, bool dry_run) const; Status _execute_skipped_constant_deal(FunctionContext* context, Block& block, - const ColumnNumbers& args, size_t result, + const ColumnNumbers& args, uint32_t result, size_t input_rows_count, bool dry_run) const; }; @@ -179,7 +178,7 @@ class IFunctionBase { /// Do preparations and return executable. /// sample_block should contain data types of arguments and values of constants, if relevant. virtual PreparedFunctionPtr prepare(FunctionContext* context, const Block& sample_block, - const ColumnNumbers& arguments, size_t result) const = 0; + const ColumnNumbers& arguments, uint32_t result) const = 0; /// Override this when function need to store state in the `FunctionContext`, or do some /// preparation work according to information from `FunctionContext`. @@ -189,7 +188,7 @@ class IFunctionBase { /// TODO: make const virtual Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count, bool dry_run = false) const { + uint32_t result, size_t input_rows_count, bool dry_run = false) const { return prepare(context, block, arguments, result) ->execute(context, block, arguments, result, input_rows_count, dry_run); } @@ -367,7 +366,7 @@ class FunctionBuilderImpl : public IFunctionBuilder { virtual FunctionBasePtr build_impl(const ColumnsWithTypeAndName& arguments, const DataTypePtr& return_type) const = 0; - virtual DataTypes get_variadic_argument_types_impl() const { return DataTypes(); } + virtual DataTypes get_variadic_argument_types_impl() const { return {}; } private: DataTypePtr get_return_type_without_low_cardinality( @@ -388,9 +387,8 @@ class IFunction : public std::enable_shared_from_this, String get_name() const override = 0; /// Notice: We should not change the column in the block, because the column may be shared by multiple expressions or exec nodes. - virtual Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, - size_t input_rows_count) const override = 0; + Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, + uint32_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; } @@ -415,7 +413,7 @@ class IFunction : public std::enable_shared_from_this, [[noreturn]] PreparedFunctionPtr prepare(FunctionContext* context, const Block& /*sample_block*/, const ColumnNumbers& /*arguments*/, - size_t /*result*/) const final { + uint32_t /*result*/) const final { throw doris::Exception(ErrorCode::NOT_IMPLEMENTED_ERROR, "prepare is not implemented for IFunction {}", get_name()); __builtin_unreachable(); @@ -459,7 +457,7 @@ class DefaultExecutable final : public PreparedFunctionImpl { protected: Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const final { + uint32_t result, size_t input_rows_count) const final { return function->execute_impl(context, block, arguments, result, input_rows_count); } @@ -473,7 +471,7 @@ class DefaultExecutable final : public PreparedFunctionImpl { } Status execute_impl_dry_run(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) const final { return function->execute_impl_dry_run(context, block, arguments, result, input_rows_count); } @@ -517,7 +515,7 @@ class DefaultFunction final : public IFunctionBase { // return a default wrapper for IFunction. PreparedFunctionPtr prepare(FunctionContext* context, const Block& /*sample_block*/, const ColumnNumbers& /*arguments*/, - size_t /*result*/) const override { + uint32_t /*result*/) const override { return std::make_shared(function); } @@ -614,7 +612,7 @@ using FunctionPtr = std::shared_ptr; * Or ColumnConst(ColumnNullable) if the result is always NULL or if the result is constant and always not NULL. */ ColumnPtr wrap_in_nullable(const ColumnPtr& src, const Block& block, const ColumnNumbers& args, - size_t result, size_t input_rows_count); + uint32_t result, size_t input_rows_count); #define NUMERIC_TYPE_TO_COLUMN_TYPE(M) \ M(UInt8, ColumnUInt8) \ diff --git a/be/src/vec/functions/function_agg_state.h b/be/src/vec/functions/function_agg_state.h index b17e8916d0e0a9..f4b7aef23af220 100644 --- a/be/src/vec/functions/function_agg_state.h +++ b/be/src/vec/functions/function_agg_state.h @@ -61,7 +61,7 @@ class FunctionAggState : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { auto col = _agg_function->create_serialize_column(); std::vector agg_columns; std::vector save_columns; diff --git a/be/src/vec/functions/function_always_not_nullable.h b/be/src/vec/functions/function_always_not_nullable.h index b6f18490bb9ea1..618e799f4ae503 100644 --- a/be/src/vec/functions/function_always_not_nullable.h +++ b/be/src/vec/functions/function_always_not_nullable.h @@ -76,7 +76,7 @@ class FunctionAlwaysNotNullable : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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_assert_true.cpp b/be/src/vec/functions/function_assert_true.cpp index 71deeab32a5071..93b7b58b204a5d 100644 --- a/be/src/vec/functions/function_assert_true.cpp +++ b/be/src/vec/functions/function_assert_true.cpp @@ -65,7 +65,7 @@ class FunctionAssertTrue : public IFunction { // column2 is const, so in default logic column1 is no way const. Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { std::string errmsg = assert_cast(*block.get_by_position(arguments[1]).column) .get_data_at(0) diff --git a/be/src/vec/functions/function_binary_arithmetic.h b/be/src/vec/functions/function_binary_arithmetic.h index 9f2af326f71901..31e1d50f45b03c 100644 --- a/be/src/vec/functions/function_binary_arithmetic.h +++ b/be/src/vec/functions/function_binary_arithmetic.h @@ -1030,7 +1030,7 @@ class FunctionBinaryArithmetic : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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_bit_test.cpp b/be/src/vec/functions/function_bit_test.cpp index 8e010fd9446444..e863e2a4cf8e52 100644 --- a/be/src/vec/functions/function_bit_test.cpp +++ b/be/src/vec/functions/function_bit_test.cpp @@ -46,7 +46,7 @@ class FunctionBitTest : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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; @@ -75,7 +75,7 @@ class FunctionBitTest : public IFunction { } template - void execute_inner(Block& block, const ColumnNumbers& arguments, size_t result, + void execute_inner(Block& block, const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) const { size_t argument_size = arguments.size(); std::vector argument_columns(argument_size); diff --git a/be/src/vec/functions/function_bitmap.cpp b/be/src/vec/functions/function_bitmap.cpp index b6072c05cf0f66..64059472efcee9 100644 --- a/be/src/vec/functions/function_bitmap.cpp +++ b/be/src/vec/functions/function_bitmap.cpp @@ -350,7 +350,7 @@ class FunctionBitmapAlwaysNull : public IFunction { 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) const override { + uint32_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(); @@ -497,7 +497,7 @@ class FunctionBitmapCount : public IFunction { 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) const override { + uint32_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); @@ -660,7 +660,7 @@ void update_bitmap_op_count(int64_t* __restrict count, const NullMap& null_map) // for bitmap_and_count, bitmap_xor_count and bitmap_and_not_count, // result is 0 for rows that if any column is null value ColumnPtr handle_bitmap_op_count_null_value(ColumnPtr& src, const Block& block, - const ColumnNumbers& args, size_t result, + const ColumnNumbers& args, uint32_t result, size_t input_rows_count) { auto* nullable = assert_cast(src.get()); ColumnPtr src_not_nullable = nullable->get_nested_column_ptr(); @@ -696,7 +696,7 @@ ColumnPtr handle_bitmap_op_count_null_value(ColumnPtr& src, const Block& block, } Status execute_bitmap_op_count_null_to_zero( - FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, + FunctionContext* context, Block& block, const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count, const std::function& exec_impl_func) { @@ -745,10 +745,10 @@ class FunctionBitmapAndNotCount : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { DCHECK_EQ(arguments.size(), 2); auto impl_func = [&](FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) { + uint32_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, @@ -756,7 +756,7 @@ class FunctionBitmapAndNotCount : public IFunction { } Status execute_impl_internal(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) const { using ResultType = typename ResultDataType::FieldType; using ColVecResult = ColumnVector; @@ -1147,7 +1147,7 @@ class FunctionBitmapSubs : public IFunction { size_t get_number_of_arguments() const override { return 3; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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); @@ -1200,7 +1200,7 @@ class FunctionBitmapToArray : public IFunction { 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) const override { + uint32_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 85cf9fc3f08fdf..44bb135335218c 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 @@ class FunctionBitmapSingle : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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); diff --git a/be/src/vec/functions/function_bitmap_variadic.cpp b/be/src/vec/functions/function_bitmap_variadic.cpp index c1e044a2a4aa69..6e1a103fdbd83b 100644 --- a/be/src/vec/functions/function_bitmap_variadic.cpp +++ b/be/src/vec/functions/function_bitmap_variadic.cpp @@ -158,7 +158,7 @@ BITMAP_FUNCTION_COUNT_VARIADIC(BitmapAndCount, bitmap_and_count, &=); BITMAP_FUNCTION_COUNT_VARIADIC(BitmapXorCount, bitmap_xor_count, ^=); Status execute_bitmap_op_count_null_to_zero( - FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, + FunctionContext* context, Block& block, const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count, const std::function& exec_impl_func); @@ -202,10 +202,10 @@ class FunctionBitMapVariadic : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { if (std::is_same_v || std::is_same_v) { auto impl_func = [&](FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { return execute_impl_internal(context, block, arguments, result, input_rows_count); }; @@ -217,7 +217,7 @@ class FunctionBitMapVariadic : public IFunction { } Status execute_impl_internal(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) const { size_t argument_size = arguments.size(); std::vector argument_columns(argument_size); diff --git a/be/src/vec/functions/function_case.h b/be/src/vec/functions/function_case.h index f02b85aed456bf..fdfecc211caed8 100644 --- a/be/src/vec/functions/function_case.h +++ b/be/src/vec/functions/function_case.h @@ -153,7 +153,7 @@ class FunctionCase : public IFunction { bool use_default_implementation_for_nulls() const override { return false; } template - Status execute_short_circuit(const DataTypePtr& data_type, Block& block, size_t result, + Status execute_short_circuit(const DataTypePtr& data_type, Block& block, uint32_t result, 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 @@ class FunctionCase : public IFunction { } template - Status execute_impl(const DataTypePtr& data_type, Block& block, size_t result, + Status execute_impl(const DataTypePtr& data_type, Block& block, uint32_t result, CaseWhenColumnHolder column_holder) const { if (column_holder.pair_count > UINT8_MAX) { return execute_short_circuit(data_type, block, result, @@ -250,7 +250,7 @@ class FunctionCase : public IFunction { } template - Status execute_update_result(const DataTypePtr& data_type, size_t result, Block& block, + Status execute_update_result(const DataTypePtr& data_type, uint32_t result, Block& block, const uint8* then_idx, CaseWhenColumnHolder& column_holder) const { auto result_column_ptr = data_type->create_column(); @@ -348,7 +348,7 @@ class FunctionCase : public IFunction { template Status execute_get_then_null(const DataTypePtr& data_type, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) const { bool then_null = false; for (int i = 1 + has_case; i < arguments.size() - has_else; i += 2) { @@ -378,7 +378,7 @@ class FunctionCase : public IFunction { template Status execute_get_when_null(const DataTypePtr& data_type, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) const { bool when_null = false; if constexpr (has_case) { @@ -404,7 +404,7 @@ class FunctionCase : public IFunction { } Status execute_get_type(const DataTypePtr& data_type, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) const { WhichDataType which( data_type->is_nullable() @@ -420,7 +420,7 @@ class FunctionCase : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 acf63a66229eb9..0e567a2b74327a 100644 --- a/be/src/vec/functions/function_cast.h +++ b/be/src/vec/functions/function_cast.h @@ -258,7 +258,7 @@ struct ConvertImpl { template static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count, + uint32_t result, size_t input_rows_count, Additions additions = Additions()) { const ColumnWithTypeAndName& named_from = block.get_by_position(arguments[0]); @@ -472,7 +472,7 @@ template requires(!T::is_parametric) struct ConvertImpl { static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t /*input_rows_count*/) { + uint32_t result, size_t /*input_rows_count*/) { block.get_by_position(result).column = block.get_by_position(arguments[0]).column; return Status::OK(); } @@ -485,7 +485,7 @@ struct ConvertImplToTimeType { using FromFieldType = typename FromDataType::FieldType; using ToFieldType = typename ToDataType::FieldType; - static Status execute(Block& block, const ColumnNumbers& arguments, size_t result, + static Status execute(Block& block, const ColumnNumbers& arguments, uint32_t result, size_t /*input_rows_count*/) { const ColumnWithTypeAndName& named_from = block.get_by_position(arguments[0]); @@ -563,14 +563,14 @@ struct ConvertImplGenericToString { } static Status execute2(FunctionContext* /*ctx*/, Block& block, const ColumnNumbers& arguments, - const size_t result, size_t /*input_rows_count*/) { + const uint32_t result, size_t /*input_rows_count*/) { return execute(block, arguments, result); } }; //this is for data in compound type struct ConvertImplGenericFromString { static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - const size_t result, size_t input_rows_count) { + const uint32_t result, size_t input_rows_count) { const auto& col_with_type_and_name = block.get_by_position(arguments[0]); const IColumn& col_from = *col_with_type_and_name.column; // result column must set type @@ -624,7 +624,7 @@ struct ConvertImplGenericFromString { template struct ConvertImplNumberToJsonb { static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - const size_t result, size_t input_rows_count) { + const uint32_t result, size_t input_rows_count) { const auto& col_with_type_and_name = block.get_by_position(arguments[0]); auto column_string = ColumnString::create(); @@ -665,7 +665,7 @@ struct ConvertImplNumberToJsonb { struct ConvertImplStringToJsonbAsJsonbString { static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - const size_t result, size_t input_rows_count) { + const uint32_t result, size_t input_rows_count) { auto data_type_to = block.get_by_position(result).type; const auto& col_with_type_and_name = block.get_by_position(arguments[0]); const IColumn& col_from = *col_with_type_and_name.column; @@ -689,7 +689,7 @@ struct ConvertImplStringToJsonbAsJsonbString { struct ConvertImplGenericFromJsonb { static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - const size_t result, size_t input_rows_count) { + const uint32_t result, size_t input_rows_count) { auto data_type_to = block.get_by_position(result).type; const auto& col_with_type_and_name = block.get_by_position(arguments[0]); const IColumn& col_from = *col_with_type_and_name.column; @@ -770,7 +770,7 @@ struct ConvertImplGenericFromJsonb { // Generic conversion of any type to jsonb. struct ConvertImplGenericToJsonb { static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - const size_t result, size_t input_rows_count) { + const uint32_t result, size_t input_rows_count) { auto data_type_to = block.get_by_position(result).type; const auto& col_with_type_and_name = block.get_by_position(arguments[0]); const IDataType& type = *col_with_type_and_name.type; @@ -823,7 +823,7 @@ struct ConvertImplGenericToJsonb { struct ConvertNothingToJsonb { static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - const size_t result, size_t input_rows_count) { + const uint32_t result, size_t input_rows_count) { const auto& col_with_type_and_name = block.get_by_position(arguments[0]); const IColumn& col_from = *col_with_type_and_name.column; auto data_type_to = block.get_by_position(result).type; @@ -839,7 +839,7 @@ struct ConvertNothingToJsonb { template struct ConvertImplFromJsonb { static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - const size_t result, size_t input_rows_count) { + const uint32_t result, size_t input_rows_count) { const auto& col_with_type_and_name = block.get_by_position(arguments[0]); const IColumn& col_from = *col_with_type_and_name.column; // result column must set type @@ -957,7 +957,7 @@ struct ConvertImpl { template static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count, + uint32_t result, size_t input_rows_count, Additions additions [[maybe_unused]] = Additions()) { return Status::RuntimeError("not support convert from string"); } @@ -1292,7 +1292,7 @@ class FunctionConvert : public IFunction { 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) const override { + uint32_t result, size_t input_rows_count) const override { if (!arguments.size()) { return Status::RuntimeError("Function {} expects at least 1 arguments", get_name()); } @@ -1495,7 +1495,7 @@ class PreparedFunctionCast : public PreparedFunctionImpl { protected: Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { return wrapper_function(context, block, arguments, result, input_rows_count); } @@ -1517,7 +1517,7 @@ struct StringParsing { template static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count, + uint32_t result, size_t input_rows_count, Additions additions [[maybe_unused]] = Additions()) { using ColVecTo = std::conditional_t, ColumnDecimal, ColumnVector>; @@ -1643,7 +1643,7 @@ class FunctionConvertFromString : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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)) { @@ -1679,7 +1679,7 @@ class FunctionConvertToTimeType : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 { @@ -1723,7 +1723,7 @@ class FunctionCast final : public IFunctionBase { PreparedFunctionPtr prepare(FunctionContext* context, const Block& /*sample_block*/, const ColumnNumbers& /*arguments*/, - size_t /*result*/) const override { + uint32_t /*result*/) const override { return std::make_shared( prepare_unpack_dictionaries(context, get_argument_types()[0], get_return_type()), name); @@ -1770,7 +1770,7 @@ class FunctionCast final : public IFunctionBase { { function->get_return_type(ColumnsWithTypeAndName(1, {nullptr, from_type, ""})); } return [function](FunctionContext* context, Block& block, const ColumnNumbers& arguments, - const size_t result, size_t input_rows_count) { + const uint32_t result, size_t input_rows_count) { return function->execute(context, block, arguments, result, input_rows_count); }; } @@ -1782,7 +1782,7 @@ class FunctionCast final : public IFunctionBase { { function->get_return_type(ColumnsWithTypeAndName(1, {nullptr, from_type, ""})); } return [function](FunctionContext* context, Block& block, const ColumnNumbers& arguments, - const size_t result, size_t input_rows_count) { + const uint32_t result, size_t input_rows_count) { return function->execute(context, block, arguments, result, input_rows_count); }; } @@ -1805,7 +1805,7 @@ class FunctionCast final : public IFunctionBase { } return [type_index, precision, scale](FunctionContext* context, Block& block, - const ColumnNumbers& arguments, const size_t result, + const ColumnNumbers& arguments, const uint32_t result, size_t input_rows_count) { auto res = call_on_index_and_data_type( type_index, [&](const auto& types) -> bool { @@ -1834,7 +1834,7 @@ class FunctionCast final : public IFunctionBase { WrapperType create_identity_wrapper(const DataTypePtr&) const { return [](FunctionContext* context, Block& block, const ColumnNumbers& arguments, - const size_t result, size_t /*input_rows_count*/) { + const uint32_t result, size_t /*input_rows_count*/) { block.get_by_position(result).column = block.get_by_position(arguments.front()).column; return Status::OK(); }; @@ -1843,7 +1843,7 @@ class FunctionCast final : public IFunctionBase { WrapperType create_nothing_wrapper(const IDataType* to_type) const { ColumnPtr res = to_type->create_column_const_with_default_value(1); return [res](FunctionContext* context, Block& block, const ColumnNumbers&, - const size_t result, size_t input_rows_count) { + const uint32_t result, size_t input_rows_count) { /// Column of Nothing type is trivially convertible to any other column block.get_by_position(result).column = res->clone_resized(input_rows_count)->convert_to_full_column_if_const(); @@ -1939,7 +1939,7 @@ class FunctionCast final : public IFunctionBase { return [nested_function, from_nested_type, to_nested_type]( FunctionContext* context, Block& block, const ColumnNumbers& arguments, - const size_t result, size_t /*input_rows_count*/) -> Status { + const uint32_t result, size_t /*input_rows_count*/) -> Status { ColumnPtr from_column = block.get_by_position(arguments.front()).column; const ColumnArray* from_col_array = @@ -2037,7 +2037,7 @@ class FunctionCast final : public IFunctionBase { struct ConvertImplGenericFromVariant { static Status execute(const FunctionCast* fn, FunctionContext* context, Block& block, - const ColumnNumbers& arguments, const size_t result, + const ColumnNumbers& arguments, const uint32_t result, size_t input_rows_count) { auto& data_type_to = block.get_by_position(result).type; const auto& col_with_type_and_name = block.get_by_position(arguments[0]); @@ -2111,7 +2111,7 @@ class FunctionCast final : public IFunctionBase { struct ConvertImplGenericToVariant { static Status execute(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, const size_t result, + const ColumnNumbers& arguments, const uint32_t result, size_t input_rows_count) { // auto& data_type_to = block.get_by_position(result).type; const auto& col_with_type_and_name = block.get_by_position(arguments[0]); @@ -2135,7 +2135,7 @@ class FunctionCast final : public IFunctionBase { WrapperType create_variant_wrapper(const DataTypeObject& from_type, const DataTypePtr& to_type) const { return [this](FunctionContext* context, Block& block, const ColumnNumbers& arguments, - const size_t result, size_t input_rows_count) -> Status { + const uint32_t result, size_t input_rows_count) -> Status { return ConvertImplGenericFromVariant::execute(this, context, block, arguments, result, input_rows_count); }; @@ -2166,7 +2166,7 @@ class FunctionCast final : public IFunctionBase { auto kv_wrappers = get_element_wrappers(context, from_kv_types, to_kv_types); return [kv_wrappers, from_kv_types, to_kv_types]( FunctionContext* context, Block& block, const ColumnNumbers& arguments, - const size_t result, size_t /*input_rows_count*/) -> Status { + const uint32_t result, size_t /*input_rows_count*/) -> Status { auto& from_column = block.get_by_position(arguments.front()).column; auto from_col_map = check_and_get_column(from_column.get()); if (!from_col_map) { @@ -2241,7 +2241,7 @@ class FunctionCast final : public IFunctionBase { auto element_wrappers = get_element_wrappers(context, from_element_types, to_element_types); return [element_wrappers, from_element_types, to_element_types]( FunctionContext* context, Block& block, const ColumnNumbers& arguments, - const size_t result, size_t /*input_rows_count*/) -> Status { + const uint32_t result, size_t /*input_rows_count*/) -> Status { auto& from_column = block.get_by_position(arguments.front()).column; auto from_col_struct = check_and_get_column(from_column.get()); if (!from_col_struct) { @@ -2282,7 +2282,7 @@ class FunctionCast final : public IFunctionBase { } return [](FunctionContext* context, Block& block, const ColumnNumbers&, - const size_t result, size_t input_rows_count) { + const uint32_t result, size_t input_rows_count) { auto& res = block.get_by_position(result); res.column = res.type->create_column_const_with_default_value(input_rows_count) ->convert_to_full_column_if_const(); @@ -2391,7 +2391,7 @@ class FunctionCast final : public IFunctionBase { if (result_is_nullable) { return [this, from_type, to_type](FunctionContext* context, Block& block, - const ColumnNumbers& arguments, const size_t result, + const ColumnNumbers& arguments, const uint32_t result, size_t input_rows_count) { auto from_type_not_nullable = remove_nullable(from_type); auto to_type_not_nullable = remove_nullable(to_type); diff --git a/be/src/vec/functions/function_coalesce.cpp b/be/src/vec/functions/function_coalesce.cpp index c461b260ab8a07..6e5db15d160c06 100644 --- a/be/src/vec/functions/function_coalesce.cpp +++ b/be/src/vec/functions/function_coalesce.cpp @@ -87,7 +87,7 @@ class FunctionCoalesce : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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; diff --git a/be/src/vec/functions/function_collection_in.h b/be/src/vec/functions/function_collection_in.h index 755f2911245467..ce58d63f44b655 100644 --- a/be/src/vec/functions/function_collection_in.h +++ b/be/src/vec/functions/function_collection_in.h @@ -138,7 +138,7 @@ class FunctionCollectionIn : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { auto in_state = reinterpret_cast( context->get_function_state(FunctionContext::FRAGMENT_LOCAL)); if (!in_state) { diff --git a/be/src/vec/functions/function_const.h b/be/src/vec/functions/function_const.h index 0ce24c85dcb0e8..1cc97170ac1392 100644 --- a/be/src/vec/functions/function_const.h +++ b/be/src/vec/functions/function_const.h @@ -44,7 +44,7 @@ class FunctionConst : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 @@ class FunctionConst : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 @@ class FunctionMathConstFloat64 : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 baac2af61ed2a3..085d982a1cbf1e 100644 --- a/be/src/vec/functions/function_conv.cpp +++ b/be/src/vec/functions/function_conv.cpp @@ -74,7 +74,7 @@ class FunctionConv : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 7765568b5f134a..962d3f598824b4 100644 --- a/be/src/vec/functions/function_convert_tz.h +++ b/be/src/vec/functions/function_convert_tz.h @@ -145,7 +145,7 @@ class FunctionConvertTZ : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { auto* convert_tz_state = reinterpret_cast( context->get_function_state(FunctionContext::FRAGMENT_LOCAL)); if (!convert_tz_state) { 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 ba75a86ef7ecc4..2dd71ec31be81f 100644 --- a/be/src/vec/functions/function_date_or_datetime_computation.h +++ b/be/src/vec/functions/function_date_or_datetime_computation.h @@ -536,7 +536,7 @@ struct DateTimeOp { template struct DateTimeAddIntervalImpl { - static Status execute(Block& block, const ColumnNumbers& arguments, size_t result, + static Status execute(Block& block, const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { using ToType = typename Transform::ReturnType::FieldType; using Op = DateTimeOp; @@ -745,7 +745,7 @@ class FunctionDateOrDateTimeComputation : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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)); @@ -823,7 +823,7 @@ class FunctionCurrentDateOrDateTime : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { return FunctionImpl::execute(context, block, arguments, result, input_rows_count); } }; @@ -842,7 +842,7 @@ struct CurrentDateTimeImpl { } static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) { + uint32_t result, size_t input_rows_count) { WhichDataType which(remove_nullable(block.get_by_position(result).type)); if constexpr (WithPrecision) { DCHECK(which.is_date_time_v2() || which.is_date_v2()); @@ -869,7 +869,7 @@ struct CurrentDateTimeImpl { template static Status executeImpl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { auto col_to = ColumnVector::create(); DateValueType dtv; @@ -957,7 +957,7 @@ struct CurrentDateImpl { using ReturnType = DateType; static constexpr auto name = FunctionName::name; static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) { + uint32_t result, size_t input_rows_count) { auto col_to = ColumnVector::create(); if constexpr (std::is_same_v) { DateV2Value dtv; @@ -988,7 +988,7 @@ struct CurrentTimeImpl { using ReturnType = DataTypeTimeV2; static constexpr auto name = FunctionName::name; static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) { + uint32_t result, size_t input_rows_count) { auto col_to = ColumnFloat64::create(); VecDateTimeValue dtv; dtv.from_unixtime(context->state()->timestamp_ms() / 1000, @@ -1007,7 +1007,7 @@ struct TimeToSecImpl { using ReturnType = DataTypeInt32; static constexpr auto name = "time_to_sec"; static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) { + uint32_t result, size_t input_rows_count) { auto res_col = ColumnInt32::create(input_rows_count); const auto& arg_col = block.get_by_position(arguments[0]).column; const auto& column_data = assert_cast(*arg_col); @@ -1027,7 +1027,7 @@ struct SecToTimeImpl { using ReturnType = DataTypeTimeV2; static constexpr auto name = "sec_to_time"; static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) { + uint32_t result, size_t input_rows_count) { const auto& arg_col = block.get_by_position(arguments[0]).column; const auto& column_data = assert_cast(*arg_col); @@ -1069,7 +1069,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) const override { + uint32_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(); @@ -1108,7 +1108,7 @@ struct UtcTimestampImpl { using ReturnType = DataTypeDateTime; static constexpr auto name = "utc_timestamp"; static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) { + uint32_t result, size_t input_rows_count) { WhichDataType which(remove_nullable(block.get_by_position(result).type)); if (which.is_date_time_v2()) { return executeImpl, UInt64>(context, block, result, @@ -1122,7 +1122,7 @@ struct UtcTimestampImpl { } template - static Status executeImpl(FunctionContext* context, Block& block, size_t result, + static Status executeImpl(FunctionContext* context, Block& block, uint32_t result, size_t input_rows_count) { auto col_to = ColumnVector::create(); DateValueType dtv; 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 4bea968a62c53b..2bc96cc7e937d7 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 @@ -94,7 +94,7 @@ class FunctionDateOrDateTimeToSomething : public IFunction { 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) const override { + uint32_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 6ffb67f9c349a8..14e8335388b2dc 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 @@ class FunctionDateOrDateTimeToString : public IFunction { 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) const override { + uint32_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 43611e68a17a89..376cf83b091110 100644 --- a/be/src/vec/functions/function_datetime_floor_ceil.cpp +++ b/be/src/vec/functions/function_datetime_floor_ceil.cpp @@ -141,7 +141,7 @@ class FunctionDateTimeFloorCeil : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 37eaefbbee08f5..5dfa32e0c9fac3 100644 --- a/be/src/vec/functions/function_datetime_string_to_string.h +++ b/be/src/vec/functions/function_datetime_string_to_string.h @@ -130,7 +130,7 @@ class FunctionDateTimeStringToString : public IFunction { 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) const override { + uint32_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_decode_varchar.cpp b/be/src/vec/functions/function_decode_varchar.cpp index 59f7ecfac04773..be41df0e08232b 100644 --- a/be/src/vec/functions/function_decode_varchar.cpp +++ b/be/src/vec/functions/function_decode_varchar.cpp @@ -74,7 +74,7 @@ class FunctionDecodeAsVarchar : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { const ColumnVector* col_source = assert_cast*>( block.get_by_position(arguments[0]).column.get()); diff --git a/be/src/vec/functions/function_encode_varchar.cpp b/be/src/vec/functions/function_encode_varchar.cpp index 2e53a511c5ba4d..1edb80bfd216f8 100644 --- a/be/src/vec/functions/function_encode_varchar.cpp +++ b/be/src/vec/functions/function_encode_varchar.cpp @@ -66,7 +66,7 @@ class FunctionEncodeVarchar : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { const ColumnString* col_str = assert_cast(block.get_by_position(arguments[0]).column.get()); diff --git a/be/src/vec/functions/function_encryption.cpp b/be/src/vec/functions/function_encryption.cpp index 9c8028b1d87cb0..8376058fea724f 100644 --- a/be/src/vec/functions/function_encryption.cpp +++ b/be/src/vec/functions/function_encryption.cpp @@ -105,7 +105,7 @@ class FunctionEncryptionAndDecrypt : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { return Impl::execute_impl_inner(context, block, arguments, result, input_rows_count); } }; @@ -181,7 +181,7 @@ struct EncryptionAndDecryptTwoImpl { } static Status execute_impl_inner(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { auto result_column = ColumnString::create(); auto result_null_map_column = ColumnUInt8::create(input_rows_count, 0); @@ -292,7 +292,7 @@ struct EncryptionAndDecryptMultiImpl { } static Status execute_impl_inner(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { auto result_column = ColumnString::create(); auto result_null_map_column = ColumnUInt8::create(input_rows_count, 0); diff --git a/be/src/vec/functions/function_fake.h b/be/src/vec/functions/function_fake.h index d180cbf3270d4b..dabb5eb039afb7 100644 --- a/be/src/vec/functions/function_fake.h +++ b/be/src/vec/functions/function_fake.h @@ -79,7 +79,7 @@ class FunctionFake : public IFunction { 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) const override { + uint32_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 0dbd50c8b947f4..0917b4d1db89ec 100644 --- a/be/src/vec/functions/function_grouping.h +++ b/be/src/vec/functions/function_grouping.h @@ -53,7 +53,7 @@ class FunctionGroupingBase : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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_helpers.cpp b/be/src/vec/functions/function_helpers.cpp index ea3d98511b0624..03df6e3d99dd6d 100644 --- a/be/src/vec/functions/function_helpers.cpp +++ b/be/src/vec/functions/function_helpers.cpp @@ -119,7 +119,7 @@ std::tuple create_block_with_nested_columns( } std::tuple create_block_with_nested_columns( - const Block& block, const ColumnNumbers& args, size_t result, + const Block& block, const ColumnNumbers& args, uint32_t result, bool need_replace_null_data_to_default) { auto [res, res_args] = create_block_with_nested_columns(block, args, true, need_replace_null_data_to_default); diff --git a/be/src/vec/functions/function_helpers.h b/be/src/vec/functions/function_helpers.h index 28f79a8d0fb193..c439f601f936f9 100644 --- a/be/src/vec/functions/function_helpers.h +++ b/be/src/vec/functions/function_helpers.h @@ -103,7 +103,7 @@ std::tuple create_block_with_nested_columns( // Same as above and return the new_res loc in tuple std::tuple create_block_with_nested_columns( - const Block& block, const ColumnNumbers& args, size_t result, + const Block& block, const ColumnNumbers& args, uint32_t result, bool need_replace_null_data_to_default = false); /// Checks argument type at specified index with predicate. diff --git a/be/src/vec/functions/function_hex.cpp b/be/src/vec/functions/function_hex.cpp index 5122fcb7ba1d64..5ba46ad4d74803 100644 --- a/be/src/vec/functions/function_hex.cpp +++ b/be/src/vec/functions/function_hex.cpp @@ -72,7 +72,7 @@ class FunctionHexVariadic : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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_hll.cpp b/be/src/vec/functions/function_hll.cpp index f47c1a8af45fb0..1040d7ea33d71b 100644 --- a/be/src/vec/functions/function_hll.cpp +++ b/be/src/vec/functions/function_hll.cpp @@ -99,7 +99,7 @@ class FunctionHLL : public IFunction { 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) const override { + uint32_t result, size_t input_rows_count) const override { auto column = block.get_by_position(arguments[0]).column; MutableColumnPtr column_result = get_return_type_impl({})->create_column(); @@ -155,7 +155,7 @@ class FunctionHllFromBase64 : public IFunction { 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) const override { + uint32_t result, size_t input_rows_count) const override { auto res_null_map = ColumnUInt8::create(input_rows_count, 0); auto res_data_column = ColumnHLL::create(); auto& null_map = res_null_map->get_data(); diff --git a/be/src/vec/functions/function_ifnull.h b/be/src/vec/functions/function_ifnull.h index 9deb7f8d71f7d5..9cd1ef5b36e0ca 100644 --- a/be/src/vec/functions/function_ifnull.h +++ b/be/src/vec/functions/function_ifnull.h @@ -78,7 +78,7 @@ class FunctionIfNull : public IFunction { // 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) const override { + uint32_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_ignore.cpp b/be/src/vec/functions/function_ignore.cpp index 1769dd94fc79e7..5f2c0f7a418133 100644 --- a/be/src/vec/functions/function_ignore.cpp +++ b/be/src/vec/functions/function_ignore.cpp @@ -37,7 +37,7 @@ class FunctionIgnore : public IFunction { 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) const override { + uint32_t result, size_t input_rows_count) const override { ColumnPtr col = ColumnBool::create(1, false); block.replace_by_position(result, ColumnConst::create(col, input_rows_count)); return Status::OK(); diff --git a/be/src/vec/functions/function_ip.h b/be/src/vec/functions/function_ip.h index 51675ae7c7d893..69fd2a8914890e 100644 --- a/be/src/vec/functions/function_ip.h +++ b/be/src/vec/functions/function_ip.h @@ -103,7 +103,7 @@ class FunctionIPv4NumToString : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { ColumnWithTypeAndName& argument = block.get_by_position(arguments[0]); switch (argument.type->get_type_id()) { @@ -231,7 +231,7 @@ class FunctionIPv4StringToNum : public IFunction { 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) const override { + uint32_t result, size_t input_rows_count) const override { ColumnPtr column = block.get_by_position(arguments[0]).column; ColumnPtr null_map_column; const NullMap* null_map = nullptr; @@ -315,7 +315,7 @@ class FunctionIPv6NumToString : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { const ColumnPtr& column = block.get_by_position(arguments[0]).column; auto col_res = ColumnString::create(); @@ -525,7 +525,7 @@ class FunctionIPv6StringToNum : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { ColumnPtr column = block.get_by_position(arguments[0]).column; ColumnPtr null_map_column; const NullMap* null_map = nullptr; @@ -566,7 +566,7 @@ class FunctionIsIPString : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { const auto& addr_column_with_type_and_name = block.get_by_position(arguments[0]); WhichDataType addr_type(addr_column_with_type_and_name.type); const ColumnPtr& addr_column = addr_column_with_type_and_name.column; @@ -736,7 +736,7 @@ class FunctionIsIPAddressInRange : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { DBUG_EXECUTE_IF("ip.inverted_index_filtered", { auto req_id = DebugPoints::instance()->get_debug_param_or_default( "ip.inverted_index_filtered", "req_id", 0); @@ -800,7 +800,7 @@ class FunctionIPv4CIDRToRange : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { ColumnWithTypeAndName& ip_column = block.get_by_position(arguments[0]); ColumnWithTypeAndName& cidr_column = block.get_by_position(arguments[1]); @@ -882,7 +882,7 @@ class FunctionIPv6CIDRToRange : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { const auto& addr_column_with_type_and_name = block.get_by_position(arguments[0]); const auto& cidr_column_with_type_and_name = block.get_by_position(arguments[1]); WhichDataType addr_type(addr_column_with_type_and_name.type); @@ -1010,7 +1010,7 @@ class FunctionIsIPv4Compat : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { const ColumnPtr& column = block.get_by_position(arguments[0]).column; const auto* col_in = assert_cast(column.get()); @@ -1051,7 +1051,7 @@ class FunctionIsIPv4Mapped : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { const ColumnPtr& column = block.get_by_position(arguments[0]).column; const auto* col_in = assert_cast(column.get()); @@ -1125,7 +1125,7 @@ class FunctionToIP : public IFunction { 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) const override { + uint32_t result, size_t input_rows_count) const override { const auto& addr_column_with_type_and_name = block.get_by_position(arguments[0]); WhichDataType addr_type(addr_column_with_type_and_name.type); const ColumnPtr& addr_column = addr_column_with_type_and_name.column; @@ -1220,7 +1220,7 @@ class FunctionIPv4ToIPv6 : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { const auto& ipv4_column_with_type_and_name = block.get_by_position(arguments[0]); const auto& [ipv4_column, ipv4_const] = unpack_if_const(ipv4_column_with_type_and_name.column); @@ -1260,7 +1260,7 @@ class FunctionCutIPv6 : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { const auto& ipv6_column_with_type_and_name = block.get_by_position(arguments[0]); const auto& bytes_to_cut_for_ipv6_column_with_type_and_name = block.get_by_position(arguments[1]); diff --git a/be/src/vec/functions/function_java_udf.cpp b/be/src/vec/functions/function_java_udf.cpp index e2c441b660201d..bea8543d6f062d 100644 --- a/be/src/vec/functions/function_java_udf.cpp +++ b/be/src/vec/functions/function_java_udf.cpp @@ -91,7 +91,7 @@ Status JavaFunctionCall::open(FunctionContext* context, FunctionContext::Functio } Status JavaFunctionCall::execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t num_rows) const { JNIEnv* env = nullptr; RETURN_IF_ERROR(JniUtil::GetJNIEnv(&env)); diff --git a/be/src/vec/functions/function_java_udf.h b/be/src/vec/functions/function_java_udf.h index e35fc67881acb5..dc2d9788e097c5 100644 --- a/be/src/vec/functions/function_java_udf.h +++ b/be/src/vec/functions/function_java_udf.h @@ -44,7 +44,7 @@ namespace doris::vectorized { class JavaUdfPreparedFunction : public PreparedFunctionImpl { public: using execute_call_back = std::function; explicit JavaUdfPreparedFunction(const execute_call_back& func, const std::string& name) @@ -54,7 +54,7 @@ class JavaUdfPreparedFunction : public PreparedFunctionImpl { protected: Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { return callback_function(context, block, arguments, result, input_rows_count); } @@ -87,7 +87,7 @@ class JavaFunctionCall : public IFunctionBase { const DataTypePtr& get_return_type() const override { return _return_type; } PreparedFunctionPtr prepare(FunctionContext* context, const Block& sample_block, - const ColumnNumbers& arguments, size_t result) const override { + const ColumnNumbers& arguments, uint32_t result) const override { return std::make_shared( [this](auto&& PH1, auto&& PH2, auto&& PH3, auto&& PH4, auto&& PH5) { return JavaFunctionCall::execute_impl( @@ -101,7 +101,7 @@ class JavaFunctionCall : public IFunctionBase { Status open(FunctionContext* context, FunctionContext::FunctionStateScope scope) override; Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const; + uint32_t result, size_t input_rows_count) const; Status close(FunctionContext* context, FunctionContext::FunctionStateScope scope) override; diff --git a/be/src/vec/functions/function_json.cpp b/be/src/vec/functions/function_json.cpp index 05915db8ec10bf..6ab03dbbb7b51c 100644 --- a/be/src/vec/functions/function_json.cpp +++ b/be/src/vec/functions/function_json.cpp @@ -725,7 +725,7 @@ class FunctionJsonAlwaysNotNullable : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { auto result_column = ColumnString::create(); std::vector column_ptrs; // prevent converted column destruct @@ -977,7 +977,7 @@ class FunctionJson : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { auto result_column = ColumnString::create(); std::vector column_ptrs; // prevent converted column destruct @@ -1007,7 +1007,7 @@ class FunctionJsonNullable : public IFunction { return make_nullable(std::make_shared()); } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { auto result_column = ColumnString::create(); auto null_map = ColumnUInt8::create(input_rows_count, 0); std::vector data_columns; @@ -1049,7 +1049,7 @@ class FunctionJsonValid : public IFunction { 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) const override { + uint32_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); @@ -1168,7 +1168,7 @@ class FunctionJsonContains : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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); @@ -1241,7 +1241,7 @@ class FunctionJsonUnquote : public IFunction { 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) const override { + uint32_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); @@ -1410,7 +1410,7 @@ class FunctionJsonModifyImpl : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { auto result_column = ColumnString::create(); bool is_nullable = false; ColumnUInt8::MutablePtr ret_null_map = nullptr; diff --git a/be/src/vec/functions/function_jsonb.cpp b/be/src/vec/functions/function_jsonb.cpp index 3da8d514402ba7..0e78eb894b20c5 100644 --- a/be/src/vec/functions/function_jsonb.cpp +++ b/be/src/vec/functions/function_jsonb.cpp @@ -189,7 +189,7 @@ class FunctionJsonbParseBase : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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); @@ -363,7 +363,7 @@ class FunctionJsonbExtract : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { DCHECK_GE(arguments.size(), 2); ColumnPtr jsonb_data_column; @@ -447,7 +447,7 @@ class FunctionJsonbKeys : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { DCHECK_GE(arguments.size(), 1); if (arguments.size() != 1 && arguments.size() != 2) { // here has argument param error @@ -619,7 +619,7 @@ class FunctionJsonbExtractPath : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { ColumnPtr jsonb_data_column; bool jsonb_data_const = false; // prepare jsonb data column @@ -1353,14 +1353,14 @@ class FunctionJsonbLength : public IFunction { 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) const override { + uint32_t result, size_t input_rows_count) const override { return Impl::execute_impl(context, block, arguments, result, input_rows_count); } }; struct JsonbLengthUtil { static Status jsonb_length_execute(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { DCHECK_GE(arguments.size(), 2); ColumnPtr jsonb_data_column; @@ -1427,7 +1427,7 @@ struct JsonbLengthImpl { static DataTypes get_variadic_argument_types() { return {std::make_shared()}; } static Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { auto path = ColumnString::create(); std::string root_path = "$"; @@ -1451,7 +1451,7 @@ struct JsonbLengthAndPathImpl { } static Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { return JsonbLengthUtil::jsonb_length_execute(context, block, arguments, result, input_rows_count); @@ -1478,14 +1478,14 @@ class FunctionJsonbContains : public IFunction { 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) const override { + uint32_t result, size_t input_rows_count) const override { return Impl::execute_impl(context, block, arguments, result, input_rows_count); } }; struct JsonbContainsUtil { static Status jsonb_contains_execute(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { DCHECK_GE(arguments.size(), 3); @@ -1569,7 +1569,7 @@ struct JsonbContainsImpl { } static Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { auto path = ColumnString::create(); std::string root_path = "$"; @@ -1594,7 +1594,7 @@ struct JsonbContainsAndPathImpl { } static Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { return JsonbContainsUtil::jsonb_contains_execute(context, block, arguments, result, input_rows_count); @@ -1828,7 +1828,7 @@ class FunctionJsonSearch : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { // the json_doc, one_or_all, and search_str must be given. // and we require the positions are static. if (arguments.size() < 3) { diff --git a/be/src/vec/functions/function_map.cpp b/be/src/vec/functions/function_map.cpp index d781fc6cac402b..5b4e4202b20de8 100644 --- a/be/src/vec/functions/function_map.cpp +++ b/be/src/vec/functions/function_map.cpp @@ -80,7 +80,7 @@ class FunctionMap : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { DCHECK(arguments.size() % 2 == 0) << "function: " << get_name() << ", arguments should not be even number"; @@ -166,7 +166,7 @@ class FunctionMapContains : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 = @@ -261,7 +261,7 @@ class FunctionMapEntries : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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_log.h b/be/src/vec/functions/function_math_log.h index e8653e4220d460..60780d0ff39a4f 100644 --- a/be/src/vec/functions/function_math_log.h +++ b/be/src/vec/functions/function_math_log.h @@ -51,7 +51,7 @@ class FunctionMathLog : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { const auto* col = assert_cast(block.get_by_position(arguments[0]).column.get()); diff --git a/be/src/vec/functions/function_math_unary.h b/be/src/vec/functions/function_math_unary.h index e5101692b86d75..617b26169e246a 100644 --- a/be/src/vec/functions/function_math_unary.h +++ b/be/src/vec/functions/function_math_unary.h @@ -54,7 +54,7 @@ class FunctionMathUnary : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { const auto* col = assert_cast(block.get_by_position(arguments[0]).column.get()); diff --git a/be/src/vec/functions/function_math_unary_alway_nullable.h b/be/src/vec/functions/function_math_unary_alway_nullable.h index 8d2cea1bc0db87..1b6e86c395a192 100644 --- a/be/src/vec/functions/function_math_unary_alway_nullable.h +++ b/be/src/vec/functions/function_math_unary_alway_nullable.h @@ -55,7 +55,7 @@ class FunctionMathUnaryAlwayNullable : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { const ColumnFloat64* col = assert_cast(block.get_by_position(arguments[0]).column.get()); auto dst = ColumnFloat64::create(); diff --git a/be/src/vec/functions/function_multi_match.cpp b/be/src/vec/functions/function_multi_match.cpp index 02697dd4b0aafe..8ab0cb2f2e542c 100644 --- a/be/src/vec/functions/function_multi_match.cpp +++ b/be/src/vec/functions/function_multi_match.cpp @@ -34,7 +34,7 @@ namespace doris::vectorized { Status FunctionMultiMatch::execute_impl(FunctionContext* /*context*/, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t /*input_rows_count*/) const { return Status::RuntimeError("only inverted index queries are supported"); } diff --git a/be/src/vec/functions/function_multi_match.h b/be/src/vec/functions/function_multi_match.h index 4aca75acc02123..ba395450a30f6f 100644 --- a/be/src/vec/functions/function_multi_match.h +++ b/be/src/vec/functions/function_multi_match.h @@ -54,7 +54,7 @@ class FunctionMultiMatch : public IFunction { } Status execute_impl(FunctionContext* /*context*/, Block& block, const ColumnNumbers& arguments, - size_t result, size_t /*input_rows_count*/) const override; + uint32_t result, size_t /*input_rows_count*/) const override; bool can_push_down_to_index() const override { return true; } diff --git a/be/src/vec/functions/function_multi_same_args.h b/be/src/vec/functions/function_multi_same_args.h index 0c45c7cd446ef7..f22bae640aeda4 100644 --- a/be/src/vec/functions/function_multi_same_args.h +++ b/be/src/vec/functions/function_multi_same_args.h @@ -45,7 +45,7 @@ class FunctionMultiSameArgs : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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_nullables.cpp b/be/src/vec/functions/function_nullables.cpp index 0fdcfbc2175271..88bb2b38fab65c 100644 --- a/be/src/vec/functions/function_nullables.cpp +++ b/be/src/vec/functions/function_nullables.cpp @@ -52,7 +52,7 @@ class FunctionNullable : public IFunction { // 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) const override { + uint32_t result, size_t input_rows_count) const override { ColumnPtr& col = block.get_by_position(arguments[0]).column; if (const auto* col_null = check_and_get_column(col); col_null == nullptr) { // not null @@ -83,7 +83,7 @@ class FunctionNonNullable : public IFunction { // 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) const override { + uint32_t result, size_t input_rows_count) const override { auto& data = block.get_by_position(arguments[0]); if (const auto* col_null = check_and_get_column(data.column); col_null == nullptr) // raise error if input is not nullable. diff --git a/be/src/vec/functions/function_quantile_state.cpp b/be/src/vec/functions/function_quantile_state.cpp index 524909314dc544..95afbf1db32d23 100644 --- a/be/src/vec/functions/function_quantile_state.cpp +++ b/be/src/vec/functions/function_quantile_state.cpp @@ -126,7 +126,7 @@ class FunctionToQuantileState : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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( @@ -175,7 +175,7 @@ class FunctionQuantileStatePercent : public IFunction { 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) const override { + uint32_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 ae24831862a443..ae508120cf9ee8 100644 --- a/be/src/vec/functions/function_regexp.cpp +++ b/be/src/vec/functions/function_regexp.cpp @@ -429,7 +429,7 @@ class FunctionRegexp : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 9a50c011b91dc2..ee0005a305d8ce 100644 --- a/be/src/vec/functions/function_reverse.h +++ b/be/src/vec/functions/function_reverse.h @@ -40,7 +40,7 @@ class FunctionReverseCommon : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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_rpc.cpp b/be/src/vec/functions/function_rpc.cpp index c27383dac62b08..6d3a64f78409c6 100644 --- a/be/src/vec/functions/function_rpc.cpp +++ b/be/src/vec/functions/function_rpc.cpp @@ -43,7 +43,7 @@ RPCFnImpl::RPCFnImpl(const TFunction& fn) : _fn(fn) { } Status RPCFnImpl::vec_call(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) { + uint32_t result, size_t input_rows_count) { PFunctionCallRequest request; PFunctionCallResponse response; if (_client == nullptr) { @@ -108,8 +108,8 @@ Status FunctionRPC::open(FunctionContext* context, FunctionContext::FunctionStat } Status FunctionRPC::execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count, bool dry_run) const { - RPCFnImpl* fn = reinterpret_cast( + uint32_t result, size_t input_rows_count, bool dry_run) const { + auto* fn = reinterpret_cast( context->get_function_state(FunctionContext::FRAGMENT_LOCAL)); return fn->vec_call(context, block, arguments, result, input_rows_count); } diff --git a/be/src/vec/functions/function_rpc.h b/be/src/vec/functions/function_rpc.h index ae71632f9746e5..fd17577ddad4ff 100644 --- a/be/src/vec/functions/function_rpc.h +++ b/be/src/vec/functions/function_rpc.h @@ -48,7 +48,7 @@ class RPCFnImpl { RPCFnImpl(const TFunction& fn); ~RPCFnImpl() = default; Status vec_call(FunctionContext* context, vectorized::Block& block, - const std::vector& arguments, size_t result, size_t input_rows_count); + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count); bool available() { return _client != nullptr; } private: @@ -88,14 +88,14 @@ class FunctionRPC : public IFunctionBase { const DataTypePtr& get_return_type() const override { return _return_type; } PreparedFunctionPtr prepare(FunctionContext* context, const Block& sample_block, - const ColumnNumbers& arguments, size_t result) const override { + const ColumnNumbers& arguments, uint32_t result) const override { return nullptr; } Status open(FunctionContext* context, FunctionContext::FunctionStateScope scope) override; Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count, bool dry_run = false) const override; + uint32_t result, size_t input_rows_count, bool dry_run = false) const override; bool is_use_default_implementation_for_constants() const override { return true; } diff --git a/be/src/vec/functions/function_size.cpp b/be/src/vec/functions/function_size.cpp index 803d6d283d37ff..68c873c8ea6c4b 100644 --- a/be/src/vec/functions/function_size.cpp +++ b/be/src/vec/functions/function_size.cpp @@ -46,7 +46,7 @@ class FunctionSize : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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_split_by_regexp.cpp b/be/src/vec/functions/function_split_by_regexp.cpp index cee2e186b5770f..a4c46b59ac1f75 100644 --- a/be/src/vec/functions/function_split_by_regexp.cpp +++ b/be/src/vec/functions/function_split_by_regexp.cpp @@ -178,7 +178,7 @@ class SplitByRegexp : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { return Impl::execute_impl(context, block, arguments, result, input_rows_count); } }; @@ -186,7 +186,7 @@ class SplitByRegexp : public IFunction { struct ExecuteImpl { using NullMapType = PaddedPODArray; static Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { const auto& [first_column, left_const] = unpack_if_const(block.get_by_position(arguments[0]).column); @@ -347,7 +347,7 @@ struct TwoArgumentImpl { } static Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { DCHECK_EQ(arguments.size(), 2); auto max_limit = ColumnConst::create(ColumnInt32::create(1, -1), input_rows_count); @@ -363,7 +363,7 @@ struct ThreeArgumentImpl { std::make_shared()}; } static Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { DCHECK_EQ(arguments.size(), 3); return ExecuteImpl::execute_impl(context, block, arguments, result, input_rows_count); diff --git a/be/src/vec/functions/function_string.cpp b/be/src/vec/functions/function_string.cpp index a7bcf9942a88d5..cee141db2a7820 100644 --- a/be/src/vec/functions/function_string.cpp +++ b/be/src/vec/functions/function_string.cpp @@ -682,7 +682,7 @@ struct Trim1Impl { static DataTypes get_variadic_argument_types() { return {std::make_shared()}; } static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) { + uint32_t result, size_t input_rows_count) { const ColumnPtr column = block.get_by_position(arguments[0]).column; if (const auto* col = assert_cast(column.get())) { auto col_res = ColumnString::create(); @@ -711,7 +711,7 @@ struct Trim2Impl { } static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) { + uint32_t result, size_t input_rows_count) { const ColumnPtr column = block.get_by_position(arguments[0]).column; const auto& rcol = assert_cast(block.get_by_position(arguments[1]).column.get()) @@ -783,7 +783,7 @@ class FunctionTrim : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 8c01b51f298b11..6143e61f86f0c6 100644 --- a/be/src/vec/functions/function_string.h +++ b/be/src/vec/functions/function_string.h @@ -165,7 +165,7 @@ struct StringOP { struct SubstringUtil { static constexpr auto name = "substring"; - static void substring_execute(Block& block, const ColumnNumbers& arguments, size_t result, + static void substring_execute(Block& block, const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { DCHECK_EQ(arguments.size(), 3); auto res = ColumnString::create(); @@ -336,7 +336,7 @@ class FunctionStrcmp : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { const auto& [arg0_column, arg0_const] = unpack_if_const(block.get_by_position(arguments[0]).column); const auto& [arg1_column, arg1_const] = @@ -396,7 +396,7 @@ class FunctionAutoPartitionName : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { size_t argument_size = arguments.size(); auto const_null_map = ColumnUInt8::create(input_rows_count, 0); auto null_map = ColumnUInt8::create(input_rows_count, 0); @@ -488,7 +488,7 @@ class FunctionAutoPartitionName : public IFunction { std::vector& is_const_args, const std::vector& null_list, auto& res_data, auto& res_offset, size_t input_rows_count, - size_t argument_size, Block& block, size_t result, + size_t argument_size, Block& block, uint32_t result, auto& res) const { int curr_len = 0; for (int row = 0; row < input_rows_count; row++) { @@ -546,7 +546,7 @@ class FunctionAutoPartitionName : public IFunction { std::vector& offsets_list, std::vector& is_const_args, auto& res_data, auto& res_offset, size_t input_rows_count, - size_t argument_size, Block& block, size_t result, + size_t argument_size, Block& block, uint32_t result, auto& res) const { const char* range_type = chars_list[1]->raw_data(); @@ -631,7 +631,7 @@ class FunctionSubstring : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { return Impl::execute_impl(context, block, arguments, result, input_rows_count); } }; @@ -643,7 +643,7 @@ struct Substr3Impl { } static Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { SubstringUtil::substring_execute(block, arguments, result, input_rows_count); return Status::OK(); @@ -656,7 +656,7 @@ struct Substr2Impl { } static Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { auto col_len = ColumnInt32::create(input_rows_count); auto& strlen_data = col_len->get_data(); @@ -705,7 +705,7 @@ class FunctionMask : public IFunction { 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) const override { + uint32_t result, size_t input_rows_count) const override { DCHECK_GE(arguments.size(), 1); DCHECK_LE(arguments.size(), 4); @@ -802,7 +802,7 @@ class FunctionMaskPartial : public IFunction { 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) const override { + uint32_t result, size_t input_rows_count) const override { int n = -1; // means unassigned auto res = ColumnString::create(); @@ -879,7 +879,7 @@ class FunctionLeft : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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, @@ -905,7 +905,7 @@ class FunctionRight : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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); @@ -947,7 +947,7 @@ struct NullOrEmptyImpl { static DataTypes get_variadic_argument_types() { return {std::make_shared()}; } static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count, bool reverse) { + uint32_t result, size_t input_rows_count, bool reverse) { auto res_map = ColumnUInt8::create(input_rows_count, 0); auto column = block.get_by_position(arguments[0]).column; @@ -988,7 +988,7 @@ class FunctionNullOrEmpty : public IFunction { 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) const override { + uint32_t result, size_t input_rows_count) const override { RETURN_IF_ERROR(NullOrEmptyImpl::execute(context, block, arguments, result, input_rows_count, false)); return Status::OK(); @@ -1009,7 +1009,7 @@ class FunctionNotNullOrEmpty : public IFunction { 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) const override { + uint32_t result, size_t input_rows_count) const override { RETURN_IF_ERROR(NullOrEmptyImpl::execute(context, block, arguments, result, input_rows_count, true)); return Status::OK(); @@ -1068,7 +1068,7 @@ class FunctionStringConcat : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { DCHECK_GE(arguments.size(), 1); if (arguments.size() == 1) { @@ -1096,7 +1096,7 @@ class FunctionStringConcat : public IFunction { } } - Status execute_vecotr(Block& block, const ColumnNumbers& arguments, size_t result, + Status execute_vecotr(Block& block, const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) const { int argument_size = arguments.size(); std::vector argument_columns(argument_size); @@ -1158,7 +1158,7 @@ class FunctionStringConcat : public IFunction { template Status execute_const(ConcatState* concat_state, Block& block, const ColumnString* col_str, - size_t result, size_t input_rows_count) const { + uint32_t result, size_t input_rows_count) const { // using tail optimize auto res = ColumnString::create(); @@ -1211,7 +1211,7 @@ class FunctionStringElt : public IFunction { 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) const override { + uint32_t result, size_t input_rows_count) const override { int arguent_size = arguments.size(); int num_children = arguent_size - 1; auto res = ColumnString::create(); @@ -1332,7 +1332,7 @@ class FunctionStringConcatWs : public IFunction { 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) const override { + uint32_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 @@ -1529,7 +1529,7 @@ class FunctionStringRepeat : public IFunction { return make_nullable(std::make_shared()); } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { DCHECK_EQ(arguments.size(), 2); auto res = ColumnString::create(); auto null_map = ColumnUInt8::create(); @@ -1635,7 +1635,7 @@ class FunctionStringPad : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 @@ -1781,7 +1781,7 @@ class FunctionSplitPart : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { DCHECK_EQ(arguments.size(), 3); auto null_map = ColumnUInt8::create(input_rows_count, 0); @@ -1952,7 +1952,7 @@ class FunctionSubstringIndex : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { DCHECK_EQ(arguments.size(), 3); // Create a zero column to simply implement @@ -2115,7 +2115,7 @@ class FunctionSplitByString : public IFunction { } Status execute_impl(FunctionContext* /*context*/, Block& block, const ColumnNumbers& arguments, - size_t result, size_t /*input_rows_count*/) const override { + uint32_t result, size_t /*input_rows_count*/) const override { DCHECK_EQ(arguments.size(), 2); const auto& [src_column, left_const] = @@ -2392,7 +2392,7 @@ class FunctionCountSubString : public IFunction { } Status execute_impl(FunctionContext* /*context*/, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { DCHECK_EQ(arguments.size(), 2); const auto& [src_column, left_const] = unpack_if_const(block.get_by_position(arguments[0]).column); @@ -2510,7 +2510,7 @@ class FunctionStringDigestOneArg : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { DCHECK_GE(arguments.size(), 1); int argument_size = arguments.size(); @@ -2574,7 +2574,7 @@ class FunctionStringDigestSHA1 : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { DCHECK_EQ(arguments.size(), 1); ColumnPtr str_col = block.get_by_position(arguments[0]).column; @@ -2613,7 +2613,7 @@ class FunctionStringDigestSHA2 : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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; @@ -2674,7 +2674,7 @@ class FunctionExtractURLParameter : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 = @@ -2718,7 +2718,7 @@ class FunctionStringParseUrl : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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(); DCHECK_GE(3, arguments.size()); @@ -2839,7 +2839,7 @@ class FunctionUrlDecode : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { auto res = ColumnString::create(); res->get_offsets().reserve(input_rows_count); @@ -2872,7 +2872,7 @@ class FunctionUrlEncode : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { auto res = ColumnString::create(); res->get_offsets().reserve(input_rows_count); @@ -2907,7 +2907,7 @@ class FunctionRandomBytes : public IFunction { bool use_default_implementation_for_constants() const final { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { auto res = ColumnString::create(); auto& res_offsets = res->get_offsets(); auto& res_chars = res->get_chars(); @@ -2973,7 +2973,7 @@ class FunctionMoneyFormat : public IFunction { 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) const override { + uint32_t result, size_t input_rows_count) const override { auto res_column = ColumnString::create(); ColumnPtr argument_column = block.get_by_position(arguments[0]).column; @@ -3272,7 +3272,7 @@ class FunctionStringLocatePos : public IFunction { 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) const override { + uint32_t result, size_t input_rows_count) const override { DCHECK_EQ(arguments.size(), 3); bool col_const[3]; ColumnPtr argument_columns[3]; @@ -3423,7 +3423,7 @@ class FunctionReplace : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { // We need a local variable to hold a reference to the converted column. // So that the converted column will not be released before we use it. ColumnPtr col[3]; @@ -3556,13 +3556,13 @@ class FunctionSubReplace : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { return Impl::execute_impl(context, block, arguments, result, input_rows_count); } }; struct SubReplaceImpl { - static Status replace_execute(Block& block, const ColumnNumbers& arguments, size_t result, + static Status replace_execute(Block& block, const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { auto res_column = ColumnString::create(); auto* result_column = assert_cast(res_column.get()); @@ -3684,7 +3684,7 @@ struct SubReplaceThreeImpl { } static Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { auto params = ColumnInt32::create(input_rows_count); auto& strlen_data = params->get_data(); @@ -3715,7 +3715,7 @@ struct SubReplaceFourImpl { } static Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { return SubReplaceImpl::replace_execute(block, arguments, result, input_rows_count); } @@ -3754,7 +3754,7 @@ class FunctionConvertTo : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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()); @@ -3945,7 +3945,7 @@ class FunctionIntToChar : public IFunction { 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) const override { + uint32_t result, size_t input_rows_count) const override { DCHECK_GE(arguments.size(), 2); int argument_size = arguments.size(); @@ -4143,7 +4143,7 @@ class FunctionOverlay : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { DCHECK_EQ(arguments.size(), 4); bool col_const[4]; @@ -4268,7 +4268,7 @@ class FunctionNgramSearch : public IFunction { // ngram_search(text,pattern,gram_num) Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { CHECK_EQ(arguments.size(), 3); auto col_res = ColumnFloat64::create(); bool col_const[3]; @@ -4398,7 +4398,7 @@ class FunctionTranslate : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { CHECK_EQ(arguments.size(), 3); auto col_res = ColumnString::create(); bool col_const[3]; diff --git a/be/src/vec/functions/function_string_to_string.h b/be/src/vec/functions/function_string_to_string.h index 3dac2cf94fd1a7..ea8c654faa1d31 100644 --- a/be/src/vec/functions/function_string_to_string.h +++ b/be/src/vec/functions/function_string_to_string.h @@ -60,7 +60,7 @@ class FunctionStringToString : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { const ColumnPtr column = block.get_by_position(arguments[0]).column; if (const auto* 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 a709589a285bc5..49348f56f9036b 100644 --- a/be/src/vec/functions/function_struct.cpp +++ b/be/src/vec/functions/function_struct.cpp @@ -74,7 +74,7 @@ class FunctionStruct : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { auto result_col = block.get_by_position(result).type->create_column(); auto struct_column = assert_cast(result_col.get()); ColumnNumbers args_num; diff --git a/be/src/vec/functions/function_struct_element.cpp b/be/src/vec/functions/function_struct_element.cpp index 8c66386cd90c5f..f547588dece646 100644 --- a/be/src/vec/functions/function_struct_element.cpp +++ b/be/src/vec/functions/function_struct_element.cpp @@ -67,7 +67,7 @@ class FunctionStructElement : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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_time_value_to_field.cpp b/be/src/vec/functions/function_time_value_to_field.cpp index da5fbca58cdbb3..8c8ec3cf9ab219 100644 --- a/be/src/vec/functions/function_time_value_to_field.cpp +++ b/be/src/vec/functions/function_time_value_to_field.cpp @@ -50,7 +50,7 @@ class FunctionTimeValueToField : public IFunction { 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) const override { + uint32_t result, size_t input_rows_count) const override { DCHECK_EQ(arguments.size(), 1); const auto* column_time = assert_cast( diff --git a/be/src/vec/functions/function_timestamp.cpp b/be/src/vec/functions/function_timestamp.cpp index 7c2e62e5723067..cc812b8968124f 100644 --- a/be/src/vec/functions/function_timestamp.cpp +++ b/be/src/vec/functions/function_timestamp.cpp @@ -107,7 +107,7 @@ struct StrToDate { } static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) { + uint32_t result, size_t input_rows_count) { auto null_map = ColumnUInt8::create(input_rows_count, 0); const auto& col0 = block.get_by_position(arguments[0]).column; @@ -253,7 +253,7 @@ struct MakeDateImpl { } static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) { + uint32_t result, size_t input_rows_count) { auto null_map = ColumnUInt8::create(input_rows_count, 0); DCHECK_EQ(arguments.size(), 2); @@ -458,7 +458,7 @@ struct DateTrunc { } static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) { + uint32_t result, size_t input_rows_count) { DCHECK_EQ(arguments.size(), 2); auto null_map = ColumnUInt8::create(input_rows_count, 0); @@ -502,7 +502,7 @@ class FromDays : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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; @@ -573,7 +573,7 @@ struct UnixTimeStampImpl { } static Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { auto col_result = ColumnVector::create(); col_result->resize(1); @@ -608,7 +608,7 @@ struct UnixTimeStampDateImpl { } static Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { const ColumnPtr& col = block.get_by_position(arguments[0]).column; DCHECK(!col->is_nullable()); @@ -692,7 +692,7 @@ struct UnixTimeStampStrImpl { } static Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { ColumnPtr col_left = nullptr, col_right = nullptr; bool source_const = false, format_const = false; @@ -763,7 +763,7 @@ class FunctionUnixTimestamp : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { return Impl::execute_impl(context, block, arguments, result, input_rows_count); } }; @@ -800,7 +800,7 @@ class DateTimeToTimestamp : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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(); @@ -860,7 +860,7 @@ class FunctionDateOrDateTimeToDate : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { return Impl::execute_impl(context, block, arguments, result, input_rows_count); } }; @@ -878,7 +878,7 @@ struct LastDayImpl { using ResultNativeType = date_cast::ValueTypeOfColumnV; static Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { const auto is_nullable = block.get_by_position(result).type->is_nullable(); ColumnPtr res_column; @@ -982,7 +982,7 @@ struct MondayImpl { using ResultNativeType = date_cast::ValueTypeOfColumnV; static Status execute_impl(FunctionContext* context, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) { const auto is_nullable = block.get_by_position(result).type->is_nullable(); ColumnPtr argument_column = remove_nullable(block.get_by_position(arguments[0]).column); @@ -1151,7 +1151,7 @@ class FunctionOtherTypesToDateType : public IFunction { //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) const override { + uint32_t result, size_t input_rows_count) const override { return Impl::execute(context, block, arguments, result, input_rows_count); } }; @@ -1170,7 +1170,7 @@ struct FromIso8601DateV2 { } static Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) { + uint32_t result, size_t input_rows_count) { const auto* src_column_ptr = block.get_by_position(arguments[0]).column.get(); auto null_map = ColumnUInt8::create(input_rows_count, 0); diff --git a/be/src/vec/functions/function_tokenize.cpp b/be/src/vec/functions/function_tokenize.cpp index be0eb5dddc960d..b8e1565ebb4822 100644 --- a/be/src/vec/functions/function_tokenize.cpp +++ b/be/src/vec/functions/function_tokenize.cpp @@ -109,7 +109,7 @@ void FunctionTokenize::_do_tokenize(const ColumnString& src_column_string, } Status FunctionTokenize::execute_impl(FunctionContext* /*context*/, Block& block, - const ColumnNumbers& arguments, size_t result, + const ColumnNumbers& arguments, uint32_t result, size_t /*input_rows_count*/) const { DCHECK_EQ(arguments.size(), 2); const auto& [src_column, left_const] = diff --git a/be/src/vec/functions/function_tokenize.h b/be/src/vec/functions/function_tokenize.h index f632d8fd4cebc1..4a7cb0dad26214 100644 --- a/be/src/vec/functions/function_tokenize.h +++ b/be/src/vec/functions/function_tokenize.h @@ -69,7 +69,7 @@ class FunctionTokenize : public IFunction { IColumn& dest_nested_column, ColumnArray::Offsets64& dest_offsets, NullMapType* dest_nested_null_map) const; Status execute_impl(FunctionContext* /*context*/, Block& block, const ColumnNumbers& arguments, - size_t result, size_t /*input_rows_count*/) const override; + uint32_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 3309fbcacdad9d..e5a2e6cfd7b8d3 100644 --- a/be/src/vec/functions/function_totype.h +++ b/be/src/vec/functions/function_totype.h @@ -52,7 +52,7 @@ class FunctionUnaryToType : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { return execute_impl(block, arguments, result, input_rows_count); } @@ -67,7 +67,7 @@ class FunctionUnaryToType : public IFunction { // handle result == DataTypeString template requires std::is_same_v - Status execute_impl(Block& block, const ColumnNumbers& arguments, size_t result, + Status execute_impl(Block& block, const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) const { const ColumnPtr column = block.get_by_position(arguments[0]).column; if constexpr (typeindex_is_int(Impl::TYPE_INDEX)) { @@ -95,7 +95,7 @@ class FunctionUnaryToType : public IFunction { } template requires(!std::is_same_v) - Status execute_impl(Block& block, const ColumnNumbers& arguments, size_t result, + Status execute_impl(Block& block, const ColumnNumbers& arguments, uint32_t result, size_t input_rows_count) const { const ColumnPtr column = block.get_by_position(arguments[0]).column; if constexpr (Impl::TYPE_INDEX == TypeIndex::String) { @@ -143,7 +143,7 @@ class FunctionBinaryToType : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t /*input_rows_count*/) const override { + uint32_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 @@ class FunctionBinaryToType : 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*/) const override { + uint32_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); @@ -313,7 +313,7 @@ class FunctionBinaryToNullType : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { auto null_map = ColumnUInt8::create(input_rows_count, 0); DCHECK_EQ(arguments.size(), 2); @@ -393,7 +393,7 @@ class FunctionBinaryStringOperateToNullType : public IFunction { } } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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]; @@ -465,7 +465,7 @@ class FunctionStringOperateToNullType : public IFunction { 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) const override { + uint32_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; @@ -503,7 +503,7 @@ class FunctionStringEncode : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { auto& col_ptr = block.get_by_position(arguments[0]).column; auto res = Impl::ColumnType::create(); diff --git a/be/src/vec/functions/function_unary_arithmetic.h b/be/src/vec/functions/function_unary_arithmetic.h index 91e33a7b9d45e2..c0febedb812ebf 100644 --- a/be/src/vec/functions/function_unary_arithmetic.h +++ b/be/src/vec/functions/function_unary_arithmetic.h @@ -107,7 +107,7 @@ class FunctionUnaryArithmetic : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 b201434537625e..40dd11677758de 100644 --- a/be/src/vec/functions/function_utility.cpp +++ b/be/src/vec/functions/function_utility.cpp @@ -75,7 +75,7 @@ class FunctionSleep : public IFunction { 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) const override { + uint32_t result, size_t input_rows_count) const override { const auto& argument_column = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); @@ -133,7 +133,7 @@ class FunctionVersion : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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_uuid.cpp b/be/src/vec/functions/function_uuid.cpp index cee5fd7a363503..1fb2f855bbb6df 100644 --- a/be/src/vec/functions/function_uuid.cpp +++ b/be/src/vec/functions/function_uuid.cpp @@ -63,7 +63,7 @@ class FunctionUuidtoInt : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { const auto& arg_column = assert_cast(*block.get_by_position(arguments[0]).column); @@ -164,7 +164,7 @@ class FunctionInttoUuid : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { const auto& arg_column = assert_cast(*block.get_by_position(arguments[0]).column); auto result_column = ColumnString::create(); diff --git a/be/src/vec/functions/function_variadic_arguments.h b/be/src/vec/functions/function_variadic_arguments.h index c8148fc90d078b..530b204e8067a1 100644 --- a/be/src/vec/functions/function_variadic_arguments.h +++ b/be/src/vec/functions/function_variadic_arguments.h @@ -55,7 +55,7 @@ class FunctionVariadicArgumentsBase : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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_variant_element.cpp b/be/src/vec/functions/function_variant_element.cpp index 53340cd61ea8d8..e04ff54dbe9d7c 100644 --- a/be/src/vec/functions/function_variant_element.cpp +++ b/be/src/vec/functions/function_variant_element.cpp @@ -95,7 +95,7 @@ class FunctionVariantElement : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_t result, size_t input_rows_count) const override { const auto* variant_col = check_and_get_column( remove_nullable(block.get_by_position(arguments[0]).column).get()); if (!variant_col) { diff --git a/be/src/vec/functions/function_width_bucket.cpp b/be/src/vec/functions/function_width_bucket.cpp index 7f9a3ae31e8765..83ba96118a0efd 100644 --- a/be/src/vec/functions/function_width_bucket.cpp +++ b/be/src/vec/functions/function_width_bucket.cpp @@ -61,7 +61,7 @@ class FunctionWidthBucket : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 = diff --git a/be/src/vec/functions/functions_comparison.h b/be/src/vec/functions/functions_comparison.h index bb1666ab864070..78a89071c76efd 100644 --- a/be/src/vec/functions/functions_comparison.h +++ b/be/src/vec/functions/functions_comparison.h @@ -273,7 +273,7 @@ class FunctionComparison : public IFunction { private: template - bool execute_num_right_type(Block& block, size_t result, const ColumnVector* col_left, + bool execute_num_right_type(Block& block, uint32_t result, const ColumnVector* col_left, const IColumn* col_right_untyped) const { if (const ColumnVector* col_right = check_and_get_column>(col_right_untyped)) { @@ -303,7 +303,7 @@ class FunctionComparison : public IFunction { } template - bool execute_num_const_right_type(Block& block, size_t result, const ColumnConst* col_left, + bool execute_num_const_right_type(Block& block, uint32_t result, const ColumnConst* col_left, const IColumn* col_right_untyped) const { if (const ColumnVector* col_right = check_and_get_column>(col_right_untyped)) { @@ -332,7 +332,7 @@ class FunctionComparison : public IFunction { } template - bool execute_num_left_type(Block& block, size_t result, const IColumn* col_left_untyped, + bool execute_num_left_type(Block& block, uint32_t result, const IColumn* col_left_untyped, const IColumn* col_right_untyped) const { if (const ColumnVector* col_left = check_and_get_column>(col_left_untyped)) { @@ -392,7 +392,7 @@ class FunctionComparison : public IFunction { return false; } - Status execute_decimal(Block& block, size_t result, const ColumnWithTypeAndName& col_left, + Status execute_decimal(Block& block, uint32_t result, const ColumnWithTypeAndName& col_left, const ColumnWithTypeAndName& col_right) const { TypeIndex left_number = col_left.type->get_type_id(); TypeIndex right_number = col_right.type->get_type_id(); @@ -414,7 +414,8 @@ class FunctionComparison : public IFunction { return Status::OK(); } - Status execute_string(Block& block, size_t result, const IColumn* c0, const IColumn* c1) const { + Status execute_string(Block& block, uint32_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); @@ -485,7 +486,7 @@ class FunctionComparison : public IFunction { return Status::OK(); } - void execute_generic_identical_types(Block& block, size_t result, const IColumn* c0, + void execute_generic_identical_types(Block& block, uint32_t result, const IColumn* c0, const IColumn* c1) const { bool c0_const = is_column_const(*c0); bool c1_const = is_column_const(*c1); @@ -512,7 +513,7 @@ class FunctionComparison : public IFunction { } } - Status execute_generic(Block& block, size_t result, const ColumnWithTypeAndName& c0, + Status execute_generic(Block& block, uint32_t result, const ColumnWithTypeAndName& c0, const ColumnWithTypeAndName& c1) const { execute_generic_identical_types(block, result, c0.column.get(), c1.column.get()); return Status::OK(); @@ -600,7 +601,7 @@ class FunctionComparison : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 ac0358d42f59f4..92d6bc1b1b0381 100644 --- a/be/src/vec/functions/functions_geo.h +++ b/be/src/vec/functions/functions_geo.h @@ -71,7 +71,7 @@ class GeoFunction : public IFunction { } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result, size_t input_rows_count) const override { + uint32_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 0643fc0a905787..0f474851f032ee 100644 --- a/be/src/vec/functions/functions_logical.cpp +++ b/be/src/vec/functions/functions_logical.cpp @@ -206,7 +206,7 @@ DataTypePtr FunctionAnyArityLogical::get_return_type_impl( template Status FunctionAnyArityLogical::execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, - size_t result_index, + uint32_t result_index, size_t input_rows_count) const { ColumnRawPtrs args_in; for (const auto arg_index : arguments) @@ -268,7 +268,8 @@ bool functionUnaryExecuteType(Block& block, const ColumnNumbers& arguments, size template