[FEAT MERGE] Add roaringbitmap type and relative expr

Co-authored-by: fkuner <784819644@qq.com>
2024-06-21 09:46:20 +00:00
parent 3723b0f580
commit 3bfa3e2070
149 changed files with 7389 additions and 222 deletions
--- a/unittest/share/test_roaringbitmap.cpp
+++ b/unittest/share/test_roaringbitmap.cpp
@ -0,0 +1,390 @@
+/**
+ * Copyright (c) 2023 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#include <gtest/gtest.h>
+#define private public
+#include "lib/roaringbitmap/ob_roaringbitmap.h"
+#include "lib/roaringbitmap/ob_rb_utils.h"
+#include "lib/utility/ob_macro_utils.h"
+
+#undef private
+
+#include <sys/time.h>
+#include <stdexcept>
+#include <exception>
+#include <typeinfo>
+
+namespace oceanbase {
+namespace common {
+
+class TestRoaringBitmap : public ::testing::Test {
+public:
+  TestRoaringBitmap()
+  {}
+  ~TestRoaringBitmap()
+  {}
+  virtual void SetUp()
+  {}
+  virtual void TearDown()
+  {}
+
+  static void SetUpTestCase()
+  {}
+
+  static void TearDownTestCase()
+  {}
+
+private:
+  // disallow copy
+  DISALLOW_COPY_AND_ASSIGN(TestRoaringBitmap);
+
+};
+
+
+TEST_F(TestRoaringBitmap, serialize_deserialize)
+{
+  ObArenaAllocator allocator(ObModIds::TEST);
+  ModulePageAllocator page_allocator_(allocator, common::ObModIds::OB_MODULE_PAGE_ALLOCATOR);
+  ObRoaringBitmap *rb = OB_NEWx(ObRoaringBitmap, &allocator, (&allocator));
+  ObRoaringBitmap *rb_64 = OB_NEWx(ObRoaringBitmap, &allocator, (&allocator));
+
+  // EMPTY Type
+  ASSERT_EQ(rb->get_version(), BITMAP_VESION_1);
+  ASSERT_EQ(rb->get_type(), ObRbType::EMPTY);
+  ASSERT_EQ(rb->get_cardinality(), 0);
+  ObString bin_empty;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_serialize(allocator, bin_empty, rb));
+  ASSERT_EQ(ObRbBinType::EMPTY, static_cast<ObRbBinType>(*(bin_empty.ptr() + 1)));
+  ObRoaringBitmap *rb_empty;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_deserialize(allocator, bin_empty, rb_empty));
+  ASSERT_EQ(rb->get_version(), rb_empty->get_version());
+  ASSERT_EQ(rb->get_type(), rb_empty->get_type());
+  ASSERT_EQ(rb->get_cardinality(), rb_empty->get_cardinality());
+
+  // SINGLE_32 Type
+  ASSERT_EQ(OB_SUCCESS, rb->value_add(100));
+  ASSERT_EQ(rb->get_type(), ObRbType::SINGLE);
+  ASSERT_EQ(rb->get_cardinality(), 1);
+  ASSERT_TRUE(rb->is_contains(100));
+  ObString bin_single;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_serialize(allocator, bin_single, rb));
+  ASSERT_EQ(ObRbBinType::SINGLE_32, static_cast<ObRbBinType>(*(bin_single.ptr() + 1)));
+  ObRoaringBitmap *rb_single;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_deserialize(allocator, bin_single, rb_single));
+  ASSERT_EQ(rb->get_version(), rb_single->get_version());
+  ASSERT_EQ(rb->get_type(), rb_single->get_type());
+  ASSERT_EQ(rb->get_cardinality(), rb_single->get_cardinality());
+  ASSERT_TRUE(rb_single->is_contains(100));
+
+  // SET_32 Type
+  ASSERT_EQ(OB_SUCCESS, rb->value_add(200));
+  ASSERT_EQ(rb->get_type(), ObRbType::SET);
+  ASSERT_EQ(rb->get_cardinality(), 2);
+  ASSERT_TRUE(rb->is_contains(100));
+  ASSERT_TRUE(rb->is_contains(200));
+  ObString bin_set;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_serialize(allocator, bin_set, rb));
+  ASSERT_EQ(ObRbBinType::SET_32, static_cast<ObRbBinType>(*(bin_set.ptr() + 1)));
+  ObRoaringBitmap *rb_set;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_deserialize(allocator, bin_set, rb_set));
+  ASSERT_EQ(rb->get_version(), rb_set->get_version());
+  ASSERT_EQ(rb->get_type(), rb_set->get_type());
+  ASSERT_EQ(rb->get_cardinality(), rb_set->get_cardinality());
+  ASSERT_TRUE(rb_set->is_contains(100));
+  ASSERT_TRUE(rb_set->is_contains(200));
+
+  // BITMAP_32 Type
+  for (int i = 0; i < MAX_BITMAP_SET_VALUES; i++) {
+    ASSERT_EQ(OB_SUCCESS, rb->value_add(300 + i));
+  }
+  ASSERT_EQ(rb->get_type(), ObRbType::BITMAP);
+  ASSERT_EQ(rb->get_cardinality(), 34);
+  for (int i = 0; i < MAX_BITMAP_SET_VALUES; i++) {
+    ASSERT_TRUE(rb->is_contains(300 + i));
+  }
+  ObString bin_bitmap;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_serialize(allocator, bin_bitmap, rb));
+  ASSERT_EQ(ObRbBinType::BITMAP_32, static_cast<ObRbBinType>(*(bin_bitmap.ptr() + 1)));
+  ObRoaringBitmap *rb_bitmap;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_deserialize(allocator, bin_bitmap, rb_bitmap));
+  ASSERT_EQ(rb->get_version(), rb_bitmap->get_version());
+  ASSERT_EQ(rb->get_type(), rb_bitmap->get_type());
+  ASSERT_EQ(rb->get_cardinality(), rb_bitmap->get_cardinality());
+  for (int i = 0; i < MAX_BITMAP_SET_VALUES; i++) {
+    ASSERT_TRUE(rb_bitmap->is_contains(300 + i));
+  }
+
+  // SINGLE_64 Type
+  ASSERT_EQ(OB_SUCCESS, rb_64->value_add(4294967295 + 100));
+  ASSERT_EQ(rb_64->get_type(), ObRbType::SINGLE);
+  ASSERT_EQ(rb_64->get_cardinality(), 1);
+  ASSERT_TRUE(rb_64->is_contains(4294967295 + 100));
+  ObString bin_single_64;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_serialize(allocator, bin_single_64, rb_64));
+  ASSERT_EQ(ObRbBinType::SINGLE_64, static_cast<ObRbBinType>(*(bin_single_64.ptr() + 1)));
+  ObRoaringBitmap *rb_single_64;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_deserialize(allocator, bin_single_64, rb_single_64));
+  ASSERT_EQ(rb_64->get_version(), rb_single_64->get_version());
+  ASSERT_EQ(rb_64->get_type(), rb_single_64->get_type());
+  ASSERT_EQ(rb_64->get_cardinality(), rb_single_64->get_cardinality());
+  ASSERT_TRUE(rb_single_64->is_contains(4294967295 + 100));
+
+  // SET_64 Type
+  ASSERT_EQ(OB_SUCCESS, rb_64->value_add(200));
+  ASSERT_EQ(rb_64->get_type(), ObRbType::SET);
+  ASSERT_EQ(rb_64->get_cardinality(), 2);
+  ASSERT_TRUE(rb_64->is_contains(4294967295 + 100));
+  ASSERT_TRUE(rb_64->is_contains(200));
+  ObString bin_set_64;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_serialize(allocator, bin_set_64, rb_64));
+  ASSERT_EQ(ObRbBinType::SET_64, static_cast<ObRbBinType>(*(bin_set_64.ptr() + 1)));
+  ObRoaringBitmap *rb_set_64;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_deserialize(allocator, bin_set_64, rb_set_64));
+  ASSERT_EQ(rb_64->get_version(), rb_set_64->get_version());
+  ASSERT_EQ(rb_64->get_type(), rb_set_64->get_type());
+  ASSERT_EQ(rb_64->get_cardinality(), rb_set_64->get_cardinality());
+  ASSERT_TRUE(rb_set_64->is_contains(4294967295 + 100));
+  ASSERT_TRUE(rb_set_64->is_contains(200));
+
+  // BITMAP_64 Type
+  for (int i = 0; i < MAX_BITMAP_SET_VALUES; i++) {
+    ASSERT_EQ(OB_SUCCESS, rb_64->value_add(i * 4294967295 + i));
+  }
+  ASSERT_EQ(rb_64->get_type(), ObRbType::BITMAP);
+  ASSERT_EQ(rb_64->get_cardinality(), 34);
+  for (int i = 0; i < MAX_BITMAP_SET_VALUES; i++) {
+    ASSERT_TRUE(rb_64->is_contains(i * 4294967295 + i));
+  }
+  ObString bin_bitmap_64;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_serialize(allocator, bin_bitmap_64, rb_64));
+  ASSERT_EQ(ObRbBinType::BITMAP_64, static_cast<ObRbBinType>(*(bin_bitmap_64.ptr() + 1)));
+  ObRoaringBitmap *rb_bitmap_64;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_deserialize(allocator, bin_bitmap_64, rb_bitmap_64));
+  ASSERT_EQ(rb_64->get_version(), rb_bitmap_64->get_version());
+  ASSERT_EQ(rb_64->get_type(), rb_bitmap_64->get_type());
+  ASSERT_EQ(rb_64->get_cardinality(), rb_bitmap_64->get_cardinality());
+  for (int i = 0; i < MAX_BITMAP_SET_VALUES; i++) {
+    ASSERT_TRUE(rb_bitmap_64->is_contains(i * 4294967295 + i));
+  }
+}
+
+TEST_F(TestRoaringBitmap, optimize)
+{
+  ObArenaAllocator allocator(ObModIds::TEST);
+  ModulePageAllocator page_allocator_(allocator, common::ObModIds::OB_MODULE_PAGE_ALLOCATOR);
+  ObRoaringBitmap *rb = OB_NEWx(ObRoaringBitmap, &allocator, (&allocator));
+
+  // add 33 value, remain 33 value
+  for (int i = 0; i < MAX_BITMAP_SET_VALUES + 1; i++) {
+    ASSERT_EQ(OB_SUCCESS, rb->value_add(300 + i));
+  }
+  ASSERT_EQ(rb->get_type(), ObRbType::BITMAP);
+  ASSERT_EQ(rb->get_cardinality(), 33);
+  ASSERT_EQ(rb->value_remove(300), OB_SUCCESS);
+  ASSERT_EQ(rb->get_cardinality(), 32);
+  ASSERT_FALSE(rb->is_contains(300));
+  rb->optimize();
+  // remove 32 value, remain 1 value
+  for (int i = 0; i < MAX_BITMAP_SET_VALUES; i++) {
+    ASSERT_EQ(rb->value_remove(300 + i), OB_SUCCESS);
+  }
+  ASSERT_EQ(rb->get_type(), ObRbType::BITMAP);
+  ASSERT_EQ(rb->get_cardinality(), 1);
+  rb->optimize();
+  ASSERT_EQ(rb->get_type(), ObRbType::SINGLE);
+  ASSERT_EQ(rb->get_cardinality(), 1);
+  // remove 1 value, remain 0 value
+  ASSERT_EQ(rb->value_remove(300 + 32), OB_SUCCESS);
+  ASSERT_EQ(rb->get_type(), ObRbType::EMPTY);
+  ASSERT_EQ(rb->get_cardinality(), 0);
+  // add 32 value, remain 32 value
+  for (int i = 0; i < MAX_BITMAP_SET_VALUES; i++) {
+    ASSERT_EQ(rb->value_add(i), OB_SUCCESS);
+  }
+  ASSERT_EQ(rb->get_type(), ObRbType::SET);
+  ASSERT_EQ(rb->get_cardinality(), 32);
+  // remove 32 value, remain 0 value
+  for (int i = 0; i < MAX_BITMAP_SET_VALUES; i++) {
+    ASSERT_EQ(rb->value_remove(i), OB_SUCCESS);
+  }
+  ASSERT_EQ(rb->get_type(), ObRbType::SET);
+  ASSERT_EQ(rb->get_cardinality(), 0);
+  // add 33 value, remain 33 value
+  for (int i = 0; i < MAX_BITMAP_SET_VALUES + 1; i++) {
+    ASSERT_EQ(rb->value_add(300 + i), OB_SUCCESS);
+  }
+  ASSERT_EQ(rb->get_type(), ObRbType::BITMAP);
+  ASSERT_EQ(rb->get_cardinality(), 33);
+  // remove 33 value, remain 0 value
+  for (int i = 0; i < MAX_BITMAP_SET_VALUES + 1; i++) {
+    ASSERT_EQ(rb->value_remove(300 + i), OB_SUCCESS);
+  }
+  ASSERT_EQ(rb->get_type(), ObRbType::BITMAP);
+  ASSERT_EQ(rb->get_cardinality(), 0);
+  rb->optimize();
+  ASSERT_EQ(rb->get_type(), ObRbType::EMPTY);
+  ASSERT_EQ(rb->get_cardinality(), 0);
+  // add 2 value, remain 2 value
+  for (int i = 0; i < 2; i++) {
+    ASSERT_EQ(rb->value_add(300 + i), OB_SUCCESS);
+  }
+  ASSERT_EQ(rb->get_type(), ObRbType::SET);
+  ASSERT_EQ(rb->get_cardinality(), 2);
+  // remove 1 value, remain 1 value
+  ASSERT_EQ(rb->value_remove(300), OB_SUCCESS);
+  ASSERT_EQ(rb->get_type(), ObRbType::SET);
+  ASSERT_EQ(rb->get_cardinality(), 1);
+  rb->optimize();
+  ASSERT_EQ(rb->get_type(), ObRbType::SINGLE);
+  ASSERT_EQ(rb->get_cardinality(), 1);
+}
+
+TEST_F(TestRoaringBitmap, to_roaring_bin)
+{
+  ObArenaAllocator allocator(ObModIds::TEST);
+  ModulePageAllocator page_allocator_(allocator, common::ObModIds::OB_MODULE_PAGE_ALLOCATOR);
+  ObRoaringBitmap *rb = OB_NEWx(ObRoaringBitmap, &allocator, (&allocator));
+  ObRoaringBitmap *rb64 = OB_NEWx(ObRoaringBitmap, &allocator, (&allocator));
+
+  // EMPTY
+  ObString bin_empty;
+  ObString roaring_bin_empty;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_serialize(allocator, bin_empty, rb));
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::binary_format_convert(allocator, bin_empty, roaring_bin_empty));
+  ObRbBinType bin_type_empty;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::check_get_bin_type(roaring_bin_empty, bin_type_empty));
+  ASSERT_EQ(ObRbBinType::BITMAP_32, bin_type_empty);
+  ObRoaringBitmap *rb_roaring_empty;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_deserialize(allocator, roaring_bin_empty, rb_roaring_empty));
+  ASSERT_EQ(rb_roaring_empty->get_version(), 1);
+  ASSERT_EQ(rb_roaring_empty->get_type(), ObRbType::BITMAP);
+  ASSERT_EQ(rb_roaring_empty->get_cardinality(), 0);
+
+  // SINGLE_32
+  ASSERT_EQ(OB_SUCCESS, rb->value_add(100));
+  ObString bin_single;
+  ObString roaring_bin_single;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_serialize(allocator, bin_single, rb));
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::binary_format_convert(allocator, bin_single, roaring_bin_single));
+  ObRbBinType bin_type_single;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::check_get_bin_type(roaring_bin_single, bin_type_single));
+  ASSERT_EQ(ObRbBinType::BITMAP_32, bin_type_single);
+  ObRoaringBitmap *rb_roaring_single;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_deserialize(allocator, roaring_bin_single, rb_roaring_single));
+  ASSERT_EQ(rb_roaring_single->get_version(), 1);
+  ASSERT_EQ(rb_roaring_single->get_type(), ObRbType::BITMAP);
+  ASSERT_EQ(rb_roaring_single->get_cardinality(), 1);
+  ASSERT_TRUE(rb_roaring_single->is_contains(100));
+
+  // SET_32
+  ASSERT_EQ(OB_SUCCESS, rb->value_add(101));
+  ObString bin_set;
+  ObString roaring_bin_set;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_serialize(allocator, bin_set, rb));
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::binary_format_convert(allocator, bin_set, roaring_bin_set));
+  ObRbBinType bin_type_set;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::check_get_bin_type(roaring_bin_set, bin_type_set));
+  ASSERT_EQ(ObRbBinType::BITMAP_32, bin_type_set);
+  ObRoaringBitmap *rb_roaring_set;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_deserialize(allocator, roaring_bin_set, rb_roaring_set));
+  ASSERT_EQ(rb_roaring_set->get_version(), 1);
+  ASSERT_EQ(rb_roaring_set->get_type(), ObRbType::BITMAP);
+  ASSERT_EQ(rb_roaring_set->get_cardinality(), 2);
+  ASSERT_TRUE(rb_roaring_set->is_contains(100));
+  ASSERT_TRUE(rb_roaring_set->is_contains(101));
+
+  // BITMAP_32
+  for (int i = 0; i < MAX_BITMAP_SET_VALUES; i++) {
+    ASSERT_EQ(OB_SUCCESS, rb->value_add(300 + i));
+  }
+  ObString bin_bitmap;
+  ObString roaring_bin_bitmap;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_serialize(allocator, bin_bitmap, rb));
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::binary_format_convert(allocator, bin_bitmap, roaring_bin_bitmap));
+  ObRbBinType bin_type_bitmap;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::check_get_bin_type(roaring_bin_bitmap, bin_type_bitmap));
+  ASSERT_EQ(ObRbBinType::BITMAP_32, bin_type_bitmap);
+  ObRoaringBitmap *rb_roaring_bitmap;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_deserialize(allocator, roaring_bin_bitmap, rb_roaring_bitmap));
+  ASSERT_EQ(rb_roaring_bitmap->get_version(), 1);
+  ASSERT_EQ(rb_roaring_bitmap->get_type(), ObRbType::BITMAP);
+  ASSERT_EQ(rb_roaring_bitmap->get_cardinality(), 34);
+  for (int i = 0; i < MAX_BITMAP_SET_VALUES; i++) {
+    ASSERT_TRUE(rb_roaring_bitmap->is_contains(300 + i));
+  }
+
+  // SINGLE_64
+  ASSERT_EQ(OB_SUCCESS, rb64->value_add(4294967295 + 100));
+  ObString bin_single64;
+  ObString roaring_bin_single64;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_serialize(allocator, bin_single64, rb64));
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::binary_format_convert(allocator, bin_single64, roaring_bin_single64));
+  ObRbBinType bin_type_single64;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::check_get_bin_type(roaring_bin_single64, bin_type_single64));
+  ASSERT_EQ(ObRbBinType::BITMAP_64, bin_type_single64);
+  ObRoaringBitmap *rb_roaring_single64;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_deserialize(allocator, roaring_bin_single64, rb_roaring_single64));
+  ASSERT_EQ(rb_roaring_single64->get_version(), 1);
+  ASSERT_EQ(rb_roaring_single64->get_type(), ObRbType::BITMAP);
+  ASSERT_EQ(rb_roaring_single64->get_cardinality(), 1);
+  ASSERT_TRUE(rb_roaring_single64->is_contains(4294967295 + 100));
+
+  // SET_64
+  ASSERT_EQ(OB_SUCCESS, rb64->value_add(4294967295 + 101));
+  ObString bin_set64;
+  ObString roaring_bin_set64;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_serialize(allocator, bin_set64, rb64));
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::binary_format_convert(allocator, bin_set64, roaring_bin_set64));
+  ObRbBinType bin_type_set64;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::check_get_bin_type(roaring_bin_set64, bin_type_set64));
+  ASSERT_EQ(ObRbBinType::BITMAP_64, bin_type_set64);
+  ObRoaringBitmap *rb_roaring_set64;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_deserialize(allocator, roaring_bin_set64, rb_roaring_set64));
+  ASSERT_EQ(rb_roaring_set64->get_version(), 1);
+  ASSERT_EQ(rb_roaring_set64->get_type(), ObRbType::BITMAP);
+  ASSERT_EQ(rb_roaring_set64->get_cardinality(), 2);
+  ASSERT_TRUE(rb_roaring_set64->is_contains(4294967295 + 100));
+  ASSERT_TRUE(rb_roaring_set64->is_contains(4294967295 + 101));
+
+  // BITMAP_64
+  for (int i = 0; i < MAX_BITMAP_SET_VALUES; i++) {
+    ASSERT_EQ(OB_SUCCESS, rb64->value_add(4294967295 + 300 + i));
+  }
+  ObString bin_bitmap64;
+  ObString roaring_bin_bitmap64;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_serialize(allocator, bin_bitmap64, rb64));
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::binary_format_convert(allocator, bin_bitmap64, roaring_bin_bitmap64));
+  ObRbBinType bin_type_bitmap64;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::check_get_bin_type(roaring_bin_bitmap64, bin_type_bitmap64));
+  ASSERT_EQ(ObRbBinType::BITMAP_64, bin_type_bitmap64);
+  ObRoaringBitmap *rb_roaring_bitmap64;
+  ASSERT_EQ(OB_SUCCESS, ObRbUtils::rb_deserialize(allocator, roaring_bin_bitmap64, rb_roaring_bitmap64));
+  ASSERT_EQ(rb_roaring_bitmap64->get_version(), 1);
+  ASSERT_EQ(rb_roaring_bitmap64->get_type(), ObRbType::BITMAP);
+  ASSERT_EQ(rb_roaring_bitmap64->get_cardinality(), 34);
+  for (int i = 0; i < MAX_BITMAP_SET_VALUES; i++) {
+    ASSERT_TRUE(rb_roaring_bitmap64->is_contains(4294967295 + 300 + i));
+  }
+
+}
+
+} // namespace common
+} // namespace oceanbase
+
+int main(int argc, char** argv)
+{
+  ::testing::InitGoogleTest(&argc, argv);
+  // system("rm -f test_geo_tree.log");
+  // OB_LOGGER.set_file_name("test_geo_tree.log");
+  OB_LOGGER.set_log_level("DEBUG");
+  return RUN_ALL_TESTS();
+}