From 02a27a587ac681be4f21b9c65b5ebf90f9af4f52 Mon Sep 17 00:00:00 2001 From: Pxl Date: Tue, 23 Jan 2024 17:17:39 +0800 Subject: [PATCH] remove some unused member function of IFunctionBase (#30260) --- be/src/vec/functions/function.h | 113 ------------------ be/src/vec/functions/function_bit.cpp | 2 +- be/src/vec/functions/function_bit_count.cpp | 2 +- be/src/vec/functions/function_cast.h | 4 - be/src/vec/functions/function_java_udf.h | 13 +- be/src/vec/functions/function_reverse.h | 2 - be/src/vec/functions/function_rpc.h | 4 - be/src/vec/functions/function_string.cpp | 2 - .../vec/functions/function_string_to_string.h | 10 +- .../vec/functions/function_unary_arithmetic.h | 3 +- be/src/vec/functions/if.cpp | 5 - be/src/vec/functions/is_not_null.cpp | 5 - be/src/vec/functions/is_null.cpp | 4 - be/src/vec/functions/math.cpp | 12 +- be/test/vec/core/block_spill_test.cpp | 6 +- be/test/vec/core/block_test.cpp | 2 +- be/test/vec/jsonb/serialize_test.cpp | 2 +- 17 files changed, 25 insertions(+), 166 deletions(-) diff --git a/be/src/vec/functions/function.h b/be/src/vec/functions/function.h index 0ca2899d74..73f49a237a 100644 --- a/be/src/vec/functions/function.h +++ b/be/src/vec/functions/function.h @@ -185,61 +185,8 @@ public: return Status::OK(); } - virtual bool is_stateful() const { return false; } - virtual bool can_fast_execute() const { return false; } - /** Should we evaluate this function while constant folding, if arguments are constants? - * Usually this is true. Notable counterexample is function 'sleep'. - * If we will call it during query analysis, we will sleep extra amount of time. - */ - virtual bool is_suitable_for_constant_folding() const { return true; } - - /** Some functions like ignore(...) or toTypeName(...) always return constant result which doesn't depend on arguments. - * In this case we can calculate result and assume that it's constant in stream header. - * There is no need to implement function if it has zero arguments. - * Must return ColumnConst with single row or nullptr. - */ - virtual ColumnPtr get_result_if_always_returns_constant_and_has_arguments( - const Block& /*block*/, const ColumnNumbers& /*arguments*/) const { - return nullptr; - } - - /** Function is called "injective" if it returns different result for different values of arguments. - * Example: hex, negate, tuple... - * - * Function could be injective with some arguments fixed to some constant values. - * Examples: - * plus(const, x); - * multiply(const, x) where x is an integer and constant is not divisible by two; - * concat(x, 'const'); - * concat(x, 'const', y) where const contain at least one non-numeric character; - * concat with FixedString - * dictGet... functions takes name of dictionary as its argument, - * and some dictionaries could be explicitly defined as injective. - * - * It could be used, for example, to remove useless function applications from GROUP BY. - * - * Sometimes, function is not really injective, but considered as injective, for purpose of query optimization. - * For example, to_string function is not injective for Float64 data type, - * as it returns 'nan' for many different representation of NaNs. - * But we assume, that it is injective. This could be documented as implementation-specific behaviour. - * - * sample_block should contain data types of arguments and values of constants, if relevant. - */ - virtual bool get_is_injective(const Block& /*sample_block*/) { return false; } - - /** Function is called "deterministic", if it returns same result for same values of arguments. - * Most of functions are deterministic. Notable counterexample is rand(). - * Sometimes, functions are "deterministic" in scope of single query - * (even for distributed query), but not deterministic it general. - * Example: now(). Another example: functions that work with periodically updated dictionaries. - */ - - virtual bool is_deterministic() const = 0; - - virtual bool is_deterministic_in_scope_of_query() const = 0; - virtual bool is_use_default_implementation_for_constants() const = 0; /// The property of monotonicity for a certain range. @@ -279,14 +226,6 @@ public: /// Get the main function name. virtual String get_name() const = 0; - /// See the comment for the same method in IFunctionBase - virtual bool is_deterministic() const = 0; - - virtual bool is_deterministic_in_scope_of_query() const = 0; - - /// Override and return true if function needs to depend on the state of the data. - virtual bool is_stateful() const = 0; - /// Override and return true if function could take different number of arguments. virtual bool is_variadic() const = 0; @@ -307,10 +246,6 @@ public: /// Returns indexes of arguments, that must be ColumnConst virtual ColumnNumbers get_arguments_that_are_always_constant() const = 0; - /// Returns indexes if arguments, that can be Nullable without making result of function Nullable - /// (for functions like is_null(x)) - virtual ColumnNumbers get_arguments_that_dont_imply_nullable_return_type( - size_t number_of_arguments) const = 0; }; using FunctionBuilderPtr = std::shared_ptr; @@ -351,9 +286,6 @@ public: return build_impl(arguments, return_type); } - bool is_deterministic() const override { return true; } - bool is_deterministic_in_scope_of_query() const override { return true; } - bool is_stateful() const override { return false; } bool is_variadic() const override { return false; } /// Default implementation. Will check only in non-variadic case. @@ -366,10 +298,6 @@ public: } ColumnNumbers get_arguments_that_are_always_constant() const override { return {}; } - ColumnNumbers get_arguments_that_dont_imply_nullable_return_type( - size_t /*number_of_arguments*/) const override { - return {}; - } protected: /// Get the result type by argument type. If the function does not apply to these arguments, throw an exception. @@ -403,9 +331,6 @@ protected: */ virtual bool use_default_implementation_for_low_cardinality_columns() const { return true; } - /// If it isn't, will convert all ColumnLowCardinality arguments to full columns. - virtual bool can_be_executed_on_low_cardinality_dictionary() const { return true; } - /// return a real function object to execute. called in build(...). virtual FunctionBasePtr build_impl(const ColumnsWithTypeAndName& arguments, const DataTypePtr& return_type) const = 0; @@ -430,8 +355,6 @@ class IFunction : public std::enable_shared_from_this, public: String get_name() const override = 0; - bool is_stateful() const override { return false; } - virtual Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) const override = 0; @@ -445,11 +368,6 @@ public: /// all constancy check should use this function to do automatically ColumnNumbers get_arguments_that_are_always_constant() const override { return {}; } - bool can_be_executed_on_low_cardinality_dictionary() const override { - return is_deterministic_in_scope_of_query(); - } - 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(); @@ -562,30 +480,12 @@ public: return function->close(context, scope); } - bool is_suitable_for_constant_folding() const override { - return function->is_suitable_for_constant_folding(); - } - ColumnPtr get_result_if_always_returns_constant_and_has_arguments( - const Block& block, const ColumnNumbers& arguments_) const override { - return function->get_result_if_always_returns_constant_and_has_arguments(block, arguments_); - } - - bool get_is_injective(const Block& sample_block) override { - return function->get_is_injective(sample_block); - } - - bool is_deterministic() const override { return function->is_deterministic(); } - bool can_fast_execute() const override { auto function_name = function->get_name(); return function_name == "eq" || function_name == "ne" || function_name == "lt" || function_name == "gt" || function_name == "le" || function_name == "ge"; } - bool is_deterministic_in_scope_of_query() const override { - return function->is_deterministic_in_scope_of_query(); - } - IFunctionBase::Monotonicity get_monotonicity_for_range(const IDataType& type, const Field& left, const Field& right) const override { return function->get_monotonicity_for_range(type, left, right); @@ -610,23 +510,13 @@ public: return function->check_number_of_arguments(number_of_arguments); } - bool is_deterministic() const override { return function->is_deterministic(); } - bool is_deterministic_in_scope_of_query() const override { - return function->is_deterministic_in_scope_of_query(); - } - String get_name() const override { return function->get_name(); } - bool is_stateful() const override { return function->is_stateful(); } bool is_variadic() const override { return function->is_variadic(); } size_t get_number_of_arguments() const override { return function->get_number_of_arguments(); } ColumnNumbers get_arguments_that_are_always_constant() const override { return function->get_arguments_that_are_always_constant(); } - ColumnNumbers get_arguments_that_dont_imply_nullable_return_type( - size_t number_of_arguments) const override { - return function->get_arguments_that_dont_imply_nullable_return_type(number_of_arguments); - } protected: DataTypePtr get_return_type_impl(const DataTypes& arguments) const override { @@ -646,9 +536,6 @@ protected: bool use_default_implementation_for_low_cardinality_columns() const override { return function->use_default_implementation_for_low_cardinality_columns(); } - bool can_be_executed_on_low_cardinality_dictionary() const override { - return function->can_be_executed_on_low_cardinality_dictionary(); - } FunctionBasePtr build_impl(const ColumnsWithTypeAndName& arguments, const DataTypePtr& return_type) const override { diff --git a/be/src/vec/functions/function_bit.cpp b/be/src/vec/functions/function_bit.cpp index 3a56d5c0cd..b115b1ae28 100644 --- a/be/src/vec/functions/function_bit.cpp +++ b/be/src/vec/functions/function_bit.cpp @@ -111,7 +111,7 @@ struct BitLengthImpl { }; using FunctionBitAnd = FunctionBinaryArithmetic; -using FunctionBitNot = FunctionUnaryArithmetic; +using FunctionBitNot = FunctionUnaryArithmetic; using FunctionBitOr = FunctionBinaryArithmetic; using FunctionBitXor = FunctionBinaryArithmetic; using FunctionBitLength = FunctionUnaryToType; diff --git a/be/src/vec/functions/function_bit_count.cpp b/be/src/vec/functions/function_bit_count.cpp index 66ef9d4c4f..aafbf8c112 100644 --- a/be/src/vec/functions/function_bit_count.cpp +++ b/be/src/vec/functions/function_bit_count.cpp @@ -52,7 +52,7 @@ struct BitCountImpl { } }; -using FunctionBitCount = FunctionUnaryArithmetic; +using FunctionBitCount = FunctionUnaryArithmetic; void register_function_bit_count(SimpleFunctionFactory& factory) { factory.register_function(); diff --git a/be/src/vec/functions/function_cast.h b/be/src/vec/functions/function_cast.h index 953d3054c6..79762af86c 100644 --- a/be/src/vec/functions/function_cast.h +++ b/be/src/vec/functions/function_cast.h @@ -1240,7 +1240,6 @@ public: bool is_variadic() const override { return true; } size_t get_number_of_arguments() const override { return 0; } - bool get_is_injective(const Block&) override { return std::is_same_v; } // This function should not be called for get DateType Ptr // using the FunctionCast::get_return_type_impl @@ -1699,9 +1698,6 @@ public: String get_name() const override { return name; } - bool is_deterministic() const override { return true; } - bool is_deterministic_in_scope_of_query() const override { return true; } - Monotonicity get_monotonicity_for_range(const IDataType& type, const Field& left, const Field& right) const override { return monotonicity_for_range(type, left, right); diff --git a/be/src/vec/functions/function_java_udf.h b/be/src/vec/functions/function_java_udf.h index bb493aa7ed..f930346a72 100644 --- a/be/src/vec/functions/function_java_udf.h +++ b/be/src/vec/functions/function_java_udf.h @@ -89,9 +89,12 @@ public: PreparedFunctionPtr prepare(FunctionContext* context, const Block& sample_block, const ColumnNumbers& arguments, size_t result) const override { return std::make_shared( - std::bind(&JavaFunctionCall::execute_impl, this, std::placeholders::_1, - std::placeholders::_2, std::placeholders::_3, - std::placeholders::_4, std::placeholders::_5), + [this](auto&& PH1, auto&& PH2, auto&& PH3, auto&& PH4, auto&& PH5) { + return JavaFunctionCall::execute_impl( + std::forward(PH1), std::forward(PH2), + std::forward(PH3), std::forward(PH4), + std::forward(PH5)); + }, fn_.name.function_name); } @@ -102,10 +105,6 @@ public: Status close(FunctionContext* context, FunctionContext::FunctionStateScope scope) override; - bool is_deterministic() const override { return false; } - - bool is_deterministic_in_scope_of_query() const override { return false; } - bool is_use_default_implementation_for_constants() const override { return true; } private: diff --git a/be/src/vec/functions/function_reverse.h b/be/src/vec/functions/function_reverse.h index 232a5fa360..9a50c011b9 100644 --- a/be/src/vec/functions/function_reverse.h +++ b/be/src/vec/functions/function_reverse.h @@ -31,8 +31,6 @@ public: size_t get_number_of_arguments() const override { return 1; } - bool get_is_injective(const Block&) override { return false; } - 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 eda4f6b00b..fa23e5b97c 100644 --- a/be/src/vec/functions/function_rpc.h +++ b/be/src/vec/functions/function_rpc.h @@ -97,10 +97,6 @@ public: Status execute(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count, bool dry_run = false) const override; - bool is_deterministic() const override { return false; } - - bool is_deterministic_in_scope_of_query() const override { return false; } - bool is_use_default_implementation_for_constants() const override { return true; } private: diff --git a/be/src/vec/functions/function_string.cpp b/be/src/vec/functions/function_string.cpp index e056f68b1f..ae12123a39 100644 --- a/be/src/vec/functions/function_string.cpp +++ b/be/src/vec/functions/function_string.cpp @@ -561,8 +561,6 @@ public: return get_variadic_argument_types_impl().size(); } - bool get_is_injective(const Block&) override { return false; } - DataTypePtr get_return_type_impl(const DataTypes& arguments) const override { if (!is_string_or_fixed_string(arguments[0])) { LOG(FATAL) << fmt::format("Illegal type {} of argument of function {}", diff --git a/be/src/vec/functions/function_string_to_string.h b/be/src/vec/functions/function_string_to_string.h index 13dce2ba6f..fdc413e20c 100644 --- a/be/src/vec/functions/function_string_to_string.h +++ b/be/src/vec/functions/function_string_to_string.h @@ -29,7 +29,7 @@ namespace doris::vectorized { -template +template class FunctionStringToString : public IFunction { public: static constexpr auto name = Name::name; @@ -42,8 +42,6 @@ public: size_t get_number_of_arguments() const override { return 1; } - bool get_is_injective(const Block&) override { return is_injective; } - DataTypePtr get_return_type_impl(const DataTypes& arguments) const override { if (!is_string_or_fixed_string(arguments[0])) { LOG(FATAL) << fmt::format("Illegal type {} of argument of function {}", @@ -54,14 +52,16 @@ public: } DataTypes get_variadic_argument_types_impl() const override { - if constexpr (has_variadic_argument) return Impl::get_variadic_argument_types(); + if constexpr (has_variadic_argument) { + return Impl::get_variadic_argument_types(); + } return {}; } Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) const override { const ColumnPtr column = block.get_by_position(arguments[0]).column; - if (const ColumnString* col = check_and_get_column(column.get())) { + if (const auto* col = check_and_get_column(column.get())) { auto col_res = ColumnString::create(); static_cast(Impl::vector(col->get_chars(), col->get_offsets(), col_res->get_chars(), col_res->get_offsets())); diff --git a/be/src/vec/functions/function_unary_arithmetic.h b/be/src/vec/functions/function_unary_arithmetic.h index 723fccad97..7159067a31 100644 --- a/be/src/vec/functions/function_unary_arithmetic.h +++ b/be/src/vec/functions/function_unary_arithmetic.h @@ -60,7 +60,7 @@ struct PositiveImpl; /// Used to indicate undefined operation struct InvalidType; -template