[refactor](predicate) Refactor zone map

be/src/olap/accept_null_predicate.h

@@ -106,12 +106,12 @@ class AcceptNullPredicate : public ColumnPredicate {
         DCHECK(false) << "should not reach here";
     }
 
-    bool evaluate_and(const std::pair<WrapperField*, WrapperField*>& statistic) const override {
+    bool evaluate_and(const ZoneMapInfo& zone_map_info) const override {
         // there is null in range, accept it
-        if (statistic.first->is_null() || statistic.second->is_null()) {
+        if (zone_map_info.has_null) {
             return true;
         }
-        return _nested->evaluate_and(statistic);
+        return _nested->evaluate_and(zone_map_info);
     }
 
     bool evaluate_and(vectorized::ParquetPredicate::ColumnStat* statistic) const override {
@@ -134,8 +134,8 @@ class AcceptNullPredicate : public ColumnPredicate {
         return row_ranges->count() > 0;
     }
 
-    bool evaluate_del(const std::pair<WrapperField*, WrapperField*>& statistic) const override {
-        return _nested->evaluate_del(statistic);
+    bool evaluate_del(const ZoneMapInfo& zone_map_info) const override {
+        return _nested->evaluate_del(zone_map_info);
     }
 
     bool evaluate_and(const BloomFilter* bf) const override { return _nested->evaluate_and(bf); }

be/src/olap/bitmap_filter_predicate.h

@@ -56,22 +56,22 @@ class BitmapFilterColumnPredicate final : public ColumnPredicate {
 
     PredicateType type() const override { return PredicateType::BITMAP_FILTER; }
 
-    bool evaluate_and(const std::pair<WrapperField*, WrapperField*>& statistic) const override {
+    bool evaluate_and(const ZoneMapInfo& zone_map_info) const override {
         if (_specific_filter->is_not_in()) {
             return true;
         }
 
         CppType max_value;
-        if (statistic.second->is_null()) {
+        if (zone_map_info.is_all_null) {
             // no non-null values
             return false;
         } else {
-            max_value = get_zone_map_value<T, CppType>(statistic.second->cell_ptr());
+            max_value = CppType(zone_map_info.max_value.template get<T>());
         }
 
-        CppType min_value = statistic.first->is_null() /* contains null values */
-                                    ? 0
-                                    : get_zone_map_value<T, CppType>(statistic.first->cell_ptr());
+        CppType min_value = zone_map_info.has_null /* contains null values */
+                                    ? CppType(0)
+                                    : CppType(zone_map_info.min_value.template get<T>());
         return _specific_filter->contains_any(min_value, max_value);
     }
 

be/src/olap/block_column_predicate.cpp

@@ -24,7 +24,6 @@ class Roaring;
 } // namespace roaring
 
 namespace doris {
-class WrapperField;
 namespace segment_v2 {
 class InvertedIndexIterator;
 } // namespace segment_v2
@@ -43,9 +42,8 @@ void SingleColumnBlockPredicate::evaluate_and(vectorized::MutableColumns& block,
     _predicate->evaluate_and(*column, sel, selected_size, flags);
 }
 
-bool SingleColumnBlockPredicate::evaluate_and(
-        const std::pair<WrapperField*, WrapperField*>& statistic) const {
-    return _predicate->evaluate_and(statistic);
+bool SingleColumnBlockPredicate::evaluate_and(const ZoneMapInfo& zone_map_info) const {
+    return _predicate->evaluate_and(zone_map_info);
 }
 
 bool SingleColumnBlockPredicate::evaluate_and(const segment_v2::BloomFilter* bf) const {
@@ -174,10 +172,9 @@ void AndBlockColumnPredicate::evaluate_and(vectorized::MutableColumns& block, ui
     }
 }
 
-bool AndBlockColumnPredicate::evaluate_and(
-        const std::pair<WrapperField*, WrapperField*>& statistic) const {
+bool AndBlockColumnPredicate::evaluate_and(const ZoneMapInfo& zone_map_info) const {
     for (auto& block_column_predicate : _block_column_predicate_vec) {
-        if (!block_column_predicate->evaluate_and(statistic)) {
+        if (!block_column_predicate->evaluate_and(zone_map_info)) {
             return false;
         }
     }

be/src/olap/block_column_predicate.h

@@ -40,8 +40,6 @@ class Roaring;
 } // namespace roaring
 
 namespace doris {
-class WrapperField;
-
 namespace segment_v2 {
 class BloomFilter;
 class InvertedIndexIterator;
@@ -76,7 +74,7 @@ class BlockColumnPredicate {
 
     virtual bool support_zonemap() const { return true; }
 
-    virtual bool evaluate_and(const std::pair<WrapperField*, WrapperField*>& statistic) const {
+    virtual bool evaluate_and(const ZoneMapInfo& zone_map_info) const {
         throw Exception(Status::FatalError("should not reach here"));
     }
 
@@ -135,7 +133,7 @@ class SingleColumnBlockPredicate : public BlockColumnPredicate {
     void evaluate_and(vectorized::MutableColumns& block, uint16_t* sel, uint16_t selected_size,
                       bool* flags) const override;
     bool support_zonemap() const override { return _predicate->support_zonemap(); }
-    bool evaluate_and(const std::pair<WrapperField*, WrapperField*>& statistic) const override;
+    bool evaluate_and(const ZoneMapInfo& zone_map_info) const override;
     bool evaluate_and(vectorized::ParquetPredicate::ColumnStat* statistic) const override {
         return _predicate->evaluate_and(statistic);
     }
@@ -240,7 +238,7 @@ class AndBlockColumnPredicate : public MutilColumnBlockPredicate {
 
     void evaluate_vec(vectorized::MutableColumns& block, uint16_t size, bool* flags) const override;
 
-    bool evaluate_and(const std::pair<WrapperField*, WrapperField*>& statistic) const override;
+    bool evaluate_and(const ZoneMapInfo& zone_map_info) const override;
 
     bool evaluate_and(const segment_v2::BloomFilter* bf) const override;
 

be/src/olap/column_predicate.h

@@ -196,6 +196,13 @@ struct PredicateTypeTraits {
         }                                                                                 \
     }
 
+struct ZoneMapInfo {
+    vectorized::Field min_value;
+    vectorized::Field max_value;
+    bool has_null;
+    bool is_all_null;
+};
+
 class ColumnPredicate : public std::enable_shared_from_this<ColumnPredicate> {
 public:
     explicit ColumnPredicate(uint32_t column_id, std::string col_name, PrimitiveType primitive_type,
@@ -260,17 +267,11 @@ class ColumnPredicate : public std::enable_shared_from_this<ColumnPredicate> {
 
     virtual bool support_zonemap() const { return true; }
 
-    virtual bool evaluate_and(const std::pair<WrapperField*, WrapperField*>& statistic) const {
-        return true;
-    }
+    virtual bool evaluate_and(const ZoneMapInfo& zone_map_info) const { return true; }
 
-    virtual bool is_always_true(const std::pair<WrapperField*, WrapperField*>& statistic) const {
-        return false;
-    }
+    virtual bool is_always_true(const ZoneMapInfo& zone_map_info) const { return false; }
 
-    virtual bool evaluate_del(const std::pair<WrapperField*, WrapperField*>& statistic) const {
-        return false;
-    }
+    virtual bool evaluate_del(const ZoneMapInfo& zone_map_info) const { return false; }
 
     virtual bool evaluate_and(const vectorized::ParquetBlockSplitBloomFilter* bf) const {
         return true;

be/src/olap/comparison_predicate.h

@@ -134,13 +134,13 @@ class ComparisonPredicateBase final : public ColumnPredicate {
         _evaluate_bit<true>(column, sel, size, flags);
     }
 
-    bool evaluate_and(const std::pair<WrapperField*, WrapperField*>& statistic) const override {
-        if (statistic.first->is_null() && statistic.second->is_null()) {
+    bool evaluate_and(const ZoneMapInfo& zone_map_info) const override {
+        if (zone_map_info.is_all_null) {
             return false;
         }
 
-        T tmp_min_value = get_zone_map_value<Type, T>(statistic.first->cell_ptr());
-        T tmp_max_value = get_zone_map_value<Type, T>(statistic.second->cell_ptr());
+        T tmp_min_value = T(zone_map_info.min_value.template get<Type>());
+        T tmp_max_value = T(zone_map_info.max_value.template get<Type>());
 
         if constexpr (PT == PredicateType::EQ) {
             return _operator(Compare::less_equal(tmp_min_value, _value) &&
@@ -254,13 +254,13 @@ class ComparisonPredicateBase final : public ColumnPredicate {
         return row_ranges->count() > 0;
     }
 
-    bool is_always_true(const std::pair<WrapperField*, WrapperField*>& statistic) const override {
-        if (statistic.first->is_null() || statistic.second->is_null()) {
+    bool is_always_true(const ZoneMapInfo& zone_map_info) const override {
+        if (zone_map_info.has_null) {
             return false;
         }
 
-        T tmp_min_value = get_zone_map_value<Type, T>(statistic.first->cell_ptr());
-        T tmp_max_value = get_zone_map_value<Type, T>(statistic.second->cell_ptr());
+        T tmp_min_value = T(zone_map_info.min_value.template get<Type>());
+        T tmp_max_value = T(zone_map_info.max_value.template get<Type>());
 
         if constexpr (PT == PredicateType::LT) {
             return _value > tmp_max_value;
@@ -275,13 +275,13 @@ class ComparisonPredicateBase final : public ColumnPredicate {
         return false;
     }
 
-    bool evaluate_del(const std::pair<WrapperField*, WrapperField*>& statistic) const override {
-        if (statistic.first->is_null() || statistic.second->is_null()) {
+    bool evaluate_del(const ZoneMapInfo& zone_map_info) const override {
+        if (zone_map_info.has_null) {
             return false;
         }
 
-        T tmp_min_value = get_zone_map_value<Type, T>(statistic.first->cell_ptr());
-        T tmp_max_value = get_zone_map_value<Type, T>(statistic.second->cell_ptr());
+        T tmp_min_value = T(zone_map_info.min_value.template get<Type>());
+        T tmp_max_value = T(zone_map_info.max_value.template get<Type>());
 
         if constexpr (PT == PredicateType::EQ) {
             return tmp_min_value == _value && tmp_max_value == _value;

be/src/olap/field.h

@@ -623,7 +623,6 @@ class FieldFactory {
             CHECK(false) << ", value column no agg type";
             return nullptr;
         }
-        return nullptr;
     }
 
     static Field* create_by_type(const FieldType& type) {

be/src/olap/in_list_predicate.h

@@ -240,14 +240,14 @@ class InListPredicateBase final : public ColumnPredicate {
         _evaluate_bit<false>(column, sel, size, flags);
     }
 
-    bool evaluate_and(const std::pair<WrapperField*, WrapperField*>& statistic) const override {
-        if (statistic.first->is_null() && statistic.second->is_null()) {
+    bool evaluate_and(const ZoneMapInfo& zone_map_info) const override {
+        if (zone_map_info.is_all_null) {
             return false;
         }
         if constexpr (PT == PredicateType::IN_LIST) {
-            return Compare::less_equal(get_zone_map_value<Type, T>(statistic.first->cell_ptr()),
+            return Compare::less_equal(T(zone_map_info.min_value.template get<Type>()),
                                        _max_value) &&
-                   Compare::greater_equal(get_zone_map_value<Type, T>(statistic.second->cell_ptr()),
+                   Compare::greater_equal(T(zone_map_info.max_value.template get<Type>()),
                                           _min_value);
         } else {
             return true;
@@ -349,15 +349,13 @@ class InListPredicateBase final : public ColumnPredicate {
         return false;
     }
 
-    bool evaluate_del(const std::pair<WrapperField*, WrapperField*>& statistic) const override {
-        if (statistic.first->is_null() || statistic.second->is_null()) {
+    bool evaluate_del(const ZoneMapInfo& zone_map_info) const override {
+        if (zone_map_info.has_null) {
             return false;
         }
         if constexpr (PT == PredicateType::NOT_IN_LIST) {
-            return Compare::greater(get_zone_map_value<Type, T>(statistic.first->cell_ptr()),
-                                    _max_value) ||
-                   Compare::less(get_zone_map_value<Type, T>(statistic.second->cell_ptr()),
-                                 _min_value);
+            return Compare::greater(T(zone_map_info.min_value.template get<Type>()), _max_value) ||
+                   Compare::less(T(zone_map_info.max_value.template get<Type>()), _min_value);
         } else {
             return false;
         }

be/src/olap/null_predicate.h

@@ -74,11 +74,11 @@ class NullPredicate final : public ColumnPredicate {
     void evaluate_and(const vectorized::IColumn& column, const uint16_t* sel, uint16_t size,
                       bool* flags) const override;
 
-    bool evaluate_and(const std::pair<WrapperField*, WrapperField*>& statistic) const override {
+    bool evaluate_and(const ZoneMapInfo& zone_map_info) const override {
         if (_is_null) {
-            return statistic.first->is_null();
+            return zone_map_info.has_null;
         } else {
-            return !statistic.second->is_null();
+            return !zone_map_info.is_all_null;
         }
     }
 
@@ -108,14 +108,14 @@ class NullPredicate final : public ColumnPredicate {
         return row_ranges->count() > 0;
     }
 
-    bool evaluate_del(const std::pair<WrapperField*, WrapperField*>& statistic) const override {
+    bool evaluate_del(const ZoneMapInfo& zone_map_info) const override {
         // evaluate_del only use for delete condition to filter page, need use delete condition origin value,
         // when opposite==true, origin value 'is null'->'is not null' and 'is not null'->'is null',
         // so when _is_null==true, need check 'is not null' and _is_null==false, need check 'is null'
         if (_is_null) {
-            return !statistic.first->is_null() && !statistic.second->is_null();
+            return !zone_map_info.has_null;
         } else {
-            return statistic.first->is_null() && statistic.second->is_null();
+            return zone_map_info.is_all_null;
         }
     }
 

be/src/olap/olap_common.h

@@ -282,8 +282,6 @@ struct Vertex {
 };
 
 class Field;
-class WrapperField;
-using KeyRange = std::pair<WrapperField*, WrapperField*>;
 
 // ReaderStatistics used to collect statistics when scan data from storage
 struct OlapReaderStatistics {