diff --git a/be/src/exprs/bitmap_function.cpp b/be/src/exprs/bitmap_function.cpp index b469c15550..bfe25f666a 100644 --- a/be/src/exprs/bitmap_function.cpp +++ b/be/src/exprs/bitmap_function.cpp @@ -333,10 +333,10 @@ BigIntVal BitmapFunctions::bitmap_count(FunctionContext* ctx, const StringVal& s // zero size means the src input is a agg object if (src.len == 0) { auto bitmap = reinterpret_cast(src.ptr); - return {bitmap->cardinality()}; + return {static_cast(bitmap->cardinality())}; } else { BitmapValue bitmap((char*)src.ptr); - return {bitmap.cardinality()}; + return {static_cast(bitmap.cardinality())}; } } @@ -491,12 +491,40 @@ StringVal BitmapFunctions::bitmap_and(FunctionContext* ctx, const StringVal& lhs } BigIntVal BitmapFunctions::bitmap_and_count(FunctionContext* ctx, const StringVal& lhs, const StringVal& rhs) { - return bitmap_count(ctx, bitmap_and(ctx, lhs, rhs)); + if (lhs.is_null || rhs.is_null) { + return BigIntVal::null(); + } + BitmapValue bitmap; + if (lhs.len == 0) { + bitmap |= *reinterpret_cast(lhs.ptr); + } else { + bitmap |= BitmapValue((char*)lhs.ptr); + } + + if (rhs.len == 0) { + return bitmap.and_cardinality(*reinterpret_cast(rhs.ptr)); + } else { + return bitmap.and_cardinality(BitmapValue((char*)rhs.ptr)); + } } BigIntVal BitmapFunctions::bitmap_or_count(FunctionContext* ctx, const StringVal& lhs, const StringVal& rhs) { - return bitmap_count(ctx, bitmap_or(ctx, lhs, rhs)); + if (lhs.is_null || rhs.is_null) { + return BigIntVal::null(); + } + BitmapValue bitmap; + if (lhs.len == 0) { + bitmap |= *reinterpret_cast(lhs.ptr); + } else { + bitmap |= BitmapValue((char*)lhs.ptr); + } + + if (rhs.len == 0) { + return bitmap.or_cardinality(*reinterpret_cast(rhs.ptr)); + } else { + return bitmap.or_cardinality(BitmapValue((char*)rhs.ptr)); + } } StringVal BitmapFunctions::bitmap_xor(FunctionContext* ctx, const StringVal& lhs, @@ -520,8 +548,22 @@ StringVal BitmapFunctions::bitmap_xor(FunctionContext* ctx, const StringVal& lhs } BigIntVal BitmapFunctions::bitmap_xor_count(FunctionContext* ctx, const StringVal& lhs, - const StringVal& rhs) { - return bitmap_count(ctx, bitmap_xor(ctx, lhs, rhs)); + const StringVal& rhs) { + if (lhs.is_null || rhs.is_null) { + return BigIntVal::null(); + } + BitmapValue bitmap; + if (lhs.len == 0) { + bitmap |= *reinterpret_cast(lhs.ptr); + } else { + bitmap |= BitmapValue((char*)lhs.ptr); + } + + if (rhs.len == 0) { + return bitmap.xor_cardinality(*reinterpret_cast(rhs.ptr)); + } else { + return bitmap.xor_cardinality(BitmapValue((char*)rhs.ptr)); + } } StringVal BitmapFunctions::bitmap_not(FunctionContext* ctx, const StringVal& lhs, @@ -550,8 +592,22 @@ StringVal BitmapFunctions::bitmap_and_not(FunctionContext* ctx, const StringVal& } BigIntVal BitmapFunctions::bitmap_and_not_count(FunctionContext* ctx, const StringVal& lhs, - const StringVal& rhs) { - return bitmap_count(ctx, bitmap_and_not(ctx, lhs, rhs)); + const StringVal& rhs) { + if (lhs.is_null || rhs.is_null) { + return BigIntVal::null(); + } + BitmapValue bitmap; + if (lhs.len == 0) { + bitmap |= *reinterpret_cast(lhs.ptr); + } else { + bitmap |= BitmapValue((char*)lhs.ptr); + } + + if (rhs.len == 0) { + return bitmap.andnot_cardinality(*reinterpret_cast(rhs.ptr)); + } else { + return bitmap.andnot_cardinality(BitmapValue((char*)rhs.ptr)); + } } StringVal BitmapFunctions::bitmap_to_string(FunctionContext* ctx, const StringVal& input) { @@ -621,16 +677,16 @@ BooleanVal BitmapFunctions::bitmap_has_any(FunctionContext* ctx, const StringVal return {bitmap.cardinality() != 0}; } -BooleanVal BitmapFunctions::bitmap_has_all(FunctionContext *ctx, const StringVal &lhs, - const StringVal &rhs) { +BooleanVal BitmapFunctions::bitmap_has_all(FunctionContext* ctx, const StringVal& lhs, + const StringVal& rhs) { if (lhs.is_null || rhs.is_null) { return BooleanVal::null(); } if (lhs.len != 0 && rhs.len != 0) { - BitmapValue bitmap = BitmapValue(reinterpret_cast(lhs.ptr)); + BitmapValue bitmap = BitmapValue(reinterpret_cast(lhs.ptr)); int64_t lhs_cardinality = bitmap.cardinality(); - bitmap |= BitmapValue(reinterpret_cast(rhs.ptr)); + bitmap |= BitmapValue(reinterpret_cast(rhs.ptr)); return {bitmap.cardinality() == lhs_cardinality}; } else if (rhs.len != 0) { return {false}; @@ -653,7 +709,8 @@ BigIntVal BitmapFunctions::bitmap_max(FunctionContext* ctx, const StringVal& src } StringVal BitmapFunctions::bitmap_subset_in_range(FunctionContext* ctx, const StringVal& src, - const BigIntVal& range_start, const BigIntVal& range_end) { + const BigIntVal& range_start, + const BigIntVal& range_end) { if (src.is_null || range_start.is_null || range_end.is_null) { return StringVal::null(); } @@ -672,7 +729,7 @@ StringVal BitmapFunctions::bitmap_subset_in_range(FunctionContext* ctx, const St } StringVal BitmapFunctions::sub_bitmap(FunctionContext* ctx, const StringVal& src, - const BigIntVal& offset, const BigIntVal& cardinality_limit) { + const BigIntVal& offset, const BigIntVal& cardinality_limit) { if (src.is_null || offset.is_null || cardinality_limit.is_null || cardinality_limit.val <= 0) { return StringVal::null(); } @@ -691,7 +748,8 @@ StringVal BitmapFunctions::sub_bitmap(FunctionContext* ctx, const StringVal& src } StringVal BitmapFunctions::bitmap_subset_limit(FunctionContext* ctx, const StringVal& src, - const BigIntVal& range_start, const BigIntVal& cardinality_limit) { + const BigIntVal& range_start, + const BigIntVal& cardinality_limit) { if (src.is_null || range_start.is_null || cardinality_limit.is_null) { return StringVal::null(); } diff --git a/be/src/util/bitmap_value.h b/be/src/util/bitmap_value.h index 6a50b9d75b..91c73202e4 100644 --- a/be/src/util/bitmap_value.h +++ b/be/src/util/bitmap_value.h @@ -18,6 +18,8 @@ #ifndef DORIS_BE_SRC_UTIL_BITMAP_VALUE_H #define DORIS_BE_SRC_UTIL_BITMAP_VALUE_H +#include + #include #include #include @@ -338,6 +340,74 @@ public: return previous + map_entry.second.cardinality(); }); } + /** + * Computes the size of the intersection between two bitmaps. + * + */ + uint64_t andCardinality(const Roaring64Map& r) const { + uint64_t card = 0; + for (auto& map_entry : roarings) { + if (r.roarings.count(map_entry.first) == 1) { + card += map_entry.second.and_cardinality(r.roarings.at(map_entry.first)); + } + } + return card; + } + + /** + * Computes the size of the union between two bitmaps. + * + */ + uint64_t orCardinality(const Roaring64Map& r) const { + uint64_t card = 0; + for (const auto& map_entry : roarings) { + if (r.roarings.count(map_entry.first) == 0) { + card += map_entry.second.cardinality(); + } + } + for (const auto& map_entry : r.roarings) { + if (roarings.count(map_entry.first) == 0) { + card += map_entry.second.cardinality(); + } else { + card += roarings.at(map_entry.first).or_cardinality(map_entry.second); + } + } + return card; + } + + /** + * Computes the size of the difference (andnot) between two bitmaps. + * r1.cardinality - (r1 & r2).cardinality + */ + uint64_t andnotCardinality(const Roaring64Map& r) const { + uint64_t card = 0; + for (const auto& map_entry : roarings) { + card += map_entry.second.cardinality(); + if (r.roarings.count(map_entry.first) == 1) { + card -= r.roarings.at(map_entry.first).and_cardinality(map_entry.second); + } + } + return card; + } + + /** + * Computes the size of the symmetric difference (andnot) between two + * bitmaps. + * r1.cardinality + r2.cardinality - 2 * (r1 & r2).cardinality + */ + uint64_t xorCardinality(const Roaring64Map& r) const { + uint64_t card = 0; + for (const auto& map_entry : roarings) { + card += map_entry.second.cardinality(); + } + for (const auto& map_entry : r.roarings) { + card += map_entry.second.cardinality(); + if (roarings.count(map_entry.first) == 1) { + card -= 2 * roarings.at(map_entry.first).and_cardinality(map_entry.second); + } + } + return card; + } /** * Returns true if the bitmap is empty (cardinality is zero). @@ -858,7 +928,7 @@ public: const_iterator end() const; private: - std::map roarings {}; + phmap::btree_map roarings {}; bool copyOnWrite {false}; static uint32_t highBytes(const uint64_t in) { return uint32_t(in >> 32); } static uint32_t lowBytes(const uint64_t in) { return uint32_t(in); } @@ -996,9 +1066,9 @@ public: } protected: - const std::map& p; - std::map::const_iterator map_iter {}; - std::map::const_iterator map_end {}; + const phmap::btree_map& p; + phmap::btree_map::const_iterator map_iter {}; + phmap::btree_map::const_iterator map_end {}; roaring::api::roaring_uint32_iterator_t i {}; }; @@ -1048,7 +1118,7 @@ public: } protected: - std::map::const_iterator map_begin; + phmap::btree_map::const_iterator map_begin; }; inline Roaring64MapSetBitForwardIterator Roaring64Map::begin() const { @@ -1307,8 +1377,7 @@ public: return false; } - // TODO should the return type be uint64_t? - int64_t cardinality() const { + uint64_t cardinality() const { switch (_type) { case EMPTY: return 0; @@ -1320,6 +1389,110 @@ public: return 0; } + uint64_t and_cardinality(const BitmapValue& rhs) const { + switch (rhs._type) { + case EMPTY: + return 0; + case SINGLE: + switch (_type) { + case EMPTY: + return 0; + case SINGLE: + return _sv == rhs._sv; + case BITMAP: + return _bitmap.contains(rhs._sv); + } + case BITMAP: + switch (_type) { + case EMPTY: + return 0; + case SINGLE: + return rhs._bitmap.contains(_sv); + case BITMAP: + return _bitmap.andCardinality(rhs._bitmap); + } + } + return 0; + } + + uint64_t or_cardinality(const BitmapValue& rhs) const { + switch (rhs._type) { + case EMPTY: + return cardinality(); + case SINGLE: + switch (_type) { + case EMPTY: + return 1; + case SINGLE: + return 1 + (_sv != rhs._sv); + case BITMAP: + return cardinality() + !_bitmap.contains(rhs._sv); + } + case BITMAP: + switch (_type) { + case EMPTY: + return rhs.cardinality(); + case SINGLE: + return rhs.cardinality() + !rhs._bitmap.contains(_sv); + case BITMAP: + return _bitmap.orCardinality(rhs._bitmap); + } + } + return 0; + } + + uint64_t xor_cardinality(const BitmapValue& rhs) const { + switch (rhs._type) { + case EMPTY: + return cardinality(); + case SINGLE: + switch (_type) { + case EMPTY: + return 1; + case SINGLE: + return 2 - 2 * (_sv == rhs._sv); + case BITMAP: + return cardinality() + 1 - 2 * (_bitmap.contains(rhs._sv)); + } + case BITMAP: + switch (_type) { + case EMPTY: + return rhs.cardinality(); + case SINGLE: + return rhs.cardinality() + 1 - 2 * (rhs._bitmap.contains(_sv)); + case BITMAP: + return _bitmap.xorCardinality(rhs._bitmap); + } + } + return 0; + } + + uint64_t andnot_cardinality(const BitmapValue& rhs) const { + switch (rhs._type) { + case EMPTY: + return cardinality(); + case SINGLE: + switch (_type) { + case EMPTY: + return 0; + case SINGLE: + return 1 - _sv == rhs._sv; + case BITMAP: + return cardinality() - _bitmap.contains(rhs._sv); + } + case BITMAP: + switch (_type) { + case EMPTY: + return 0; + case SINGLE: + return !rhs._bitmap.contains(_sv); + case BITMAP: + return _bitmap.andnotCardinality(rhs._bitmap); + } + } + return 0; + } + // Return how many bytes are required to serialize this bitmap. // See BitmapTypeCode for the serialized format. size_t getSizeInBytes() { @@ -1439,23 +1612,23 @@ public: return ss.str(); } - doris_udf::BigIntVal maximum() { switch (_type) { - case SINGLE: - return doris_udf::BigIntVal(_sv); - case BITMAP: - return doris_udf::BigIntVal(_bitmap.maximum()); - default: - return doris_udf::BigIntVal::null(); + case SINGLE: + return doris_udf::BigIntVal(_sv); + case BITMAP: + return doris_udf::BigIntVal(_bitmap.maximum()); + default: + return doris_udf::BigIntVal::null(); } } /** * Return new set with specified range (not include the range_end) */ - int64_t sub_range(const int64_t& range_start, const int64_t& range_end, BitmapValue* ret_bitmap) { - int64_t count = 0; + int64_t sub_range(const int64_t& range_start, const int64_t& range_end, + BitmapValue* ret_bitmap) { + int64_t count = 0; for (auto it = _bitmap.begin(); it != _bitmap.end(); ++it) { if (*it < range_start) { continue; @@ -1476,7 +1649,8 @@ public: * @param cardinality_limit the length of the subset * @return the real count for subset, maybe less than cardinality_limit */ - int64_t sub_limit(const int64_t& range_start, const int64_t& cardinality_limit, BitmapValue* ret_bitmap) { + int64_t sub_limit(const int64_t& range_start, const int64_t& cardinality_limit, + BitmapValue* ret_bitmap) { int64_t count = 0; for (auto it = _bitmap.begin(); it != _bitmap.end(); ++it) { if (*it < range_start) { @@ -1509,10 +1683,10 @@ public: int64_t count = 0; int64_t offset_count = 0; auto it = _bitmap.begin(); - for (;it != _bitmap.end() && offset_count < abs_offset; ++it) { + for (; it != _bitmap.end() && offset_count < abs_offset; ++it) { ++offset_count; } - for (;it != _bitmap.end() && count < limit; ++it, ++count) { + for (; it != _bitmap.end() && count < limit; ++it, ++count) { ret_bitmap->add(*it); } return count; diff --git a/be/test/exprs/bitmap_function_test.cpp b/be/test/exprs/bitmap_function_test.cpp index 8a2a950328..49642e3481 100644 --- a/be/test/exprs/bitmap_function_test.cpp +++ b/be/test/exprs/bitmap_function_test.cpp @@ -372,7 +372,7 @@ TEST_F(BitmapFunctionsTest, bitmap_xor_count) { BigIntVal result = BitmapFunctions::bitmap_xor_count(ctx, bitmap_src, bitmap_dst); BigIntVal expected(4); - ASSERT_EQ(expected, result); + ASSERT_EQ(expected.val, result.val); } { BitmapValue bitmap1({1, 2, 3}); @@ -384,7 +384,7 @@ TEST_F(BitmapFunctionsTest, bitmap_xor_count) { BigIntVal result = BitmapFunctions::bitmap_xor_count(ctx, bitmap_src, bitmap_dst); BigIntVal expected(0); - ASSERT_EQ(expected, result); + ASSERT_EQ(expected.val, result.val); } { BitmapValue bitmap1({1, 2, 3}); @@ -396,7 +396,46 @@ TEST_F(BitmapFunctionsTest, bitmap_xor_count) { BigIntVal result = BitmapFunctions::bitmap_xor_count(ctx, bitmap_src, bitmap_dst); BigIntVal expected(6); - ASSERT_EQ(expected, result); + ASSERT_EQ(expected.val, result.val); + } +} + +TEST_F(BitmapFunctionsTest, bitmap_xor_count_64) { + { + BitmapValue bitmap1({14001230000000000501ull, 2, 1404560000000000503ull}); + BitmapValue bitmap2({1404560000000000503ull, 4, 14111000000000000505ull}); + + StringVal bitmap_src = convert_bitmap_to_string(ctx, bitmap1); + StringVal bitmap_dst = convert_bitmap_to_string(ctx, bitmap2); + + BigIntVal result = BitmapFunctions::bitmap_xor_count(ctx, bitmap_src, bitmap_dst); + + BigIntVal expected(4); + ASSERT_EQ(expected.val, result.val); + } + { + BitmapValue bitmap1({14123400000000000501ull, 2, 1498760000000000503ull}); + BitmapValue bitmap2({14123400000000000501ull, 2, 1498760000000000503ull}); + + StringVal bitmap_src = convert_bitmap_to_string(ctx, bitmap1); + StringVal bitmap_dst = convert_bitmap_to_string(ctx, bitmap2); + + BigIntVal result = BitmapFunctions::bitmap_xor_count(ctx, bitmap_src, bitmap_dst); + + BigIntVal expected(0); + ASSERT_EQ(expected.val, result.val); + } + { + BitmapValue bitmap1({15000000000000000501ull, 2, 1200000000000000503ull}); + BitmapValue bitmap2({13000000000000000504ull, 5, 1160000000000000506ull}); + + StringVal bitmap_src = convert_bitmap_to_string(ctx, bitmap1); + StringVal bitmap_dst = convert_bitmap_to_string(ctx, bitmap2); + + BigIntVal result = BitmapFunctions::bitmap_xor_count(ctx, bitmap_src, bitmap_dst); + + BigIntVal expected(6); + ASSERT_EQ(expected.val, result.val); } } @@ -406,24 +445,52 @@ TEST_F(BitmapFunctionsTest, bitmap_and_count) { StringVal bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); StringVal bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); BigIntVal result = BitmapFunctions::bitmap_and_count(ctx, bitmap_src1, bitmap_src2); - ASSERT_EQ(BigIntVal(0), result); + ASSERT_EQ(0, result.val); result = BitmapFunctions::bitmap_and_count(ctx, bitmap_src1, StringVal::null()); - ASSERT_EQ(BigIntVal(0), result); + ASSERT_EQ(0, result.val); - bitmap1 = BitmapValue({0, 1, 2,std::numeric_limits::min()}); - bitmap2 = BitmapValue({0, 1, 2,std::numeric_limits::max()}); + bitmap1 = BitmapValue({0, 1, 2, std::numeric_limits::min()}); + bitmap2 = BitmapValue({0, 1, 2, std::numeric_limits::max()}); bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_and_count(ctx, bitmap_src1, bitmap_src2); - ASSERT_EQ(BigIntVal(3), result); + ASSERT_EQ(3, result.val); bitmap1 = BitmapValue({1, 2, 3}); bitmap2 = BitmapValue({3, 4, 5}); bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_and_count(ctx, bitmap_src1, bitmap_src2); - ASSERT_EQ(BigIntVal(1), result); + ASSERT_EQ(1, result.val); +} + +TEST_F(BitmapFunctionsTest, bitmap_and_count_64) { + BitmapValue bitmap1({14333000000000000501ull, 2, 1454100000000000503ull}); + BitmapValue bitmap2; + StringVal bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); + StringVal bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); + BigIntVal result = BitmapFunctions::bitmap_and_count(ctx, bitmap_src1, bitmap_src2); + ASSERT_EQ(0, result.val); + + result = BitmapFunctions::bitmap_and_count(ctx, bitmap_src1, StringVal::null()); + ASSERT_EQ(0, result.val); + + bitmap1 = BitmapValue({11598000000000000501ull, 2, 1923400000000000503ull, + std::numeric_limits::min()}); + bitmap2 = BitmapValue({11598000000000000501ull, 2, 1923400000000000503ull, + std::numeric_limits::max()}); + bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); + bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); + result = BitmapFunctions::bitmap_and_count(ctx, bitmap_src1, bitmap_src2); + ASSERT_EQ(3, result.val); + + bitmap1 = BitmapValue({15555500000000000501ull, 2, 1400000000000000503ull}); + bitmap2 = BitmapValue({1400000000000000503ull, 5, 1400324000000000506ull}); + bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); + bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); + result = BitmapFunctions::bitmap_and_count(ctx, bitmap_src1, bitmap_src2); + ASSERT_EQ(1, result.val); } TEST_F(BitmapFunctionsTest, bitmap_or_count) { @@ -432,24 +499,52 @@ TEST_F(BitmapFunctionsTest, bitmap_or_count) { StringVal bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); StringVal bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); BigIntVal result = BitmapFunctions::bitmap_or_count(ctx, bitmap_src1, bitmap_src2); - ASSERT_EQ(BigIntVal(3), result); + ASSERT_EQ(3, result.val); result = BitmapFunctions::bitmap_or_count(ctx, bitmap_src1, StringVal::null()); - ASSERT_EQ(BigIntVal(0), result); + ASSERT_EQ(0, result.val); bitmap1 = BitmapValue({0, 1, 2, std::numeric_limits::min()}); bitmap2 = BitmapValue({0, 1, 2, std::numeric_limits::max()}); bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_or_count(ctx, bitmap_src1, bitmap_src2); - ASSERT_EQ(BigIntVal(4), result); + ASSERT_EQ(4, result.val); bitmap1 = BitmapValue({1, 2, 3}); bitmap2 = BitmapValue({3, 4, 5}); bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_or_count(ctx, bitmap_src1, bitmap_src2); - ASSERT_EQ(BigIntVal(5), result); + ASSERT_EQ(5, result.val); +} + +TEST_F(BitmapFunctionsTest, bitmap_or_count_64) { + BitmapValue bitmap1({14087600000000000501ull, 2, 1234500000000000503ull}); + BitmapValue bitmap2; + StringVal bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); + StringVal bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); + BigIntVal result = BitmapFunctions::bitmap_or_count(ctx, bitmap_src1, bitmap_src2); + ASSERT_EQ(3, result.val); + + result = BitmapFunctions::bitmap_or_count(ctx, bitmap_src1, StringVal::null()); + ASSERT_EQ(0, result.val); + + bitmap1 = BitmapValue({11870000000000000501ull, 2, 1378900000000000503ull, + std::numeric_limits::min()}); + bitmap2 = BitmapValue({11870000000000000501ull, 2, 1378900000000000503ull, + std::numeric_limits::max()}); + bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); + bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); + result = BitmapFunctions::bitmap_or_count(ctx, bitmap_src1, bitmap_src2); + ASSERT_EQ(5, result.val); + + bitmap1 = BitmapValue({17870000000000000501ull, 2, 1400000000000000503ull}); + bitmap2 = BitmapValue({1400000000000000503ull, 5, 1678900000000000503ull}); + bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); + bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); + result = BitmapFunctions::bitmap_or_count(ctx, bitmap_src1, bitmap_src2); + ASSERT_EQ(5, result.val); } TEST_F(BitmapFunctionsTest, bitmap_not) { @@ -552,7 +647,7 @@ TEST_F(BitmapFunctionsTest, bitmap_and_not_count) { BigIntVal result = BitmapFunctions::bitmap_and_not_count(ctx, bitmap_src, bitmap_dst); BigIntVal expected(2); - ASSERT_EQ(expected, result); + ASSERT_EQ(expected.val, result.val); } { BitmapValue bitmap1({1, 2, 3}); @@ -564,7 +659,7 @@ TEST_F(BitmapFunctionsTest, bitmap_and_not_count) { BigIntVal result = BitmapFunctions::bitmap_and_not_count(ctx, bitmap_src, bitmap_dst); BigIntVal expected(0); - ASSERT_EQ(expected, result); + ASSERT_EQ(expected.val, result.val); } { BitmapValue bitmap1({1, 2, 3}); @@ -576,7 +671,7 @@ TEST_F(BitmapFunctionsTest, bitmap_and_not_count) { BigIntVal result = BitmapFunctions::bitmap_and_not_count(ctx, bitmap_src, bitmap_dst); BigIntVal expected(3); - ASSERT_EQ(expected, result); + ASSERT_EQ(expected.val, result.val); } } @@ -610,33 +705,35 @@ TEST_F(BitmapFunctionsTest, bitmap_has_any) { } TEST_F(BitmapFunctionsTest, bitmap_has_all) { - BitmapValue bitmap1({1, 4, 5, std::numeric_limits::max(), std::numeric_limits::min()}); - BitmapValue bitmap2({4, std::numeric_limits::max(), std::numeric_limits::min()}); + BitmapValue bitmap1( + {1, 4, 5, std::numeric_limits::max(), std::numeric_limits::min()}); + BitmapValue bitmap2( + {4, std::numeric_limits::max(), std::numeric_limits::min()}); StringVal string_val1 = convert_bitmap_to_string(ctx, bitmap1); StringVal string_val2 = convert_bitmap_to_string(ctx, bitmap2); BooleanVal result = BitmapFunctions::bitmap_has_all(ctx, string_val1, string_val2); - ASSERT_EQ(BooleanVal{true}, result); + ASSERT_EQ(BooleanVal {true}, result); bitmap1 = BitmapValue({0, 1, 2}); bitmap2 = BitmapValue({0, 1, 2, std::numeric_limits::max()}); string_val1 = convert_bitmap_to_string(ctx, bitmap1); string_val2 = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_has_all(ctx, string_val1, string_val2); - ASSERT_EQ(BooleanVal{false}, result); + ASSERT_EQ(BooleanVal {false}, result); bitmap1 = BitmapValue(); bitmap2 = BitmapValue({0, 1, 2}); string_val1 = convert_bitmap_to_string(ctx, bitmap1); string_val2 = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_has_all(ctx, string_val1, string_val2); - ASSERT_EQ(BooleanVal{false}, result); + ASSERT_EQ(BooleanVal {false}, result); bitmap1 = BitmapValue(); bitmap2 = BitmapValue(); string_val1 = convert_bitmap_to_string(ctx, bitmap1); string_val2 = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_has_all(ctx, string_val1, string_val2); - ASSERT_EQ(BooleanVal{true}, result); + ASSERT_EQ(BooleanVal {true}, result); bitmap1 = BitmapValue(); string_val1 = convert_bitmap_to_string(ctx, bitmap1); @@ -694,7 +791,8 @@ TEST_F(BitmapFunctionsTest, bitmap_max) { TEST_F(BitmapFunctionsTest, bitmap_subset_in_range) { // null - StringVal res = BitmapFunctions::bitmap_subset_in_range(ctx, StringVal::null(), BigIntVal(1), BigIntVal(3)); + StringVal res = BitmapFunctions::bitmap_subset_in_range(ctx, StringVal::null(), BigIntVal(1), + BigIntVal(3)); ASSERT_TRUE(res.is_null); // empty @@ -705,7 +803,9 @@ TEST_F(BitmapFunctionsTest, bitmap_subset_in_range) { ASSERT_EQ(BigIntVal(0), result); // normal - BitmapValue bitmap1({0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,208,23,24,25,26,27,28,29,30,31,32,33,100,200,500}); + BitmapValue bitmap1({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 208, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 100, 200, 500}); StringVal bitmap_src = convert_bitmap_to_string(ctx, bitmap1); res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal(30), BigIntVal(200)); @@ -720,18 +820,19 @@ TEST_F(BitmapFunctionsTest, bitmap_subset_in_range) { result = BitmapFunctions::bitmap_count(ctx, res); ASSERT_EQ(BigIntVal(4), result); - res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal(11), DecimalV2Value::MAX_INT64); + res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal(11), + DecimalV2Value::MAX_INT64); result = BitmapFunctions::bitmap_count(ctx, res); ASSERT_EQ(BigIntVal(27), result); // innormal - // start >= end + // start >= end res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal(30), BigIntVal(20)); ASSERT_TRUE(res.is_null); res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal(20), BigIntVal(20)); ASSERT_TRUE(res.is_null); - + // negative range res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal(-10), BigIntVal(20)); ASSERT_TRUE(res.is_null); @@ -743,35 +844,40 @@ TEST_F(BitmapFunctionsTest, bitmap_subset_in_range) { ASSERT_TRUE(res.is_null); // null range - res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal::null(), BigIntVal(20)); + res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal::null(), + BigIntVal(20)); ASSERT_TRUE(res.is_null); - res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal(10), BigIntVal::null()); + res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal(10), + BigIntVal::null()); ASSERT_TRUE(res.is_null); - res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal::null(), BigIntVal::null()); + res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal::null(), + BigIntVal::null()); ASSERT_TRUE(res.is_null); } TEST_F(BitmapFunctionsTest, sub_bitmap) { // normal - BitmapValue bitmap1({0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,100,200,500}); + BitmapValue bitmap1({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 100, 200, 500}); StringVal bitmap_src = convert_bitmap_to_string(ctx, bitmap1); StringVal res = BitmapFunctions::sub_bitmap(ctx, bitmap_src, BigIntVal(30), BigIntVal(6)); - BitmapValue bitmap2({30,31,32,33,100,200}); + BitmapValue bitmap2({30, 31, 32, 33, 100, 200}); ASSERT_EQ(res, convert_bitmap_to_string(ctx, bitmap2)); res = BitmapFunctions::sub_bitmap(ctx, bitmap_src, BigIntVal(30), BigIntVal(100)); - BitmapValue bitmap3({30,31,32,33,100,200,500}); + BitmapValue bitmap3({30, 31, 32, 33, 100, 200, 500}); ASSERT_EQ(res, convert_bitmap_to_string(ctx, bitmap3)); res = BitmapFunctions::sub_bitmap(ctx, bitmap_src, BigIntVal(30), BigIntVal(INT64_MAX)); - BitmapValue bitmap4({30,31,32,33,100,200,500}); + BitmapValue bitmap4({30, 31, 32, 33, 100, 200, 500}); ASSERT_EQ(res, convert_bitmap_to_string(ctx, bitmap4)); res = BitmapFunctions::sub_bitmap(ctx, bitmap_src, BigIntVal(0), BigIntVal(2)); - BitmapValue bitmap5({0,1}); + BitmapValue bitmap5({0, 1}); ASSERT_EQ(res, convert_bitmap_to_string(ctx, bitmap5)); res = BitmapFunctions::sub_bitmap(ctx, bitmap_src, BigIntVal(-1), BigIntVal(2)); @@ -779,7 +885,7 @@ TEST_F(BitmapFunctionsTest, sub_bitmap) { ASSERT_EQ(res, convert_bitmap_to_string(ctx, bitmap6)); res = BitmapFunctions::sub_bitmap(ctx, bitmap_src, BigIntVal(-7), BigIntVal(6)); - BitmapValue bitmap7({30,31,32,33,100,200}); + BitmapValue bitmap7({30, 31, 32, 33, 100, 200}); ASSERT_EQ(res, convert_bitmap_to_string(ctx, bitmap7)); // null @@ -813,7 +919,8 @@ TEST_F(BitmapFunctionsTest, sub_bitmap) { TEST_F(BitmapFunctionsTest, bitmap_subset_limit) { // null - StringVal res = BitmapFunctions::bitmap_subset_limit(ctx, StringVal::null(), BigIntVal(1), BigIntVal(3)); + StringVal res = BitmapFunctions::bitmap_subset_limit(ctx, StringVal::null(), BigIntVal(1), + BigIntVal(3)); ASSERT_TRUE(res.is_null); // empty @@ -824,7 +931,9 @@ TEST_F(BitmapFunctionsTest, bitmap_subset_limit) { ASSERT_EQ(BigIntVal(0), result); // normal - BitmapValue bitmap1({0,1,2,3,4,5,6,7,45,47,49,43,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,100,200,500}); + BitmapValue bitmap1({0, 1, 2, 3, 4, 5, 6, 7, 45, 47, 49, 43, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 100, 200, 500}); StringVal bitmap_src = convert_bitmap_to_string(ctx, bitmap1); res = BitmapFunctions::bitmap_subset_limit(ctx, bitmap_src, BigIntVal(4), BigIntVal(10)); @@ -839,7 +948,8 @@ TEST_F(BitmapFunctionsTest, bitmap_subset_limit) { result = BitmapFunctions::bitmap_count(ctx, res); ASSERT_EQ(BigIntVal(7), result); - res = BitmapFunctions::bitmap_subset_limit(ctx, bitmap_src, BigIntVal(31), DecimalV2Value::MAX_INT64); + res = BitmapFunctions::bitmap_subset_limit(ctx, bitmap_src, BigIntVal(31), + DecimalV2Value::MAX_INT64); result = BitmapFunctions::bitmap_count(ctx, res); ASSERT_EQ(BigIntVal(10), result); @@ -861,9 +971,9 @@ TEST_F(BitmapFunctionsTest, bitmap_subset_limit) { res = BitmapFunctions::bitmap_subset_limit(ctx, bitmap_src, BigIntVal(10), BigIntVal::null()); ASSERT_TRUE(res.is_null); - res = BitmapFunctions::bitmap_subset_limit(ctx, bitmap_src, BigIntVal::null(), BigIntVal::null()); + res = BitmapFunctions::bitmap_subset_limit(ctx, bitmap_src, BigIntVal::null(), + BigIntVal::null()); ASSERT_TRUE(res.is_null); - } } // namespace doris