From d64be9565dd37d03507bb5bb2160fe2df5de7b69 Mon Sep 17 00:00:00 2001 From: Pxl Date: Mon, 22 May 2023 10:58:29 +0800 Subject: [PATCH] [Bug](function) fix function in get wrong result when input const column (#19791) fix function in get wrong result when input const column --- be/src/exprs/create_predicate_function.h | 4 +- be/src/olap/schema_change.cpp | 2 + be/src/vec/exprs/vcase_expr.cpp | 8 +-- be/src/vec/exprs/vectorized_fn_call.cpp | 22 ++++--- be/src/vec/exprs/vectorized_fn_call.h | 7 +++ be/src/vec/exprs/vexpr.cpp | 57 +++++++++++-------- be/src/vec/exprs/vexpr.h | 11 ++-- .../functions/array/function_array_binary.h | 2 - .../functions/array/function_array_count.cpp | 2 - .../functions/array/function_array_range.cpp | 2 - .../functions/array/function_array_zip.cpp | 2 - .../functions/comparison_equal_for_null.cpp | 1 - be/src/vec/functions/function.cpp | 11 +--- be/src/vec/functions/function.h | 25 +++++--- .../functions/function_always_not_nullable.h | 1 - be/src/vec/functions/function_bitmap.cpp | 9 --- .../functions/function_bitmap_min_or_max.h | 2 - .../functions/function_bitmap_variadic.cpp | 1 - be/src/vec/functions/function_case.h | 18 +++--- be/src/vec/functions/function_cast.h | 6 +- be/src/vec/functions/function_coalesce.cpp | 2 - be/src/vec/functions/function_conv.cpp | 1 - be/src/vec/functions/function_convert_tz.h | 1 - .../function_date_or_datetime_computation.h | 2 - .../function_date_or_datetime_to_something.h | 1 - .../function_date_or_datetime_to_string.h | 1 - .../function_datetime_floor_ceil.cpp | 2 - .../function_datetime_string_to_string.h | 1 - be/src/vec/functions/function_encryption.cpp | 2 - be/src/vec/functions/function_grouping.h | 2 - be/src/vec/functions/function_hex.cpp | 2 - be/src/vec/functions/function_ifnull.h | 2 - be/src/vec/functions/function_java_udf.h | 2 + be/src/vec/functions/function_json.cpp | 8 --- be/src/vec/functions/function_jsonb.cpp | 4 -- be/src/vec/functions/function_math_unary.h | 2 - .../function_math_unary_to_null_type.h | 2 - .../vec/functions/function_multi_same_args.h | 2 - be/src/vec/functions/function_nonnullable.cpp | 1 - .../vec/functions/function_quantile_state.cpp | 4 -- be/src/vec/functions/function_regexp.cpp | 2 - be/src/vec/functions/function_reverse.h | 2 - be/src/vec/functions/function_rpc.h | 2 + .../functions/function_running_difference.h | 2 - be/src/vec/functions/function_string.cpp | 2 - be/src/vec/functions/function_string.h | 27 +-------- .../vec/functions/function_string_to_string.h | 2 - be/src/vec/functions/function_timestamp.cpp | 5 -- be/src/vec/functions/function_totype.h | 11 ---- .../vec/functions/function_unary_arithmetic.h | 2 - be/src/vec/functions/function_utility.cpp | 1 - .../functions/function_variadic_arguments.h | 1 - be/src/vec/functions/functions_geo.h | 1 - be/src/vec/functions/functions_logical.h | 4 -- .../functions_multi_string_position.cpp | 2 - .../functions_multi_string_search.cpp | 2 - be/src/vec/functions/hll_cardinality.cpp | 1 - be/src/vec/functions/in.h | 17 +++--- be/src/vec/functions/is_not_null.cpp | 1 - be/src/vec/functions/is_null.cpp | 1 - be/src/vec/functions/like.h | 2 - be/src/vec/functions/nullif.cpp | 2 - be/src/vec/functions/round.h | 2 +- be/src/vec/utils/util.hpp | 9 +++ .../query_p0/sql_functions/test_in_expr.out | 10 ++++ .../sql_functions/test_in_expr.groovy | 6 ++ 66 files changed, 135 insertions(+), 221 deletions(-) diff --git a/be/src/exprs/create_predicate_function.h b/be/src/exprs/create_predicate_function.h index a71ad46ffb..e7395d9442 100644 --- a/be/src/exprs/create_predicate_function.h +++ b/be/src/exprs/create_predicate_function.h @@ -122,7 +122,7 @@ typename Traits::BasePtr create_predicate_function(PrimitiveType type) { APPLY_FOR_PRIMTYPE(M) #undef M default: - DCHECK(false) << "Invalid type."; + DCHECK(false) << "Invalid type: " << type_to_string(type); } return nullptr; @@ -142,7 +142,7 @@ typename Traits::BasePtr create_bitmap_predicate_function(PrimitiveType type) { case TYPE_BIGINT: return Creator::template create(); default: - DCHECK(false) << "Invalid type."; + DCHECK(false) << "Invalid type: " << type_to_string(type); } return nullptr; diff --git a/be/src/olap/schema_change.cpp b/be/src/olap/schema_change.cpp index 34b75436d3..cffa9ad605 100644 --- a/be/src/olap/schema_change.cpp +++ b/be/src/olap/schema_change.cpp @@ -310,6 +310,8 @@ Status BlockChanger::change_block(vectorized::Block* ref_block, int result_column_id = -1; RETURN_IF_ERROR(ctx->execute(ref_block, &result_column_id)); + ref_block->replace_by_position_if_const(result_column_id); + if (ref_block->get_by_position(result_column_id).column->size() != row_size) { return Status::Error( "{} size invalid, expect={}, real={}", new_block->get_by_position(idx).name, diff --git a/be/src/vec/exprs/vcase_expr.cpp b/be/src/vec/exprs/vcase_expr.cpp index 4a6b013185..5dc9eec6e8 100644 --- a/be/src/vec/exprs/vcase_expr.cpp +++ b/be/src/vec/exprs/vcase_expr.cpp @@ -28,6 +28,7 @@ #include "common/status.h" #include "vec/aggregate_functions/aggregate_function.h" +#include "vec/columns/column.h" #include "vec/core/block.h" #include "vec/core/column_numbers.h" #include "vec/core/column_with_type_and_name.h" @@ -54,8 +55,7 @@ VCaseExpr::VCaseExpr(const TExprNode& node) } } -Status VCaseExpr::prepare(doris::RuntimeState* state, const doris::RowDescriptor& desc, - VExprContext* context) { +Status VCaseExpr::prepare(RuntimeState* state, const RowDescriptor& desc, VExprContext* context) { RETURN_IF_ERROR_OR_PREPARED(VExpr::prepare(state, desc, context)); ColumnsWithTypeAndName argument_template; @@ -92,14 +92,12 @@ void VCaseExpr::close(RuntimeState* state, VExprContext* context, Status VCaseExpr::execute(VExprContext* context, Block* block, int* result_column_id) { ColumnNumbers arguments(_children.size()); - for (int i = 0; i < _children.size(); i++) { int column_id = -1; RETURN_IF_ERROR(_children[i]->execute(context, block, &column_id)); arguments[i] = column_id; - - block->replace_by_position_if_const(column_id); } + RETURN_IF_ERROR(check_constant(*block, arguments)); size_t num_columns_without_result = block->columns(); block->insert({nullptr, _data_type, _expr_name}); diff --git a/be/src/vec/exprs/vectorized_fn_call.cpp b/be/src/vec/exprs/vectorized_fn_call.cpp index bec7d0c1a3..96c7d5bd88 100644 --- a/be/src/vec/exprs/vectorized_fn_call.cpp +++ b/be/src/vec/exprs/vectorized_fn_call.cpp @@ -50,10 +50,10 @@ class TExprNode; namespace doris::vectorized { -VectorizedFnCall::VectorizedFnCall(const doris::TExprNode& node) : VExpr(node) {} +VectorizedFnCall::VectorizedFnCall(const TExprNode& node) : VExpr(node) {} -doris::Status VectorizedFnCall::prepare(doris::RuntimeState* state, - const doris::RowDescriptor& desc, VExprContext* context) { +Status VectorizedFnCall::prepare(RuntimeState* state, const RowDescriptor& desc, + VExprContext* context) { RETURN_IF_ERROR_OR_PREPARED(VExpr::prepare(state, desc, context)); ColumnsWithTypeAndName argument_template; argument_template.reserve(_children.size()); @@ -89,33 +89,36 @@ doris::Status VectorizedFnCall::prepare(doris::RuntimeState* state, } VExpr::register_function_context(state, context); _expr_name = fmt::format("{}({})", _fn.name.function_name, child_expr_name); + _function_name = _fn.name.function_name; _can_fast_execute = _function->can_fast_execute(); return Status::OK(); } -doris::Status VectorizedFnCall::open(doris::RuntimeState* state, VExprContext* context, - FunctionContext::FunctionStateScope scope) { +Status VectorizedFnCall::open(RuntimeState* state, VExprContext* context, + FunctionContext::FunctionStateScope scope) { RETURN_IF_ERROR(VExpr::open(state, context, scope)); RETURN_IF_ERROR(VExpr::init_function_context(context, scope, _function)); return Status::OK(); } -void VectorizedFnCall::close(doris::RuntimeState* state, VExprContext* context, +void VectorizedFnCall::close(RuntimeState* state, VExprContext* context, FunctionContext::FunctionStateScope scope) { VExpr::close_function_context(context, scope, _function); VExpr::close(state, context, scope); } -doris::Status VectorizedFnCall::execute(VExprContext* context, doris::vectorized::Block* block, - int* result_column_id) { +Status VectorizedFnCall::execute(VExprContext* context, vectorized::Block* block, + int* result_column_id) { // TODO: not execute const expr again, but use the const column in function context - doris::vectorized::ColumnNumbers arguments(_children.size()); + vectorized::ColumnNumbers arguments(_children.size()); for (int i = 0; i < _children.size(); ++i) { int column_id = -1; RETURN_IF_ERROR(_children[i]->execute(context, block, &column_id)); arguments[i] = column_id; } + RETURN_IF_ERROR(check_constant(*block, arguments)); + // call function size_t num_columns_without_result = block->columns(); // prepare a column to save result @@ -133,6 +136,7 @@ doris::Status VectorizedFnCall::execute(VExprContext* context, doris::vectorized RETURN_IF_ERROR(_function->execute(context->fn_context(_fn_context_index), *block, arguments, num_columns_without_result, block->rows(), false)); *result_column_id = num_columns_without_result; + return Status::OK(); } diff --git a/be/src/vec/exprs/vectorized_fn_call.h b/be/src/vec/exprs/vectorized_fn_call.h index dc5330433e..9fcd3563c9 100644 --- a/be/src/vec/exprs/vectorized_fn_call.h +++ b/be/src/vec/exprs/vectorized_fn_call.h @@ -56,6 +56,12 @@ public: } const std::string& expr_name() const override; std::string debug_string() const override; + bool is_constant() const override { + if (!_function->is_use_default_implementation_for_constants()) { + return false; + } + return VExpr::is_constant(); + } static std::string debug_string(const std::vector& exprs); bool fast_execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, @@ -65,5 +71,6 @@ private: FunctionBasePtr _function; bool _can_fast_execute = false; std::string _expr_name; + std::string _function_name; }; } // namespace doris::vectorized diff --git a/be/src/vec/exprs/vexpr.cpp b/be/src/vec/exprs/vexpr.cpp index 23c6e115d6..9f66bba50f 100644 --- a/be/src/vec/exprs/vexpr.cpp +++ b/be/src/vec/exprs/vexpr.cpp @@ -49,6 +49,7 @@ #include "vec/exprs/vslot_ref.h" #include "vec/exprs/vstruct_literal.h" #include "vec/exprs/vtuple_is_null_predicate.h" +#include "vec/utils/util.hpp" namespace doris { class RowDescriptor; @@ -61,7 +62,7 @@ using doris::RuntimeState; using doris::RowDescriptor; using doris::TypeDescriptor; -VExpr::VExpr(const doris::TExprNode& node) +VExpr::VExpr(const TExprNode& node) : _node_type(node.node_type), _opcode(node.__isset.opcode ? node.opcode : TExprOpcode::INVALID_OPCODE), _type(TypeDescriptor::from_thrift(node.type)), @@ -119,14 +120,14 @@ Status VExpr::open(RuntimeState* state, VExprContext* context, return Status::OK(); } -void VExpr::close(doris::RuntimeState* state, VExprContext* context, +void VExpr::close(RuntimeState* state, VExprContext* context, FunctionContext::FunctionStateScope scope) { for (int i = 0; i < _children.size(); ++i) { _children[i]->close(state, context, scope); } } -Status VExpr::create_expr(ObjectPool* pool, const doris::TExprNode& texpr_node, VExpr** expr) { +Status VExpr::create_expr(ObjectPool* pool, const TExprNode& texpr_node, VExpr** expr) { try { switch (texpr_node.node_type) { case TExprNodeType::BOOL_LITERAL: @@ -153,43 +154,43 @@ Status VExpr::create_expr(ObjectPool* pool, const doris::TExprNode& texpr_node, *expr = pool->add(VStructLiteral::create_unique(texpr_node).release()); break; } - case doris::TExprNodeType::SLOT_REF: { + case TExprNodeType::SLOT_REF: { *expr = pool->add(VSlotRef::create_unique(texpr_node).release()); break; } - case doris::TExprNodeType::COLUMN_REF: { + case TExprNodeType::COLUMN_REF: { *expr = pool->add(VColumnRef::create_unique(texpr_node).release()); break; } - case doris::TExprNodeType::COMPOUND_PRED: { + case TExprNodeType::COMPOUND_PRED: { *expr = pool->add(VcompoundPred::create_unique(texpr_node).release()); break; } - case doris::TExprNodeType::LAMBDA_FUNCTION_EXPR: { + case TExprNodeType::LAMBDA_FUNCTION_EXPR: { *expr = pool->add(VLambdaFunctionExpr::create_unique(texpr_node).release()); break; } - case doris::TExprNodeType::LAMBDA_FUNCTION_CALL_EXPR: { + case TExprNodeType::LAMBDA_FUNCTION_CALL_EXPR: { *expr = pool->add(VLambdaFunctionCallExpr::create_unique(texpr_node).release()); break; } - case doris::TExprNodeType::ARITHMETIC_EXPR: - case doris::TExprNodeType::BINARY_PRED: - case doris::TExprNodeType::FUNCTION_CALL: - case doris::TExprNodeType::COMPUTE_FUNCTION_CALL: - case doris::TExprNodeType::MATCH_PRED: { + case TExprNodeType::ARITHMETIC_EXPR: + case TExprNodeType::BINARY_PRED: + case TExprNodeType::FUNCTION_CALL: + case TExprNodeType::COMPUTE_FUNCTION_CALL: + case TExprNodeType::MATCH_PRED: { *expr = pool->add(VectorizedFnCall::create_unique(texpr_node).release()); break; } - case doris::TExprNodeType::CAST_EXPR: { + case TExprNodeType::CAST_EXPR: { *expr = pool->add(VCastExpr::create_unique(texpr_node).release()); break; } - case doris::TExprNodeType::IN_PRED: { + case TExprNodeType::IN_PRED: { *expr = pool->add(VInPredicate::create_unique(texpr_node).release()); break; } - case doris::TExprNodeType::CASE_EXPR: { + case TExprNodeType::CASE_EXPR: { if (!texpr_node.__isset.case_expr) { return Status::InternalError("Case expression not set in thrift node"); } @@ -211,7 +212,7 @@ Status VExpr::create_expr(ObjectPool* pool, const doris::TExprNode& texpr_node, default: return Status::InternalError("Unknown expr node type: {}", texpr_node.node_type); } - } catch (const doris::Exception& e) { + } catch (const Exception& e) { return Status::Error(e.code(), e.to_string()); } if (!(*expr)->data_type()) { @@ -220,9 +221,8 @@ Status VExpr::create_expr(ObjectPool* pool, const doris::TExprNode& texpr_node, return Status::OK(); } -Status VExpr::create_tree_from_thrift(doris::ObjectPool* pool, - const std::vector& nodes, int* node_idx, - VExpr** root_expr, VExprContext** ctx) { +Status VExpr::create_tree_from_thrift(ObjectPool* pool, const std::vector& nodes, + int* node_idx, VExpr** root_expr, VExprContext** ctx) { // propagate error case if (*node_idx >= nodes.size()) { return Status::InternalError("Failed to reconstruct expression tree from thrift."); @@ -237,9 +237,9 @@ Status VExpr::create_tree_from_thrift(doris::ObjectPool* pool, DCHECK(root_expr != nullptr); DCHECK(ctx != nullptr); *root_expr = root; - *ctx = pool->add(VExprContext::create_unique(root).release()); // short path for leaf node if (root_children <= 0) { + *ctx = pool->add(VExprContext::create_unique(root).release()); return Status::OK(); } @@ -266,11 +266,11 @@ Status VExpr::create_tree_from_thrift(doris::ObjectPool* pool, s.push({expr, num_children}); } } + *ctx = pool->add(VExprContext::create_unique(root).release()); return Status::OK(); } -Status VExpr::create_expr_tree(doris::ObjectPool* pool, const doris::TExpr& texpr, - VExprContext** ctx) { +Status VExpr::create_expr_tree(ObjectPool* pool, const TExpr& texpr, VExprContext** ctx) { if (texpr.nodes.size() == 0) { *ctx = nullptr; return Status::OK(); @@ -291,7 +291,7 @@ Status VExpr::create_expr_tree(doris::ObjectPool* pool, const doris::TExpr& texp return status; } -Status VExpr::create_expr_trees(ObjectPool* pool, const std::vector& texprs, +Status VExpr::create_expr_trees(ObjectPool* pool, const std::vector& texprs, std::vector* ctxs) { ctxs->clear(); for (int i = 0; i < texprs.size(); ++i) { @@ -407,7 +407,7 @@ Status VExpr::get_const_col(VExprContext* context, return Status::OK(); } -void VExpr::register_function_context(doris::RuntimeState* state, VExprContext* context) { +void VExpr::register_function_context(RuntimeState* state, VExprContext* context) { std::vector arg_types; for (int i = 0; i < _children.size(); ++i) { arg_types.push_back(_children[i]->type()); @@ -448,4 +448,11 @@ void VExpr::close_function_context(VExprContext* context, FunctionContext::Funct } } +Status VExpr::check_constant(const Block& block, ColumnNumbers arguments) const { + if (is_constant() && !VectorizedUtils::all_arguments_are_constant(block, arguments)) { + return Status::InternalError("const check failed, expr={}", debug_string()); + } + return Status::OK(); +} + } // namespace doris::vectorized diff --git a/be/src/vec/exprs/vexpr.h b/be/src/vec/exprs/vexpr.h index f4b684499f..2eb2e78a32 100644 --- a/be/src/vec/exprs/vexpr.h +++ b/be/src/vec/exprs/vexpr.h @@ -149,9 +149,8 @@ public: static Status create_expr(ObjectPool* pool, const TExprNode& texpr_node, VExpr** expr); - static Status create_tree_from_thrift(doris::ObjectPool* pool, - const std::vector& nodes, int* node_idx, - VExpr** root_expr, VExprContext** ctx); + static Status create_tree_from_thrift(ObjectPool* pool, const std::vector& nodes, + int* node_idx, VExpr** root_expr, VExprContext** ctx); virtual const std::vector& children() const { return _children; } void set_children(std::vector children) { _children = children; } virtual std::string debug_string() const; @@ -178,7 +177,7 @@ public: int fn_context_index() const { return _fn_context_index; } static const VExpr* expr_without_cast(const VExpr* expr) { - if (expr->node_type() == doris::TExprNodeType::CAST_EXPR) { + if (expr->node_type() == TExprNodeType::CAST_EXPR) { return expr_without_cast(expr->_children[0]); } return expr; @@ -211,9 +210,11 @@ protected: return out.str(); } + Status check_constant(const Block& block, ColumnNumbers arguments) const; + /// Helper function that calls ctx->register(), sets fn_context_index_, and returns the /// registered FunctionContext - void register_function_context(doris::RuntimeState* state, VExprContext* context); + void register_function_context(RuntimeState* state, VExprContext* context); /// Helper function to initialize function context, called in `open` phase of VExpr: /// 1. Set constant columns result of function arguments. diff --git a/be/src/vec/functions/array/function_array_binary.h b/be/src/vec/functions/array/function_array_binary.h index d77d7028fe..27b5fd594d 100644 --- a/be/src/vec/functions/array/function_array_binary.h +++ b/be/src/vec/functions/array/function_array_binary.h @@ -36,8 +36,6 @@ public: bool is_variadic() const override { return false; } size_t get_number_of_arguments() const override { return 2; } - bool use_default_implementation_for_constants() const override { return true; } - DataTypePtr get_return_type_impl(const DataTypes& arguments) const override { DCHECK(is_array(arguments[0])) << arguments[0]->get_name(); DCHECK(is_array(arguments[1])) << arguments[1]->get_name(); diff --git a/be/src/vec/functions/array/function_array_count.cpp b/be/src/vec/functions/array/function_array_count.cpp index bf0f9bb890..25c15c0912 100644 --- a/be/src/vec/functions/array/function_array_count.cpp +++ b/be/src/vec/functions/array/function_array_count.cpp @@ -41,8 +41,6 @@ public: bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } - ColumnNumbers get_arguments_that_are_always_constant() const override { return {1}; } DataTypePtr get_return_type_impl(const DataTypes& arguments) const override { diff --git a/be/src/vec/functions/array/function_array_range.cpp b/be/src/vec/functions/array/function_array_range.cpp index 06cb8fda15..356941e261 100644 --- a/be/src/vec/functions/array/function_array_range.cpp +++ b/be/src/vec/functions/array/function_array_range.cpp @@ -64,8 +64,6 @@ public: bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } - size_t get_number_of_arguments() const override { return get_variadic_argument_types_impl().size(); } diff --git a/be/src/vec/functions/array/function_array_zip.cpp b/be/src/vec/functions/array/function_array_zip.cpp index 7f82492ce8..af925c1718 100644 --- a/be/src/vec/functions/array/function_array_zip.cpp +++ b/be/src/vec/functions/array/function_array_zip.cpp @@ -66,8 +66,6 @@ public: bool is_variadic() const override { return true; } - bool use_default_implementation_for_constants() const override { return true; } - size_t get_number_of_arguments() const override { return 0; } DataTypePtr get_return_type_impl(const DataTypes& arguments) const override { diff --git a/be/src/vec/functions/comparison_equal_for_null.cpp b/be/src/vec/functions/comparison_equal_for_null.cpp index ae08523a59..20f7e8859a 100644 --- a/be/src/vec/functions/comparison_equal_for_null.cpp +++ b/be/src/vec/functions/comparison_equal_for_null.cpp @@ -61,7 +61,6 @@ public: } bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { diff --git a/be/src/vec/functions/function.cpp b/be/src/vec/functions/function.cpp index c0eced8691..1a92f475cb 100644 --- a/be/src/vec/functions/function.cpp +++ b/be/src/vec/functions/function.cpp @@ -135,15 +135,6 @@ NullPresence get_null_presence(const Block& block, const ColumnNumbers& args) { return res; } -bool all_arguments_are_constant(const Block& block, const ColumnNumbers& args) { - for (const auto& arg : args) { - if (!is_column_const(*block.get_by_position(arg).column)) { - return false; - } - } - return true; -} - inline Status PreparedFunctionImpl::_execute_skipped_constant_deal( FunctionContext* context, Block& block, const ColumnNumbers& args, size_t result, size_t input_rows_count, bool dry_run) { @@ -177,7 +168,7 @@ Status PreparedFunctionImpl::default_implementation_for_constant_arguments( } if (args.empty() || !use_default_implementation_for_constants() || - !all_arguments_are_constant(block, args)) { + !VectorizedUtils::all_arguments_are_constant(block, args)) { return Status::OK(); } diff --git a/be/src/vec/functions/function.h b/be/src/vec/functions/function.h index 4d233f6915..c6b01ee712 100644 --- a/be/src/vec/functions/function.h +++ b/be/src/vec/functions/function.h @@ -89,6 +89,13 @@ public: Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count, bool dry_run = false) final; + /** If the function have non-zero number of arguments, + * and if all arguments are constant, that we could automatically provide default implementation: + * arguments are converted to ordinary columns with single value which is not const, then function is executed as usual, + * and then the result is converted to constant column. + */ + virtual bool use_default_implementation_for_constants() const { return true; } + protected: virtual Status execute_impl_dry_run(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, @@ -108,13 +115,6 @@ protected: */ virtual bool use_default_implementation_for_nulls() const { return true; } - /** If the function have non-zero number of arguments, - * and if all arguments are constant, that we could automatically provide default implementation: - * arguments are converted to ordinary columns with single value which is not const, then function is executed as usual, - * and then the result is converted to constant column. - */ - virtual bool use_default_implementation_for_constants() const { return false; } - /** If function arguments has single low cardinality column and all other arguments are constants, call function on nested column. * Otherwise, convert all low cardinality columns to ordinary columns. * Returns ColumnLowCardinality if at least one argument is ColumnLowCardinality. @@ -239,6 +239,8 @@ public: */ virtual bool has_information_about_monotonicity() const { return false; } + virtual bool is_use_default_implementation_for_constants() const = 0; + /// The property of monotonicity for a certain range. struct Monotonicity { bool is_monotonic = false; /// Is the function monotonous (nondecreasing or nonincreasing). @@ -418,7 +420,6 @@ public: /// Override this functions to change default implementation behavior. See details in IMyFunction. bool use_default_implementation_for_nulls() const override { return true; } - bool use_default_implementation_for_constants() const override { return false; } bool use_default_implementation_for_low_cardinality_columns() const override { return true; } /// all constancy check should use this function to do automatically @@ -429,6 +430,10 @@ public: bool is_deterministic() const override { return true; } bool is_deterministic_in_scope_of_query() const override { return true; } + bool is_use_default_implementation_for_constants() const override { + return use_default_implementation_for_constants(); + } + using PreparedFunctionImpl::execute; using PreparedFunctionImpl::execute_impl_dry_run; using FunctionBuilderImpl::get_return_type_impl; @@ -566,6 +571,10 @@ public: return function->get_monotonicity_for_range(type, left, right); } + bool is_use_default_implementation_for_constants() const override { + return function->is_use_default_implementation_for_constants(); + } + private: std::shared_ptr function; DataTypes arguments; diff --git a/be/src/vec/functions/function_always_not_nullable.h b/be/src/vec/functions/function_always_not_nullable.h index a86fe4da95..72c0048bf4 100644 --- a/be/src/vec/functions/function_always_not_nullable.h +++ b/be/src/vec/functions/function_always_not_nullable.h @@ -38,7 +38,6 @@ public: return std::make_shared(); } - bool use_default_implementation_for_constants() const override { return true; } bool use_default_implementation_for_nulls() const override { return false; } template diff --git a/be/src/vec/functions/function_bitmap.cpp b/be/src/vec/functions/function_bitmap.cpp index 680aea73dd..74035f6f7d 100644 --- a/be/src/vec/functions/function_bitmap.cpp +++ b/be/src/vec/functions/function_bitmap.cpp @@ -305,8 +305,6 @@ public: bool use_default_implementation_for_nulls() const override { return true; } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { auto res_null_map = ColumnUInt8::create(input_rows_count, 0); @@ -445,8 +443,6 @@ public: bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { auto res_data_column = ColumnInt64::create(); @@ -693,8 +689,6 @@ public: return return_nullable ? make_nullable(result_type) : result_type; } - bool use_default_implementation_for_constants() const override { return true; } - bool use_default_implementation_for_nulls() const override { // for bitmap_and_not_count, result is always not null, and if the bitmap op result is null, // the count is 0 @@ -1022,8 +1016,6 @@ public: bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { DCHECK_EQ(arguments.size(), 3); @@ -1082,7 +1074,6 @@ public: size_t get_number_of_arguments() const override { return 1; } bool use_default_implementation_for_nulls() const override { return true; } - bool use_default_implementation_for_constants() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { 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 4f7018292d..a467a65647 100644 --- a/be/src/vec/functions/function_bitmap_min_or_max.h +++ b/be/src/vec/functions/function_bitmap_min_or_max.h @@ -49,8 +49,6 @@ public: return make_nullable(std::make_shared()); } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { auto result_column = ColumnInt64::create(); diff --git a/be/src/vec/functions/function_bitmap_variadic.cpp b/be/src/vec/functions/function_bitmap_variadic.cpp index 44b18d108a..e128bf4a40 100644 --- a/be/src/vec/functions/function_bitmap_variadic.cpp +++ b/be/src/vec/functions/function_bitmap_variadic.cpp @@ -194,7 +194,6 @@ public: } } - bool use_default_implementation_for_constants() const override { return true; } bool use_default_implementation_for_nulls() const override { // result is null only when all columns is null for bitmap_or. // for count functions, result is always not null, and if the bitmap op result is null, diff --git a/be/src/vec/functions/function_case.h b/be/src/vec/functions/function_case.h index bd7e8f68a5..4b085ada3d 100644 --- a/be/src/vec/functions/function_case.h +++ b/be/src/vec/functions/function_case.h @@ -239,7 +239,7 @@ public: } } else { auto* __restrict cond_raw_data = - reinterpret_cast(when_column_ptr.get()) + assert_cast(when_column_ptr.get()) ->get_data() .data(); @@ -304,7 +304,7 @@ public: size_t rows_count = column_holder.rows_count; result_column_ptr->resize(rows_count); auto* __restrict result_raw_data = - reinterpret_cast(result_column_ptr.get())->get_data().data(); + assert_cast(result_column_ptr.get())->get_data().data(); // set default value for (int i = 0; i < rows_count; i++) { @@ -314,7 +314,7 @@ public: // some types had simd automatically, but some not. for (uint8_t i = (has_else ? 0 : 1); i < column_holder.pair_count; i++) { auto* __restrict column_raw_data = - reinterpret_cast( + assert_cast( column_holder.then_ptrs[i].value()->assume_mutable().get()) ->get_data() .data(); @@ -375,6 +375,10 @@ public: } } + for (int i = 0; i < arguments.size(); i++) { + block.replace_by_position_if_const(arguments[i]); + } + if (when_null) { return execute_get_then_null(data_type, block, arguments, result, input_rows_count); @@ -387,10 +391,10 @@ public: Status execute_get_type(const DataTypePtr& data_type, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) { - WhichDataType which(data_type->is_nullable() - ? reinterpret_cast(data_type.get()) - ->get_nested_type() - : data_type); + WhichDataType which( + data_type->is_nullable() + ? assert_cast(data_type.get())->get_nested_type() + : data_type); #define DISPATCH(TYPE, COLUMN_TYPE) \ if (which.idx == TypeIndex::TYPE) \ return execute_get_when_null(data_type, block, arguments, result, \ diff --git a/be/src/vec/functions/function_cast.h b/be/src/vec/functions/function_cast.h index 3074face87..5c27f33bfd 100644 --- a/be/src/vec/functions/function_cast.h +++ b/be/src/vec/functions/function_cast.h @@ -1033,7 +1033,6 @@ public: return std::make_shared(); } - bool use_default_implementation_for_constants() const override { return true; } ColumnNumbers get_arguments_that_are_always_constant() const override { return {1}; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, @@ -1239,7 +1238,6 @@ protected: } bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } bool use_default_implementation_for_low_cardinality_columns() const override { return false; } ColumnNumbers get_arguments_that_are_always_constant() const override { return {1}; } @@ -1363,7 +1361,6 @@ public: bool is_variadic() const override { return true; } size_t get_number_of_arguments() const override { return 0; } - bool use_default_implementation_for_constants() const override { return true; } ColumnNumbers get_arguments_that_are_always_constant() const override { return {1}; } // This function should not be called for get DateType Ptr @@ -1407,7 +1404,6 @@ public: bool is_variadic() const override { return true; } size_t get_number_of_arguments() const override { return 0; } - bool use_default_implementation_for_constants() const override { return true; } ColumnNumbers get_arguments_that_are_always_constant() const override { return {1}; } // This function should not be called for get DateType Ptr @@ -1481,6 +1477,8 @@ public: return monotonicity_for_range(type, left, right); } + bool is_use_default_implementation_for_constants() const override { return true; } + private: const char* name; MonotonicityForRange monotonicity_for_range; diff --git a/be/src/vec/functions/function_coalesce.cpp b/be/src/vec/functions/function_coalesce.cpp index 800e1de854..2a53f03d9a 100644 --- a/be/src/vec/functions/function_coalesce.cpp +++ b/be/src/vec/functions/function_coalesce.cpp @@ -62,8 +62,6 @@ public: String get_name() const override { return name; } - bool use_default_implementation_for_constants() const override { return true; } - bool use_default_implementation_for_nulls() const override { return false; } bool is_variadic() const override { return true; } diff --git a/be/src/vec/functions/function_conv.cpp b/be/src/vec/functions/function_conv.cpp index bd49398c8d..b0a7ef7df9 100644 --- a/be/src/vec/functions/function_conv.cpp +++ b/be/src/vec/functions/function_conv.cpp @@ -73,7 +73,6 @@ public: } bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { diff --git a/be/src/vec/functions/function_convert_tz.h b/be/src/vec/functions/function_convert_tz.h index ae5723aef1..829f86a66b 100644 --- a/be/src/vec/functions/function_convert_tz.h +++ b/be/src/vec/functions/function_convert_tz.h @@ -199,7 +199,6 @@ public: return Transform::get_variadic_argument_types(); } - bool use_default_implementation_for_constants() const override { return true; } bool use_default_implementation_for_nulls() const override { return false; } Status open(FunctionContext* context, FunctionContext::FunctionStateScope scope) override { 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 80163db45e..e31d8f64c6 100644 --- a/be/src/vec/functions/function_date_or_datetime_computation.h +++ b/be/src/vec/functions/function_date_or_datetime_computation.h @@ -686,8 +686,6 @@ public: RETURN_REAL_TYPE_FOR_DATEV2_FUNCTION(typename Transform::ReturnType); } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { const auto& first_arg_type = block.get_by_position(arguments[0]).type; 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 b5c8078b01..a822df9fed 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 @@ -88,7 +88,6 @@ public: RETURN_REAL_TYPE_FOR_DATEV2_FUNCTION(ToDataType); } - bool use_default_implementation_for_constants() const override { return true; } ColumnNumbers get_arguments_that_are_always_constant() const override { return {1}; } bool use_default_implementation_for_nulls() const override { return false; } 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 6782d9236a..85ad246621 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 @@ -77,7 +77,6 @@ public: return {}; } - bool use_default_implementation_for_constants() const override { return true; } ColumnNumbers get_arguments_that_are_always_constant() const override { return {1}; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, diff --git a/be/src/vec/functions/function_datetime_floor_ceil.cpp b/be/src/vec/functions/function_datetime_floor_ceil.cpp index 7a6773f415..a2389295cd 100644 --- a/be/src/vec/functions/function_datetime_floor_ceil.cpp +++ b/be/src/vec/functions/function_datetime_floor_ceil.cpp @@ -90,8 +90,6 @@ public: String get_name() const override { return name; } - bool use_default_implementation_for_constants() const override { return false; } - size_t get_number_of_arguments() const override { return 0; } bool is_variadic() const override { return true; } 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 b16da8abd6..68b8290a59 100644 --- a/be/src/vec/functions/function_datetime_string_to_string.h +++ b/be/src/vec/functions/function_datetime_string_to_string.h @@ -70,7 +70,6 @@ public: } bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } ColumnNumbers get_arguments_that_are_always_constant() const override { return {1}; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, diff --git a/be/src/vec/functions/function_encryption.cpp b/be/src/vec/functions/function_encryption.cpp index 9b93172475..a2758fcb15 100644 --- a/be/src/vec/functions/function_encryption.cpp +++ b/be/src/vec/functions/function_encryption.cpp @@ -108,8 +108,6 @@ public: bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { size_t argument_size = arguments.size(); diff --git a/be/src/vec/functions/function_grouping.h b/be/src/vec/functions/function_grouping.h index bf8c90a224..6eb220286d 100644 --- a/be/src/vec/functions/function_grouping.h +++ b/be/src/vec/functions/function_grouping.h @@ -46,8 +46,6 @@ class FunctionGroupingBase : public IFunction { public: size_t get_number_of_arguments() const override { return 1; } - bool use_default_implementation_for_constants() const override { return false; } - bool use_default_implementation_for_nulls() const override { return false; } DataTypePtr get_return_type_impl(const ColumnsWithTypeAndName& arguments) const override { diff --git a/be/src/vec/functions/function_hex.cpp b/be/src/vec/functions/function_hex.cpp index 2f11072183..9db623bbd2 100644 --- a/be/src/vec/functions/function_hex.cpp +++ b/be/src/vec/functions/function_hex.cpp @@ -69,8 +69,6 @@ public: return Impl::get_variadic_argument_types(); } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { ColumnPtr& argument_column = block.get_by_position(arguments[0]).column; diff --git a/be/src/vec/functions/function_ifnull.h b/be/src/vec/functions/function_ifnull.h index 5ecf4d153e..a64d79bc51 100644 --- a/be/src/vec/functions/function_ifnull.h +++ b/be/src/vec/functions/function_ifnull.h @@ -56,8 +56,6 @@ public: size_t get_number_of_arguments() const override { return 2; } - bool use_default_implementation_for_constants() const override { return false; } - // be compatible with fe code /* if (fn.functionName().equalsIgnoreCase("ifnull") || fn.functionName().equalsIgnoreCase("nvl")) { diff --git a/be/src/vec/functions/function_java_udf.h b/be/src/vec/functions/function_java_udf.h index b1cae9289e..1f47394c69 100644 --- a/be/src/vec/functions/function_java_udf.h +++ b/be/src/vec/functions/function_java_udf.h @@ -76,6 +76,8 @@ public: bool is_deterministic_in_scope_of_query() const override { return false; } + bool is_use_default_implementation_for_constants() const override { return true; } + private: const TFunction& fn_; const DataTypes _argument_types; diff --git a/be/src/vec/functions/function_json.cpp b/be/src/vec/functions/function_json.cpp index 200ea3c237..e78bd1ba82 100644 --- a/be/src/vec/functions/function_json.cpp +++ b/be/src/vec/functions/function_json.cpp @@ -695,8 +695,6 @@ public: bool is_variadic() const override { return true; } - bool use_default_implementation_for_constants() const override { return true; } - DataTypePtr get_return_type_impl(const DataTypes& arguments) const override { return std::make_shared(); } @@ -846,8 +844,6 @@ public: bool is_variadic() const override { return true; } - bool use_default_implementation_for_constants() const override { return true; } - DataTypePtr get_return_type_impl(const DataTypes& arguments) const override { return std::make_shared(); } @@ -891,8 +887,6 @@ public: bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { const IColumn& col_from = *(block.get_by_position(arguments[0]).column); @@ -954,8 +948,6 @@ public: bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { const IColumn& col_from = *(block.get_by_position(arguments[0]).column); diff --git a/be/src/vec/functions/function_jsonb.cpp b/be/src/vec/functions/function_jsonb.cpp index d89d1ef120..fbe5f11313 100644 --- a/be/src/vec/functions/function_jsonb.cpp +++ b/be/src/vec/functions/function_jsonb.cpp @@ -151,8 +151,6 @@ public: bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } - Status open(FunctionContext* context, FunctionContext::FunctionStateScope scope) override { if constexpr (parse_error_handle_mode == JsonbParseErrorMode::RETURN_VALUE) { if (context->is_col_constant(1)) { @@ -337,8 +335,6 @@ public: return make_nullable(std::make_shared()); } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { auto null_map = ColumnUInt8::create(input_rows_count, 0); diff --git a/be/src/vec/functions/function_math_unary.h b/be/src/vec/functions/function_math_unary.h index 5f9fd7dd3b..29bcbcf419 100644 --- a/be/src/vec/functions/function_math_unary.h +++ b/be/src/vec/functions/function_math_unary.h @@ -127,8 +127,6 @@ private: return true; } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { const ColumnWithTypeAndName& col = block.get_by_position(arguments[0]); diff --git a/be/src/vec/functions/function_math_unary_to_null_type.h b/be/src/vec/functions/function_math_unary_to_null_type.h index dc9789f761..3e64001dc8 100644 --- a/be/src/vec/functions/function_math_unary_to_null_type.h +++ b/be/src/vec/functions/function_math_unary_to_null_type.h @@ -100,8 +100,6 @@ private: return true; } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { const ColumnWithTypeAndName& col = block.get_by_position(arguments[0]); diff --git a/be/src/vec/functions/function_multi_same_args.h b/be/src/vec/functions/function_multi_same_args.h index 95ecd1d034..3da03beffd 100644 --- a/be/src/vec/functions/function_multi_same_args.h +++ b/be/src/vec/functions/function_multi_same_args.h @@ -35,8 +35,6 @@ public: String get_name() const override { return name; } - bool use_default_implementation_for_constants() const override { return true; } - bool use_default_implementation_for_nulls() const override { return true; } bool is_variadic() const override { return true; } diff --git a/be/src/vec/functions/function_nonnullable.cpp b/be/src/vec/functions/function_nonnullable.cpp index ebebbcf36b..22d9c688b4 100644 --- a/be/src/vec/functions/function_nonnullable.cpp +++ b/be/src/vec/functions/function_nonnullable.cpp @@ -54,7 +54,6 @@ public: return remove_nullable(arguments[0]); } - bool use_default_implementation_for_constants() const override { return true; } bool use_default_implementation_for_nulls() const override { return false; } // trans nullable column to non-nullable column. If argument is already non-nullable, raise error. diff --git a/be/src/vec/functions/function_quantile_state.cpp b/be/src/vec/functions/function_quantile_state.cpp index 7ab9c908d6..dc31f9227c 100644 --- a/be/src/vec/functions/function_quantile_state.cpp +++ b/be/src/vec/functions/function_quantile_state.cpp @@ -91,8 +91,6 @@ public: bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } - template Status execute_internal(const ColumnPtr& column, const DataTypePtr& data_type, MutableColumnPtr& column_result) { @@ -248,8 +246,6 @@ public: bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { auto res_data_column = ColumnFloat64::create(); diff --git a/be/src/vec/functions/function_regexp.cpp b/be/src/vec/functions/function_regexp.cpp index 730761594a..50f845acc3 100644 --- a/be/src/vec/functions/function_regexp.cpp +++ b/be/src/vec/functions/function_regexp.cpp @@ -380,8 +380,6 @@ public: String get_name() const override { return name; } - bool use_default_implementation_for_constants() const override { return false; } - bool use_default_implementation_for_nulls() const override { return false; } size_t get_number_of_arguments() const override { diff --git a/be/src/vec/functions/function_reverse.h b/be/src/vec/functions/function_reverse.h index 98bfb41d3a..074fa59880 100644 --- a/be/src/vec/functions/function_reverse.h +++ b/be/src/vec/functions/function_reverse.h @@ -33,8 +33,6 @@ public: bool get_is_injective(const Block&) override { return false; } - bool use_default_implementation_for_constants() const override { return true; } - DataTypePtr get_return_type_impl(const DataTypes& arguments) const override { DCHECK(is_string_or_fixed_string(arguments[0]) || is_array(arguments[0])) << fmt::format("Illegal type {} used for argument of function {}", diff --git a/be/src/vec/functions/function_rpc.h b/be/src/vec/functions/function_rpc.h index ec7d97677a..5623183470 100644 --- a/be/src/vec/functions/function_rpc.h +++ b/be/src/vec/functions/function_rpc.h @@ -101,6 +101,8 @@ public: bool is_deterministic_in_scope_of_query() const override { return false; } + bool is_use_default_implementation_for_constants() const override { return true; } + private: DataTypes _argument_types; DataTypePtr _return_type; diff --git a/be/src/vec/functions/function_running_difference.h b/be/src/vec/functions/function_running_difference.h index ba38f66fd0..248c29a9a5 100644 --- a/be/src/vec/functions/function_running_difference.h +++ b/be/src/vec/functions/function_running_difference.h @@ -60,8 +60,6 @@ public: bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } - template using DstFieldType = typename NumberTraits::ResultOfSubtraction::Type; diff --git a/be/src/vec/functions/function_string.cpp b/be/src/vec/functions/function_string.cpp index 6c278125ae..670644bba4 100644 --- a/be/src/vec/functions/function_string.cpp +++ b/be/src/vec/functions/function_string.cpp @@ -552,8 +552,6 @@ public: // The second parameter of "trim" is a constant. ColumnNumbers get_arguments_that_are_always_constant() const override { return {1}; } - bool use_default_implementation_for_constants() const override { return true; } - DataTypes get_variadic_argument_types_impl() const override { return impl::get_variadic_argument_types(); } diff --git a/be/src/vec/functions/function_string.h b/be/src/vec/functions/function_string.h index cdcbd2515a..9e41a98adc 100644 --- a/be/src/vec/functions/function_string.h +++ b/be/src/vec/functions/function_string.h @@ -313,7 +313,6 @@ public: } bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { @@ -392,7 +391,6 @@ public: bool is_variadic() const override { return true; } bool use_default_implementation_for_nulls() const override { return true; } - bool use_default_implementation_for_constants() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { @@ -486,7 +484,6 @@ public: bool is_variadic() const override { return true; } bool use_default_implementation_for_nulls() const override { return true; } - bool use_default_implementation_for_constants() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { @@ -562,7 +559,6 @@ public: } bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { @@ -590,7 +586,6 @@ public: } bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { @@ -684,7 +679,6 @@ public: } bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { @@ -705,7 +699,6 @@ public: } bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { @@ -726,7 +719,6 @@ public: return std::make_shared(); } bool use_default_implementation_for_nulls() const override { return true; } - bool use_default_implementation_for_constants() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { @@ -812,7 +804,6 @@ public: return make_nullable(std::make_shared()); } bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { @@ -934,7 +925,6 @@ public: } } bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { @@ -1133,7 +1123,6 @@ public: DataTypePtr get_return_type_impl(const DataTypes& arguments) const override { return make_nullable(std::make_shared()); } - bool use_default_implementation_for_constants() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { DCHECK_EQ(arguments.size(), 2); @@ -1244,7 +1233,6 @@ public: return make_nullable(std::make_shared()); } bool use_default_implementation_for_nulls() const override { return true; } - bool use_default_implementation_for_constants() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { @@ -1388,7 +1376,6 @@ public: } bool use_default_implementation_for_nulls() const override { return true; } - bool use_default_implementation_for_constants() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { @@ -1561,6 +1548,7 @@ public: } bool use_default_implementation_for_nulls() const override { return true; } + bool use_default_implementation_for_constants() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, @@ -2008,8 +1996,6 @@ public: return std::make_shared(); } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { auto col_url = @@ -2149,8 +2135,6 @@ public: } size_t get_number_of_arguments() const override { return 1; } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { auto res_column = ColumnString::create(); @@ -2347,8 +2331,6 @@ public: bool is_variadic() const override { return true; } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { DCHECK_EQ(arguments.size(), 3); @@ -2491,8 +2473,6 @@ public: std::make_shared()}; } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { auto col_origin = @@ -2580,8 +2560,6 @@ public: bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { return Impl::execute_impl(context, block, arguments, result, input_rows_count); @@ -2704,8 +2682,6 @@ public: return std::make_shared(); } - bool use_default_implementation_for_constants() const override { return true; } - Status open(FunctionContext* context, FunctionContext::FunctionStateScope scope) override { if (scope != FunctionContext::THREAD_LOCAL) { return Status::OK(); @@ -2913,7 +2889,6 @@ public: return make_nullable(std::make_shared()); } bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { diff --git a/be/src/vec/functions/function_string_to_string.h b/be/src/vec/functions/function_string_to_string.h index 15435a5192..742e1687f3 100644 --- a/be/src/vec/functions/function_string_to_string.h +++ b/be/src/vec/functions/function_string_to_string.h @@ -53,8 +53,6 @@ public: return arguments[0]; } - bool use_default_implementation_for_constants() const override { return true; } - DataTypes get_variadic_argument_types_impl() const override { if constexpr (has_variadic_argument) return Impl::get_variadic_argument_types(); return {}; diff --git a/be/src/vec/functions/function_timestamp.cpp b/be/src/vec/functions/function_timestamp.cpp index 03a15779bf..64bc8d4e1f 100644 --- a/be/src/vec/functions/function_timestamp.cpp +++ b/be/src/vec/functions/function_timestamp.cpp @@ -463,8 +463,6 @@ public: String get_name() const override { return name; } - bool use_default_implementation_for_constants() const override { return true; } - size_t get_number_of_arguments() const override { return 1; } bool use_default_implementation_for_nulls() const override { return true; } @@ -776,8 +774,6 @@ public: bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } - size_t get_number_of_arguments() const override { return 1; } bool is_variadic() const override { return true; } @@ -1180,7 +1176,6 @@ public: return Impl::get_return_type_impl(arguments); } - bool use_default_implementation_for_constants() const override { return true; } //TODO: add function below when we fixed be-ut. //ColumnNumbers get_arguments_that_are_always_constant() const override { return {1}; } diff --git a/be/src/vec/functions/function_totype.h b/be/src/vec/functions/function_totype.h index 2ead9ab704..3c2eb8f9d4 100644 --- a/be/src/vec/functions/function_totype.h +++ b/be/src/vec/functions/function_totype.h @@ -51,8 +51,6 @@ public: return std::make_shared(); } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { return execute_impl(block, arguments, result, input_rows_count); @@ -142,8 +140,6 @@ public: return std::make_shared(); } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t /*input_rows_count*/) override { DCHECK_EQ(arguments.size(), 2); @@ -219,8 +215,6 @@ public: bool is_variadic() const override { return true; } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t /*input_rows_count*/) override { const auto& left = block.get_by_position(arguments[0]); @@ -318,8 +312,6 @@ public: return make_nullable(std::make_shared()); } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { auto null_map = ColumnUInt8::create(input_rows_count, 0); @@ -393,7 +385,6 @@ public: DataTypePtr get_return_type_impl(const DataTypes& arguments) const override { return make_nullable(std::make_shared()); } - bool use_default_implementation_for_constants() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { auto null_map = ColumnUInt8::create(input_rows_count, 0); @@ -465,8 +456,6 @@ public: return make_nullable(std::make_shared()); } - bool use_default_implementation_for_constants() const override { return true; } - bool use_default_implementation_for_nulls() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, diff --git a/be/src/vec/functions/function_unary_arithmetic.h b/be/src/vec/functions/function_unary_arithmetic.h index 8113f42179..7081298de5 100644 --- a/be/src/vec/functions/function_unary_arithmetic.h +++ b/be/src/vec/functions/function_unary_arithmetic.h @@ -85,8 +85,6 @@ public: size_t get_number_of_arguments() const override { return 1; } bool get_is_injective(const Block&) override { return is_injective; } - bool use_default_implementation_for_constants() const override { return true; } - DataTypePtr get_return_type_impl(const DataTypes& arguments) const override { DataTypePtr result; bool valid = cast_type(arguments[0].get(), [&](const auto& type) { diff --git a/be/src/vec/functions/function_utility.cpp b/be/src/vec/functions/function_utility.cpp index f6c22e5f2e..9637c7a21a 100644 --- a/be/src/vec/functions/function_utility.cpp +++ b/be/src/vec/functions/function_utility.cpp @@ -68,7 +68,6 @@ public: return std::make_shared(); } - bool use_default_implementation_for_constants() const override { return true; } bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, diff --git a/be/src/vec/functions/function_variadic_arguments.h b/be/src/vec/functions/function_variadic_arguments.h index 2d0294297c..0ba9bf81b3 100644 --- a/be/src/vec/functions/function_variadic_arguments.h +++ b/be/src/vec/functions/function_variadic_arguments.h @@ -37,7 +37,6 @@ public: static FunctionPtr create() { return std::make_shared(); } bool is_variadic() const override { return true; } size_t get_number_of_arguments() const override { return 0; } - bool use_default_implementation_for_constants() const override { return true; } DataTypePtr get_return_type_impl(const ColumnsWithTypeAndName& arguments) const override { DataTypePtr res; diff --git a/be/src/vec/functions/functions_geo.h b/be/src/vec/functions/functions_geo.h index 6f5158968d..48a048e534 100644 --- a/be/src/vec/functions/functions_geo.h +++ b/be/src/vec/functions/functions_geo.h @@ -69,7 +69,6 @@ public: return make_nullable(std::make_shared()); } bool use_default_implementation_for_nulls() const override { return true; } - bool use_default_implementation_for_constants() const override { return true; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override { diff --git a/be/src/vec/functions/functions_logical.h b/be/src/vec/functions/functions_logical.h index e3c68183d3..2b0ffb29bf 100644 --- a/be/src/vec/functions/functions_logical.h +++ b/be/src/vec/functions/functions_logical.h @@ -115,7 +115,6 @@ public: bool use_default_implementation_for_nulls() const override { return !Impl::special_implementation_for_nulls(); } - bool use_default_implementation_for_constants() const override { return true; } /// Get result types by argument types. If the function does not apply to these arguments, throw an exception. DataTypePtr get_return_type_impl(const DataTypes& arguments) const override; @@ -130,15 +129,12 @@ public: static constexpr auto name = Name::name; static FunctionPtr create() { return std::make_shared(); } -public: String get_name() const override { return name; } size_t get_number_of_arguments() const override { return 1; } DataTypePtr get_return_type_impl(const DataTypes& arguments) const override; - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) override; }; diff --git a/be/src/vec/functions/functions_multi_string_position.cpp b/be/src/vec/functions/functions_multi_string_position.cpp index 3db079efad..f323032563 100644 --- a/be/src/vec/functions/functions_multi_string_position.cpp +++ b/be/src/vec/functions/functions_multi_string_position.cpp @@ -71,8 +71,6 @@ public: size_t get_number_of_arguments() const override { return 2; } - bool use_default_implementation_for_constants() const override { return true; } - bool use_default_implementation_for_nulls() const override { return false; } DataTypePtr get_return_type_impl(const DataTypes& arguments) const override { diff --git a/be/src/vec/functions/functions_multi_string_search.cpp b/be/src/vec/functions/functions_multi_string_search.cpp index 0791a96125..bc7b68dea5 100644 --- a/be/src/vec/functions/functions_multi_string_search.cpp +++ b/be/src/vec/functions/functions_multi_string_search.cpp @@ -69,8 +69,6 @@ public: size_t get_number_of_arguments() const override { return 2; } - bool use_default_implementation_for_constants() const override { return true; } - bool use_default_implementation_for_nulls() const override { return false; } DataTypePtr get_return_type_impl(const DataTypes& arguments) const override { diff --git a/be/src/vec/functions/hll_cardinality.cpp b/be/src/vec/functions/hll_cardinality.cpp index bd2a8a1363..5bd5a5e422 100644 --- a/be/src/vec/functions/hll_cardinality.cpp +++ b/be/src/vec/functions/hll_cardinality.cpp @@ -92,7 +92,6 @@ public: return std::make_shared(); } - bool use_default_implementation_for_constants() const override { return true; } bool use_default_implementation_for_nulls() const override { return false; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, diff --git a/be/src/vec/functions/in.h b/be/src/vec/functions/in.h index 3cd0884605..ea20f6bd62 100644 --- a/be/src/vec/functions/in.h +++ b/be/src/vec/functions/in.h @@ -96,12 +96,13 @@ public: std::shared_ptr state = std::make_shared(); context->set_function_state(scope, state); DCHECK(context->get_num_args() >= 1); - if (context->get_arg_type(0)->type == doris::PrimitiveType::TYPE_CHAR || - context->get_arg_type(0)->type == doris::PrimitiveType::TYPE_VARCHAR || - context->get_arg_type(0)->type == doris::PrimitiveType::TYPE_STRING) { + if (context->get_arg_type(0)->type == PrimitiveType::TYPE_NULL) { + state->hybrid_set.reset(create_set(TYPE_BOOLEAN, 0)); + } else if (context->get_arg_type(0)->type == PrimitiveType::TYPE_CHAR || + context->get_arg_type(0)->type == PrimitiveType::TYPE_VARCHAR || + context->get_arg_type(0)->type == PrimitiveType::TYPE_STRING) { // the StringValue's memory is held by FunctionContext, so we can use StringValueSet here directly state->hybrid_set.reset(create_string_value_set((size_t)(context->get_num_args() - 1))); - } else { state->hybrid_set.reset(create_set(context->get_arg_type(0)->type, (size_t)(context->get_num_args() - 1))); @@ -140,7 +141,6 @@ public: col_null_map_to = ColumnUInt8::create(input_rows_count, false); auto& vec_null_map_to = col_null_map_to->get_data(); - /// First argument may be a single column. const ColumnWithTypeAndName& left_arg = block.get_by_position(arguments[0]); const auto& [materialized_column, col_const] = unpack_if_const(left_arg.column); @@ -148,14 +148,14 @@ public: if (materialized_column->is_nullable()) { auto* null_col_ptr = vectorized::check_and_get_column( materialized_column); - auto& null_map = reinterpret_cast( + auto& null_map = assert_cast( null_col_ptr->get_null_map_column()) .get_data(); auto* nested_col_ptr = null_col_ptr->get_nested_column_ptr().get(); if (nested_col_ptr->is_column_string()) { const auto* column_string_ptr = - reinterpret_cast(nested_col_ptr); + assert_cast(nested_col_ptr); search_hash_set_check_null(in_state, input_rows_count, vec_res, null_map, column_string_ptr); } else { @@ -177,8 +177,7 @@ public: } else { // non-nullable if (materialized_column->is_column_string()) { const auto* column_string_ptr = - reinterpret_cast( - materialized_column.get()); + assert_cast(materialized_column.get()); search_hash_set(in_state, input_rows_count, vec_res, column_string_ptr); } else { search_hash_set(in_state, input_rows_count, vec_res, materialized_column.get()); diff --git a/be/src/vec/functions/is_not_null.cpp b/be/src/vec/functions/is_not_null.cpp index fecfeb0e80..3cb2c688ce 100644 --- a/be/src/vec/functions/is_not_null.cpp +++ b/be/src/vec/functions/is_not_null.cpp @@ -59,7 +59,6 @@ public: size_t get_number_of_arguments() const override { return 1; } bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } ColumnNumbers get_arguments_that_dont_imply_nullable_return_type( size_t /*number_of_arguments*/) const override { return {0}; diff --git a/be/src/vec/functions/is_null.cpp b/be/src/vec/functions/is_null.cpp index 37c8da647d..104e1c3c7d 100644 --- a/be/src/vec/functions/is_null.cpp +++ b/be/src/vec/functions/is_null.cpp @@ -55,7 +55,6 @@ public: size_t get_number_of_arguments() const override { return 1; } bool use_default_implementation_for_nulls() const override { return false; } - bool use_default_implementation_for_constants() const override { return true; } ColumnNumbers get_arguments_that_dont_imply_nullable_return_type( size_t /*number_of_arguments*/) const override { return {0}; diff --git a/be/src/vec/functions/like.h b/be/src/vec/functions/like.h index 7480d52989..8c22eb1f06 100644 --- a/be/src/vec/functions/like.h +++ b/be/src/vec/functions/like.h @@ -138,8 +138,6 @@ public: return std::make_shared(); } - bool use_default_implementation_for_constants() const override { return true; } - Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t /*input_rows_count*/) override; diff --git a/be/src/vec/functions/nullif.cpp b/be/src/vec/functions/nullif.cpp index 65f9922cad..cc13a84815 100644 --- a/be/src/vec/functions/nullif.cpp +++ b/be/src/vec/functions/nullif.cpp @@ -63,8 +63,6 @@ public: size_t get_number_of_arguments() const override { return 2; } - bool use_default_implementation_for_constants() const override { return false; } - bool use_default_implementation_for_nulls() const override { return false; } DataTypePtr get_return_type_impl(const DataTypes& arguments) const override { diff --git a/be/src/vec/functions/round.h b/be/src/vec/functions/round.h index 8645963ec6..15565c87c7 100644 --- a/be/src/vec/functions/round.h +++ b/be/src/vec/functions/round.h @@ -22,6 +22,7 @@ #include "vec/columns/column_const.h" #include "vec/columns/columns_number.h" +#include "vec/functions/function.h" #if defined(__SSE4_1__) || defined(__aarch64__) #include "util/sse_util.hpp" #else @@ -518,7 +519,6 @@ public: return Status::OK(); } - bool use_default_implementation_for_constants() const override { return true; } ColumnNumbers get_arguments_that_are_always_constant() const override { return {1}; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, diff --git a/be/src/vec/utils/util.hpp b/be/src/vec/utils/util.hpp index 91e7de7afa..6530a66212 100644 --- a/be/src/vec/utils/util.hpp +++ b/be/src/vec/utils/util.hpp @@ -120,6 +120,15 @@ public: return left_child != nullptr ? left_child : right_child; } } + + static bool all_arguments_are_constant(const Block& block, const ColumnNumbers& args) { + for (const auto& arg : args) { + if (!is_column_const(*block.get_by_position(arg).column)) { + return false; + } + } + return true; + } }; } // namespace doris::vectorized diff --git a/regression-test/data/query_p0/sql_functions/test_in_expr.out b/regression-test/data/query_p0/sql_functions/test_in_expr.out index c7f58848a5..6cb6bd195f 100644 --- a/regression-test/data/query_p0/sql_functions/test_in_expr.out +++ b/regression-test/data/query_p0/sql_functions/test_in_expr.out @@ -63,3 +63,13 @@ d 3 4 +-- !select -- +\N +\N +\N +\N +\N +\N + +-- !select -- + diff --git a/regression-test/suites/query_p0/sql_functions/test_in_expr.groovy b/regression-test/suites/query_p0/sql_functions/test_in_expr.groovy index a7a324f631..4d37566020 100644 --- a/regression-test/suites/query_p0/sql_functions/test_in_expr.groovy +++ b/regression-test/suites/query_p0/sql_functions/test_in_expr.groovy @@ -124,4 +124,10 @@ suite("test_in_expr", "query") { qt_select "select t11.c0 from t11 group by t11.c0 having not ('1' in (t11.c0)) order by t11.c0;" qt_select "select t11.c0 from t11 group by t11.c0 having ('1' not in (t11.c0)) order by t11.c0;" + + qt_select "SELECT (abs(1)=1) IN (null) FROM t11;" + + qt_select """ + SELECT CASE (TIMESTAMP '1970-12-04 03:51:34' NOT BETWEEN TIMESTAMP '1970-11-11 16:41:26' AND TIMESTAMP 'CURRENT_TIMESTAMP') WHEN (0.7532032132148743 BETWEEN 0.7817240953445435 AND CAST('.' AS FLOAT) ) THEN (- (- 2093562249)) WHEN CAST((true IN (false)) AS BOOLEAN) THEN (+ 1351956476) END FROM t11 WHERE (NULL IN (CASE CAST('-658171195' AS BOOLEAN) WHEN ((TIMESTAMP '1970-02-25 22:11:59') IS NOT NULL) THEN NULL WHEN ((true) IS NULL) THEN NULL END )) GROUP BY t11.c0 ORDER BY 1; + """ }