This is an automated email from the ASF dual-hosted git repository.
yiguolei pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/master by this push:
new b203497bcd4 remove some unused member function of IFunctionBase
(#30260)
b203497bcd4 is described below
commit b203497bcd476730a21cd3e3b2d0fe63d9a38e0e
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]
