This is an automated email from the ASF dual-hosted git repository. yiguolei pushed a commit to branch branch-2.1 in repository https://gitbox.apache.org/repos/asf/doris.git
commit 02a27a587ac681be4f21b9c65b5ebf90f9af4f52 Author: Pxl <[email protected]> AuthorDate: Tue Jan 23 17:17:39 2024 +0800 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 - be/src/vec/functions/function_string_to_string.h | 10 +- be/src/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 0ca2899d748..73f49a237ae 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<IFunctionBuilder>; @@ -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<IFunction>, 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 3a56d5c0cd3..b115b1ae286 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<BitAndImpl, NameBitAnd, false>; -using FunctionBitNot = FunctionUnaryArithmetic<BitNotImpl, NameBitNot, false>; +using FunctionBitNot = FunctionUnaryArithmetic<BitNotImpl, NameBitNot>; using FunctionBitOr = FunctionBinaryArithmetic<BitOrImpl, NameBitOr, false>; using FunctionBitXor = FunctionBinaryArithmetic<BitXorImpl, NameBitXor, false>; using FunctionBitLength = FunctionUnaryToType<BitLengthImpl, NameBitLength>; diff --git a/be/src/vec/functions/function_bit_count.cpp b/be/src/vec/functions/function_bit_count.cpp index 66ef9d4c4f7..aafbf8c1125 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<BitCountImpl, NameBitCount, false>; +using FunctionBitCount = FunctionUnaryArithmetic<BitCountImpl, NameBitCount>; void register_function_bit_count(SimpleFunctionFactory& factory) { factory.register_function<FunctionBitCount>(); diff --git a/be/src/vec/functions/function_cast.h b/be/src/vec/functions/function_cast.h index 953d3054c6b..79762af86ce 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<Name, NameToString>; } // 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 bb493aa7ed4..f930346a72d 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<JavaUdfPreparedFunction>( - std::bind<Status>(&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<decltype(PH1)>(PH1), std::forward<decltype(PH2)>(PH2), + std::forward<decltype(PH3)>(PH3), std::forward<decltype(PH4)>(PH4), + std::forward<decltype(PH5)>(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 232a5fa3603..9a50c011b91 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 eda4f6b00b1..fa23e5b97cb 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 e056f68b1fb..ae12123a398 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 13dce2ba6f5..fdc413e20cb 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 <typename Impl, typename Name, bool is_injective = false> +template <typename Impl, typename Name> 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<ColumnString>(column.get())) { + if (const auto* col = check_and_get_column<ColumnString>(column.get())) { auto col_res = ColumnString::create(); static_cast<void>(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 723fccad972..7159067a31c 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 <template <typename> class Op, typename Name, bool is_injective> +template <template <typename> class Op, typename Name> class FunctionUnaryArithmetic : public IFunction { static constexpr bool allow_decimal = std::is_same_v<Op<Int8>, NegativeImpl<Int8>> || std::is_same_v<Op<Int8>, AbsImpl<Int8>> || @@ -83,7 +83,6 @@ public: String get_name() const override { return name; } 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 { DataTypePtr result; diff --git a/be/src/vec/functions/if.cpp b/be/src/vec/functions/if.cpp index 0d433514a11..14233f29725 100644 --- a/be/src/vec/functions/if.cpp +++ b/be/src/vec/functions/if.cpp @@ -185,11 +185,6 @@ public: size_t get_number_of_arguments() const override { return 3; } bool use_default_implementation_for_nulls() const override { return false; } - ColumnNumbers get_arguments_that_dont_imply_nullable_return_type( - size_t /*number_of_arguments*/) const override { - return {0}; - } - DataTypePtr get_return_type_impl(const DataTypes& arguments) const override { // if return type is custom, one of nullable return type will be nullable bool nullable = arguments[1]->is_nullable() || arguments[2]->is_nullable(); diff --git a/be/src/vec/functions/is_not_null.cpp b/be/src/vec/functions/is_not_null.cpp index 11294a52085..fb67ae2f4bb 100644 --- a/be/src/vec/functions/is_not_null.cpp +++ b/be/src/vec/functions/is_not_null.cpp @@ -59,11 +59,6 @@ public: size_t get_number_of_arguments() const override { return 1; } bool use_default_implementation_for_nulls() const override { return false; } - ColumnNumbers get_arguments_that_dont_imply_nullable_return_type( - size_t /*number_of_arguments*/) const override { - return {0}; - } - DataTypePtr get_return_type_impl(const DataTypes&) const override { return std::make_shared<DataTypeUInt8>(); } diff --git a/be/src/vec/functions/is_null.cpp b/be/src/vec/functions/is_null.cpp index 5a2abba27c4..5061b0b76b6 100644 --- a/be/src/vec/functions/is_null.cpp +++ b/be/src/vec/functions/is_null.cpp @@ -55,10 +55,6 @@ public: size_t get_number_of_arguments() const override { return 1; } bool use_default_implementation_for_nulls() const override { return false; } - ColumnNumbers get_arguments_that_dont_imply_nullable_return_type( - size_t /*number_of_arguments*/) const override { - return {0}; - } DataTypePtr get_return_type_impl(const DataTypes&) const override { return std::make_shared<DataTypeUInt8>(); diff --git a/be/src/vec/functions/math.cpp b/be/src/vec/functions/math.cpp index 98cfc65e2f4..c3a5111ac57 100644 --- a/be/src/vec/functions/math.cpp +++ b/be/src/vec/functions/math.cpp @@ -153,7 +153,7 @@ struct SignImpl { struct NameSign { static constexpr auto name = "sign"; }; -using FunctionSign = FunctionUnaryArithmetic<SignImpl, NameSign, false>; +using FunctionSign = FunctionUnaryArithmetic<SignImpl, NameSign>; template <typename A> struct AbsImpl { @@ -176,7 +176,7 @@ struct NameAbs { static constexpr auto name = "abs"; }; -using FunctionAbs = FunctionUnaryArithmetic<AbsImpl, NameAbs, false>; +using FunctionAbs = FunctionUnaryArithmetic<AbsImpl, NameAbs>; template <typename A> struct NegativeImpl { @@ -189,7 +189,7 @@ struct NameNegative { static constexpr auto name = "negative"; }; -using FunctionNegative = FunctionUnaryArithmetic<NegativeImpl, NameNegative, false>; +using FunctionNegative = FunctionUnaryArithmetic<NegativeImpl, NameNegative>; template <typename A> struct PositiveImpl { @@ -202,7 +202,7 @@ struct NamePositive { static constexpr auto name = "positive"; }; -using FunctionPositive = FunctionUnaryArithmetic<PositiveImpl, NamePositive, false>; +using FunctionPositive = FunctionUnaryArithmetic<PositiveImpl, NamePositive>; struct SinName { static constexpr auto name = "sin"; @@ -237,7 +237,7 @@ struct NameRadians { static constexpr auto name = "radians"; }; -using FunctionRadians = FunctionUnaryArithmetic<RadiansImpl, NameRadians, false>; +using FunctionRadians = FunctionUnaryArithmetic<RadiansImpl, NameRadians>; template <typename A> struct DegreesImpl { @@ -252,7 +252,7 @@ struct NameDegrees { static constexpr auto name = "degrees"; }; -using FunctionDegrees = FunctionUnaryArithmetic<DegreesImpl, NameDegrees, false>; +using FunctionDegrees = FunctionUnaryArithmetic<DegreesImpl, NameDegrees>; struct NameBin { static constexpr auto name = "bin"; diff --git a/be/test/vec/core/block_spill_test.cpp b/be/test/vec/core/block_spill_test.cpp index 9f7868f9b3d..45156dee48c 100644 --- a/be/test/vec/core/block_spill_test.cpp +++ b/be/test/vec/core/block_spill_test.cpp @@ -454,7 +454,7 @@ TEST_F(TestBlockSpill, TestBitmap) { vectorized::DataTypePtr bitmap_data_type(std::make_shared<vectorized::DataTypeBitMap>()); auto bitmap_column = bitmap_data_type->create_column(); std::vector<BitmapValue>& container = - ((vectorized::ColumnComplexType<BitmapValue>*)bitmap_column.get())->get_data(); + ((vectorized::ColumnBitmap*)bitmap_column.get())->get_data(); std::vector<std::string> expected_bitmap_str; for (int i = 0; i < total_rows; ++i) { BitmapValue bv; @@ -487,7 +487,7 @@ TEST_F(TestBlockSpill, TestBitmap) { EXPECT_EQ(block_read.rows(), batch_size); auto column = block_read.get_by_position(0).column; - auto* real_column = (vectorized::ColumnComplexType<BitmapValue>*)column.get(); + auto* real_column = (vectorized::ColumnBitmap*)column.get(); for (size_t j = 0; j < batch_size; ++j) { auto bitmap_str = convert_bitmap_to_string(real_column->get_element(j)); EXPECT_EQ(bitmap_str, expected_bitmap_str[j + i * batch_size]); @@ -500,7 +500,7 @@ TEST_F(TestBlockSpill, TestBitmap) { EXPECT_EQ(block_read.rows(), 1); auto column = block_read.get_by_position(0).column; - auto* real_column = (vectorized::ColumnComplexType<BitmapValue>*)column.get(); + auto* real_column = (vectorized::ColumnBitmap*)column.get(); auto bitmap_str = convert_bitmap_to_string(real_column->get_element(0)); EXPECT_EQ(bitmap_str, expected_bitmap_str[3 * batch_size]); } diff --git a/be/test/vec/core/block_test.cpp b/be/test/vec/core/block_test.cpp index 7e8a26ce438..4b2ae60fdf7 100644 --- a/be/test/vec/core/block_test.cpp +++ b/be/test/vec/core/block_test.cpp @@ -187,7 +187,7 @@ void serialize_and_deserialize_test(segment_v2::CompressionTypePB compression_ty vectorized::DataTypePtr bitmap_data_type(std::make_shared<vectorized::DataTypeBitMap>()); auto bitmap_column = bitmap_data_type->create_column(); std::vector<BitmapValue>& container = - ((vectorized::ColumnComplexType<BitmapValue>*)bitmap_column.get())->get_data(); + ((vectorized::ColumnBitmap*)bitmap_column.get())->get_data(); for (int i = 0; i < 1024; ++i) { BitmapValue bv; for (int j = 0; j <= i; ++j) { diff --git a/be/test/vec/jsonb/serialize_test.cpp b/be/test/vec/jsonb/serialize_test.cpp index f918e4be2d6..bfbf5620e08 100644 --- a/be/test/vec/jsonb/serialize_test.cpp +++ b/be/test/vec/jsonb/serialize_test.cpp @@ -397,7 +397,7 @@ TEST(BlockSerializeTest, JsonbBlock) { vectorized::DataTypePtr bitmap_data_type(std::make_shared<vectorized::DataTypeBitMap>()); auto bitmap_column = bitmap_data_type->create_column(); std::vector<BitmapValue>& container = - ((vectorized::ColumnComplexType<BitmapValue>*)bitmap_column.get())->get_data(); + ((vectorized::ColumnBitmap*)bitmap_column.get())->get_data(); for (int i = 0; i < 1024; ++i) { BitmapValue bv; for (int j = 0; j <= i; ++j) { --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
