From e1587537bcdc5839567f6084a9dbba964cdbd778 Mon Sep 17 00:00:00 2001 From: zclllyybb Date: Mon, 11 Dec 2023 11:04:58 +0800 Subject: [PATCH] [Fix](status) fix unhandled status in exprs #28218 which marked static_cast in https://github.com/apache/doris/pull/23395/files partially fixed #28160 --- be/src/common/exception.h | 1 + be/src/common/status.h | 8 ++++ be/src/exprs/runtime_filter.cpp | 3 +- .../pipeline/exec/table_function_operator.cpp | 20 ++++---- .../pipeline/exec/table_function_operator.h | 4 +- be/src/vec/exec/vtable_function_node.cpp | 20 ++++---- be/src/vec/exec/vtable_function_node.h | 7 ++- .../vec/exprs/table_function/table_function.h | 14 +++--- be/src/vec/exprs/table_function/vexplode.cpp | 8 ++-- be/src/vec/exprs/table_function/vexplode.h | 4 +- .../exprs/table_function/vexplode_bitmap.cpp | 21 ++++----- .../exprs/table_function/vexplode_bitmap.h | 8 ++-- .../table_function/vexplode_json_array.cpp | 8 ++-- .../table_function/vexplode_json_array.h | 4 +- .../exprs/table_function/vexplode_numbers.cpp | 10 ++-- .../exprs/table_function/vexplode_numbers.h | 6 +-- .../exprs/table_function/vexplode_split.cpp | 14 +++--- .../vec/exprs/table_function/vexplode_split.h | 4 +- be/src/vec/exprs/vectorized_agg_fn.cpp | 25 ++++------ be/src/vec/exprs/vexpr.cpp | 47 +++++++++---------- be/test/vec/function/function_test_util.cpp | 7 +-- 21 files changed, 112 insertions(+), 131 deletions(-) diff --git a/be/src/common/exception.h b/be/src/common/exception.h index 299c0da043..3a2be01062 100644 --- a/be/src/common/exception.h +++ b/be/src/common/exception.h @@ -38,6 +38,7 @@ class Exception : public std::exception { public: Exception() : _code(ErrorCode::OK) {} Exception(int code, const std::string_view& msg); + Exception(const Status& status) : Exception(status.code(), status.msg()) {} // add nested exception as first param, or the template may could not find // the correct method for ...args Exception(const Exception& nested, int code, const std::string_view& msg); diff --git a/be/src/common/status.h b/be/src/common/status.h index 2b01e5ec47..d0bbda6632 100644 --- a/be/src/common/status.h +++ b/be/src/common/status.h @@ -537,6 +537,14 @@ inline std::string Status::to_string_no_stack() const { } \ } while (false) +#define THROW_IF_ERROR(stmt) \ + do { \ + Status _status_ = (stmt); \ + if (UNLIKELY(!_status_.ok())) { \ + throw Exception(_status_); \ + } \ + } while (false) + #define RETURN_ERROR_IF_NON_VEC \ return Status::NotSupported("Non-vectorized engine is not supported since Doris 2.0."); diff --git a/be/src/exprs/runtime_filter.cpp b/be/src/exprs/runtime_filter.cpp index 8398311654..de3f2ad4fd 100644 --- a/be/src/exprs/runtime_filter.cpp +++ b/be/src/exprs/runtime_filter.cpp @@ -208,9 +208,8 @@ PFilterType get_type(RuntimeFilterType type) { } Status create_literal(const TypeDescriptor& type, const void* data, vectorized::VExprSPtr& expr) { - TExprNode node = create_texpr_node_from(data, type.type, type.precision, type.scale); - try { + TExprNode node = create_texpr_node_from(data, type.type, type.precision, type.scale); expr = vectorized::VLiteral::create_shared(node); } catch (const Exception& e) { return e.to_status(); diff --git a/be/src/pipeline/exec/table_function_operator.cpp b/be/src/pipeline/exec/table_function_operator.cpp index 6e947c640c..cf14b3ec5e 100644 --- a/be/src/pipeline/exec/table_function_operator.cpp +++ b/be/src/pipeline/exec/table_function_operator.cpp @@ -115,7 +115,7 @@ int TableFunctionLocalState::_find_last_fn_eos_idx() const { bool TableFunctionLocalState::_roll_table_functions(int last_eos_idx) { int i = last_eos_idx - 1; for (; i >= 0; --i) { - static_cast(_fns[i]->forward()); + _fns[i]->forward(); if (!_fns[i]->eos()) { break; } @@ -127,7 +127,7 @@ bool TableFunctionLocalState::_roll_table_functions(int last_eos_idx) { } for (int j = i + 1; j < _parent->cast()._fn_num; ++j) { - static_cast(_fns[j]->reset()); + _fns[j]->reset(); } return true; @@ -171,7 +171,7 @@ Status TableFunctionLocalState::get_expanded_block(RuntimeState* state, if (idx == 0 || skip_child_row) { _copy_output_slots(columns); // all table functions' results are exhausted, process next child row. - RETURN_IF_ERROR(process_next_child_row()); + process_next_child_row(); if (_cur_child_offset == -1) { break; } @@ -196,7 +196,7 @@ Status TableFunctionLocalState::get_expanded_block(RuntimeState* state, _fns[i]->get_value(columns[i + p._child_slots.size()]); } _current_row_insert_times++; - static_cast(_fns[p._fn_num - 1]->forward()); + _fns[p._fn_num - 1]->forward(); } } } @@ -218,27 +218,25 @@ Status TableFunctionLocalState::get_expanded_block(RuntimeState* state, return Status::OK(); } -Status TableFunctionLocalState::process_next_child_row() { +void TableFunctionLocalState::process_next_child_row() { _cur_child_offset++; if (_cur_child_offset >= _child_block->rows()) { // release block use count. for (vectorized::TableFunction* fn : _fns) { - RETURN_IF_ERROR(fn->process_close()); + fn->process_close(); } _child_block->clear_column_data(_parent->cast() ._child_x->row_desc() .num_materialized_slots()); _cur_child_offset = -1; - return Status::OK(); + return; } for (vectorized::TableFunction* fn : _fns) { - RETURN_IF_ERROR(fn->process_row(_cur_child_offset)); + fn->process_row(_cur_child_offset); } - - return Status::OK(); } TableFunctionOperatorX::TableFunctionOperatorX(ObjectPool* pool, const TPlanNode& tnode, @@ -289,7 +287,7 @@ Status TableFunctionOperatorX::init(const TPlanNode& tnode, RuntimeState* state) Status TableFunctionOperatorX::prepare(RuntimeState* state) { RETURN_IF_ERROR(Base::prepare(state)); - for (auto fn : _fns) { + for (auto* fn : _fns) { RETURN_IF_ERROR(fn->prepare()); } RETURN_IF_ERROR(vectorized::VExpr::prepare(_vfn_ctxs, state, _row_descriptor)); diff --git a/be/src/pipeline/exec/table_function_operator.h b/be/src/pipeline/exec/table_function_operator.h index 0d292c324f..2198f336c8 100644 --- a/be/src/pipeline/exec/table_function_operator.h +++ b/be/src/pipeline/exec/table_function_operator.h @@ -56,7 +56,7 @@ public: ~TableFunctionLocalState() override = default; Status init(RuntimeState* state, LocalStateInfo& info) override; - Status process_next_child_row(); + void process_next_child_row(); Status get_expanded_block(RuntimeState* state, vectorized::Block* output_block, SourceState& source_state); @@ -106,7 +106,7 @@ public: for (auto* fn : local_state._fns) { RETURN_IF_ERROR(fn->process_init(input_block, state)); } - RETURN_IF_ERROR(local_state.process_next_child_row()); + local_state.process_next_child_row(); return Status::OK(); } diff --git a/be/src/vec/exec/vtable_function_node.cpp b/be/src/vec/exec/vtable_function_node.cpp index be93bde029..b7302aedcd 100644 --- a/be/src/vec/exec/vtable_function_node.cpp +++ b/be/src/vec/exec/vtable_function_node.cpp @@ -106,7 +106,7 @@ Status VTableFunctionNode::prepare(RuntimeState* state) { SCOPED_TIMER(_exec_timer); _num_rows_filtered_counter = ADD_COUNTER(_runtime_profile, "RowsFiltered", TUnit::UNIT); - for (auto fn : _fns) { + for (auto* fn : _fns) { RETURN_IF_ERROR(fn->prepare()); } RETURN_IF_ERROR(VExpr::prepare(_vfn_ctxs, state, _row_descriptor)); @@ -182,7 +182,7 @@ Status VTableFunctionNode::_get_expanded_block(RuntimeState* state, Block* outpu if (idx == 0 || skip_child_row) { _copy_output_slots(columns); // all table functions' results are exhausted, process next child row. - RETURN_IF_ERROR(_process_next_child_row()); + _process_next_child_row(); if (_cur_child_offset == -1) { break; } @@ -207,7 +207,7 @@ Status VTableFunctionNode::_get_expanded_block(RuntimeState* state, Block* outpu _fns[i]->get_value(columns[i + _child_slots.size()]); } _current_row_insert_times++; - static_cast(_fns[_fn_num - 1]->forward()); + _fns[_fn_num - 1]->forward(); } } } @@ -226,25 +226,23 @@ Status VTableFunctionNode::_get_expanded_block(RuntimeState* state, Block* outpu return Status::OK(); } -Status VTableFunctionNode::_process_next_child_row() { +void VTableFunctionNode::_process_next_child_row() { _cur_child_offset++; if (_cur_child_offset >= _child_block->rows()) { // release block use count. for (TableFunction* fn : _fns) { - RETURN_IF_ERROR(fn->process_close()); + fn->process_close(); } release_block_memory(*_child_block); _cur_child_offset = -1; - return Status::OK(); + return; } for (TableFunction* fn : _fns) { - RETURN_IF_ERROR(fn->process_row(_cur_child_offset)); + fn->process_row(_cur_child_offset); } - - return Status::OK(); } // Returns the index of fn of the last eos counted from back to front @@ -287,7 +285,7 @@ int VTableFunctionNode::_find_last_fn_eos_idx() { bool VTableFunctionNode::_roll_table_functions(int last_eos_idx) { int i = last_eos_idx - 1; for (; i >= 0; --i) { - static_cast(_fns[i]->forward()); + _fns[i]->forward(); if (!_fns[i]->eos()) { break; } @@ -299,7 +297,7 @@ bool VTableFunctionNode::_roll_table_functions(int last_eos_idx) { } for (int j = i + 1; j < _fn_num; ++j) { - static_cast(_fns[j]->reset()); + _fns[j]->reset(); } return true; diff --git a/be/src/vec/exec/vtable_function_node.h b/be/src/vec/exec/vtable_function_node.h index bcee8ced50..0b64fe47cc 100644 --- a/be/src/vec/exec/vtable_function_node.h +++ b/be/src/vec/exec/vtable_function_node.h @@ -17,8 +17,7 @@ #pragma once -#include - +#include #include #include "common/global_types.h" @@ -81,7 +80,7 @@ public: for (TableFunction* fn : _fns) { RETURN_IF_ERROR(fn->process_init(input_block, state)); } - RETURN_IF_ERROR(_process_next_child_row()); + _process_next_child_row(); return Status::OK(); } @@ -106,7 +105,7 @@ private: bool _roll_table_functions(int last_eos_idx); - Status _process_next_child_row(); + void _process_next_child_row(); /* Now the output tuples for table function node is base_table_tuple + tf1 + tf2 + ... But not all slots are used, the real used slots are inside table_function_node.outputSlotIds. diff --git a/be/src/vec/exprs/table_function/table_function.h b/be/src/vec/exprs/table_function/table_function.h index 04c80ba220..98d8113643 100644 --- a/be/src/vec/exprs/table_function/table_function.h +++ b/be/src/vec/exprs/table_function/table_function.h @@ -38,20 +38,19 @@ public: virtual Status process_init(Block* block, RuntimeState* state) = 0; - virtual Status process_row(size_t row_idx) { + virtual void process_row(size_t row_idx) { if (!_is_const) { _cur_size = 0; } - return reset(); + reset(); } // only used for vectorized. - virtual Status process_close() = 0; + virtual void process_close() = 0; - virtual Status reset() { + virtual void reset() { _eos = false; _cur_offset = 0; - return Status::OK(); } virtual void get_value(MutableColumnPtr& column) = 0; @@ -61,14 +60,14 @@ public: int i = 0; for (; i < max_step && !eos(); i++) { get_value(column); - static_cast(forward()); + forward(); } return i; } virtual Status close() { return Status::OK(); } - virtual Status forward(int step = 1) { + virtual void forward(int step = 1) { if (current_empty()) { _eos = true; } else { @@ -77,7 +76,6 @@ public: _eos = true; } } - return Status::OK(); } std::string name() const { return _fn_name; } diff --git a/be/src/vec/exprs/table_function/vexplode.cpp b/be/src/vec/exprs/table_function/vexplode.cpp index 912b7acb5d..b505339ea7 100644 --- a/be/src/vec/exprs/table_function/vexplode.cpp +++ b/be/src/vec/exprs/table_function/vexplode.cpp @@ -56,22 +56,20 @@ Status VExplodeTableFunction::process_init(Block* block, RuntimeState* state) { return Status::OK(); } -Status VExplodeTableFunction::process_row(size_t row_idx) { +void VExplodeTableFunction::process_row(size_t row_idx) { DCHECK(row_idx < _array_column->size()); - RETURN_IF_ERROR(TableFunction::process_row(row_idx)); + TableFunction::process_row(row_idx); if (!_detail.array_nullmap_data || !_detail.array_nullmap_data[row_idx]) { _array_offset = (*_detail.offsets_ptr)[row_idx - 1]; _cur_size = (*_detail.offsets_ptr)[row_idx] - _array_offset; } - return Status::OK(); } -Status VExplodeTableFunction::process_close() { +void VExplodeTableFunction::process_close() { _array_column = nullptr; _detail.reset(); _array_offset = 0; - return Status::OK(); } void VExplodeTableFunction::get_value(MutableColumnPtr& column) { diff --git a/be/src/vec/exprs/table_function/vexplode.h b/be/src/vec/exprs/table_function/vexplode.h index 2da97d11a4..d5d84a70e2 100644 --- a/be/src/vec/exprs/table_function/vexplode.h +++ b/be/src/vec/exprs/table_function/vexplode.h @@ -41,8 +41,8 @@ public: ~VExplodeTableFunction() override = default; Status process_init(Block* block, RuntimeState* state) override; - Status process_row(size_t row_idx) override; - Status process_close() override; + void process_row(size_t row_idx) override; + void process_close() override; void get_value(MutableColumnPtr& column) override; private: diff --git a/be/src/vec/exprs/table_function/vexplode_bitmap.cpp b/be/src/vec/exprs/table_function/vexplode_bitmap.cpp index 9ce7771454..ac037ea3ae 100644 --- a/be/src/vec/exprs/table_function/vexplode_bitmap.cpp +++ b/be/src/vec/exprs/table_function/vexplode_bitmap.cpp @@ -19,6 +19,7 @@ #include +#include #include #include @@ -53,22 +54,21 @@ Status VExplodeBitmapTableFunction::process_init(Block* block, RuntimeState* sta return Status::OK(); } -Status VExplodeBitmapTableFunction::reset() { +void VExplodeBitmapTableFunction::reset() { _eos = false; _cur_offset = 0; if (!current_empty()) { - _cur_iter.reset(new BitmapValueIterator(*_cur_bitmap)); + _cur_iter = std::make_unique(*_cur_bitmap); } - return Status::OK(); } -Status VExplodeBitmapTableFunction::forward(int step) { +void VExplodeBitmapTableFunction::forward(int step) { if (!current_empty()) { for (int i = 0; i < step; i++) { ++(*_cur_iter); } } - return TableFunction::forward(step); + TableFunction::forward(step); } void VExplodeBitmapTableFunction::get_value(MutableColumnPtr& column) { @@ -88,8 +88,8 @@ void VExplodeBitmapTableFunction::get_value(MutableColumnPtr& column) { } } -Status VExplodeBitmapTableFunction::process_row(size_t row_idx) { - RETURN_IF_ERROR(TableFunction::process_row(row_idx)); +void VExplodeBitmapTableFunction::process_row(size_t row_idx) { + TableFunction::process_row(row_idx); StringRef value = _value_column->get_data_at(row_idx); @@ -98,16 +98,13 @@ Status VExplodeBitmapTableFunction::process_row(size_t row_idx) { _cur_size = _cur_bitmap->cardinality(); if (!current_empty()) { - _cur_iter.reset(new BitmapValueIterator(*_cur_bitmap)); + _cur_iter = std::make_unique(*_cur_bitmap); } } - - return Status::OK(); } -Status VExplodeBitmapTableFunction::process_close() { +void VExplodeBitmapTableFunction::process_close() { _value_column = nullptr; - return Status::OK(); } } // namespace doris::vectorized diff --git a/be/src/vec/exprs/table_function/vexplode_bitmap.h b/be/src/vec/exprs/table_function/vexplode_bitmap.h index bc11dd7ca8..b3f2fe697f 100644 --- a/be/src/vec/exprs/table_function/vexplode_bitmap.h +++ b/be/src/vec/exprs/table_function/vexplode_bitmap.h @@ -41,13 +41,13 @@ public: VExplodeBitmapTableFunction(); ~VExplodeBitmapTableFunction() override = default; - Status reset() override; + void reset() override; void get_value(MutableColumnPtr& column) override; - Status forward(int step = 1) override; + void forward(int step = 1) override; Status process_init(Block* block, RuntimeState* state) override; - Status process_row(size_t row_idx) override; - Status process_close() override; + void process_row(size_t row_idx) override; + void process_close() override; private: void _reset_iterator(); diff --git a/be/src/vec/exprs/table_function/vexplode_json_array.cpp b/be/src/vec/exprs/table_function/vexplode_json_array.cpp index 64dec1a7e3..1a149d949a 100644 --- a/be/src/vec/exprs/table_function/vexplode_json_array.cpp +++ b/be/src/vec/exprs/table_function/vexplode_json_array.cpp @@ -195,8 +195,8 @@ Status VExplodeJsonArrayTableFunction::process_init(Block* block, RuntimeState* return Status::OK(); } -Status VExplodeJsonArrayTableFunction::process_row(size_t row_idx) { - RETURN_IF_ERROR(TableFunction::process_row(row_idx)); +void VExplodeJsonArrayTableFunction::process_row(size_t row_idx) { + TableFunction::process_row(row_idx); StringRef text = _text_column->get_data_at(row_idx); if (text.data != nullptr) { @@ -206,12 +206,10 @@ Status VExplodeJsonArrayTableFunction::process_row(size_t row_idx) { _cur_size = _parsed_data.set_output(_type, document); } } - return Status::OK(); } -Status VExplodeJsonArrayTableFunction::process_close() { +void VExplodeJsonArrayTableFunction::process_close() { _text_column = nullptr; - return Status::OK(); } void VExplodeJsonArrayTableFunction::get_value(MutableColumnPtr& column) { diff --git a/be/src/vec/exprs/table_function/vexplode_json_array.h b/be/src/vec/exprs/table_function/vexplode_json_array.h index 62f818a053..42b3cba299 100644 --- a/be/src/vec/exprs/table_function/vexplode_json_array.h +++ b/be/src/vec/exprs/table_function/vexplode_json_array.h @@ -90,8 +90,8 @@ public: ~VExplodeJsonArrayTableFunction() override = default; Status process_init(Block* block, RuntimeState* state) override; - Status process_row(size_t row_idx) override; - Status process_close() override; + void process_row(size_t row_idx) override; + void process_close() override; void get_value(MutableColumnPtr& column) override; private: diff --git a/be/src/vec/exprs/table_function/vexplode_numbers.cpp b/be/src/vec/exprs/table_function/vexplode_numbers.cpp index 01f674f59e..9b5f7ffcbb 100644 --- a/be/src/vec/exprs/table_function/vexplode_numbers.cpp +++ b/be/src/vec/exprs/table_function/vexplode_numbers.cpp @@ -76,22 +76,20 @@ Status VExplodeNumbersTableFunction::process_init(Block* block, RuntimeState* st return Status::OK(); } -Status VExplodeNumbersTableFunction::process_row(size_t row_idx) { - RETURN_IF_ERROR(TableFunction::process_row(row_idx)); +void VExplodeNumbersTableFunction::process_row(size_t row_idx) { + TableFunction::process_row(row_idx); if (_is_const) { - return Status::OK(); + return; } StringRef value = _value_column->get_data_at(row_idx); if (value.data != nullptr) { _cur_size = std::max(0, *reinterpret_cast(value.data)); } - return Status::OK(); } -Status VExplodeNumbersTableFunction::process_close() { +void VExplodeNumbersTableFunction::process_close() { _value_column = nullptr; - return Status::OK(); } void VExplodeNumbersTableFunction::get_value(MutableColumnPtr& column) { diff --git a/be/src/vec/exprs/table_function/vexplode_numbers.h b/be/src/vec/exprs/table_function/vexplode_numbers.h index d8c5c37da9..211565ec8b 100644 --- a/be/src/vec/exprs/table_function/vexplode_numbers.h +++ b/be/src/vec/exprs/table_function/vexplode_numbers.h @@ -44,8 +44,8 @@ public: ~VExplodeNumbersTableFunction() override = default; Status process_init(Block* block, RuntimeState* state) override; - Status process_row(size_t row_idx) override; - Status process_close() override; + void process_row(size_t row_idx) override; + void process_close() override; void get_value(MutableColumnPtr& column) override; int get_value(MutableColumnPtr& column, int max_step) override { if (_is_const) { @@ -62,7 +62,7 @@ public: ->insert_range_from(*_elements_column, _cur_offset, max_step); } - static_cast(forward(max_step)); + forward(max_step); return max_step; } diff --git a/be/src/vec/exprs/table_function/vexplode_split.cpp b/be/src/vec/exprs/table_function/vexplode_split.cpp index c2a48f456a..094e901035 100644 --- a/be/src/vec/exprs/table_function/vexplode_split.cpp +++ b/be/src/vec/exprs/table_function/vexplode_split.cpp @@ -83,18 +83,18 @@ Status VExplodeSplitTableFunction::process_init(Block* block, RuntimeState* stat return Status::OK(); } -Status VExplodeSplitTableFunction::process_row(size_t row_idx) { - RETURN_IF_ERROR(TableFunction::process_row(row_idx)); +void VExplodeSplitTableFunction::process_row(size_t row_idx) { + TableFunction::process_row(row_idx); if (!(_test_null_map && _test_null_map[row_idx]) && _delimiter.data != nullptr) { // TODO: use the function to be better string_view/StringRef split auto split = [](std::string_view strv, std::string_view delims = " ") { std::vector output; - auto first = strv.begin(); - auto last = strv.end(); + const auto* first = strv.begin(); + const auto* last = strv.end(); do { - const auto second = + const auto* second = std::search(first, last, std::cbegin(delims), std::cend(delims)); if (first != second) { output.emplace_back(strv.substr(std::distance(strv.begin(), first), @@ -115,15 +115,13 @@ Status VExplodeSplitTableFunction::process_row(size_t row_idx) { _cur_size = _backup.size(); } - return Status::OK(); } -Status VExplodeSplitTableFunction::process_close() { +void VExplodeSplitTableFunction::process_close() { _text_column = nullptr; _real_text_column = nullptr; _test_null_map = nullptr; _delimiter = {}; - return Status::OK(); } void VExplodeSplitTableFunction::get_value(MutableColumnPtr& column) { diff --git a/be/src/vec/exprs/table_function/vexplode_split.h b/be/src/vec/exprs/table_function/vexplode_split.h index 629e2259b6..343f83406c 100644 --- a/be/src/vec/exprs/table_function/vexplode_split.h +++ b/be/src/vec/exprs/table_function/vexplode_split.h @@ -46,8 +46,8 @@ public: Status open() override; Status process_init(Block* block, RuntimeState* state) override; - Status process_row(size_t row_idx) override; - Status process_close() override; + void process_row(size_t row_idx) override; + void process_close() override; void get_value(MutableColumnPtr& column) override; private: diff --git a/be/src/vec/exprs/vectorized_agg_fn.cpp b/be/src/vec/exprs/vectorized_agg_fn.cpp index f0f1d3f815..0e63838e87 100644 --- a/be/src/vec/exprs/vectorized_agg_fn.cpp +++ b/be/src/vec/exprs/vectorized_agg_fn.cpp @@ -66,11 +66,7 @@ AggregateFunctionPtr get_agg_state_function(const DataTypes& argument_types, AggFnEvaluator::AggFnEvaluator(const TExprNode& desc) : _fn(desc.fn), _is_merge(desc.agg_expr.is_merge_agg), - _return_type(TypeDescriptor::from_thrift(desc.fn.ret_type)), - _intermediate_slot_desc(nullptr), - _output_slot_desc(nullptr), - _merge_timer(nullptr), - _expr_timer(nullptr) { + _return_type(TypeDescriptor::from_thrift(desc.fn.ret_type)) { bool nullable = true; if (desc.__isset.is_nullable) { nullable = desc.is_nullable; @@ -78,10 +74,10 @@ AggFnEvaluator::AggFnEvaluator(const TExprNode& desc) _data_type = DataTypeFactory::instance().create_data_type(_return_type, nullable); if (desc.agg_expr.__isset.param_types) { - auto& param_types = desc.agg_expr.param_types; - for (int i = 0; i < param_types.size(); i++) { + const auto& param_types = desc.agg_expr.param_types; + for (const auto& param_type : param_types) { _argument_types_with_sort.push_back( - DataTypeFactory::instance().create_data_type(param_types[i])); + DataTypeFactory::instance().create_data_type(param_type)); } } } @@ -134,10 +130,10 @@ Status AggFnEvaluator::prepare(RuntimeState* state, const RowDescriptor& desc, std::vector child_expr_name; // prepare for argument - for (int i = 0; i < _input_exprs_ctxs.size(); ++i) { - auto data_type = _input_exprs_ctxs[i]->root()->data_type(); + for (auto& _input_exprs_ctx : _input_exprs_ctxs) { + auto data_type = _input_exprs_ctx->root()->data_type(); tmp_argument_types.emplace_back(data_type); - child_expr_name.emplace_back(_input_exprs_ctxs[i]->root()->expr_name()); + child_expr_name.emplace_back(_input_exprs_ctx->root()->expr_name()); } const DataTypes& argument_types = @@ -334,15 +330,14 @@ AggFnEvaluator::AggFnEvaluator(AggFnEvaluator& evaluator, RuntimeState* state) DataTypes tmp_argument_types; tmp_argument_types.reserve(evaluator._input_exprs_ctxs.size()); // prepare for argument - for (int i = 0; i < evaluator._input_exprs_ctxs.size(); ++i) { - auto data_type = evaluator._input_exprs_ctxs[i]->root()->data_type(); + for (auto& _input_exprs_ctx : evaluator._input_exprs_ctxs) { + auto data_type = _input_exprs_ctx->root()->data_type(); tmp_argument_types.emplace_back(data_type); } const DataTypes& argument_types = _real_argument_types.empty() ? tmp_argument_types : _real_argument_types; _function = AggregateJavaUdaf::create(evaluator._fn, argument_types, evaluator._data_type); - static_cast( - static_cast(_function.get())->check_udaf(evaluator._fn)); + THROW_IF_ERROR(static_cast(_function.get())->check_udaf(evaluator._fn)); } DCHECK(_function != nullptr); diff --git a/be/src/vec/exprs/vexpr.cpp b/be/src/vec/exprs/vexpr.cpp index bcd06cb664..97611867e7 100644 --- a/be/src/vec/exprs/vexpr.cpp +++ b/be/src/vec/exprs/vexpr.cpp @@ -61,85 +61,83 @@ TExprNode create_texpr_node_from(const void* data, const PrimitiveType& type, in switch (type) { case TYPE_BOOLEAN: { - static_cast(create_texpr_literal_node(data, &node)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node)); break; } case TYPE_TINYINT: { - static_cast(create_texpr_literal_node(data, &node)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node)); break; } case TYPE_SMALLINT: { - static_cast(create_texpr_literal_node(data, &node)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node)); break; } case TYPE_INT: { - static_cast(create_texpr_literal_node(data, &node)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node)); break; } case TYPE_BIGINT: { - static_cast(create_texpr_literal_node(data, &node)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node)); break; } case TYPE_LARGEINT: { - static_cast(create_texpr_literal_node(data, &node)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node)); break; } case TYPE_FLOAT: { - static_cast(create_texpr_literal_node(data, &node)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node)); break; } case TYPE_DOUBLE: { - static_cast(create_texpr_literal_node(data, &node)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node)); break; } case TYPE_DATEV2: { - static_cast(create_texpr_literal_node(data, &node)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node)); break; } case TYPE_DATETIMEV2: { - static_cast(create_texpr_literal_node(data, &node)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node)); break; } case TYPE_DATE: { - static_cast(create_texpr_literal_node(data, &node)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node)); break; } case TYPE_DATETIME: { - static_cast(create_texpr_literal_node(data, &node)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node)); break; } case TYPE_DECIMALV2: { - static_cast(create_texpr_literal_node(data, &node, precision, scale)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node, precision, scale)); break; } case TYPE_DECIMAL32: { - static_cast(create_texpr_literal_node(data, &node, precision, scale)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node, precision, scale)); break; } case TYPE_DECIMAL64: { - static_cast(create_texpr_literal_node(data, &node, precision, scale)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node, precision, scale)); break; } case TYPE_DECIMAL128I: { - static_cast( - create_texpr_literal_node(data, &node, precision, scale)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node, precision, scale)); break; } case TYPE_DECIMAL256: { - static_cast( - create_texpr_literal_node(data, &node, precision, scale)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node, precision, scale)); break; } case TYPE_CHAR: { - static_cast(create_texpr_literal_node(data, &node)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node)); break; } case TYPE_VARCHAR: { - static_cast(create_texpr_literal_node(data, &node)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node)); break; } case TYPE_STRING: { - static_cast(create_texpr_literal_node(data, &node)); + THROW_IF_ERROR(create_texpr_literal_node(data, &node)); break; } default: @@ -541,9 +539,10 @@ void VExpr::close_function_context(VExprContext* context, FunctionContext::Funct const FunctionBasePtr& function) const { if (_fn_context_index != -1) { FunctionContext* fn_ctx = context->fn_context(_fn_context_index); - static_cast(function->close(fn_ctx, FunctionContext::THREAD_LOCAL)); + // close failed will make system unstable. dont swallow it. + THROW_IF_ERROR(function->close(fn_ctx, FunctionContext::THREAD_LOCAL)); if (scope == FunctionContext::FRAGMENT_LOCAL) { - static_cast(function->close(fn_ctx, FunctionContext::FRAGMENT_LOCAL)); + THROW_IF_ERROR(function->close(fn_ctx, FunctionContext::FRAGMENT_LOCAL)); } } } diff --git a/be/test/vec/function/function_test_util.cpp b/be/test/vec/function/function_test_util.cpp index c0a1df599f..4ae7907921 100644 --- a/be/test/vec/function/function_test_util.cpp +++ b/be/test/vec/function/function_test_util.cpp @@ -356,10 +356,7 @@ Block* process_table_function(TableFunction* fn, Block* input_block, // process table function for all rows for (size_t row = 0; row < input_block->rows(); ++row) { - if (fn->process_row(row) != Status::OK()) { - LOG(WARNING) << "TableFunction process_row failed"; - return nullptr; - } + fn->process_row(row); // consider outer if (!fn->is_outer() && fn->current_empty()) { @@ -368,7 +365,7 @@ Block* process_table_function(TableFunction* fn, Block* input_block, do { fn->get_value(column); - static_cast(fn->forward()); + fn->forward(); } while (!fn->eos()); }