Re: [PR] [feat](test) add bloomfilter ut case [doris]

[via GitHub]

github-actions[bot] commented on code in PR #44351:
URL: https://github.com/apache/doris/pull/44351#discussion_r1850244178


##########
be/test/olap/rowset/segment_v2/bloom_filter_index_reader_writer_test.cpp:
##########
@@ -295,5 +296,261 @@
     delete[] val;
 }
 
+TEST_F(BloomFilterIndexReaderWriterTest, test_datev2) {
+    size_t num = 1024 * 3 - 1;
+    uint32_t* val = new uint32_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = 20210101 + i; // YYYYMMDD
+    }
+
+    std::string file_name = "bloom_filter_datev2";
+    uint32_t not_exist_value = 20211231;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DATEV2>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_datetimev2) {
+    size_t num = 1024 * 3 - 1;
+    uint64_t* val = new uint64_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = 20210101000000 + i; // YYYYMMDDHHMMSS
+    }
+
+    std::string file_name = "bloom_filter_datetimev2";
+    uint64_t not_exist_value = 20211231235959;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DATETIMEV2>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_decimal32) {
+    size_t num = 1024 * 3 - 1;
+    int32_t* val = new int32_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = static_cast<int32_t>(i * 100 + 1);
+    }
+
+    std::string file_name = "bloom_filter_decimal32";
+    int32_t not_exist_value = 99999;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DECIMAL32>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_decimal64) {
+    size_t num = 1024 * 3 - 1;
+    ;
+    int64_t* val = new int64_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = static_cast<int64_t>(i * 1000 + 123);
+    }
+
+    std::string file_name = "bloom_filter_decimal64";
+    int64_t not_exist_value = 9999999;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DECIMAL64>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_ipv4) {
+    size_t num = 1024 * 3 - 1;
+    uint32_t* val = new uint32_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = (192 << 24) | (168 << 16) | (i >> 8) | (i & 0xFF);
+    }
+
+    std::string file_name = "bloom_filter_ipv4";
+    uint32_t not_exist_value = (10 << 24) | (0 << 16) | (0 << 8) | 1;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_IPV4>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_decimal128i) {
+    size_t num = 1024 * 3 - 1;
+    int128_t* val = new int128_t[num];

Review Comment:
   warning: use auto when initializing with new to avoid duplicating the type 
name [modernize-use-auto]
   
   ```suggestion
       auto* val = new int128_t[num];
   ```
   



##########
be/test/olap/rowset/segment_v2/bloom_filter_index_reader_writer_test.cpp:
##########
@@ -295,5 +296,261 @@
     delete[] val;
 }
 
+TEST_F(BloomFilterIndexReaderWriterTest, test_datev2) {
+    size_t num = 1024 * 3 - 1;
+    uint32_t* val = new uint32_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = 20210101 + i; // YYYYMMDD
+    }
+
+    std::string file_name = "bloom_filter_datev2";
+    uint32_t not_exist_value = 20211231;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DATEV2>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_datetimev2) {
+    size_t num = 1024 * 3 - 1;
+    uint64_t* val = new uint64_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = 20210101000000 + i; // YYYYMMDDHHMMSS
+    }
+
+    std::string file_name = "bloom_filter_datetimev2";
+    uint64_t not_exist_value = 20211231235959;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DATETIMEV2>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_decimal32) {
+    size_t num = 1024 * 3 - 1;
+    int32_t* val = new int32_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = static_cast<int32_t>(i * 100 + 1);
+    }
+
+    std::string file_name = "bloom_filter_decimal32";
+    int32_t not_exist_value = 99999;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DECIMAL32>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_decimal64) {
+    size_t num = 1024 * 3 - 1;
+    ;
+    int64_t* val = new int64_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = static_cast<int64_t>(i * 1000 + 123);
+    }
+
+    std::string file_name = "bloom_filter_decimal64";
+    int64_t not_exist_value = 9999999;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DECIMAL64>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_ipv4) {
+    size_t num = 1024 * 3 - 1;
+    uint32_t* val = new uint32_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = (192 << 24) | (168 << 16) | (i >> 8) | (i & 0xFF);
+    }
+
+    std::string file_name = "bloom_filter_ipv4";
+    uint32_t not_exist_value = (10 << 24) | (0 << 16) | (0 << 8) | 1;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_IPV4>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_decimal128i) {
+    size_t num = 1024 * 3 - 1;
+    int128_t* val = new int128_t[num];
+
+    int128_t base_value = int128_t(1000000000ULL) * int128_t(1000000000ULL);
+
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = base_value + int128_t(i);
+    }
+
+    std::string file_name = "bloom_filter_decimal128i";
+    int128_t not_exist_value = int128_t(9999999999999999999ULL);
+
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DECIMAL128I>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_decimal256) {
+    size_t num = 1024 * 3 - 1;
+    using Decimal256Type = wide::Int256;
+
+    Decimal256Type* val = new Decimal256Type[num];
+
+    Decimal256Type base_value = Decimal256Type(1000000000ULL); // 1e9
+    base_value *= Decimal256Type(1000000000ULL);               // base_value = 
1e18
+    base_value *= Decimal256Type(100000000ULL);                // base_value = 
1e26
+    base_value *= Decimal256Type(100000000ULL);                // base_value = 
1e34
+    base_value *= Decimal256Type(10000ULL);                    // base_value = 
1e38
+
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = base_value + Decimal256Type(i);
+    }
+
+    std::string file_name = "bloom_filter_decimal256";
+
+    Decimal256Type not_exist_value = base_value + Decimal256Type(9999999ULL);
+
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DECIMAL256>(
+            file_name, val, num, 1, &not_exist_value);
+
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_ipv6) {
+    size_t num = 1024 * 3 - 1;
+    uint128_t* val = new uint128_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = (uint128_t(0x20010DB800000000) << 64) | uint128_t(i);
+    }
+
+    std::string file_name = "bloom_filter_ipv6";
+    uint128_t not_exist_value = (uint128_t(0x20010DB800000000) << 64) | 
uint128_t(999999);
+
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_IPV6>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+void test_ngram_bloom_filter_index_reader_writer(const std::string& file_name, 
Slice* values,

Review Comment:
   warning: function 'test_ngram_bloom_filter_index_reader_writer' exceeds 
recommended size/complexity thresholds [readability-function-size]
   ```cpp
   void test_ngram_bloom_filter_index_reader_writer(const std::string& 
file_name, Slice* values,
        ^
   ```
   <details>
   <summary>Additional context</summary>
   
   
**be/test/olap/rowset/segment_v2/bloom_filter_index_reader_writer_test.cpp:428:**
 95 lines including whitespace and comments (threshold 80)
   ```cpp
   void test_ngram_bloom_filter_index_reader_writer(const std::string& 
file_name, Slice* values,
        ^
   ```
   
   </details>
   



##########
be/test/olap/rowset/segment_v2/bloom_filter_index_reader_writer_test.cpp:
##########
@@ -295,5 +296,261 @@
     delete[] val;
 }
 
+TEST_F(BloomFilterIndexReaderWriterTest, test_datev2) {
+    size_t num = 1024 * 3 - 1;
+    uint32_t* val = new uint32_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = 20210101 + i; // YYYYMMDD
+    }
+
+    std::string file_name = "bloom_filter_datev2";
+    uint32_t not_exist_value = 20211231;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DATEV2>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_datetimev2) {
+    size_t num = 1024 * 3 - 1;
+    uint64_t* val = new uint64_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = 20210101000000 + i; // YYYYMMDDHHMMSS
+    }
+
+    std::string file_name = "bloom_filter_datetimev2";
+    uint64_t not_exist_value = 20211231235959;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DATETIMEV2>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_decimal32) {
+    size_t num = 1024 * 3 - 1;
+    int32_t* val = new int32_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = static_cast<int32_t>(i * 100 + 1);
+    }
+
+    std::string file_name = "bloom_filter_decimal32";
+    int32_t not_exist_value = 99999;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DECIMAL32>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_decimal64) {
+    size_t num = 1024 * 3 - 1;
+    ;
+    int64_t* val = new int64_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = static_cast<int64_t>(i * 1000 + 123);
+    }
+
+    std::string file_name = "bloom_filter_decimal64";
+    int64_t not_exist_value = 9999999;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DECIMAL64>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_ipv4) {
+    size_t num = 1024 * 3 - 1;
+    uint32_t* val = new uint32_t[num];

Review Comment:
   warning: use auto when initializing with new to avoid duplicating the type 
name [modernize-use-auto]
   
   ```suggestion
       auto* val = new uint32_t[num];
   ```
   



##########
be/test/olap/rowset/segment_v2/bloom_filter_index_reader_writer_test.cpp:
##########
@@ -295,5 +296,261 @@
     delete[] val;
 }
 
+TEST_F(BloomFilterIndexReaderWriterTest, test_datev2) {
+    size_t num = 1024 * 3 - 1;
+    uint32_t* val = new uint32_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = 20210101 + i; // YYYYMMDD
+    }
+
+    std::string file_name = "bloom_filter_datev2";
+    uint32_t not_exist_value = 20211231;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DATEV2>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_datetimev2) {
+    size_t num = 1024 * 3 - 1;
+    uint64_t* val = new uint64_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = 20210101000000 + i; // YYYYMMDDHHMMSS
+    }
+
+    std::string file_name = "bloom_filter_datetimev2";
+    uint64_t not_exist_value = 20211231235959;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DATETIMEV2>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_decimal32) {
+    size_t num = 1024 * 3 - 1;
+    int32_t* val = new int32_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = static_cast<int32_t>(i * 100 + 1);
+    }
+
+    std::string file_name = "bloom_filter_decimal32";
+    int32_t not_exist_value = 99999;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DECIMAL32>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_decimal64) {
+    size_t num = 1024 * 3 - 1;
+    ;
+    int64_t* val = new int64_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = static_cast<int64_t>(i * 1000 + 123);
+    }
+
+    std::string file_name = "bloom_filter_decimal64";
+    int64_t not_exist_value = 9999999;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DECIMAL64>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_ipv4) {
+    size_t num = 1024 * 3 - 1;
+    uint32_t* val = new uint32_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = (192 << 24) | (168 << 16) | (i >> 8) | (i & 0xFF);
+    }
+
+    std::string file_name = "bloom_filter_ipv4";
+    uint32_t not_exist_value = (10 << 24) | (0 << 16) | (0 << 8) | 1;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_IPV4>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_decimal128i) {
+    size_t num = 1024 * 3 - 1;
+    int128_t* val = new int128_t[num];
+
+    int128_t base_value = int128_t(1000000000ULL) * int128_t(1000000000ULL);
+
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = base_value + int128_t(i);
+    }
+
+    std::string file_name = "bloom_filter_decimal128i";
+    int128_t not_exist_value = int128_t(9999999999999999999ULL);
+
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DECIMAL128I>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_decimal256) {
+    size_t num = 1024 * 3 - 1;
+    using Decimal256Type = wide::Int256;
+
+    Decimal256Type* val = new Decimal256Type[num];
+
+    Decimal256Type base_value = Decimal256Type(1000000000ULL); // 1e9
+    base_value *= Decimal256Type(1000000000ULL);               // base_value = 
1e18
+    base_value *= Decimal256Type(100000000ULL);                // base_value = 
1e26
+    base_value *= Decimal256Type(100000000ULL);                // base_value = 
1e34
+    base_value *= Decimal256Type(10000ULL);                    // base_value = 
1e38
+
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = base_value + Decimal256Type(i);
+    }
+
+    std::string file_name = "bloom_filter_decimal256";
+
+    Decimal256Type not_exist_value = base_value + Decimal256Type(9999999ULL);
+
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DECIMAL256>(
+            file_name, val, num, 1, &not_exist_value);
+
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_ipv6) {
+    size_t num = 1024 * 3 - 1;
+    uint128_t* val = new uint128_t[num];

Review Comment:
   warning: use auto when initializing with new to avoid duplicating the type 
name [modernize-use-auto]
   
   ```suggestion
       auto* val = new uint128_t[num];
   ```
   



##########
be/test/olap/rowset/segment_v2/bloom_filter_index_reader_writer_test.cpp:
##########
@@ -295,5 +296,261 @@
     delete[] val;
 }
 
+TEST_F(BloomFilterIndexReaderWriterTest, test_datev2) {
+    size_t num = 1024 * 3 - 1;
+    uint32_t* val = new uint32_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = 20210101 + i; // YYYYMMDD
+    }
+
+    std::string file_name = "bloom_filter_datev2";
+    uint32_t not_exist_value = 20211231;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DATEV2>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_datetimev2) {
+    size_t num = 1024 * 3 - 1;
+    uint64_t* val = new uint64_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = 20210101000000 + i; // YYYYMMDDHHMMSS
+    }
+
+    std::string file_name = "bloom_filter_datetimev2";
+    uint64_t not_exist_value = 20211231235959;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DATETIMEV2>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_decimal32) {
+    size_t num = 1024 * 3 - 1;
+    int32_t* val = new int32_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = static_cast<int32_t>(i * 100 + 1);
+    }
+
+    std::string file_name = "bloom_filter_decimal32";
+    int32_t not_exist_value = 99999;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DECIMAL32>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_decimal64) {
+    size_t num = 1024 * 3 - 1;
+    ;
+    int64_t* val = new int64_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = static_cast<int64_t>(i * 1000 + 123);
+    }
+
+    std::string file_name = "bloom_filter_decimal64";
+    int64_t not_exist_value = 9999999;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DECIMAL64>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_ipv4) {
+    size_t num = 1024 * 3 - 1;
+    uint32_t* val = new uint32_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = (192 << 24) | (168 << 16) | (i >> 8) | (i & 0xFF);
+    }
+
+    std::string file_name = "bloom_filter_ipv4";
+    uint32_t not_exist_value = (10 << 24) | (0 << 16) | (0 << 8) | 1;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_IPV4>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_decimal128i) {
+    size_t num = 1024 * 3 - 1;
+    int128_t* val = new int128_t[num];
+
+    int128_t base_value = int128_t(1000000000ULL) * int128_t(1000000000ULL);
+
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = base_value + int128_t(i);
+    }
+
+    std::string file_name = "bloom_filter_decimal128i";
+    int128_t not_exist_value = int128_t(9999999999999999999ULL);

Review Comment:
   warning: use auto when initializing with a cast to avoid duplicating the 
type name [modernize-use-auto]
   
   ```suggestion
       auto not_exist_value = int128_t(9999999999999999999ULL);
   ```
   



##########
be/test/olap/rowset/segment_v2/bloom_filter_index_reader_writer_test.cpp:
##########
@@ -295,5 +296,261 @@ TEST_F(BloomFilterIndexReaderWriterTest, test_decimal) {
     delete[] val;
 }
 
+TEST_F(BloomFilterIndexReaderWriterTest, test_datev2) {
+    size_t num = 1024 * 3 - 1;
+    uint32_t* val = new uint32_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = 20210101 + i; // YYYYMMDD
+    }
+
+    std::string file_name = "bloom_filter_datev2";
+    uint32_t not_exist_value = 20211231;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DATEV2>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_datetimev2) {
+    size_t num = 1024 * 3 - 1;
+    uint64_t* val = new uint64_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = 20210101000000 + i; // YYYYMMDDHHMMSS
+    }
+
+    std::string file_name = "bloom_filter_datetimev2";
+    uint64_t not_exist_value = 20211231235959;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DATETIMEV2>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_decimal32) {
+    size_t num = 1024 * 3 - 1;
+    int32_t* val = new int32_t[num];
+    for (size_t i = 0; i < num; ++i) {
+        val[i] = static_cast<int32_t>(i * 100 + 1);
+    }
+
+    std::string file_name = "bloom_filter_decimal32";
+    int32_t not_exist_value = 99999;
+    
test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DECIMAL32>(
+            file_name, val, num, 1, &not_exist_value);
+    delete[] val;
+}
+
+TEST_F(BloomFilterIndexReaderWriterTest, test_decimal64) {
+    size_t num = 1024 * 3 - 1;
+    ;
+    int64_t* val = new int64_t[num];

Review Comment:
   warning: use auto when initializing with new to avoid duplicating the type 
name [modernize-use-auto]
   
   ```suggestion
       auto* val = new int64_t[num];
   ```
   



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: commits-unsubscr...@doris.apache.org

For queries about this service, please contact Infrastructure at:
us...@infra.apache.org


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscr...@doris.apache.org
For additional commands, e-mail: commits-h...@doris.apache.org