diff --git a/be/src/exec/operator/olap_scan_operator.cpp b/be/src/exec/operator/olap_scan_operator.cpp
index da855aff32d4d8..911a321f21f5f9 100644
--- a/be/src/exec/operator/olap_scan_operator.cpp
+++ b/be/src/exec/operator/olap_scan_operator.cpp
@@ -222,6 +222,16 @@ Status OlapScanLocalState::_init_profile() {
     _stats_filtered_counter = ADD_COUNTER(_segment_profile, "RowsStatsFiltered", TUnit::UNIT);
     _stats_rp_filtered_counter =
             ADD_COUNTER(_segment_profile, "RowsZoneMapRuntimePredicateFiltered", TUnit::UNIT);
+    _expr_zonemap_filtered_segment_counter =
+            ADD_COUNTER(_segment_profile, "ExprZoneMapFilteredSegments", TUnit::UNIT);
+    _expr_zonemap_filtered_page_counter =
+            ADD_COUNTER(_segment_profile, "ExprZoneMapFilteredPages", TUnit::UNIT);
+    _expr_zonemap_unusable_counter =
+            ADD_COUNTER(_segment_profile, "ExprZoneMapUnusableEvals", TUnit::UNIT);
+    _in_zonemap_point_check_counter =
+            ADD_COUNTER(_segment_profile, "InZoneMapPointCheckCount", TUnit::UNIT);
+    _in_zonemap_range_only_counter =
+            ADD_COUNTER(_segment_profile, "InZoneMapRangeOnlyCount", TUnit::UNIT);
     _bf_filtered_counter = ADD_COUNTER(_segment_profile, "RowsBloomFilterFiltered", TUnit::UNIT);
     _dict_filtered_counter = ADD_COUNTER(_segment_profile, "SegmentDictFiltered", TUnit::UNIT);
     _del_filtered_counter = ADD_COUNTER(_scanner_profile, "RowsDelFiltered", TUnit::UNIT);
diff --git a/be/src/exec/operator/olap_scan_operator.h b/be/src/exec/operator/olap_scan_operator.h
index e8664257714f16..57c4912b777f6b 100644
--- a/be/src/exec/operator/olap_scan_operator.h
+++ b/be/src/exec/operator/olap_scan_operator.h
@@ -156,6 +156,17 @@ class OlapScanLocalState final : public ScanLocalState<OlapScanLocalState> {
 
     RuntimeProfile::Counter* _stats_filtered_counter = nullptr;
     RuntimeProfile::Counter* _stats_rp_filtered_counter = nullptr;
+    // Number of whole segments skipped by expression ZoneMap evaluation.
+    RuntimeProfile::Counter* _expr_zonemap_filtered_segment_counter = nullptr;
+    // Number of pages skipped by expression ZoneMap evaluation after page index ranges are built.
+    RuntimeProfile::Counter* _expr_zonemap_filtered_page_counter = nullptr;
+    // Number of expression ZoneMap evaluations that reached the evaluator but could not use the
+    // current ZoneMap context, such as missing slot/page ZoneMap or unusable range statistics.
+    RuntimeProfile::Counter* _expr_zonemap_unusable_counter = nullptr;
+    // Number of IN-predicate ZoneMap evaluations that used per-value point checks.
+    RuntimeProfile::Counter* _in_zonemap_point_check_counter = nullptr;
+    // Number of IN-predicate ZoneMap evaluations that fell back to min/max range overlap only.
+    RuntimeProfile::Counter* _in_zonemap_range_only_counter = nullptr;
     RuntimeProfile::Counter* _bf_filtered_counter = nullptr;
     RuntimeProfile::Counter* _dict_filtered_counter = nullptr;
     RuntimeProfile::Counter* _del_filtered_counter = nullptr;
diff --git a/be/src/exec/runtime_filter/runtime_filter_consumer.cpp b/be/src/exec/runtime_filter/runtime_filter_consumer.cpp
index e33bb8e41c39d8..d82900d2540c22 100644
--- a/be/src/exec/runtime_filter/runtime_filter_consumer.cpp
+++ b/be/src/exec/runtime_filter/runtime_filter_consumer.cpp
@@ -101,7 +101,7 @@ Status RuntimeFilterConsumer::_get_push_exprs(std::vector<VRuntimeFilterPtr>& co
         node.in_predicate.__set_is_not_in(false);
         node.__set_opcode(TExprOpcode::FILTER_IN);
         node.__set_is_nullable(false);
-        auto in_pred = VDirectInPredicate::create_shared(node, _wrapper->hybrid_set());
+        auto in_pred = VDirectInPredicate::create_shared(node, _wrapper->hybrid_set(), true);
         in_pred->add_child(probe_ctx->root());
         auto wrapper = VRuntimeFilterWrapper::create_shared(
                 node, in_pred, get_in_list_ignore_thredhold(_wrapper->hybrid_set()->size()),
diff --git a/be/src/exec/scan/olap_scanner.cpp b/be/src/exec/scan/olap_scanner.cpp
index 5dec25aca0c4b5..56684d5ffff802 100644
--- a/be/src/exec/scan/olap_scanner.cpp
+++ b/be/src/exec/scan/olap_scanner.cpp
@@ -739,6 +739,14 @@ void OlapScanner::_collect_profile_before_close() {
     COUNTER_UPDATE(local_state->_rows_expr_cond_input_counter, stats.expr_cond_input_rows);
     COUNTER_UPDATE(local_state->_stats_filtered_counter, stats.rows_stats_filtered);
     COUNTER_UPDATE(local_state->_stats_rp_filtered_counter, stats.rows_stats_rp_filtered);
+    COUNTER_UPDATE(local_state->_expr_zonemap_filtered_segment_counter,
+                   stats.expr_zonemap_filtered_segments);
+    COUNTER_UPDATE(local_state->_expr_zonemap_filtered_page_counter,
+                   stats.expr_zonemap_filtered_pages);
+    COUNTER_UPDATE(local_state->_expr_zonemap_unusable_counter, stats.expr_zonemap_unusable_evals);
+    COUNTER_UPDATE(local_state->_in_zonemap_point_check_counter,
+                   stats.in_zonemap_point_check_count);
+    COUNTER_UPDATE(local_state->_in_zonemap_range_only_counter, stats.in_zonemap_range_only_count);
     COUNTER_UPDATE(local_state->_dict_filtered_counter, stats.segment_dict_filtered);
     COUNTER_UPDATE(local_state->_bf_filtered_counter, stats.rows_bf_filtered);
     COUNTER_UPDATE(local_state->_del_filtered_counter, stats.rows_del_filtered);
diff --git a/be/src/exprs/expr_zonemap_filter.cpp b/be/src/exprs/expr_zonemap_filter.cpp
new file mode 100644
index 00000000000000..19457beb37416b
--- /dev/null
+++ b/be/src/exprs/expr_zonemap_filter.cpp
@@ -0,0 +1,267 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "exprs/expr_zonemap_filter.h"
+
+#include <algorithm>
+#include <set>
+#include <utility>
+
+#include "common/logging.h"
+#include "core/column/column.h"
+#include "core/data_type/data_type_nullable.h"
+#include "core/string_ref.h"
+#include "exprs/hybrid_set.h"
+#include "exprs/vexpr.h"
+#include "exprs/vexpr_context.h"
+#include "exprs/vliteral.h"
+#include "exprs/vslot_ref.h"
+#include "runtime/runtime_state.h"
+
+namespace doris::expr_zonemap {
+namespace {
+
+constexpr size_t kInZoneMapPointCheckThreshold = 64;
+
+std::optional<std::pair<Field, DataTypePtr>> field_from_literal_expr(const VExprSPtr& expr) {
+    auto literal = std::dynamic_pointer_cast<VLiteral>(expr);
+    if (literal == nullptr) {
+        return std::nullopt;
+    }
+    Field field;
+    literal->get_column_ptr()->get(0, field);
+    return std::make_pair(std::move(field), literal->get_data_type());
+}
+
+bool value_in_range(const Field& value, const Field& min_value, const Field& max_value) {
+    return value >= min_value && value <= max_value;
+}
+
+} // namespace
+
+TExprNode create_texpr_node_from_hybrid_set_value(const void* data, const PrimitiveType& type,
+                                                  int precision, int scale) {
+    if (is_string_type(type)) {
+        const auto* value = reinterpret_cast<const StringRef*>(data);
+        auto field = Field::create_field<TYPE_STRING>(String(value->data, value->size));
+        return create_texpr_node_from(field, type, precision, scale);
+    }
+    return create_texpr_node_from(data, type, precision, scale);
+}
+
+Status materialize_hybrid_set_for_zonemap_filter(HybridSetBase& set, const DataTypePtr& data_type,
+                                                 InZonemapMaterializedSet* result) {
+    DORIS_CHECK(result != nullptr);
+    DORIS_CHECK(data_type != nullptr);
+    const auto value_type = remove_nullable(data_type);
+    DORIS_CHECK(value_type != nullptr);
+
+    result->contains_null = set.contain_null();
+    result->values.clear();
+    result->min_value = Field();
+    result->max_value = Field();
+
+    auto* iterator = set.begin();
+    while (iterator->has_next()) {
+        const void* value = iterator->get_value();
+        if (value != nullptr) {
+            TExprNode literal_node = create_texpr_node_from_hybrid_set_value(
+                    value, value_type->get_primitive_type(), value_type->get_precision(),
+                    value_type->get_scale());
+            auto literal = VLiteral::create_shared(literal_node);
+            Field field;
+            literal->get_column_ptr()->get(0, field);
+            result->values.emplace_back(std::move(field));
+        }
+        iterator->next();
+    }
+
+    if (!result->values.empty()) {
+        auto minmax = std::ranges::minmax_element(
+                result->values, [](const Field& lhs, const Field& rhs) { return lhs < rhs; });
+        result->min_value = *minmax.min;
+        result->max_value = *minmax.max;
+    }
+    return Status::OK();
+}
+
+std::optional<SlotLiteral> extract_slot_and_literal(const VExprSPtrs& args) {
+    if (args.size() != 2) {
+        return std::nullopt;
+    }
+
+    if (auto slot = std::dynamic_pointer_cast<VSlotRef>(args[0]); slot) {
+        auto literal = field_from_literal_expr(args[1]);
+        if (!literal.has_value()) {
+            return std::nullopt;
+        }
+        auto [literal_value, literal_type] = std::move(*literal);
+        return SlotLiteral {.slot_index = slot->column_id(),
+                            .slot_type = slot->data_type(),
+                            .literal = std::move(literal_value),
+                            .literal_type = std::move(literal_type),
+                            .literal_on_left = false};
+    }
+
+    if (auto slot = std::dynamic_pointer_cast<VSlotRef>(args[1]); slot) {
+        auto literal = field_from_literal_expr(args[0]);
+        if (!literal.has_value()) {
+            return std::nullopt;
+        }
+        auto [literal_value, literal_type] = std::move(*literal);
+        return SlotLiteral {.slot_index = slot->column_id(),
+                            .slot_type = slot->data_type(),
+                            .literal = std::move(literal_value),
+                            .literal_type = std::move(literal_type),
+                            .literal_on_left = true};
+    }
+
+    return std::nullopt;
+}
+
+bool range_stats_usable_for_zonemap(const segment_v2::ZoneMap& zone_map,
+                                    const DataTypePtr& data_type) {
+    if (zone_map.pass_all || zone_map.has_nan || zone_map.has_positive_inf ||
+        zone_map.has_negative_inf) {
+        return false;
+    }
+    DORIS_CHECK(data_type != nullptr);
+    auto primitive_type = remove_nullable(data_type)->get_primitive_type();
+    DORIS_CHECK(field_types_compatible(zone_map.min_value.get_type(), primitive_type));
+    DORIS_CHECK(field_types_compatible(zone_map.max_value.get_type(), primitive_type));
+    return true;
+}
+
+ZoneMapFilterResult eval_null_zonemap(const ZoneMapEvalContext& ctx, const VExprSPtrs& arguments,
+                                      bool is_null) {
+    DORIS_CHECK(arguments.size() == 1);
+    auto slot = std::dynamic_pointer_cast<VSlotRef>(arguments[0]);
+    DORIS_CHECK(slot != nullptr);
+    auto zone_map_ptr = ctx.zone_map(slot->column_id());
+    if (zone_map_ptr == nullptr) {
+        return unsupported_zonemap_filter(ctx);
+    }
+    const auto& zone_map = *zone_map_ptr;
+    if (is_null) {
+        return zone_map.has_null ? ZoneMapFilterResult::kMayMatch : ZoneMapFilterResult::kNoMatch;
+    }
+    return zone_map.has_not_null ? ZoneMapFilterResult::kMayMatch : ZoneMapFilterResult::kNoMatch;
+}
+
+ZoneMapFilterResult eval_in_zonemap(const ZoneMapEvalContext& ctx, const VExprSPtr& slot_expr,
+                                    bool is_not_in, const std::vector<Field>& values,
+                                    const Field& min_value, const Field& max_value) {
+    auto slot = std::dynamic_pointer_cast<VSlotRef>(slot_expr);
+    DORIS_CHECK(slot != nullptr);
+    // Empty IN has no candidate values, while NOT IN with an empty set cannot filter anything.
+    if (values.empty()) {
+        return is_not_in ? ZoneMapFilterResult::kMayMatch : ZoneMapFilterResult::kNoMatch;
+    }
+
+    // The caller has materialized the IN set and precomputed its non-null min/max. They must match
+    // the expression slot type before being compared with storage zone-map statistics.
+    DORIS_CHECK(!min_value.is_null());
+    DORIS_CHECK(!max_value.is_null());
+    auto data_type = remove_nullable(slot->data_type());
+    DORIS_CHECK(data_type != nullptr);
+    DORIS_CHECK(field_types_compatible(min_value.get_type(), data_type->get_primitive_type()));
+    DORIS_CHECK(field_types_compatible(max_value.get_type(), data_type->get_primitive_type()));
+
+    // Re-check against the reader-schema type and the available zone map. Missing or unsupported
+    // metadata must conservatively fall back to may-match.
+    auto slot_type = fetch_compatible_slot_type(ctx, slot->column_id(), slot->data_type());
+    if (slot_type == nullptr) {
+        return unsupported_zonemap_filter(ctx);
+    }
+    auto zone_map_ptr = ctx.zone_map(slot->column_id());
+    if (zone_map_ptr == nullptr) {
+        return unsupported_zonemap_filter(ctx);
+    }
+    const auto& zone_map = *zone_map_ptr;
+    // IN values are all non-null here, so an all-null zone cannot match.
+    if (!zone_map.has_not_null) {
+        return ZoneMapFilterResult::kNoMatch;
+    }
+
+    if (!range_stats_usable_for_zonemap(zone_map, slot_type)) {
+        return unsupported_zonemap_filter(ctx);
+    }
+
+    if (is_not_in) {
+        // NOT IN can only prune when the whole zone contains exactly one non-null value and that
+        // value is excluded by the set. Wider ranges may contain values that are not filtered.
+        if (zone_map.min_value == zone_map.max_value) {
+            const bool only_value_is_filtered = std::ranges::any_of(
+                    values, [&](const Field& value) { return value == zone_map.min_value; });
+            return only_value_is_filtered ? ZoneMapFilterResult::kNoMatch
+                                          : ZoneMapFilterResult::kMayMatch;
+        }
+        return ZoneMapFilterResult::kMayMatch;
+    }
+
+    // First use the materialized IN-set min/max to rule out disjoint zone-map ranges.
+    if (zone_map.max_value < min_value || zone_map.min_value > max_value) {
+        return ZoneMapFilterResult::kNoMatch;
+    }
+
+    // For large IN sets, avoid checking every point on the scan hot path. The range overlap above
+    // is only a coarse may-match signal.
+    if (values.size() > kInZoneMapPointCheckThreshold) {
+        ++ctx.stats.in_zonemap_range_only_count;
+        return ZoneMapFilterResult::kMayMatch;
+    }
+
+    // For small IN sets, verify whether any candidate value can fall into the zone-map range.
+    ++ctx.stats.in_zonemap_point_check_count;
+    for (const auto& value : values) {
+        if (value_in_range(value, zone_map.min_value, zone_map.max_value)) {
+            return ZoneMapFilterResult::kMayMatch;
+        }
+    }
+    return ZoneMapFilterResult::kNoMatch;
+}
+
+// Return the only slot ordinal referenced by a zonemap-evaluable expression. A negative result is
+// the conservative fallback marker for unsupported expressions, multi-slot expressions, or invalid
+// slot ordinals, so callers can skip schema-indexed zonemap pruning safely.
+int single_slot_zonemap_index(const VExprContextSPtr& ctx) {
+    DORIS_CHECK(ctx != nullptr);
+    const auto& root = ctx->root();
+    DORIS_CHECK(root != nullptr);
+    if (!root->can_evaluate_zonemap_filter()) {
+        return -1;
+    }
+
+    std::set<int> slot_indexes;
+    root->collect_slot_column_ids(slot_indexes);
+    if (slot_indexes.size() != 1) {
+        return -1;
+    }
+
+    return *slot_indexes.begin();
+}
+
+bool is_expr_zonemap_filter_enabled(const RuntimeState* state) {
+    if (state == nullptr) {
+        return true;
+    }
+    const auto& query_options = state->query_options();
+    return !query_options.__isset.enable_expr_zonemap_filter ||
+           query_options.enable_expr_zonemap_filter;
+}
+
+} // namespace doris::expr_zonemap
diff --git a/be/src/exprs/expr_zonemap_filter.h b/be/src/exprs/expr_zonemap_filter.h
new file mode 100644
index 00000000000000..2d8ff4d0c72207
--- /dev/null
+++ b/be/src/exprs/expr_zonemap_filter.h
@@ -0,0 +1,124 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <compare>
+#include <optional>
+#include <vector>
+
+#include "common/status.h"
+#include "core/data_type/data_type.h"
+#include "core/data_type/data_type_nullable.h"
+#include "core/data_type/define_primitive_type.h"
+#include "core/field.h"
+#include "exprs/vexpr_fwd.h"
+#include "storage/index/zone_map/zonemap_eval_context.h"
+#include "storage/index/zone_map/zonemap_filter_result.h"
+
+namespace doris {
+class HybridSetBase;
+class RuntimeState;
+class TExprNode;
+} // namespace doris
+
+namespace doris::expr_zonemap {
+
+struct InZonemapMaterializedSet {
+    bool contains_null = false;
+    std::vector<Field> values;
+    Field min_value;
+    Field max_value;
+};
+
+struct SlotLiteral {
+    // Slot ordinal in the current expression binding. It is also the key used to look up the
+    // corresponding reader-schema type and zone map from ZoneMapEvalContext.
+    int slot_index;
+    // Type carried by the slot expression. It is kept separately because evaluation first has to
+    // verify that the expression binding is compatible with the reader-schema type stored in the
+    // ZoneMapEvalContext before using schema-indexed zone-map statistics.
+    DataTypePtr slot_type;
+    // Constant literal value paired with the slot, already materialized as a Field for zone-map
+    // comparisons.
+    Field literal;
+    // Type carried by the literal expression. It is needed with slot_type so capability checks can
+    // reject incompatible slot/literal comparisons before runtime evaluation instead of evaluating
+    // zone-map ranges with mismatched Field types.
+    DataTypePtr literal_type;
+    // Whether the original expression shape is literal <op> slot instead of slot <op> literal. The
+    // comparison operator is directional, so evaluators need this flag to normalize cases like
+    // `5 < slot` into the equivalent slot-side comparison before checking the zone map. Non-symmetric
+    // function evaluators also use it to reject unsupported shapes such as `starts_with(literal,
+    // slot)`, because only `starts_with(slot, literal)` can be mapped to a safe zone-map range.
+    bool literal_on_left;
+};
+
+std::optional<SlotLiteral> extract_slot_and_literal(const VExprSPtrs& args);
+
+TExprNode create_texpr_node_from_hybrid_set_value(const void* data, const PrimitiveType& type,
+                                                  int precision, int scale);
+
+Status materialize_hybrid_set_for_zonemap_filter(HybridSetBase& set, const DataTypePtr& data_type,
+                                                 InZonemapMaterializedSet* result);
+
+inline bool field_types_compatible(PrimitiveType lhs, PrimitiveType rhs) {
+    return lhs == rhs || (is_string_type(lhs) && is_string_type(rhs));
+}
+
+inline bool data_types_compatible(const DataTypePtr& lhs, const DataTypePtr& rhs) {
+    if (lhs == nullptr || rhs == nullptr) {
+        return false;
+    }
+    const auto lhs_type = remove_nullable(lhs);
+    const auto rhs_type = remove_nullable(rhs);
+    const auto lhs_primitive_type = lhs_type->get_primitive_type();
+    const auto rhs_primitive_type = rhs_type->get_primitive_type();
+    if (is_string_type(lhs_primitive_type) && is_string_type(rhs_primitive_type)) {
+        return true;
+    }
+    return lhs_type->equals(*rhs_type);
+}
+
+inline DataTypePtr fetch_compatible_slot_type(const ZoneMapEvalContext& ctx, int slot_index,
+                                              const DataTypePtr& expr_slot_type) {
+    auto slot_type = ctx.data_type(slot_index);
+    if (slot_type == nullptr) {
+        return nullptr;
+    }
+    DORIS_CHECK(data_types_compatible(slot_type, expr_slot_type));
+    return slot_type;
+}
+
+bool range_stats_usable_for_zonemap(const segment_v2::ZoneMap& zone_map,
+                                    const DataTypePtr& data_type);
+
+ZoneMapFilterResult eval_null_zonemap(const ZoneMapEvalContext& ctx, const VExprSPtrs& arguments,
+                                      bool is_null);
+
+ZoneMapFilterResult eval_in_zonemap(const ZoneMapEvalContext& ctx, const VExprSPtr& slot_expr,
+                                    bool is_not_in, const std::vector<Field>& values,
+                                    const Field& min_value, const Field& max_value);
+
+// Return the only slot ordinal referenced by a zonemap-evaluable expression in its current
+// binding. Expressions that are unsupported by zonemap pruning, reference multiple slots, or use an
+// invalid negative slot ordinal return a negative value.
+int single_slot_zonemap_index(const VExprContextSPtr& ctx);
+
+bool is_expr_zonemap_filter_enabled(const RuntimeState* state);
+
+} // namespace doris::expr_zonemap
diff --git a/be/src/exprs/function/function.cpp b/be/src/exprs/function/function.cpp
index fa5b12fea2ec6d..6cec038864e8b7 100644
--- a/be/src/exprs/function/function.cpp
+++ b/be/src/exprs/function/function.cpp
@@ -39,6 +39,7 @@
 #include "exec/common/util.hpp"
 #include "exprs/aggregate/aggregate_function.h"
 #include "exprs/function/function_helpers.h"
+#include "storage/index/zone_map/zonemap_eval_context.h"
 
 namespace doris {
 #include "common/compile_check_begin.h"
@@ -407,5 +408,10 @@ bool FunctionBuilderImpl::is_nested_type_date_or_datetime_or_decimal(
     }
 }
 
+ZoneMapFilterResult IFunctionBase::evaluate_zonemap_filter(
+        const ZoneMapEvalContext& ctx, const VExprSPtrs& function_arguments) const {
+    return unsupported_zonemap_filter(ctx);
+}
+
 #include "common/compile_check_end.h"
 } // namespace doris
diff --git a/be/src/exprs/function/function.h b/be/src/exprs/function/function.h
index 9e0aebdabaf032..171e889f79b21d 100644
--- a/be/src/exprs/function/function.h
+++ b/be/src/exprs/function/function.h
@@ -43,8 +43,10 @@
 #include "core/data_type/define_primitive_type.h"
 #include "core/types.h"
 #include "exprs/function_context.h"
+#include "exprs/vexpr_fwd.h"
 #include "storage/index/inverted/inverted_index_iterator.h" // IWYU pragma: keep
 #include "storage/index/inverted/inverted_index_parser.h"
+#include "storage/index/zone_map/zonemap_filter_result.h"
 
 namespace doris {
 struct InvertedIndexAnalyzerCtx;
@@ -76,6 +78,7 @@ struct FunctionAttr {
 
 class Field;
 class VExpr;
+class ZoneMapEvalContext;
 
 // Only use dispose the variadic argument
 template <typename T>
@@ -226,6 +229,13 @@ class IFunctionBase {
     virtual bool can_push_down_to_index() const { return false; }
 
     virtual bool is_blockable() const { return false; }
+
+    virtual ZoneMapFilterResult evaluate_zonemap_filter(const ZoneMapEvalContext& ctx,
+                                                        const VExprSPtrs& function_arguments) const;
+
+    virtual bool can_evaluate_zonemap_filter(const VExprSPtrs& /*function_arguments*/) const {
+        return false;
+    }
 };
 
 using FunctionBasePtr = std::shared_ptr<IFunctionBase>;
@@ -492,6 +502,15 @@ class DefaultFunction final : public IFunctionBase {
 
     bool is_blockable() const override { return function->is_blockable(); }
 
+    ZoneMapFilterResult evaluate_zonemap_filter(
+            const ZoneMapEvalContext& ctx, const VExprSPtrs& function_arguments) const override {
+        return function->evaluate_zonemap_filter(ctx, function_arguments);
+    }
+
+    bool can_evaluate_zonemap_filter(const VExprSPtrs& function_arguments) const override {
+        return function->can_evaluate_zonemap_filter(function_arguments);
+    }
+
 private:
     std::shared_ptr<IFunction> function;
     DataTypes arguments;
diff --git a/be/src/exprs/function/function_string.cpp b/be/src/exprs/function/function_string.cpp
index 4ce5e484b8609d..4eb0b1462cb3d5 100644
--- a/be/src/exprs/function/function_string.cpp
+++ b/be/src/exprs/function/function_string.cpp
@@ -24,16 +24,23 @@
 #include <unicode/ustream.h>
 
 #include <bitset>
+#include <compare>
 #include <cstddef>
 #include <cstdint>
+#include <limits>
+#include <optional>
+#include <string>
 #include <string_view>
 
 #include "common/cast_set.h"
+#include "common/logging.h"
 #include "common/status.h"
 #include "core/column/column.h"
 #include "core/column/column_string.h"
+#include "core/data_type/data_type_nullable.h"
 #include "core/pod_array_fwd.h"
 #include "core/string_ref.h"
+#include "exprs/expr_zonemap_filter.h"
 #include "exprs/function/function_reverse.h"
 #include "exprs/function/function_string_concat.h"
 #include "exprs/function/function_string_format.h"
@@ -1330,8 +1337,87 @@ using FunctionCrc32 = FunctionUnaryToType<Crc32Impl, NameCrc32>;
 using FunctionStringUTF8Length = FunctionUnaryToType<StringUtf8LengthImpl, NameStringUtf8Length>;
 using FunctionStringSpace = FunctionUnaryToType<StringSpace, NameStringSpace>;
 using FunctionIsValidUTF8 = FunctionUnaryToType<IsValidUTF8Impl, NameIsValidUTF8>;
-using FunctionStringStartsWith =
-        FunctionBinaryToType<DataTypeString, DataTypeString, StringStartsWithImpl, NameStartsWith>;
+
+class FunctionStringStartsWith : public FunctionBinaryToType<DataTypeString, DataTypeString,
+                                                             StringStartsWithImpl, NameStartsWith> {
+public:
+    static FunctionPtr create() { return std::make_shared<FunctionStringStartsWith>(); }
+
+    ZoneMapFilterResult evaluate_zonemap_filter(const ZoneMapEvalContext& ctx,
+                                                const VExprSPtrs& arguments) const override {
+        auto slot_literal = expr_zonemap::extract_slot_and_literal(arguments);
+        auto slot_type = expr_zonemap::fetch_compatible_slot_type(ctx, slot_literal->slot_index,
+                                                                  slot_literal->slot_type);
+        if (slot_type == nullptr) {
+            return unsupported_zonemap_filter(ctx);
+        }
+        auto zone_map_ref = ctx.zone_map(slot_literal->slot_index);
+        if (zone_map_ref == nullptr) {
+            return unsupported_zonemap_filter(ctx);
+        }
+        const auto& zone_map = *zone_map_ref;
+        if (!zone_map.has_not_null) {
+            return ZoneMapFilterResult::kNoMatch;
+        }
+        if (!expr_zonemap::range_stats_usable_for_zonemap(zone_map, slot_type)) {
+            return unsupported_zonemap_filter(ctx);
+        }
+
+        const auto prefix = slot_literal->literal.as_string_view();
+        auto lower = Field::create_field<TYPE_STRING>(std::string(prefix));
+        if (zone_map.max_value < lower) {
+            return ZoneMapFilterResult::kNoMatch;
+        }
+        auto upper_prefix = _next_prefix_for_starts_with_zonemap(prefix);
+        if (upper_prefix.has_value() &&
+            !(zone_map.min_value < Field::create_field<TYPE_STRING>(*upper_prefix))) {
+            return ZoneMapFilterResult::kNoMatch;
+        }
+        return ZoneMapFilterResult::kMayMatch;
+    }
+
+    bool can_evaluate_zonemap_filter(const VExprSPtrs& arguments) const override {
+        auto slot_literal = expr_zonemap::extract_slot_and_literal(arguments);
+        if (!slot_literal.has_value() || slot_literal->literal_on_left) {
+            return false;
+        }
+
+        // A NULL prefix makes starts_with(slot, NULL) evaluate to NULL. An empty prefix matches
+        // every non-NULL string and cannot prune by range. Reject both shapes here before
+        // evaluate_zonemap_filter is called.
+        if (slot_literal->literal.is_null()) {
+            return false;
+        }
+
+        DORIS_CHECK(slot_literal->slot_type != nullptr);
+        DORIS_CHECK(slot_literal->literal_type != nullptr);
+        DORIS_CHECK(is_string_type(remove_nullable(slot_literal->slot_type)->get_primitive_type()));
+        DORIS_CHECK(
+                is_string_type(remove_nullable(slot_literal->literal_type)->get_primitive_type()));
+
+        const auto prefix = slot_literal->literal.as_string_view();
+        return !prefix.empty();
+    }
+
+private:
+    static std::optional<std::string> _next_prefix_for_starts_with_zonemap(
+            std::string_view prefix) {
+        // ZoneMap string bounds are compared by bytewise Field ordering. For starts_with(s, p),
+        // the safe upper bound is the next byte string after p: p <= s < next_prefix(p).
+        // For example, starts_with(s, "ab") can use the range "ab" <= s < "ac".
+        std::string upper(prefix);
+        for (auto i = static_cast<int64_t>(upper.size()) - 1; i >= 0; --i) {
+            auto byte = static_cast<unsigned char>(upper[i]);
+            if (byte != std::numeric_limits<unsigned char>::max()) {
+                upper[i] = static_cast<char>(byte + 1);
+                upper.resize(i + 1);
+                return upper;
+            }
+        }
+        return std::nullopt;
+    }
+};
+
 using FunctionStringEndsWith =
         FunctionBinaryToType<DataTypeString, DataTypeString, StringEndsWithImpl, NameEndsWith>;
 using FunctionStringInstr =
diff --git a/be/src/exprs/function/functions_comparison.h b/be/src/exprs/function/functions_comparison.h
index d51e6add28517b..062e5d857e390b 100644
--- a/be/src/exprs/function/functions_comparison.h
+++ b/be/src/exprs/function/functions_comparison.h
@@ -20,16 +20,21 @@
 
 #pragma once
 
+#include <compare>
 #include <limits>
+#include <optional>
+#include <string_view>
 #include <type_traits>
 
 #include "common/logging.h"
+#include "common/status.h"
 #include "core/accurate_comparison.h"
 #include "core/assert_cast.h"
 #include "core/column/column_const.h"
 #include "core/column/column_decimal.h"
 #include "core/column/column_nullable.h"
 #include "core/column/column_string.h"
+#include "core/data_type/data_type_nullable.h"
 #include "core/data_type/data_type_number.h"
 #include "core/data_type/data_type_string.h"
 #include "core/data_type/define_primitive_type.h"
@@ -37,9 +42,11 @@
 #include "core/field.h"
 #include "core/memcmp_small.h"
 #include "core/value/vdatetime_value.h"
+#include "exprs/expr_zonemap_filter.h"
 #include "exprs/function/function.h"
 #include "exprs/function/function_helpers.h"
 #include "exprs/function/functions_logical.h"
+#include "exprs/vexpr.h"
 #include "storage/index/index_reader_helper.h"
 
 namespace doris {
@@ -265,6 +272,131 @@ struct NameGreaterOrEquals {
     static constexpr auto name = "ge";
 };
 
+namespace comparison_zonemap_detail {
+enum class Op {
+    EQ,
+    NE,
+    LT,
+    LE,
+    GT,
+    GE,
+};
+
+inline Op symmetric_op(Op op) {
+    switch (op) {
+    case Op::EQ:
+    case Op::NE:
+        return op;
+    case Op::LT:
+        return Op::GT;
+    case Op::LE:
+        return Op::GE;
+    case Op::GT:
+        return Op::LT;
+    case Op::GE:
+        return Op::LE;
+    }
+    __builtin_unreachable();
+}
+
+inline ZoneMapFilterResult evaluate(const ZoneMapEvalContext& ctx, const VExprSPtrs& arguments,
+                                    Op op) {
+    auto slot_literal = expr_zonemap::extract_slot_and_literal(arguments);
+
+    auto slot_type = expr_zonemap::fetch_compatible_slot_type(ctx, slot_literal->slot_index,
+                                                              slot_literal->slot_type);
+    if (slot_type == nullptr) {
+        return unsupported_zonemap_filter(ctx);
+    }
+    auto zone_map_ptr = ctx.zone_map(slot_literal->slot_index);
+    if (zone_map_ptr == nullptr) {
+        return unsupported_zonemap_filter(ctx);
+    }
+    const auto& zone_map = *zone_map_ptr;
+    if (!zone_map.has_not_null) {
+        return ZoneMapFilterResult::kNoMatch;
+    }
+    if (!expr_zonemap::range_stats_usable_for_zonemap(zone_map, slot_type)) {
+        return unsupported_zonemap_filter(ctx);
+    }
+
+    const auto effective_op = slot_literal->literal_on_left ? symmetric_op(op) : op;
+    const auto& literal = slot_literal->literal;
+    switch (effective_op) {
+    case Op::EQ:
+        return literal < zone_map.min_value || zone_map.max_value < literal
+                       ? ZoneMapFilterResult::kNoMatch
+                       : ZoneMapFilterResult::kMayMatch;
+    case Op::NE:
+        return zone_map.min_value == literal && zone_map.max_value == literal
+                       ? ZoneMapFilterResult::kNoMatch
+                       : ZoneMapFilterResult::kMayMatch;
+    case Op::LT:
+        return zone_map.min_value >= literal ? ZoneMapFilterResult::kNoMatch
+                                             : ZoneMapFilterResult::kMayMatch;
+    case Op::LE:
+        return zone_map.min_value > literal ? ZoneMapFilterResult::kNoMatch
+                                            : ZoneMapFilterResult::kMayMatch;
+    case Op::GT:
+        return zone_map.max_value <= literal ? ZoneMapFilterResult::kNoMatch
+                                             : ZoneMapFilterResult::kMayMatch;
+    case Op::GE:
+        return zone_map.max_value < literal ? ZoneMapFilterResult::kNoMatch
+                                            : ZoneMapFilterResult::kMayMatch;
+    }
+
+    // keep this to avoid compile failure with g++.
+    __builtin_unreachable();
+}
+
+inline bool can_evaluate(const VExprSPtrs& arguments) {
+    auto slot_literal = expr_zonemap::extract_slot_and_literal(arguments);
+    if (!slot_literal.has_value()) {
+        return false;
+    }
+
+    // A NULL literal makes the comparison evaluate to NULL instead of a byte range predicate on
+    // the slot. This zonemap evaluator only derives bounds from non-NULL literals, so reject this
+    // shape here before evaluate_zonemap_filter is called.
+    if (slot_literal->literal.is_null()) {
+        return false;
+    }
+
+    DORIS_CHECK(slot_literal->slot_type != nullptr);
+    DORIS_CHECK(slot_literal->literal_type != nullptr);
+    if (!expr_zonemap::data_types_compatible(slot_literal->slot_type, slot_literal->literal_type)) {
+        // The optimizer may generate a bare slot/literal comparison whose logical types differ
+        // only by attributes such as DATETIMEV2 scale. Expr zonemap evaluates stored Field
+        // values without running expression casts, so conservatively skip this optimization.
+        return false;
+    }
+
+    return true;
+}
+
+inline std::optional<Op> op_from_name(std::string_view name) {
+    if (name == NameEquals::name) {
+        return Op::EQ;
+    }
+    if (name == NameNotEquals::name) {
+        return Op::NE;
+    }
+    if (name == NameLess::name) {
+        return Op::LT;
+    }
+    if (name == NameLessOrEquals::name) {
+        return Op::LE;
+    }
+    if (name == NameGreater::name) {
+        return Op::GT;
+    }
+    if (name == NameGreaterOrEquals::name) {
+        return Op::GE;
+    }
+    return std::nullopt;
+}
+} // namespace comparison_zonemap_detail
+
 template <template <PrimitiveType> class Op, typename Name>
 class FunctionComparison : public IFunction {
 public:
@@ -445,6 +577,18 @@ class FunctionComparison : public IFunction {
 
     size_t get_number_of_arguments() const override { return 2; }
 
+    ZoneMapFilterResult evaluate_zonemap_filter(const ZoneMapEvalContext& ctx,
+                                                const VExprSPtrs& arguments) const override {
+        auto op = comparison_zonemap_detail::op_from_name(name);
+        DORIS_CHECK(op.has_value());
+        return comparison_zonemap_detail::evaluate(ctx, arguments, *op);
+    }
+
+    bool can_evaluate_zonemap_filter(const VExprSPtrs& arguments) const override {
+        return comparison_zonemap_detail::op_from_name(name).has_value() &&
+               comparison_zonemap_detail::can_evaluate(arguments);
+    }
+
     /// Get result types by argument types. If the function does not apply to these arguments, throw an exception.
     DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
         return std::make_shared<DataTypeUInt8>();
diff --git a/be/src/exprs/function/is_not_null.h b/be/src/exprs/function/is_not_null.h
index 34e57b59474eb9..73313005f83ce4 100644
--- a/be/src/exprs/function/is_not_null.h
+++ b/be/src/exprs/function/is_not_null.h
@@ -37,7 +37,9 @@
 #include "core/data_type/data_type_number.h"
 #include "core/field.h"
 #include "exprs/aggregate/aggregate_function.h"
+#include "exprs/expr_zonemap_filter.h"
 #include "exprs/function/function.h"
+#include "exprs/vslot_ref.h"
 
 namespace doris {
 class FunctionContext;
@@ -61,6 +63,15 @@ class FunctionIsNotNull : public IFunction {
         return std::make_shared<DataTypeUInt8>();
     }
 
+    ZoneMapFilterResult evaluate_zonemap_filter(const ZoneMapEvalContext& ctx,
+                                                const VExprSPtrs& arguments) const override {
+        return expr_zonemap::eval_null_zonemap(ctx, arguments, false);
+    }
+
+    bool can_evaluate_zonemap_filter(const VExprSPtrs& arguments) const override {
+        return std::dynamic_pointer_cast<VSlotRef>(arguments[0]) != nullptr;
+    }
+
     Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,
                         uint32_t result, size_t input_rows_count) const override {
         const ColumnWithTypeAndName& elem = block.get_by_position(arguments[0]);
@@ -114,4 +125,4 @@ class FunctionIsNotNull : public IFunction {
     }
 };
 
-} // namespace doris
\ No newline at end of file
+} // namespace doris
diff --git a/be/src/exprs/function/is_null.h b/be/src/exprs/function/is_null.h
index 32d420c8b91861..eeceadedd4d322 100644
--- a/be/src/exprs/function/is_null.h
+++ b/be/src/exprs/function/is_null.h
@@ -34,7 +34,9 @@
 #include "core/data_type/data_type_number.h"
 #include "core/field.h"
 #include "exprs/aggregate/aggregate_function.h"
+#include "exprs/expr_zonemap_filter.h"
 #include "exprs/function/function.h"
+#include "exprs/vslot_ref.h"
 
 namespace doris {
 class FunctionContext;
@@ -59,6 +61,15 @@ class FunctionIsNull : public IFunction {
         return std::make_shared<DataTypeUInt8>();
     }
 
+    ZoneMapFilterResult evaluate_zonemap_filter(const ZoneMapEvalContext& ctx,
+                                                const VExprSPtrs& arguments) const override {
+        return expr_zonemap::eval_null_zonemap(ctx, arguments, true);
+    }
+
+    bool can_evaluate_zonemap_filter(const VExprSPtrs& arguments) const override {
+        return std::dynamic_pointer_cast<VSlotRef>(arguments[0]) != nullptr;
+    }
+
     Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,
                         uint32_t result, size_t input_rows_count) const override {
         const ColumnWithTypeAndName& elem = block.get_by_position(arguments[0]);
diff --git a/be/src/exprs/vcompound_pred.h b/be/src/exprs/vcompound_pred.h
index 45759e2639bae0..e4965567d63fdb 100644
--- a/be/src/exprs/vcompound_pred.h
+++ b/be/src/exprs/vcompound_pred.h
@@ -21,6 +21,7 @@
 #include <algorithm>
 #include <cstdint>
 
+#include "common/logging.h"
 #include "common/status.h"
 #include "core/assert_cast.h"
 #include "core/column/column.h"
@@ -28,6 +29,7 @@
 #include "exprs/vectorized_fn_call.h"
 #include "exprs/vexpr_context.h"
 #include "exprs/vexpr_fwd.h"
+#include "storage/index/zone_map/zonemap_eval_context.h"
 #include "util/simd/bits.h"
 
 namespace doris {
@@ -60,6 +62,52 @@ class VCompoundPred : public VectorizedFnCall {
 
     const std::string& expr_name() const override { return _expr_name; }
 
+    bool can_evaluate_zonemap_filter() const override {
+        switch (_op) {
+        case TExprOpcode::COMPOUND_AND:
+            return std::ranges::any_of(_children, [](const VExprSPtr& child) {
+                return child->can_evaluate_zonemap_filter();
+            });
+        case TExprOpcode::COMPOUND_OR:
+            return !_children.empty() && std::ranges::all_of(_children, [](const VExprSPtr& child) {
+                return child->can_evaluate_zonemap_filter();
+            });
+        case TExprOpcode::COMPOUND_NOT:
+            return false;
+        default:
+            return false;
+        }
+    }
+
+    ZoneMapFilterResult evaluate_zonemap_filter(const ZoneMapEvalContext& ctx) const override {
+        switch (_op) {
+        case TExprOpcode::COMPOUND_AND: {
+            for (const auto& child : _children) {
+                if (!child->can_evaluate_zonemap_filter()) {
+                    continue;
+                }
+                if (child->evaluate_zonemap_filter(ctx) == ZoneMapFilterResult::kNoMatch) {
+                    return ZoneMapFilterResult::kNoMatch;
+                }
+            }
+            return ZoneMapFilterResult::kMayMatch;
+        }
+        case TExprOpcode::COMPOUND_OR: {
+            for (const auto& child : _children) {
+                DORIS_CHECK(child->can_evaluate_zonemap_filter());
+                if (child->evaluate_zonemap_filter(ctx) != ZoneMapFilterResult::kNoMatch) {
+                    return ZoneMapFilterResult::kMayMatch;
+                }
+            }
+            return ZoneMapFilterResult::kNoMatch;
+        }
+        case TExprOpcode::COMPOUND_NOT:
+            return unsupported_zonemap_filter(ctx);
+        default:
+            return unsupported_zonemap_filter(ctx);
+        }
+    }
+
     Status evaluate_inverted_index(VExprContext* context, uint32_t segment_num_rows) override {
         segment_v2::InvertedIndexResultBitmap res;
         bool all_pass = true;
diff --git a/be/src/exprs/vdirect_in_predicate.h b/be/src/exprs/vdirect_in_predicate.h
index aad6244232c126..a9237cba652271 100644
--- a/be/src/exprs/vdirect_in_predicate.h
+++ b/be/src/exprs/vdirect_in_predicate.h
@@ -17,7 +17,14 @@
 
 #pragma once
 
+#include <utility>
+#include <vector>
+
+#include "common/logging.h"
 #include "common/status.h"
+#include "core/field.h"
+#include "core/types.h"
+#include "exprs/expr_zonemap_filter.h"
 #include "exprs/hybrid_set.h"
 #include "exprs/vexpr.h"
 #include "exprs/vin_predicate.h"
@@ -31,8 +38,20 @@ class VDirectInPredicate final : public VExpr {
     ENABLE_FACTORY_CREATOR(VDirectInPredicate);
 
 public:
-    VDirectInPredicate(const TExprNode& node, const std::shared_ptr<HybridSetBase>& filter)
-            : VExpr(node), _filter(filter), _expr_name("direct_in_predicate") {}
+    // `hybrid_set_values_match_child_type` tells whether values in `filter` can be interpreted with
+    // the child expression type. Parquet/ORC dictionary-filter rewrites evaluate the original
+    // logical predicate against dictionary entries and then rewrite it to matched physical
+    // dictionary codes, for example `col IN ('a', 'b')` becomes `dict_code IN (0, 1)`. In that
+    // shape the HybridSet stores TYPE_INT dictionary codes while the child slot still has the
+    // original logical type such as STRING. Callers must pass false to disable zonemap
+    // materialization and slot-IN rewrite that would otherwise rebuild child-typed literals from
+    // dictionary codes.
+    VDirectInPredicate(const TExprNode& node, const std::shared_ptr<HybridSetBase>& filter,
+                       bool hybrid_set_values_match_child_type)
+            : VExpr(node),
+              _filter(filter),
+              _hybrid_set_values_match_child_type(hybrid_set_values_match_child_type),
+              _expr_name("direct_in_predicate") {}
     ~VDirectInPredicate() override = default;
 
 #ifdef BE_TEST
@@ -42,6 +61,7 @@ class VDirectInPredicate final : public VExpr {
     Status prepare(RuntimeState* state, const RowDescriptor& row_desc,
                    VExprContext* context) override {
         RETURN_IF_ERROR_OR_PREPARED(VExpr::prepare(state, row_desc, context));
+        RETURN_IF_ERROR(_materialize_for_zonemap_filter());
         _prepare_finished = true;
         return Status::OK();
     }
@@ -69,7 +89,20 @@ class VDirectInPredicate final : public VExpr {
 
     std::shared_ptr<HybridSetBase> get_set_func() const override { return _filter; }
 
+    ZoneMapFilterResult evaluate_zonemap_filter(const ZoneMapEvalContext& ctx) const override {
+        return expr_zonemap::eval_in_zonemap(ctx, get_child(0), false, _seg_filter_values,
+                                             _seg_filter_min, _seg_filter_max);
+    }
+
+    bool can_evaluate_zonemap_filter() const override {
+        return _zonemap_materialized &&
+               std::dynamic_pointer_cast<VSlotRef>(get_child(0)) != nullptr;
+    }
+
     bool get_slot_in_expr(VExprSPtr& new_root) const {
+        if (!_hybrid_set_values_match_child_type) {
+            return false;
+        }
         if (!get_child(0)->is_slot_ref()) {
             return false;
         }
@@ -97,9 +130,9 @@ class VDirectInPredicate final : public VExpr {
                 DCHECK(iter->get_value() != nullptr);
                 auto* value = const_cast<void*>(iter->get_value());
 
-                TExprNode node = create_texpr_node_from(value, slot_data_type->get_primitive_type(),
-                                                        slot_data_type->get_precision(),
-                                                        slot_data_type->get_scale());
+                TExprNode node = expr_zonemap::create_texpr_node_from_hybrid_set_value(
+                        value, slot_data_type->get_primitive_type(),
+                        slot_data_type->get_precision(), slot_data_type->get_scale());
                 new_root->add_child(VLiteral::create_shared(node));
                 iter->next();
             }
@@ -151,8 +184,34 @@ class VDirectInPredicate final : public VExpr {
         return Status::OK();
     }
 
+    Status _materialize_for_zonemap_filter() {
+        if (!_hybrid_set_values_match_child_type) {
+            _zonemap_materialized = false;
+            return Status::OK();
+        }
+        DORIS_CHECK(_filter != nullptr);
+        auto& filter = *_filter;
+        const auto& data_type = remove_nullable(get_child(0)->data_type());
+        expr_zonemap::InZonemapMaterializedSet materialized;
+        RETURN_IF_ERROR(expr_zonemap::materialize_hybrid_set_for_zonemap_filter(filter, data_type,
+                                                                                &materialized));
+        _seg_filter_values = std::move(materialized.values);
+        _seg_filter_min = std::move(materialized.min_value);
+        _seg_filter_max = std::move(materialized.max_value);
+        _zonemap_materialized = true;
+        return Status::OK();
+    }
+
     std::shared_ptr<HybridSetBase> _filter;
+    // Dictionary-filter rewrites may store physical dictionary codes in the HybridSet while the
+    // child slot keeps the original logical type. Such values must not be materialized as child-type
+    // literals for zonemap pruning or slot-IN rewrite.
+    bool _hybrid_set_values_match_child_type = true;
     std::string _expr_name;
+    bool _zonemap_materialized = false;
+    std::vector<Field> _seg_filter_values;
+    Field _seg_filter_min;
+    Field _seg_filter_max;
 };
 
 #include "common/compile_check_end.h"
diff --git a/be/src/exprs/vectorized_fn_call.cpp b/be/src/exprs/vectorized_fn_call.cpp
index 542eaf98512304..df616ebc2e22bc 100644
--- a/be/src/exprs/vectorized_fn_call.cpp
+++ b/be/src/exprs/vectorized_fn_call.cpp
@@ -61,6 +61,7 @@
 #include "storage/index/ann/ann_index_iterator.h"
 #include "storage/index/ann/ann_search_params.h"
 #include "storage/index/index_reader.h"
+#include "storage/index/zone_map/zonemap_eval_context.h"
 #include "storage/segment/column_reader.h"
 #include "storage/segment/virtual_column_iterator.h"
 
@@ -209,6 +210,15 @@ Status VectorizedFnCall::evaluate_inverted_index(VExprContext* context, uint32_t
     return _evaluate_inverted_index(context, _function, segment_num_rows);
 }
 
+ZoneMapFilterResult VectorizedFnCall::evaluate_zonemap_filter(const ZoneMapEvalContext& ctx) const {
+    return _function->evaluate_zonemap_filter(ctx, _children);
+}
+
+bool VectorizedFnCall::can_evaluate_zonemap_filter() const {
+    return _function != nullptr && !_function->is_blockable() &&
+           _function->can_evaluate_zonemap_filter(_children);
+}
+
 Status VectorizedFnCall::_do_execute(VExprContext* context, const Block* block, Selector* selector,
                                      size_t count, ColumnPtr& result_column,
                                      ColumnPtr* arg_column) const {
diff --git a/be/src/exprs/vectorized_fn_call.h b/be/src/exprs/vectorized_fn_call.h
index 61034b34d75dd9..f423e7f6470ee7 100644
--- a/be/src/exprs/vectorized_fn_call.h
+++ b/be/src/exprs/vectorized_fn_call.h
@@ -59,6 +59,8 @@ class VectorizedFnCall : public VExpr {
                                   const uint8_t* __restrict filter, size_t count,
                                   ColumnPtr& result_column, ColumnPtr* arg_column) const override;
     Status evaluate_inverted_index(VExprContext* context, uint32_t segment_num_rows) override;
+    ZoneMapFilterResult evaluate_zonemap_filter(const ZoneMapEvalContext& ctx) const override;
+    bool can_evaluate_zonemap_filter() const override;
     Status prepare(RuntimeState* state, const RowDescriptor& desc, VExprContext* context) override;
     Status open(RuntimeState* state, VExprContext* context,
                 FunctionContext::FunctionStateScope scope) override;
diff --git a/be/src/exprs/vexpr.cpp b/be/src/exprs/vexpr.cpp
index d26d209cb550a4..d5686f8ca533b6 100644
--- a/be/src/exprs/vexpr.cpp
+++ b/be/src/exprs/vexpr.cpp
@@ -42,6 +42,7 @@
 #include "core/data_type/data_type_number.h"
 #include "core/data_type/define_primitive_type.h"
 #include "core/field.h"
+#include "core/string_ref.h"
 #include "core/value/timestamptz_value.h"
 #include "exec/common/util.hpp"
 #include "exec/pipeline/pipeline_task.h"
@@ -69,6 +70,7 @@
 #include "storage/index/ann/ann_search_params.h"
 #include "storage/index/ann/ann_topn_runtime.h"
 #include "storage/index/inverted/inverted_index_parser.h"
+#include "storage/index/zone_map/zonemap_eval_context.h"
 #include "storage/segment/column_reader.h"
 
 namespace doris {
@@ -77,6 +79,10 @@ namespace doris {
 class RowDescriptor;
 class RuntimeState;
 
+ZoneMapFilterResult VExpr::evaluate_zonemap_filter(const ZoneMapEvalContext& ctx) const {
+    return unsupported_zonemap_filter(ctx);
+}
+
 // NOLINTBEGIN(readability-function-cognitive-complexity)
 // NOLINTBEGIN(readability-function-size)
 TExprNode create_texpr_node_from(const void* data, const PrimitiveType& type, int precision,
diff --git a/be/src/exprs/vexpr.h b/be/src/exprs/vexpr.h
index 7cb5abca21f1b7..6796058fe402e4 100644
--- a/be/src/exprs/vexpr.h
+++ b/be/src/exprs/vexpr.h
@@ -50,6 +50,7 @@
 #include "storage/index/ann/ann_search_params.h"
 #include "storage/index/index_reader.h"
 #include "storage/index/inverted/inverted_index_reader.h"
+#include "storage/index/zone_map/zonemap_filter_result.h"
 #include "util/date_func.h"
 
 namespace doris {
@@ -58,6 +59,7 @@ class HybridSetBase;
 class ObjectPool;
 class RowDescriptor;
 class RuntimeState;
+class ZoneMapEvalContext;
 
 namespace segment_v2 {
 class IndexIterator;
@@ -176,6 +178,9 @@ class VExpr {
         return Status::OK();
     }
 
+    virtual ZoneMapFilterResult evaluate_zonemap_filter(const ZoneMapEvalContext& ctx) const;
+    virtual bool can_evaluate_zonemap_filter() const { return false; }
+
     // Get analyzer key for inverted index queries (overridden by VMatchPredicate)
     [[nodiscard]] virtual const std::string& get_analyzer_key() const {
         static const std::string empty;
diff --git a/be/src/exprs/vexpr_context.cpp b/be/src/exprs/vexpr_context.cpp
index a129285dbd34a3..ba031cf8ea9de1 100644
--- a/be/src/exprs/vexpr_context.cpp
+++ b/be/src/exprs/vexpr_context.cpp
@@ -25,6 +25,7 @@
 #include "common/cast_set.h"
 #include "common/compiler_util.h" // IWYU pragma: keep
 #include "common/exception.h"
+#include "common/logging.h"
 #include "common/status.h"
 #include "core/block/column_numbers.h"
 #include "core/block/column_with_type_and_name.h"
@@ -188,6 +189,22 @@ Status VExprContext::evaluate_inverted_index(uint32_t segment_num_rows) {
     return st;
 }
 
+ZoneMapFilterResult VExprContext::evaluate_zonemap_filter(const VExprContextSPtrs& conjuncts,
+                                                          const ZoneMapEvalContext& ctx) {
+    for (const auto& conjunct : conjuncts) {
+        DORIS_CHECK(conjunct != nullptr);
+        const auto& root = conjunct->root();
+        DORIS_CHECK(root != nullptr);
+        if (!root->can_evaluate_zonemap_filter()) {
+            continue;
+        }
+        if (root->evaluate_zonemap_filter(ctx) == ZoneMapFilterResult::kNoMatch) {
+            return ZoneMapFilterResult::kNoMatch;
+        }
+    }
+    return ZoneMapFilterResult::kMayMatch;
+}
+
 bool VExprContext::all_expr_inverted_index_evaluated() {
     return _index_context->has_index_result_for_expr(_root.get());
 }
diff --git a/be/src/exprs/vexpr_context.h b/be/src/exprs/vexpr_context.h
index b07027ef162c6f..757593a9d2e105 100644
--- a/be/src/exprs/vexpr_context.h
+++ b/be/src/exprs/vexpr_context.h
@@ -38,11 +38,13 @@
 #include "storage/index/ann/ann_range_search_runtime.h"
 #include "storage/index/ann/ann_search_params.h"
 #include "storage/index/inverted/inverted_index_reader.h"
+#include "storage/index/zone_map/zonemap_filter_result.h"
 #include "storage/segment/column_reader.h"
 
 namespace doris {
 class RowDescriptor;
 class RuntimeState;
+class ZoneMapEvalContext;
 } // namespace doris
 
 namespace doris::segment_v2 {
@@ -293,6 +295,9 @@ class VExprContext {
     //  skip this expr, just do not apply index anymore.
     [[nodiscard]] Status evaluate_inverted_index(uint32_t segment_num_rows);
 
+    [[nodiscard]] static ZoneMapFilterResult evaluate_zonemap_filter(
+            const VExprContextSPtrs& conjuncts, const ZoneMapEvalContext& ctx);
+
     bool all_expr_inverted_index_evaluated();
 
     Status execute_filter(const Block* block, uint8_t* __restrict result_filter_data, size_t rows,
diff --git a/be/src/exprs/vin_predicate.cpp b/be/src/exprs/vin_predicate.cpp
index 79b39c3f60af1a..ce57421b97e5b6 100644
--- a/be/src/exprs/vin_predicate.cpp
+++ b/be/src/exprs/vin_predicate.cpp
@@ -30,9 +30,10 @@
 #include "core/block/column_numbers.h"
 #include "core/block/column_with_type_and_name.h"
 #include "core/block/columns_with_type_and_name.h"
+#include "exprs/expr_zonemap_filter.h"
+#include "exprs/function/in.h"
 #include "exprs/function/simple_function_factory.h"
 #include "exprs/vexpr_context.h"
-#include "exprs/vliteral.h"
 #include "exprs/vslot_ref.h"
 #include "runtime/runtime_state.h"
 
@@ -99,6 +100,10 @@ Status VInPredicate::open(RuntimeState* state, VExprContext* context,
 
     _is_args_all_constant = std::all_of(_children.begin() + 1, _children.end(),
                                         [](const VExprSPtr& expr) { return expr->is_constant(); });
+    if (scope == FunctionContext::FRAGMENT_LOCAL && _is_args_all_constant &&
+        !_zonemap_materialized) {
+        RETURN_IF_ERROR(_materialize_for_zonemap_filter(context));
+    }
     _open_finished = true;
     return Status::OK();
 }
@@ -113,6 +118,52 @@ Status VInPredicate::evaluate_inverted_index(VExprContext* context, uint32_t seg
     return _evaluate_inverted_index(context, _function, segment_num_rows);
 }
 
+Status VInPredicate::_materialize_for_zonemap_filter(VExprContext* context) {
+    _seg_filter_values.clear();
+    _seg_filter_contains_null = false;
+    _zonemap_materialized = false;
+    if (_children.size() < 2 || !_children[0]->is_slot_ref()) {
+        return Status::OK();
+    }
+
+    const auto data_type = remove_nullable(_children[0]->data_type());
+    DORIS_CHECK(data_type != nullptr);
+    if (is_complex_type(data_type->get_primitive_type())) {
+        return Status::OK();
+    }
+
+    DORIS_CHECK(context != nullptr);
+    auto* fn_ctx = context->fn_context(_fn_context_index);
+    DORIS_CHECK(fn_ctx != nullptr);
+    auto* in_state =
+            reinterpret_cast<InState*>(fn_ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL));
+    DORIS_CHECK(in_state != nullptr);
+    DORIS_CHECK(in_state->use_set);
+    DORIS_CHECK(in_state->hybrid_set != nullptr);
+
+    expr_zonemap::InZonemapMaterializedSet materialized;
+    RETURN_IF_ERROR(expr_zonemap::materialize_hybrid_set_for_zonemap_filter(
+            *in_state->hybrid_set, data_type, &materialized));
+    _seg_filter_contains_null = materialized.contains_null;
+    _seg_filter_values = std::move(materialized.values);
+    _seg_filter_min = std::move(materialized.min_value);
+    _seg_filter_max = std::move(materialized.max_value);
+    _zonemap_materialized = true;
+    return Status::OK();
+}
+
+ZoneMapFilterResult VInPredicate::evaluate_zonemap_filter(const ZoneMapEvalContext& ctx) const {
+    if (_is_not_in && _seg_filter_contains_null) {
+        return ZoneMapFilterResult::kNoMatch;
+    }
+    return expr_zonemap::eval_in_zonemap(ctx, get_child(0), _is_not_in, _seg_filter_values,
+                                         _seg_filter_min, _seg_filter_max);
+}
+
+bool VInPredicate::can_evaluate_zonemap_filter() const {
+    return _zonemap_materialized && std::dynamic_pointer_cast<VSlotRef>(get_child(0)) != nullptr;
+}
+
 Status VInPredicate::execute_column(VExprContext* context, const Block* block, Selector* selector,
                                     size_t count, ColumnPtr& result_column) const {
     if (is_const_and_have_executed()) { // const have execute in open function
diff --git a/be/src/exprs/vin_predicate.h b/be/src/exprs/vin_predicate.h
index 818efcc4ddcf92..23d78e7e958c93 100644
--- a/be/src/exprs/vin_predicate.h
+++ b/be/src/exprs/vin_predicate.h
@@ -18,9 +18,11 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 #include "common/object_pool.h"
 #include "common/status.h"
+#include "core/field.h"
 #include "exprs/function/function.h"
 #include "exprs/function_context.h"
 #include "exprs/vexpr.h"
@@ -58,10 +60,14 @@ class VInPredicate MOCK_REMOVE(final) : public VExpr {
 
     bool is_not_in() const { return _is_not_in; };
     Status evaluate_inverted_index(VExprContext* context, uint32_t segment_num_rows) override;
+    ZoneMapFilterResult evaluate_zonemap_filter(const ZoneMapEvalContext& ctx) const override;
+    bool can_evaluate_zonemap_filter() const override;
 
     uint64_t get_digest(uint64_t seed) const override { return 0; }
 
 private:
+    Status _materialize_for_zonemap_filter(VExprContext* context);
+
     FunctionBasePtr _function;
     std::string _expr_name;
 
@@ -69,5 +75,10 @@ class VInPredicate MOCK_REMOVE(final) : public VExpr {
     static const constexpr char* function_name = "in";
     uint32_t _in_list_value_count_threshold = 10;
     bool _is_args_all_constant = false;
+    bool _zonemap_materialized = false;
+    bool _seg_filter_contains_null = false;
+    std::vector<Field> _seg_filter_values;
+    Field _seg_filter_min;
+    Field _seg_filter_max;
 };
-} // namespace doris
\ No newline at end of file
+} // namespace doris
diff --git a/be/src/exprs/virtual_slot_ref.h b/be/src/exprs/virtual_slot_ref.h
index 8fbf2567719304..f9eabe8734ca40 100644
--- a/be/src/exprs/virtual_slot_ref.h
+++ b/be/src/exprs/virtual_slot_ref.h
@@ -38,6 +38,7 @@ class VirtualSlotRef MOCK_REMOVE(final) : public VExpr {
     std::string debug_string() const override;
     bool is_constant() const override { return false; }
     int column_id() const { return _column_id; }
+    void set_column_id(int column_id) { _column_id = column_id; }
     int slot_id() const { return _slot_id; }
     bool equals(const VExpr& other) override;
     size_t estimate_memory(const size_t rows) override { return 0; }
@@ -113,7 +114,6 @@ class VirtualSlotRef MOCK_REMOVE(final) : public VExpr {
 
 #ifdef BE_TEST
     // Test-only setter methods for unit testing
-    void set_column_id(int column_id) { _column_id = column_id; }
     void set_column_name(const std::string* column_name) { _column_name = column_name; }
     void set_column_data_type(DataTypePtr column_data_type) {
         _column_data_type = std::move(column_data_type);
diff --git a/be/src/exprs/vruntimefilter_wrapper.cpp b/be/src/exprs/vruntimefilter_wrapper.cpp
index 074c580614de6a..c090c8376c269a 100644
--- a/be/src/exprs/vruntimefilter_wrapper.cpp
+++ b/be/src/exprs/vruntimefilter_wrapper.cpp
@@ -21,6 +21,7 @@
 
 #include <cstddef>
 
+#include "common/logging.h"
 #include "core/block/block.h"
 #include "core/block/column_numbers.h"
 #include "core/block/column_with_type_and_name.h"
@@ -29,7 +30,9 @@
 #include "core/data_type/data_type.h"
 #include "core/types.h"
 #include "exec/common/util.hpp"
+#include "exprs/vslot_ref.h"
 #include "runtime/runtime_profile.h"
+#include "storage/index/zone_map/zonemap_eval_context.h"
 
 namespace doris {
 #include "common/compile_check_begin.h"
@@ -63,7 +66,9 @@ VRuntimeFilterWrapper::VRuntimeFilterWrapper(const TExprNode& node, VExprSPtr im
           _ignore_thredhold(ignore_thredhold),
           _null_aware(null_aware),
           _filter_id(filter_id),
-          _sampling_frequency(sampling_frequency) {}
+          _sampling_frequency(sampling_frequency) {
+    DORIS_CHECK(_impl != nullptr);
+}
 
 Status VRuntimeFilterWrapper::prepare(RuntimeState* state, const RowDescriptor& desc,
                                       VExprContext* context) {
@@ -193,5 +198,36 @@ Status VRuntimeFilterWrapper::execute_filter(VExprContext* context, const Block*
     return Status::OK();
 }
 
+ZoneMapFilterResult VRuntimeFilterWrapper::evaluate_zonemap_filter(
+        const ZoneMapEvalContext& ctx) const {
+    if (_null_aware) {
+        const auto child = _impl->get_child(0);
+        if (auto slot_ref = std::dynamic_pointer_cast<VSlotRef>(child); slot_ref != nullptr) {
+            auto zone_map = ctx.zone_map(slot_ref->column_id());
+            if (zone_map == nullptr) {
+                return unsupported_zonemap_filter(ctx);
+            }
+
+            if (zone_map->has_null) {
+                return ZoneMapFilterResult::kMayMatch;
+            }
+        } else {
+            // RuntimeFilterExpr implementations generated by RuntimeFilterConsumer put the probe
+            // slot as child 0. If a custom RF expression violates this shape, keep the null-aware
+            // evaluation conservative because we cannot decide whether the target zone has NULLs.
+            return unsupported_zonemap_filter(ctx);
+        }
+    }
+    return _impl->evaluate_zonemap_filter(ctx);
+}
+
+bool VRuntimeFilterWrapper::can_evaluate_zonemap_filter() const {
+    return _impl->can_evaluate_zonemap_filter();
+}
+
+void VRuntimeFilterWrapper::collect_slot_column_ids(std::set<int>& column_ids) const {
+    _impl->collect_slot_column_ids(column_ids);
+}
+
 #include "common/compile_check_end.h"
 } // namespace doris
diff --git a/be/src/exprs/vruntimefilter_wrapper.h b/be/src/exprs/vruntimefilter_wrapper.h
index d69e5510ae814c..a3996944d76468 100644
--- a/be/src/exprs/vruntimefilter_wrapper.h
+++ b/be/src/exprs/vruntimefilter_wrapper.h
@@ -22,6 +22,7 @@
 #include <atomic>
 #include <cstdint>
 #include <memory>
+#include <set>
 #include <string>
 
 #include "common/config.h"
@@ -102,6 +103,10 @@ class VRuntimeFilterWrapper final : public VExpr {
 
     bool is_rf_wrapper() const override { return true; }
 
+    ZoneMapFilterResult evaluate_zonemap_filter(const ZoneMapEvalContext& ctx) const override;
+    bool can_evaluate_zonemap_filter() const override;
+    void collect_slot_column_ids(std::set<int>& column_ids) const override;
+
     int filter_id() const { return _filter_id; }
 
     std::shared_ptr<RuntimeProfile::Counter> predicate_filtered_rows_counter() const {
diff --git a/be/src/exprs/vslot_ref.h b/be/src/exprs/vslot_ref.h
index 07c65770aa9bb9..c442179a5ff6eb 100644
--- a/be/src/exprs/vslot_ref.h
+++ b/be/src/exprs/vslot_ref.h
@@ -39,9 +39,9 @@ class VSlotRef MOCK_REMOVE(final) : public VExpr {
     VSlotRef(const SlotDescriptor* desc);
 #ifdef BE_TEST
     VSlotRef() = default;
-    void set_column_id(int column_id) { _column_id = column_id; }
     void set_slot_id(int slot_id) { _slot_id = slot_id; }
 #endif
+    void set_column_id(int column_id) { _column_id = column_id; }
     Status prepare(RuntimeState* state, const RowDescriptor& desc, VExprContext* context) override;
     Status open(RuntimeState* state, VExprContext* context,
                 FunctionContext::FunctionStateScope scope) override;
diff --git a/be/src/format/orc/vorc_reader.cpp b/be/src/format/orc/vorc_reader.cpp
index a1b8a25182e0e0..ad2f6ba3a383ad 100644
--- a/be/src/format/orc/vorc_reader.cpp
+++ b/be/src/format/orc/vorc_reader.cpp
@@ -3238,7 +3238,7 @@ Status OrcReader::_rewrite_dict_conjuncts(std::vector<int32_t>& dict_codes, int
             for (int& dict_code : dict_codes) {
                 hybrid_set->insert(&dict_code);
             }
-            root = VDirectInPredicate::create_shared(node, hybrid_set);
+            root = VDirectInPredicate::create_shared(node, hybrid_set, false);
         }
         {
             SlotDescriptor* slot = nullptr;
diff --git a/be/src/format/parquet/vparquet_group_reader.cpp b/be/src/format/parquet/vparquet_group_reader.cpp
index c24437e10485c8..7867841593d3da 100644
--- a/be/src/format/parquet/vparquet_group_reader.cpp
+++ b/be/src/format/parquet/vparquet_group_reader.cpp
@@ -1337,7 +1337,7 @@ Status RowGroupReader::_rewrite_dict_conjuncts(std::vector<int32_t>& dict_codes,
             for (int j = 0; j < dict_codes.size(); ++j) {
                 hybrid_set->insert(&dict_codes[j]);
             }
-            root = VDirectInPredicate::create_shared(node, hybrid_set);
+            root = VDirectInPredicate::create_shared(node, hybrid_set, false);
         }
         {
             SlotDescriptor* slot = nullptr;
diff --git a/be/src/format/parquet/vparquet_reader.cpp b/be/src/format/parquet/vparquet_reader.cpp
index a019302b5006b3..3ce33fb1eace57 100644
--- a/be/src/format/parquet/vparquet_reader.cpp
+++ b/be/src/format/parquet/vparquet_reader.cpp
@@ -24,6 +24,8 @@
 
 #include <algorithm>
 #include <functional>
+#include <set>
+#include <unordered_map>
 #include <utility>
 
 #include "common/status.h"
@@ -34,6 +36,7 @@
 #include "core/typeid_cast.h"
 #include "core/types.h"
 #include "exec/scan/file_scanner.h"
+#include "exprs/expr_zonemap_filter.h"
 #include "exprs/vbloom_predicate.h"
 #include "exprs/vdirect_in_predicate.h"
 #include "exprs/vexpr.h"
@@ -58,6 +61,7 @@
 #include "io/fs/file_reader_writer_fwd.h"
 #include "io/fs/tracing_file_reader.h"
 #include "runtime/descriptors.h"
+#include "storage/index/zone_map/zonemap_eval_context.h"
 #include "util/slice.h"
 #include "util/string_util.h"
 #include "util/timezone_utils.h"
@@ -202,6 +206,8 @@ void ParquetReader::_init_profile() {
                 _profile, "RowGroupsFiltered", TUnit::UNIT, parquet_profile, 1);
         _parquet_profile.filtered_row_groups_by_min_max = ADD_CHILD_COUNTER_WITH_LEVEL(
                 _profile, "RowGroupsFilteredByMinMax", TUnit::UNIT, parquet_profile, 1);
+        _parquet_profile.filtered_row_groups_by_expr_zonemap = ADD_CHILD_COUNTER_WITH_LEVEL(
+                _profile, "ParquetExprZoneMapFilteredRowGroups", TUnit::UNIT, parquet_profile, 1);
         _parquet_profile.filtered_row_groups_by_bloom_filter = ADD_CHILD_COUNTER_WITH_LEVEL(
                 _profile, "RowGroupsFilteredByBloomFilter", TUnit::UNIT, parquet_profile, 1);
         _parquet_profile.to_read_row_groups = ADD_CHILD_COUNTER_WITH_LEVEL(
@@ -238,6 +244,12 @@ void ParquetReader::_init_profile() {
                 ADD_CHILD_TIMER_WITH_LEVEL(_profile, "PageIndexParseTime", parquet_profile, 1);
         _parquet_profile.row_group_filter_time =
                 ADD_CHILD_TIMER_WITH_LEVEL(_profile, "RowGroupFilterTime", parquet_profile, 1);
+        _parquet_profile.expr_zonemap_unusable = ADD_CHILD_COUNTER_WITH_LEVEL(
+                _profile, "ExprZoneMapUnusableEvals", TUnit::UNIT, parquet_profile, 1);
+        _parquet_profile.in_zonemap_point_check = ADD_CHILD_COUNTER_WITH_LEVEL(
+                _profile, "InZoneMapPointCheckCount", TUnit::UNIT, parquet_profile, 1);
+        _parquet_profile.in_zonemap_range_only = ADD_CHILD_COUNTER_WITH_LEVEL(
+                _profile, "InZoneMapRangeOnlyCount", TUnit::UNIT, parquet_profile, 1);
         _parquet_profile.file_footer_read_calls =
                 ADD_COUNTER_WITH_LEVEL(_profile, "FileFooterReadCalls", TUnit::UNIT, 1);
         _parquet_profile.file_footer_hit_cache =
@@ -949,6 +961,43 @@ bool ParquetReader::_is_misaligned_range_group(const tparquet::RowGroup& row_gro
     return false;
 }
 
+bool ParquetReader::_expr_zonemap_page_slot_index(const VExprContextSPtr& conjunct,
+                                                  int* cid) const {
+    DORIS_CHECK(cid != nullptr);
+    if (conjunct == nullptr || conjunct->root() == nullptr ||
+        !conjunct->root()->can_evaluate_zonemap_filter()) {
+        return false;
+    }
+
+    std::set<int> column_ids;
+    conjunct->root()->collect_slot_column_ids(column_ids);
+    if (column_ids.size() != 1) {
+        return false;
+    }
+
+    const int slot_index = *column_ids.begin();
+    if (slot_index < 0 || static_cast<size_t>(slot_index) >= _tuple_descriptor->slots().size()) {
+        return false;
+    }
+    auto* slot = _tuple_descriptor->slots()[slot_index];
+    if (!_exists_in_file(slot->col_name()) || !_type_matches(slot_index)) {
+        return false;
+    }
+
+    *cid = slot_index;
+    return true;
+}
+
+bool ParquetReader::_has_expr_zonemap_page_filter() const {
+    if (!expr_zonemap::is_expr_zonemap_filter_enabled(_state)) {
+        return false;
+    }
+    return std::ranges::any_of(_lazy_read_ctx.conjuncts, [this](const auto& conjunct) {
+        int cid = -1;
+        return _expr_zonemap_page_slot_index(conjunct, &cid);
+    });
+}
+
 Status ParquetReader::_process_page_index_filter(
         const tparquet::RowGroup& row_group, const RowGroupReader::RowGroupIndex& row_group_index,
         const std::vector<std::unique_ptr<MutilColumnBlockPredicate>>& push_down_pred,
@@ -1028,8 +1077,9 @@ Status ParquetReader::_process_page_index_filter(
     // from https://github.com/apache/doris/pull/55795
     RETURN_IF_ERROR(parse_offset_index());
 
-    // Check if page index is needed for min-max filter.
-    if (!_enable_filter_by_min_max) {
+    // Check if page index is needed for min-max or expr-zonemap filter.
+    const bool has_expr_zonemap_filter = _has_expr_zonemap_page_filter();
+    if (!_enable_filter_by_min_max || (push_down_pred.empty() && !has_expr_zonemap_filter)) {
         read_whole_row_group();
         return Status::OK();
     }
@@ -1144,6 +1194,86 @@ Status ParquetReader::_process_page_index_filter(
         }
         RowRanges::ranges_intersection(*candidate_row_ranges, tmp_row_range, candidate_row_ranges);
     }
+    bool filtered_row_group_by_expr_zonemap = false;
+    RETURN_IF_ERROR(_process_expr_zonemap_page_filter(&cached_page_index, candidate_row_ranges,
+                                                      &filtered_row_group_by_expr_zonemap));
+    if (filtered_row_group_by_expr_zonemap) {
+        ++_reader_statistics.filtered_row_groups_by_expr_zonemap;
+    }
+    return Status::OK();
+}
+
+Status ParquetReader::_process_expr_zonemap_page_filter(
+        ParquetPredicate::CachedPageIndexStat* cached_page_index, RowRanges* candidate_row_ranges,
+        bool* filtered_row_group_by_expr_zonemap) {
+    DORIS_CHECK(cached_page_index != nullptr);
+    DORIS_CHECK(candidate_row_ranges != nullptr);
+    DORIS_CHECK(filtered_row_group_by_expr_zonemap != nullptr);
+    *filtered_row_group_by_expr_zonemap = false;
+    const auto& all_conjuncts = _lazy_read_ctx.conjuncts;
+    if (!expr_zonemap::is_expr_zonemap_filter_enabled(_state) || all_conjuncts.empty() ||
+        candidate_row_ranges->is_empty()) {
+        return Status::OK();
+    }
+
+    std::unordered_map<int, VExprContextSPtrs> ctxs_by_column;
+    for (const auto& conjunct : all_conjuncts) {
+        int cid = -1;
+        if (_expr_zonemap_page_slot_index(conjunct, &cid)) {
+            ctxs_by_column[cid].emplace_back(conjunct);
+        }
+    }
+
+    for (const auto& [cid, conjuncts] : ctxs_by_column) {
+        auto* slot = _tuple_descriptor->slots()[cid];
+        ParquetPredicate::PageIndexStat* stat = nullptr;
+        if (!cached_page_index->get_stat_func(&stat, cid) || stat == nullptr || !stat->available) {
+            continue;
+        }
+        RowRanges expr_ranges;
+        ZoneMapEvalStats page_stats;
+        for (int64_t page_id = 0; page_id < stat->num_of_pages; ++page_id) {
+            DORIS_CHECK(page_id < stat->ranges.size());
+            DORIS_CHECK(page_id < stat->has_null.size());
+            DORIS_CHECK(page_id < stat->is_all_null.size());
+            const auto& page_range = stat->ranges[page_id];
+            DORIS_CHECK(page_range.is_valid());
+
+            ZoneMapEvalContext ctx;
+            ZoneMapEvalContext::SlotZoneMap slot_zone_map;
+            slot_zone_map.data_type = slot->type();
+            segment_v2::ZoneMap zone_map;
+            zone_map.has_null = stat->has_null[page_id];
+            zone_map.has_not_null = !stat->is_all_null[page_id];
+            if (!stat->is_all_null[page_id]) {
+                DORIS_CHECK(page_id < stat->encoded_min_value.size());
+                DORIS_CHECK(page_id < stat->encoded_max_value.size());
+                Status status = ParquetPredicate::parse_min_max_value(
+                        stat->col_schema, stat->encoded_min_value[page_id],
+                        stat->encoded_max_value[page_id], *cached_page_index->ctz,
+                        &zone_map.min_value, &zone_map.max_value);
+                if (status.ok()) {
+                    slot_zone_map.zone_map =
+                            std::make_shared<segment_v2::ZoneMap>(std::move(zone_map));
+                }
+            } else {
+                slot_zone_map.zone_map = std::make_shared<segment_v2::ZoneMap>(std::move(zone_map));
+            }
+            ctx.slots.emplace(cid, std::move(slot_zone_map));
+            const auto result = VExprContext::evaluate_zonemap_filter(conjuncts, ctx);
+            page_stats.merge_page_eval_stats(ctx.stats);
+            if (result != ZoneMapFilterResult::kNoMatch) {
+                expr_ranges.add(page_range);
+            }
+        }
+        page_stats.accumulate_to(&_reader_statistics);
+        const auto before_expr_page_count = candidate_row_ranges->count();
+        RowRanges::ranges_intersection(*candidate_row_ranges, expr_ranges, candidate_row_ranges);
+        if (before_expr_page_count > 0 && candidate_row_ranges->is_empty()) {
+            *filtered_row_group_by_expr_zonemap = true;
+            return Status::OK();
+        }
+    }
     return Status::OK();
 }
 
@@ -1181,6 +1311,9 @@ Status ParquetReader::_process_min_max_bloom_filter(
         RETURN_IF_ERROR(_process_column_stat_filter(row_group, push_down_pred,
                                                     &filter_this_row_group, &filtered_by_min_max,
                                                     &filtered_by_bloom_filter));
+        if (!filter_this_row_group) {
+            RETURN_IF_ERROR(_process_expr_zonemap_filter(row_group, &filter_this_row_group));
+        }
         // Update statistics based on filter type
         if (filter_this_row_group) {
             if (filtered_by_min_max) {
@@ -1334,6 +1467,82 @@ Status ParquetReader::_process_column_stat_filter(
     return Status::OK();
 }
 
+Status ParquetReader::_process_expr_zonemap_filter(const tparquet::RowGroup& row_group,
+                                                   bool* filter_group) {
+    DORIS_CHECK(filter_group != nullptr);
+    const auto& all_conjuncts = _lazy_read_ctx.conjuncts;
+    if (!expr_zonemap::is_expr_zonemap_filter_enabled(_state) || all_conjuncts.empty() ||
+        !_enable_filter_by_min_max) {
+        return Status::OK();
+    }
+
+    std::set<int> column_ids;
+    for (const auto& conjunct : all_conjuncts) {
+        if (conjunct->root() != nullptr && conjunct->root()->can_evaluate_zonemap_filter()) {
+            conjunct->root()->collect_slot_column_ids(column_ids);
+        }
+    }
+    if (column_ids.empty()) {
+        return Status::OK();
+    }
+
+    ZoneMapEvalContext ctx;
+    for (const int cid : column_ids) {
+        if (cid < 0 || cid >= _tuple_descriptor->slots().size()) {
+            continue;
+        }
+        auto* slot = _tuple_descriptor->slots()[cid];
+        ZoneMapEvalContext::SlotZoneMap slot_zone_map;
+        slot_zone_map.data_type = slot->type();
+        if (!_exists_in_file(slot->col_name()) || !_type_matches(cid)) {
+            ctx.slots.emplace(cid, std::move(slot_zone_map));
+            continue;
+        }
+        const auto& file_col_name =
+                _table_info_node_ptr->children_file_column_name(slot->col_name());
+        const FieldSchema* col_schema = _file_metadata->schema().get_column(file_col_name);
+        int parquet_col_id = col_schema->physical_column_index;
+        if (parquet_col_id < 0) {
+            // Complex parent fields do not map to a physical Parquet column.
+            ctx.slots.emplace(cid, std::move(slot_zone_map));
+            continue;
+        }
+        const auto& meta_data = row_group.columns[parquet_col_id].meta_data;
+
+        ParquetPredicate::ColumnStat stat;
+        stat.ctz = _ctz;
+        auto status = ParquetPredicate::read_column_stats(col_schema, meta_data, &_ignored_stats,
+                                                          _t_metadata->created_by, &stat);
+        if (!status.ok()) {
+            ctx.slots.emplace(cid, std::move(slot_zone_map));
+            continue;
+        }
+
+        segment_v2::ZoneMap zone_map;
+        zone_map.has_null = stat.has_null;
+        zone_map.has_not_null = !stat.is_all_null;
+        if (!stat.is_all_null) {
+            status = ParquetPredicate::parse_min_max_value(
+                    col_schema, stat.encoded_min_value, stat.encoded_max_value, *_ctz,
+                    &zone_map.min_value, &zone_map.max_value);
+            if (!status.ok()) {
+                ctx.slots.emplace(cid, std::move(slot_zone_map));
+                continue;
+            }
+        }
+        slot_zone_map.zone_map = std::make_shared<segment_v2::ZoneMap>(std::move(zone_map));
+        ctx.slots.emplace(cid, std::move(slot_zone_map));
+    }
+
+    const auto result = VExprContext::evaluate_zonemap_filter(all_conjuncts, ctx);
+    ctx.stats.accumulate_to(&_reader_statistics);
+    if (result == ZoneMapFilterResult::kNoMatch) {
+        *filter_group = true;
+        ++_reader_statistics.filtered_row_groups_by_expr_zonemap;
+    }
+    return Status::OK();
+}
+
 int64_t ParquetReader::_get_column_start_offset(const tparquet::ColumnMetaData& column) {
     return has_dict_page(column) ? column.dictionary_page_offset : column.data_page_offset;
 }
@@ -1349,6 +1558,8 @@ void ParquetReader::_collect_profile() {
     COUNTER_UPDATE(_parquet_profile.filtered_row_groups, _reader_statistics.filtered_row_groups);
     COUNTER_UPDATE(_parquet_profile.filtered_row_groups_by_min_max,
                    _reader_statistics.filtered_row_groups_by_min_max);
+    COUNTER_UPDATE(_parquet_profile.filtered_row_groups_by_expr_zonemap,
+                   _reader_statistics.filtered_row_groups_by_expr_zonemap);
     COUNTER_UPDATE(_parquet_profile.filtered_row_groups_by_bloom_filter,
                    _reader_statistics.filtered_row_groups_by_bloom_filter);
     COUNTER_UPDATE(_parquet_profile.to_read_row_groups, _reader_statistics.read_row_groups);
@@ -1372,6 +1583,12 @@ void ParquetReader::_collect_profile() {
                    _reader_statistics.parse_page_index_time);
     COUNTER_UPDATE(_parquet_profile.row_group_filter_time,
                    _reader_statistics.row_group_filter_time);
+    COUNTER_UPDATE(_parquet_profile.expr_zonemap_unusable,
+                   _reader_statistics.expr_zonemap_unusable_evals);
+    COUNTER_UPDATE(_parquet_profile.in_zonemap_point_check,
+                   _reader_statistics.in_zonemap_point_check_count);
+    COUNTER_UPDATE(_parquet_profile.in_zonemap_range_only,
+                   _reader_statistics.in_zonemap_range_only_count);
     COUNTER_UPDATE(_parquet_profile.file_footer_read_calls,
                    _reader_statistics.file_footer_read_calls);
     COUNTER_UPDATE(_parquet_profile.file_footer_hit_cache,
diff --git a/be/src/format/parquet/vparquet_reader.h b/be/src/format/parquet/vparquet_reader.h
index e2dbd0f963f661..868ff8927d8f79 100644
--- a/be/src/format/parquet/vparquet_reader.h
+++ b/be/src/format/parquet/vparquet_reader.h
@@ -76,6 +76,7 @@ class ParquetReader : public GenericReader {
     struct ReaderStatistics {
         int32_t filtered_row_groups = 0;
         int32_t filtered_row_groups_by_min_max = 0;
+        int32_t filtered_row_groups_by_expr_zonemap = 0;
         int32_t filtered_row_groups_by_bloom_filter = 0;
         int32_t read_row_groups = 0;
         int64_t filtered_group_rows = 0;
@@ -97,6 +98,9 @@ class ParquetReader : public GenericReader {
         int64_t predicate_filter_time = 0;
         int64_t dict_filter_rewrite_time = 0;
         int64_t bloom_filter_read_time = 0;
+        int64_t expr_zonemap_unusable_evals = 0;
+        int64_t in_zonemap_point_check_count = 0;
+        int64_t in_zonemap_range_only_count = 0;
     };
 
     ParquetReader(RuntimeProfile* profile, const TFileScanRangeParams& params,
@@ -121,6 +125,9 @@ class ParquetReader : public GenericReader {
 #ifdef BE_TEST
     // for unit test
     void set_file_reader(io::FileReaderSPtr file_reader);
+    void set_conjuncts_for_test(const VExprContextSPtrs& conjuncts) {
+        _lazy_read_ctx.conjuncts = conjuncts;
+    }
 #endif
 
     Status init_reader(
@@ -190,6 +197,7 @@ class ParquetReader : public GenericReader {
     struct ParquetProfile {
         RuntimeProfile::Counter* filtered_row_groups = nullptr;
         RuntimeProfile::Counter* filtered_row_groups_by_min_max = nullptr;
+        RuntimeProfile::Counter* filtered_row_groups_by_expr_zonemap = nullptr;
         RuntimeProfile::Counter* filtered_row_groups_by_bloom_filter = nullptr;
         RuntimeProfile::Counter* to_read_row_groups = nullptr;
         RuntimeProfile::Counter* total_row_groups = nullptr;
@@ -231,6 +239,9 @@ class ParquetReader : public GenericReader {
         RuntimeProfile::Counter* predicate_filter_time = nullptr;
         RuntimeProfile::Counter* dict_filter_rewrite_time = nullptr;
         RuntimeProfile::Counter* bloom_filter_read_time = nullptr;
+        RuntimeProfile::Counter* expr_zonemap_unusable = nullptr;
+        RuntimeProfile::Counter* in_zonemap_point_check = nullptr;
+        RuntimeProfile::Counter* in_zonemap_range_only = nullptr;
     };
 
     Status _open_file();
@@ -249,6 +260,11 @@ class ParquetReader : public GenericReader {
             const RowGroupReader::RowGroupIndex& row_group_index,
             const std::vector<std::unique_ptr<MutilColumnBlockPredicate>>& push_down_pred,
             RowRanges* candidate_row_ranges);
+    Status _process_expr_zonemap_page_filter(
+            ParquetPredicate::CachedPageIndexStat* cached_page_index,
+            RowRanges* candidate_row_ranges, bool* filtered_row_group_by_expr_zonemap);
+    bool _expr_zonemap_page_slot_index(const VExprContextSPtr& conjunct, int* cid) const;
+    bool _has_expr_zonemap_page_filter() const;
 
     // check this range contain this row group.
     bool _is_misaligned_range_group(const tparquet::RowGroup& row_group);
@@ -258,6 +274,7 @@ class ParquetReader : public GenericReader {
             const tparquet::RowGroup& row_group,
             const std::vector<std::unique_ptr<MutilColumnBlockPredicate>>& push_down_pred,
             bool* filter_group, bool* filtered_by_min_max, bool* filtered_by_bloom_filter);
+    Status _process_expr_zonemap_filter(const tparquet::RowGroup& row_group, bool* filter_group);
 
     /*
      * 1. row group min-max filter
diff --git a/be/src/storage/index/zone_map/zonemap_eval_context.cpp b/be/src/storage/index/zone_map/zonemap_eval_context.cpp
new file mode 100644
index 00000000000000..b65d4400e8af2c
--- /dev/null
+++ b/be/src/storage/index/zone_map/zonemap_eval_context.cpp
@@ -0,0 +1,49 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "storage/index/zone_map/zonemap_eval_context.h"
+
+#include <algorithm>
+
+namespace doris {
+
+std::shared_ptr<const segment_v2::ZoneMap> ZoneMapEvalContext::zone_map(int slot_index) const {
+    auto it = slots.find(slot_index);
+    if (it == slots.end()) {
+        return nullptr;
+    }
+    return it->second.zone_map;
+}
+
+DataTypePtr ZoneMapEvalContext::data_type(int slot_index) const {
+    auto it = slots.find(slot_index);
+    if (it == slots.end()) {
+        return nullptr;
+    }
+    return it->second.data_type;
+}
+
+void ZoneMapEvalStats::merge_page_eval_stats(const ZoneMapEvalStats& src) {
+    // Page-level evaluation repeats the same conjuncts for many pages. Keep structural
+    // diagnostics once per column, while operation counters still reflect actual page checks.
+    unusable_zonemap_eval_count =
+            std::max(unusable_zonemap_eval_count, src.unusable_zonemap_eval_count);
+    in_zonemap_point_check_count += src.in_zonemap_point_check_count;
+    in_zonemap_range_only_count += src.in_zonemap_range_only_count;
+}
+
+} // namespace doris
diff --git a/be/src/storage/index/zone_map/zonemap_eval_context.h b/be/src/storage/index/zone_map/zonemap_eval_context.h
new file mode 100644
index 00000000000000..c5a750b05914c1
--- /dev/null
+++ b/be/src/storage/index/zone_map/zonemap_eval_context.h
@@ -0,0 +1,70 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <parallel_hashmap/phmap.h>
+
+#include <memory>
+
+#include "core/data_type/data_type.h"
+#include "storage/index/zone_map/zone_map_index.h"
+#include "storage/index/zone_map/zonemap_filter_result.h"
+
+namespace doris {
+
+class ZoneMapEvalStats {
+public:
+    void merge_page_eval_stats(const ZoneMapEvalStats& src);
+
+    template <typename ReaderStatistics>
+    void accumulate_to(ReaderStatistics* stats) const {
+        if (stats == nullptr) {
+            return;
+        }
+        stats->expr_zonemap_unusable_evals += unusable_zonemap_eval_count;
+        stats->in_zonemap_point_check_count += in_zonemap_point_check_count;
+        stats->in_zonemap_range_only_count += in_zonemap_range_only_count;
+    }
+
+    // Evaluations that reached expr-zonemap but could not use the current zone map/context.
+    int64_t unusable_zonemap_eval_count = 0;
+    int64_t in_zonemap_point_check_count = 0;
+    int64_t in_zonemap_range_only_count = 0;
+};
+
+class ZoneMapEvalContext {
+public:
+    struct SlotZoneMap {
+        DataTypePtr data_type;
+        std::shared_ptr<const segment_v2::ZoneMap> zone_map;
+    };
+
+    std::shared_ptr<const segment_v2::ZoneMap> zone_map(int slot_index) const;
+    DataTypePtr data_type(int slot_index) const;
+
+    phmap::flat_hash_map<int, SlotZoneMap> slots;
+
+    mutable ZoneMapEvalStats stats;
+};
+
+inline ZoneMapFilterResult unsupported_zonemap_filter(const ZoneMapEvalContext& ctx) {
+    ++ctx.stats.unusable_zonemap_eval_count;
+    return ZoneMapFilterResult::kUnsupported;
+}
+
+} // namespace doris
diff --git a/be/src/storage/index/zone_map/zonemap_filter_result.h b/be/src/storage/index/zone_map/zonemap_filter_result.h
new file mode 100644
index 00000000000000..15bce693260a0a
--- /dev/null
+++ b/be/src/storage/index/zone_map/zonemap_filter_result.h
@@ -0,0 +1,30 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <cstdint>
+
+namespace doris {
+
+enum class ZoneMapFilterResult : uint8_t {
+    kNoMatch,
+    kMayMatch,
+    kUnsupported,
+};
+
+} // namespace doris
diff --git a/be/src/storage/olap_common.h b/be/src/storage/olap_common.h
index 4c9a4fd83525ec..86959a19a8639f 100644
--- a/be/src/storage/olap_common.h
+++ b/be/src/storage/olap_common.h
@@ -335,6 +335,11 @@ struct OlapReaderStatistics {
     int64_t rows_key_range_filtered = 0;
     int64_t rows_stats_filtered = 0;
     int64_t rows_stats_rp_filtered = 0;
+    int64_t expr_zonemap_filtered_segments = 0;
+    int64_t expr_zonemap_filtered_pages = 0;
+    int64_t expr_zonemap_unusable_evals = 0;
+    int64_t in_zonemap_point_check_count = 0;
+    int64_t in_zonemap_range_only_count = 0;
     int64_t rows_bf_filtered = 0;
     int64_t segment_dict_filtered = 0;
     // Including the number of rows filtered out according to the Delete information in the Tablet,
diff --git a/be/src/storage/segment/column_reader.cpp b/be/src/storage/segment/column_reader.cpp
index 9ca528cc122b81..84f6b87e7446fb 100644
--- a/be/src/storage/segment/column_reader.cpp
+++ b/be/src/storage/segment/column_reader.cpp
@@ -615,6 +615,35 @@ Status ColumnReader::_load_zone_map_index(bool use_page_cache, bool kept_in_memo
     return Status::OK();
 }
 
+Status ColumnReader::get_segment_zone_map(segment_v2::ZoneMap* zone_map) const {
+    DORIS_CHECK(zone_map != nullptr);
+    DORIS_CHECK(_segment_zone_map != nullptr);
+    return ZoneMap::from_proto(*_segment_zone_map, _data_type, *zone_map);
+}
+
+Status ColumnReader::get_page_zone_maps(const ColumnIteratorOptions& iter_opts,
+                                        const std::vector<ZoneMapPB>** zone_maps) {
+    DORIS_CHECK(zone_maps != nullptr);
+    if (_zone_map_index == nullptr) {
+        *zone_maps = nullptr;
+        return Status::OK();
+    }
+    RETURN_IF_ERROR(_load_zone_map_index(_use_index_page_cache, _opts.kept_in_memory, iter_opts));
+    *zone_maps = &_zone_map_index->page_zone_maps();
+    return Status::OK();
+}
+
+Status ColumnReader::get_row_range_for_page(uint32_t page_index,
+                                            const ColumnIteratorOptions& iter_opts,
+                                            RowRange* row_range) {
+    DORIS_CHECK(row_range != nullptr);
+    RETURN_IF_ERROR(_load_ordinal_index(_use_index_page_cache, _opts.kept_in_memory, iter_opts));
+    DORIS_CHECK(page_index < _ordinal_index->num_data_pages());
+    *row_range = RowRange(_ordinal_index->get_first_ordinal(page_index),
+                          _ordinal_index->get_last_ordinal(page_index) + 1);
+    return Status::OK();
+}
+
 Status ColumnReader::_load_index(const std::shared_ptr<IndexFileReader>& index_file_reader,
                                  const TabletIndex* index_meta) {
     std::unique_lock<std::shared_mutex> wlock(_load_index_lock);
diff --git a/be/src/storage/segment/column_reader.h b/be/src/storage/segment/column_reader.h
index c939d617346f87..11583eae67465a 100644
--- a/be/src/storage/segment/column_reader.h
+++ b/be/src/storage/segment/column_reader.h
@@ -48,6 +48,7 @@
 #include "storage/segment/page_handle.h" // for PageHandle
 #include "storage/segment/page_pointer.h"
 #include "storage/segment/parsed_page.h" // for ParsedPage
+#include "storage/segment/row_ranges.h"
 #include "storage/segment/segment_prefetcher.h"
 #include "storage/segment/stream_reader.h"
 #include "storage/tablet/tablet_schema.h"
@@ -213,6 +214,12 @@ class ColumnReader : public MetadataAdder<ColumnReader>,
     Status prune_predicates_by_zone_map(std::vector<std::shared_ptr<ColumnPredicate>>& predicates,
                                         const int column_id, bool* pruned) const;
 
+    Status get_segment_zone_map(segment_v2::ZoneMap* zone_map) const;
+    Status get_page_zone_maps(const ColumnIteratorOptions& iter_opts,
+                              const std::vector<ZoneMapPB>** zone_maps);
+    Status get_row_range_for_page(uint32_t page_index, const ColumnIteratorOptions& iter_opts,
+                                  RowRange* row_range);
+
     CompressionTypePB get_compression() const { return _meta_compression; }
 
     uint64_t num_rows() const { return _num_rows; }
diff --git a/be/src/storage/segment/segment.cpp b/be/src/storage/segment/segment.cpp
index a1d00fbbd0f127..dad30af600c7ad 100644
--- a/be/src/storage/segment/segment.cpp
+++ b/be/src/storage/segment/segment.cpp
@@ -25,6 +25,7 @@
 
 #include <cstring>
 #include <memory>
+#include <set>
 #include <sstream>
 #include <utility>
 
@@ -41,6 +42,8 @@
 #include "core/field.h"
 #include "core/string_ref.h"
 #include "cpp/sync_point.h"
+#include "exprs/expr_zonemap_filter.h"
+#include "exprs/vexpr_context.h"
 #include "io/cache/block_file_cache.h"
 #include "io/cache/block_file_cache_factory.h"
 #include "io/cache/cached_remote_file_reader.h"
@@ -55,6 +58,7 @@
 #include "storage/index/indexed_column_reader.h"
 #include "storage/index/primary_key_index.h"
 #include "storage/index/short_key_index.h"
+#include "storage/index/zone_map/zonemap_eval_context.h"
 #include "storage/iterator/vgeneric_iterators.h"
 #include "storage/iterators.h"
 #include "storage/key_coder.h"
@@ -85,6 +89,63 @@ namespace doris::segment_v2 {
 
 class InvertedIndexIterator;
 
+namespace {
+
+Status build_segment_zonemap_context(Segment* segment, const Schema& schema,
+                                     const StorageReadOptions& read_options,
+                                     const VExprContextSPtrs& conjuncts, ZoneMapEvalContext* ctx) {
+    DORIS_CHECK(segment != nullptr);
+    DORIS_CHECK(ctx != nullptr);
+    std::set<int> slot_indexes;
+    for (const auto& conjunct : conjuncts) {
+        DORIS_CHECK(conjunct != nullptr);
+        const auto& root = conjunct->root();
+        DORIS_CHECK(root != nullptr);
+        if (!root->can_evaluate_zonemap_filter()) {
+            continue;
+        }
+        // Segment zone maps have one min/max/null summary per column for the whole segment, so a
+        // segment-level context can safely hold every slot referenced by a compound expression.
+        // Page zone maps are page-aligned per column and still use single-slot filtering in
+        // SegmentIterator.
+        root->collect_slot_column_ids(slot_indexes);
+    }
+    for (const int slot_index : slot_indexes) {
+        if (slot_index < 0 || cast_set<size_t>(slot_index) >= schema.num_column_ids()) {
+            continue;
+        }
+        const auto column_id = schema.column_id(cast_set<size_t>(slot_index));
+        const auto* tablet_column = schema.column(column_id);
+        DORIS_CHECK(tablet_column != nullptr);
+        if (!segment->can_apply_predicate_safely(
+                    column_id, schema, read_options.target_cast_type_for_variants, read_options)) {
+            continue;
+        }
+        auto data_type = segment->get_data_type_of(*tablet_column, read_options);
+        if (data_type == nullptr) {
+            continue;
+        }
+        ZoneMapEvalContext::SlotZoneMap slot_zone_map;
+        slot_zone_map.data_type = data_type;
+        std::shared_ptr<ColumnReader> reader;
+        Status st = segment->get_column_reader(*tablet_column, &reader, read_options.stats);
+        if (st.is<ErrorCode::NOT_FOUND>()) {
+            ctx->slots.emplace(slot_index, std::move(slot_zone_map));
+            continue;
+        }
+        RETURN_IF_ERROR(st);
+        if (reader != nullptr && reader->has_zone_map()) {
+            ZoneMap zone_map;
+            RETURN_IF_ERROR(reader->get_segment_zone_map(&zone_map));
+            slot_zone_map.zone_map = std::make_shared<ZoneMap>(std::move(zone_map));
+        }
+        ctx->slots.emplace(slot_index, std::move(slot_zone_map));
+    }
+    return Status::OK();
+}
+
+} // namespace
+
 Status Segment::open(io::FileSystemSPtr fs, const std::string& path, int64_t tablet_id,
                      uint32_t segment_id, RowsetId rowset_id, TabletSchemaSPtr tablet_schema,
                      const io::FileReaderOptions& reader_options, std::shared_ptr<Segment>* output,
@@ -285,6 +346,24 @@ Status Segment::new_iterator(SchemaSPtr schema, const StorageReadOptions& read_o
         }
     }
 
+    // Segment-level expr-zonemap runs before SegmentIterator can rebind storage expressions to
+    // the reader schema. Only apply it when scan tuple slot ordinals already match this schema.
+    if (expr_zonemap::is_expr_zonemap_filter_enabled(read_options.runtime_state) &&
+        !read_options.common_expr_ctxs_push_down.empty()) {
+        ZoneMapEvalContext ctx;
+        RETURN_IF_ERROR(build_segment_zonemap_context(
+                this, *schema, read_options, read_options.common_expr_ctxs_push_down, &ctx));
+        const auto result =
+                VExprContext::evaluate_zonemap_filter(read_options.common_expr_ctxs_push_down, ctx);
+        ctx.stats.accumulate_to(read_options.stats);
+        if (result == ZoneMapFilterResult::kNoMatch) {
+            *iter = std::make_unique<EmptySegmentIterator>(*schema);
+            read_options.stats->filtered_segment_number++;
+            read_options.stats->expr_zonemap_filtered_segments++;
+            return Status::OK();
+        }
+    }
+
     {
         SCOPED_RAW_TIMER(&read_options.stats->segment_load_index_timer_ns);
         RETURN_IF_ERROR(load_index(read_options.stats));
diff --git a/be/src/storage/segment/segment_iterator.cpp b/be/src/storage/segment/segment_iterator.cpp
index 75becf85d60ed6..3b5ef0199143ae 100644
--- a/be/src/storage/segment/segment_iterator.cpp
+++ b/be/src/storage/segment/segment_iterator.cpp
@@ -28,6 +28,7 @@
 #include <cstdint>
 #include <memory>
 #include <numeric>
+#include <optional>
 #include <set>
 #include <unordered_map>
 #include <utility>
@@ -59,6 +60,7 @@
 #include "core/string_ref.h"
 #include "core/typeid_cast.h"
 #include "core/types.h"
+#include "exprs/expr_zonemap_filter.h"
 #include "exprs/function/array/function_array_index.h"
 #include "exprs/vexpr.h"
 #include "exprs/vexpr_context.h"
@@ -87,6 +89,8 @@
 #include "storage/index/ordinal_page_index.h"
 #include "storage/index/primary_key_index.h"
 #include "storage/index/short_key_index.h"
+#include "storage/index/zone_map/zone_map_index.h"
+#include "storage/index/zone_map/zonemap_eval_context.h"
 #include "storage/iterators.h"
 #include "storage/olap_common.h"
 #include "storage/predicate/bloom_filter_predicate.h"
@@ -106,6 +110,7 @@
 #include "storage/utils.h"
 #include "util/concurrency_stats.h"
 #include "util/defer_op.h"
+#include "util/json/path_in_data.h"
 #include "util/simd/bits.h"
 
 namespace doris {
@@ -606,7 +611,8 @@ void SegmentIterator::_init_segment_prefetchers() {
     bool enable_prefetch = is_query ? config::enable_query_segment_file_cache_prefetch
                                     : config::enable_compaction_segment_file_cache_prefetch;
     LOG_IF(INFO, config::enable_segment_prefetch_verbose_log) << fmt::format(
-            "[verbose] SegmentIterator _init_segment_prefetchers, is_query={}, enable_prefetch={}, "
+            "[verbose] SegmentIterator _init_segment_prefetchers, is_query={}, "
+            "enable_prefetch={}, "
             "_row_bitmap.isEmpty()={}, row_bitmap.cardinality()={}, tablet={}, rowset={}, "
             "segment={}, predicate_column_ids={}, non_predicate_column_ids={}",
             is_query, enable_prefetch, _row_bitmap.isEmpty(), _row_bitmap.cardinality(),
@@ -847,7 +853,8 @@ Status SegmentIterator::_get_row_ranges_by_column_conditions() {
 
     if (!_row_bitmap.isEmpty() &&
         (!_opts.topn_filter_source_node_ids.empty() || !_opts.col_id_to_predicates.empty() ||
-         _opts.delete_condition_predicates->num_of_column_predicate() > 0)) {
+         _opts.delete_condition_predicates->num_of_column_predicate() > 0 ||
+         !_common_expr_ctxs_push_down.empty())) {
         RowRanges condition_row_ranges = RowRanges::create_single(_segment->num_rows());
         RETURN_IF_ERROR(_get_row_ranges_from_conditions(&condition_row_ranges));
         size_t pre_size = _row_bitmap.cardinality();
@@ -923,7 +930,8 @@ Status SegmentIterator::_apply_ann_topn_predicate() {
 
     if (ann_index_reader->get_metric_type() != _ann_topn_runtime->get_metric_type()) {
         VLOG_DEBUG << fmt::format(
-                "Ann topn metric type {} not match index metric type {}, can not be evaluated by "
+                "Ann topn metric type {} not match index metric type {}, can not be evaluated "
+                "by "
                 "ann index",
                 metric_to_string(_ann_topn_runtime->get_metric_type()),
                 metric_to_string(ann_index_reader->get_metric_type()));
@@ -1118,6 +1126,17 @@ Status SegmentIterator::_get_row_ranges_from_conditions(RowRanges* condition_row
         _opts.stats->rows_stats_filtered += (pre_size - condition_row_ranges->count());
     }
 
+    {
+        SCOPED_RAW_TIMER(&_opts.stats->generate_row_ranges_by_zonemap_ns);
+        if (!_common_expr_ctxs_push_down.empty()) {
+            const auto pre_expr_zonemap_size = condition_row_ranges->count();
+            RETURN_IF_ERROR(_apply_expr_zonemap_to_row_ranges(_common_expr_ctxs_push_down, 0,
+                                                              condition_row_ranges));
+            _opts.stats->rows_stats_filtered +=
+                    (pre_expr_zonemap_size - condition_row_ranges->count());
+        }
+    }
+
     return Status::OK();
 }
 
@@ -2246,7 +2265,8 @@ Status SegmentIterator::_read_columns_by_index(uint32_t nrows_read_limit, uint16
     bool is_continuous = (nrows_read > 1) &&
                          (_block_rowids[nrows_read - 1] - _block_rowids[0] == nrows_read - 1);
     VLOG_DEBUG << fmt::format(
-            "nrows_read from range iterator: {}, is_continus {}, _cols_read_by_column_predicate "
+            "nrows_read from range iterator: {}, is_continus {}, "
+            "_cols_read_by_column_predicate "
             "[{}]",
             nrows_read, is_continuous, fmt::join(_predicate_column_ids, ","));
 
@@ -3102,6 +3122,100 @@ Status SegmentIterator::_construct_compound_expr_context() {
     return Status::OK();
 }
 
+Status SegmentIterator::_apply_expr_zonemap_to_row_ranges(const VExprContextSPtrs& conjuncts,
+                                                          rowid_t min_rowid,
+                                                          RowRanges* row_ranges) {
+    DORIS_CHECK(row_ranges != nullptr);
+    if (!expr_zonemap::is_expr_zonemap_filter_enabled(_opts.runtime_state) || conjuncts.empty() ||
+        row_ranges->is_empty()) {
+        return Status::OK();
+    }
+
+    std::unordered_map<int, VExprContextSPtrs> ctxs_by_slot;
+    for (const auto& conjunct : conjuncts) {
+        auto slot_index = expr_zonemap::single_slot_zonemap_index(conjunct);
+        if (slot_index >= 0) {
+            ctxs_by_slot[slot_index].emplace_back(conjunct);
+        }
+    }
+    // Page zone maps are stored per column. Multi-slot expressions need page alignment across
+    // multiple column readers and are therefore left to segment-level pruning for now.
+    if (ctxs_by_slot.empty()) {
+        return Status::OK();
+    }
+
+    ColumnIteratorOptions iter_opts {
+            .use_page_cache = _opts.use_page_cache,
+            .file_reader = _file_reader.get(),
+            .stats = _opts.stats,
+            .io_ctx = _opts.io_ctx,
+    };
+    for (const auto& [slot_index, slot_conjuncts] : ctxs_by_slot) {
+        if (cast_set<size_t>(slot_index) >= _schema->num_column_ids()) {
+            continue;
+        }
+        const auto cid = _schema->column_id(cast_set<size_t>(slot_index));
+        if (!_segment->can_apply_predicate_safely(cid, *_schema,
+                                                  _opts.target_cast_type_for_variants, _opts)) {
+            continue;
+        }
+        const auto* tablet_column = _schema->column(cid);
+        if (tablet_column == nullptr) {
+            continue;
+        }
+        std::shared_ptr<ColumnReader> reader;
+        Status st = _segment->get_column_reader(*tablet_column, &reader, _opts.stats);
+        if (st.is<ErrorCode::NOT_FOUND>()) {
+            continue;
+        }
+        RETURN_IF_ERROR(st);
+        if (reader == nullptr || !reader->has_zone_map()) {
+            continue;
+        }
+        const std::vector<ZoneMapPB>* page_zone_maps = nullptr;
+        RETURN_IF_ERROR(reader->get_page_zone_maps(iter_opts, &page_zone_maps));
+        if (page_zone_maps == nullptr || page_zone_maps->empty()) {
+            continue;
+        }
+        auto data_type = _segment->get_data_type_of(*tablet_column, _opts);
+        if (data_type == nullptr) {
+            continue;
+        }
+
+        RowRanges column_ranges;
+        ZoneMapEvalStats page_stats;
+        for (uint32_t page_index = 0; page_index < page_zone_maps->size(); ++page_index) {
+            RowRange page_range;
+            RETURN_IF_ERROR(reader->get_row_range_for_page(page_index, iter_opts, &page_range));
+            if (!page_range.is_valid() || page_range.to() <= min_rowid) {
+                continue;
+            }
+            ZoneMapEvalContext ctx;
+            ZoneMapEvalContext::SlotZoneMap slot_zone_map;
+            slot_zone_map.data_type = data_type;
+            ZoneMap zone_map;
+            RETURN_IF_ERROR(
+                    ZoneMap::from_proto((*page_zone_maps)[page_index], data_type, zone_map));
+            slot_zone_map.zone_map = std::make_shared<ZoneMap>(std::move(zone_map));
+            ctx.slots.emplace(slot_index, std::move(slot_zone_map));
+            const auto result = VExprContext::evaluate_zonemap_filter(slot_conjuncts, ctx);
+            page_stats.merge_page_eval_stats(ctx.stats);
+            if (result != ZoneMapFilterResult::kNoMatch) {
+                column_ranges.add(
+                        RowRange(std::max<int64_t>(page_range.from(), min_rowid), page_range.to()));
+            } else {
+                ++_opts.stats->expr_zonemap_filtered_pages;
+            }
+        }
+        page_stats.accumulate_to(_opts.stats);
+        RowRanges::ranges_intersection(*row_ranges, column_ranges, row_ranges);
+        if (row_ranges->is_empty()) {
+            return Status::OK();
+        }
+    }
+    return Status::OK();
+}
+
 void SegmentIterator::_calculate_common_expr_index_exec_status() {
     for (const auto& root_expr_ctx : _common_expr_ctxs_push_down) {
         const auto& root_expr = root_expr_ctx->root();
@@ -3281,7 +3395,8 @@ Status SegmentIterator::_materialization_of_virtual_column(Block* block) {
                     column_expr->root()->debug_string());
         } else if (block->get_by_position(idx_in_block).column.get() == nullptr) {
             return Status::InternalError(
-                    "Virtual column index {} is null, block columns {}, virtual columns size {}, "
+                    "Virtual column index {} is null, block columns {}, virtual columns size "
+                    "{}, "
                     "virtual column expr {}",
                     idx_in_block, block->columns(), _vir_cid_to_idx_in_block.size(),
                     column_expr->root()->debug_string());
diff --git a/be/src/storage/segment/segment_iterator.h b/be/src/storage/segment/segment_iterator.h
index 5cc09f647d90db..d8f61daeba3553 100644
--- a/be/src/storage/segment/segment_iterator.h
+++ b/be/src/storage/segment/segment_iterator.h
@@ -188,6 +188,9 @@ class SegmentIterator : public RowwiseIterator {
     // calculate row ranges that satisfy requested column conditions using various column index
     [[nodiscard]] Status _get_row_ranges_by_column_conditions();
     [[nodiscard]] Status _get_row_ranges_from_conditions(RowRanges* condition_row_ranges);
+    [[nodiscard]] Status _apply_expr_zonemap_to_row_ranges(const VExprContextSPtrs& conjuncts,
+                                                           rowid_t min_rowid,
+                                                           RowRanges* row_ranges);
     [[nodiscard]] Status _apply_inverted_index();
     [[nodiscard]] Status _apply_inverted_index_on_column_predicate(
             std::shared_ptr<ColumnPredicate> pred,
diff --git a/be/test/exprs/expr_zonemap_filter_test.cpp b/be/test/exprs/expr_zonemap_filter_test.cpp
new file mode 100644
index 00000000000000..96e5d318006c0e
--- /dev/null
+++ b/be/test/exprs/expr_zonemap_filter_test.cpp
@@ -0,0 +1,819 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "exprs/expr_zonemap_filter.h"
+
+#include <gtest/gtest.h>
+
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "common/object_pool.h"
+#include "core/data_type/data_type_date_or_datetime_v2.h"
+#include "core/data_type/data_type_decimal.h"
+#include "core/data_type/data_type_nullable.h"
+#include "core/data_type/data_type_number.h"
+#include "core/data_type/data_type_string.h"
+#include "core/field.h"
+#include "core/string_ref.h"
+#include "core/value/vdatetime_value.h"
+#include "exprs/create_predicate_function.h"
+#include "exprs/function/functions_comparison.h"
+#include "exprs/function/simple_function_factory.h"
+#include "exprs/hybrid_set.h"
+#include "exprs/vcompound_pred.h"
+#include "exprs/vexpr.h"
+#include "exprs/vexpr_context.h"
+#include "exprs/vliteral.h"
+#include "exprs/vruntimefilter_wrapper.h"
+#include "exprs/vslot_ref.h"
+#include "runtime/descriptor_helper.h"
+#include "runtime/descriptors.h"
+#include "runtime/runtime_state.h"
+#include "storage/index/zone_map/zone_map_index.h"
+#include "storage/index/zone_map/zonemap_eval_context.h"
+#include "storage/segment/segment_iterator.h"
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wkeyword-macro"
+#endif
+#define private public
+#include "exprs/vdirect_in_predicate.h"
+#include "exprs/vin_predicate.h"
+#undef private
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+namespace doris {
+namespace {
+
+Field int_field(int32_t value) {
+    return Field::create_field<TYPE_INT>(value);
+}
+
+DataTypePtr int_type() {
+    return std::make_shared<DataTypeInt32>();
+}
+
+VExprSPtr make_slot(int column_id, const DataTypePtr& data_type) {
+    auto slot = std::make_shared<VSlotRef>();
+    slot->set_node_type(TExprNodeType::SLOT_REF);
+    slot->set_column_id(column_id);
+    slot->data_type() = data_type;
+    return slot;
+}
+
+VExprSPtr make_int_literal(int32_t value) {
+    return std::make_shared<VLiteral>(create_texpr_node_from(int_field(value), TYPE_INT, 0, 0));
+}
+
+Field datetimev2_field(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute,
+                       uint8_t second, uint32_t microsecond) {
+    DateV2Value<DateTimeV2ValueType> value;
+    value.unchecked_set_time(year, month, day, hour, minute, second, microsecond);
+    return Field::create_field<TYPE_DATETIMEV2>(value);
+}
+
+VExprSPtr make_datetimev2_literal(int scale) {
+    return std::make_shared<VLiteral>(create_texpr_node_from(
+            datetimev2_field(2024, 1, 2, 0, 0, 0, 0), TYPE_DATETIMEV2, 0, scale));
+}
+
+VExprSPtr make_null_int_literal() {
+    TExprNode node;
+    node.__set_node_type(TExprNodeType::NULL_LITERAL);
+    node.__set_type(create_type_desc(PrimitiveType::TYPE_INT));
+    node.__set_is_nullable(true);
+    return std::make_shared<VLiteral>(node);
+}
+
+VExprSPtr make_null_string_literal() {
+    TExprNode node;
+    node.__set_node_type(TExprNodeType::NULL_LITERAL);
+    node.__set_type(create_type_desc(PrimitiveType::TYPE_STRING));
+    node.__set_is_nullable(true);
+    return std::make_shared<VLiteral>(node);
+}
+
+VExprSPtr make_string_literal(std::string value) {
+    auto field = Field::create_field<TYPE_STRING>(std::move(value));
+    return std::make_shared<VLiteral>(create_texpr_node_from(field, TYPE_STRING, 0, 0));
+}
+
+ZoneMapEvalContext make_context(segment_v2::ZoneMap zone_map, const DataTypePtr& data_type) {
+    ZoneMapEvalContext ctx;
+    ZoneMapEvalContext::SlotZoneMap slot_zone_map;
+    slot_zone_map.data_type = data_type;
+    slot_zone_map.zone_map = std::make_shared<segment_v2::ZoneMap>(std::move(zone_map));
+    ctx.slots.emplace(0, std::move(slot_zone_map));
+    return ctx;
+}
+
+segment_v2::ZoneMap make_int_zonemap(int32_t min_value, int32_t max_value) {
+    segment_v2::ZoneMap zone_map;
+    zone_map.min_value = int_field(min_value);
+    zone_map.max_value = int_field(max_value);
+    zone_map.has_not_null = true;
+    return zone_map;
+}
+
+segment_v2::ZoneMap make_string_zonemap(std::string min_value, std::string max_value) {
+    segment_v2::ZoneMap zone_map;
+    zone_map.min_value = Field::create_field<TYPE_STRING>(std::move(min_value));
+    zone_map.max_value = Field::create_field<TYPE_STRING>(std::move(max_value));
+    zone_map.has_not_null = true;
+    return zone_map;
+}
+
+TDescriptorTable make_k2_scan_desc_tbl() {
+    TDescriptorTableBuilder desc_tbl_builder;
+    TTupleDescriptorBuilder tuple_builder;
+    auto k2_slot = TSlotDescriptorBuilder()
+                           .type(TYPE_INT)
+                           .column_name("k2")
+                           .column_pos(0)
+                           .nullable(false)
+                           .build();
+    k2_slot.__set_col_unique_id(1);
+    tuple_builder.add_slot(k2_slot);
+    tuple_builder.build(&desc_tbl_builder);
+    return desc_tbl_builder.desc_tbl();
+}
+
+TExprNode make_compound_node(TExprOpcode::type opcode, int num_children) {
+    TExprNode node;
+    node.__set_type(create_type_desc(PrimitiveType::TYPE_BOOLEAN));
+    node.__set_node_type(TExprNodeType::COMPOUND_PRED);
+    node.__set_opcode(opcode);
+    node.__set_num_children(num_children);
+    node.__set_is_nullable(false);
+    return node;
+}
+
+TExprNode make_in_predicate_node(bool is_not_in, int num_children) {
+    TExprNode node;
+    node.__set_type(create_type_desc(PrimitiveType::TYPE_BOOLEAN));
+    node.__set_node_type(TExprNodeType::IN_PRED);
+    node.__set_opcode(is_not_in ? TExprOpcode::FILTER_NOT_IN : TExprOpcode::FILTER_IN);
+    node.__set_num_children(num_children);
+    node.__set_is_nullable(false);
+    node.in_predicate.__set_is_not_in(is_not_in);
+    return node;
+}
+
+class FixedZonemapExpr final : public VExpr {
+public:
+    explicit FixedZonemapExpr(ZoneMapFilterResult result) : _result(result) {
+        _data_type = std::make_shared<DataTypeUInt8>();
+    }
+
+    const std::string& expr_name() const override { return _expr_name; }
+
+    Status execute_column(VExprContext*, const Block*, Selector*, size_t,
+                          ColumnPtr&) const override {
+        return Status::InternalError("FixedZonemapExpr is only used by zonemap tests");
+    }
+
+    ZoneMapFilterResult evaluate_zonemap_filter(const ZoneMapEvalContext&) const override {
+        return _result;
+    }
+
+    bool can_evaluate_zonemap_filter() const override { return true; }
+
+private:
+    ZoneMapFilterResult _result;
+    std::string _expr_name = "fixed_zonemap_expr";
+};
+
+class UnsupportedSingleSlotExpr final : public VExpr {
+public:
+    explicit UnsupportedSingleSlotExpr(const VExprSPtr& slot) {
+        _data_type = std::make_shared<DataTypeUInt8>();
+        add_child(slot);
+    }
+
+    const std::string& expr_name() const override { return _expr_name; }
+
+    Status execute_column(VExprContext*, const Block*, Selector*, size_t,
+                          ColumnPtr&) const override {
+        return Status::InternalError("UnsupportedSingleSlotExpr is only used by zonemap tests");
+    }
+
+private:
+    std::string _expr_name = "unsupported_single_slot_expr";
+};
+
+VExprSPtr make_fixed_zonemap_expr(ZoneMapFilterResult result) {
+    return std::make_shared<FixedZonemapExpr>(result);
+}
+
+} // namespace
+
+TEST(ExprZonemapFilterTest, DataTypesCompatibleRequiresExactNonStringType) {
+    EXPECT_TRUE(expr_zonemap::data_types_compatible(std::make_shared<DataTypeInt32>(),
+                                                    std::make_shared<DataTypeInt32>()));
+    EXPECT_TRUE(expr_zonemap::data_types_compatible(
+            std::make_shared<DataTypeString>(10, TYPE_CHAR),
+            std::make_shared<DataTypeString>(-1, TYPE_VARCHAR)));
+
+    EXPECT_FALSE(expr_zonemap::data_types_compatible(std::make_shared<DataTypeInt32>(),
+                                                     std::make_shared<DataTypeInt64>()));
+    EXPECT_FALSE(expr_zonemap::data_types_compatible(std::make_shared<DataTypeDecimal64>(10, 2),
+                                                     std::make_shared<DataTypeDecimal64>(10, 0)));
+}
+
+TEST(ExprZonemapFilterTest, ComparisonZonemapPrunesDisjointRanges) {
+    auto type = int_type();
+    auto slot = make_slot(0, type);
+    auto ctx = make_context(make_int_zonemap(10, 20), type);
+
+    FunctionComparison<LessOp, NameLess> less;
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              less.evaluate_zonemap_filter(ctx, {slot, make_int_literal(10)}));
+
+    FunctionComparison<GreaterOp, NameGreater> greater;
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              greater.evaluate_zonemap_filter(ctx, {slot, make_int_literal(20)}));
+
+    FunctionComparison<EqualsOp, NameEquals> equals;
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              equals.evaluate_zonemap_filter(ctx, {slot, make_int_literal(30)}));
+    EXPECT_EQ(ZoneMapFilterResult::kMayMatch,
+              equals.evaluate_zonemap_filter(ctx, {slot, make_int_literal(15)}));
+}
+
+TEST(ExprZonemapFilterTest, ComparisonZonemapHandlesLiteralOnLeft) {
+    auto type = int_type();
+    auto slot = make_slot(0, type);
+    auto ctx = make_context(make_int_zonemap(10, 20), type);
+
+    FunctionComparison<LessOp, NameLess> less;
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              less.evaluate_zonemap_filter(ctx, {make_int_literal(25), slot}));
+    EXPECT_EQ(ZoneMapFilterResult::kMayMatch,
+              less.evaluate_zonemap_filter(ctx, {make_int_literal(15), slot}));
+}
+
+TEST(ExprZonemapFilterTest, ComparisonZonemapHandlesBoundariesAndAllOperators) {
+    auto type = int_type();
+    auto slot = make_slot(0, type);
+    auto ctx = make_context(make_int_zonemap(10, 20), type);
+
+    FunctionComparison<LessOrEqualsOp, NameLessOrEquals> less_equal;
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              less_equal.evaluate_zonemap_filter(ctx, {slot, make_int_literal(9)}));
+    EXPECT_EQ(ZoneMapFilterResult::kMayMatch,
+              less_equal.evaluate_zonemap_filter(ctx, {slot, make_int_literal(10)}));
+
+    FunctionComparison<GreaterOrEqualsOp, NameGreaterOrEquals> greater_equal;
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              greater_equal.evaluate_zonemap_filter(ctx, {slot, make_int_literal(21)}));
+    EXPECT_EQ(ZoneMapFilterResult::kMayMatch,
+              greater_equal.evaluate_zonemap_filter(ctx, {slot, make_int_literal(20)}));
+
+    FunctionComparison<NotEqualsOp, NameNotEquals> not_equals;
+    EXPECT_EQ(ZoneMapFilterResult::kMayMatch,
+              not_equals.evaluate_zonemap_filter(ctx, {slot, make_int_literal(10)}));
+
+    auto single_value_ctx = make_context(make_int_zonemap(10, 10), type);
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              not_equals.evaluate_zonemap_filter(single_value_ctx, {slot, make_int_literal(10)}));
+    EXPECT_EQ(ZoneMapFilterResult::kMayMatch,
+              not_equals.evaluate_zonemap_filter(single_value_ctx, {slot, make_int_literal(11)}));
+
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              greater_equal.evaluate_zonemap_filter(ctx, {make_int_literal(9), slot}));
+    EXPECT_EQ(ZoneMapFilterResult::kMayMatch,
+              greater_equal.evaluate_zonemap_filter(ctx, {make_int_literal(10), slot}));
+}
+
+TEST(ExprZonemapFilterTest, ComparisonZonemapHandlesNullAndUnsupportedInputs) {
+    auto type = int_type();
+    auto slot = make_slot(0, type);
+
+    FunctionComparison<EqualsOp, NameEquals> equals;
+    EXPECT_FALSE(equals.can_evaluate_zonemap_filter({slot, make_null_int_literal()}));
+
+    auto string_type = std::make_shared<DataTypeString>();
+    auto string_slot = make_slot(0, string_type);
+    EXPECT_TRUE(equals.can_evaluate_zonemap_filter({string_slot, make_string_literal("10")}));
+
+    auto datetimev2_slot = make_slot(
+            0, std::make_shared<DataTypeNullable>(std::make_shared<DataTypeDateTimeV2>(6)));
+    EXPECT_FALSE(equals.can_evaluate_zonemap_filter({datetimev2_slot, make_datetimev2_literal(0)}));
+
+    ZoneMapEvalContext missing_zonemap_ctx;
+    ZoneMapEvalContext::SlotZoneMap slot_without_zonemap;
+    slot_without_zonemap.data_type = type;
+    missing_zonemap_ctx.slots.emplace(0, std::move(slot_without_zonemap));
+    EXPECT_EQ(ZoneMapFilterResult::kUnsupported,
+              equals.evaluate_zonemap_filter(missing_zonemap_ctx, {slot, make_int_literal(10)}));
+    EXPECT_EQ(1, missing_zonemap_ctx.stats.unusable_zonemap_eval_count);
+
+    auto pass_all_zonemap = make_int_zonemap(10, 20);
+    pass_all_zonemap.pass_all = true;
+    auto pass_all_ctx = make_context(std::move(pass_all_zonemap), type);
+    EXPECT_EQ(ZoneMapFilterResult::kUnsupported,
+              equals.evaluate_zonemap_filter(pass_all_ctx, {slot, make_int_literal(10)}));
+    EXPECT_EQ(1, pass_all_ctx.stats.unusable_zonemap_eval_count);
+}
+
+TEST(ExprZonemapFilterTest, MissingSlotTypeCountsUnsupportedZonemapEvalOnce) {
+    auto type = int_type();
+    auto slot = make_slot(0, type);
+
+    FunctionComparison<EqualsOp, NameEquals> equals;
+    ZoneMapEvalContext comparison_ctx;
+    EXPECT_EQ(ZoneMapFilterResult::kUnsupported,
+              equals.evaluate_zonemap_filter(comparison_ctx, {slot, make_int_literal(10)}));
+    EXPECT_EQ(1, comparison_ctx.stats.unusable_zonemap_eval_count);
+
+    auto string_type = std::make_shared<DataTypeString>();
+    auto string_slot = make_slot(0, string_type);
+    auto starts_with = SimpleFunctionFactory::instance().get_function(
+            "starts_with",
+            ColumnsWithTypeAndName {{nullptr, string_type, "slot"},
+                                    {nullptr, string_type, "prefix"}},
+            std::make_shared<DataTypeUInt8>());
+    ASSERT_NE(starts_with, nullptr);
+    ZoneMapEvalContext starts_with_ctx;
+    EXPECT_EQ(ZoneMapFilterResult::kUnsupported,
+              starts_with->evaluate_zonemap_filter(starts_with_ctx,
+                                                   {string_slot, make_string_literal("ab")}));
+    EXPECT_EQ(1, starts_with_ctx.stats.unusable_zonemap_eval_count);
+
+    std::vector<Field> values {int_field(10)};
+    ZoneMapEvalContext in_ctx;
+    EXPECT_EQ(ZoneMapFilterResult::kUnsupported,
+              expr_zonemap::eval_in_zonemap(in_ctx, slot, false, values, int_field(10),
+                                            int_field(10)));
+    EXPECT_EQ(1, in_ctx.stats.unusable_zonemap_eval_count);
+}
+
+TEST(ExprZonemapFilterTest, NullZonemapUsesNullFlagsOnly) {
+    auto type = int_type();
+    auto slot = make_slot(0, type);
+
+    struct NullFlagCase {
+        bool has_null;
+        bool has_not_null;
+        ZoneMapFilterResult is_null_result;
+        ZoneMapFilterResult is_not_null_result;
+    };
+    const std::vector<NullFlagCase> cases {
+            {false, false, ZoneMapFilterResult::kNoMatch, ZoneMapFilterResult::kNoMatch},
+            {true, false, ZoneMapFilterResult::kMayMatch, ZoneMapFilterResult::kNoMatch},
+            {false, true, ZoneMapFilterResult::kNoMatch, ZoneMapFilterResult::kMayMatch},
+            {true, true, ZoneMapFilterResult::kMayMatch, ZoneMapFilterResult::kMayMatch}};
+
+    for (const auto& c : cases) {
+        segment_v2::ZoneMap zone_map;
+        zone_map.has_null = c.has_null;
+        zone_map.has_not_null = c.has_not_null;
+        auto ctx = make_context(zone_map, type);
+
+        EXPECT_EQ(c.is_null_result, expr_zonemap::eval_null_zonemap(ctx, {slot}, true))
+                << "has_null=" << c.has_null << ", has_not_null=" << c.has_not_null;
+        EXPECT_EQ(c.is_not_null_result, expr_zonemap::eval_null_zonemap(ctx, {slot}, false))
+                << "has_null=" << c.has_null << ", has_not_null=" << c.has_not_null;
+    }
+}
+
+TEST(ExprZonemapFilterTest, RangeStatsUnusableFlagsFallback) {
+    auto type = int_type();
+    auto slot = make_slot(0, type);
+    FunctionComparison<EqualsOp, NameEquals> equals;
+
+    for (int flag = 0; flag < 4; ++flag) {
+        auto zone_map = make_int_zonemap(10, 20);
+        zone_map.pass_all = flag == 0;
+        zone_map.has_nan = flag == 1;
+        zone_map.has_positive_inf = flag == 2;
+        zone_map.has_negative_inf = flag == 3;
+
+        auto ctx = make_context(std::move(zone_map), type);
+
+        EXPECT_EQ(ZoneMapFilterResult::kUnsupported,
+                  equals.evaluate_zonemap_filter(ctx, {slot, make_int_literal(10)}))
+                << "flag=" << flag;
+        EXPECT_EQ(1, ctx.stats.unusable_zonemap_eval_count) << "flag=" << flag;
+    }
+}
+
+TEST(ExprZonemapFilterTest, InZonemapSkipsZonesWithoutNonNullValues) {
+    auto type = int_type();
+    auto slot = make_slot(0, type);
+    std::vector<Field> values {int_field(10)};
+
+    segment_v2::ZoneMap empty_zone;
+    auto empty_ctx = make_context(empty_zone, type);
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              expr_zonemap::eval_in_zonemap(empty_ctx, slot, false, values, int_field(10),
+                                            int_field(10)));
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              expr_zonemap::eval_in_zonemap(empty_ctx, slot, true, values, int_field(10),
+                                            int_field(10)));
+
+    segment_v2::ZoneMap only_null_zone;
+    only_null_zone.has_null = true;
+    auto only_null_ctx = make_context(only_null_zone, type);
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              expr_zonemap::eval_in_zonemap(only_null_ctx, slot, false, values, int_field(10),
+                                            int_field(10)));
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              expr_zonemap::eval_in_zonemap(only_null_ctx, slot, true, values, int_field(10),
+                                            int_field(10)));
+}
+
+TEST(ExprZonemapFilterTest, FunctionStringStartsWithZonemapUsesPrefixRange) {
+    auto type = std::make_shared<DataTypeString>();
+    auto slot = make_slot(0, type);
+    auto starts_with = SimpleFunctionFactory::instance().get_function(
+            "starts_with",
+            ColumnsWithTypeAndName {{nullptr, type, "slot"}, {nullptr, type, "prefix"}},
+            std::make_shared<DataTypeUInt8>());
+    ASSERT_NE(starts_with, nullptr);
+    EXPECT_EQ("starts_with", starts_with->get_name());
+
+    EXPECT_TRUE(starts_with->can_evaluate_zonemap_filter({slot, make_string_literal("ab")}));
+    EXPECT_FALSE(starts_with->can_evaluate_zonemap_filter({slot, make_null_string_literal()}));
+    EXPECT_FALSE(starts_with->can_evaluate_zonemap_filter({slot, make_string_literal("")}));
+    EXPECT_FALSE(starts_with->can_evaluate_zonemap_filter({make_string_literal("ab"), slot}));
+
+    auto below_prefix_ctx = make_context(make_string_zonemap("aa", "aa"), type);
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              starts_with->evaluate_zonemap_filter(below_prefix_ctx,
+                                                   {slot, make_string_literal("ab")}));
+
+    auto above_prefix_ctx = make_context(make_string_zonemap("ac", "ad"), type);
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              starts_with->evaluate_zonemap_filter(above_prefix_ctx,
+                                                   {slot, make_string_literal("ab")}));
+
+    auto overlap_ctx = make_context(make_string_zonemap("aa", "abz"), type);
+    EXPECT_EQ(ZoneMapFilterResult::kMayMatch,
+              starts_with->evaluate_zonemap_filter(overlap_ctx, {slot, make_string_literal("ab")}));
+
+    segment_v2::ZoneMap only_null;
+    only_null.has_null = true;
+    auto null_ctx = make_context(only_null, type);
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              starts_with->evaluate_zonemap_filter(null_ctx, {slot, make_string_literal("ab")}));
+
+    std::string max_byte_prefix(1, static_cast<char>(0xff));
+    EXPECT_TRUE(
+            starts_with->can_evaluate_zonemap_filter({slot, make_string_literal(max_byte_prefix)}));
+    auto max_prefix_ctx =
+            make_context(make_string_zonemap(max_byte_prefix, max_byte_prefix + "z"), type);
+    EXPECT_EQ(ZoneMapFilterResult::kMayMatch,
+              starts_with->evaluate_zonemap_filter(max_prefix_ctx,
+                                                   {slot, make_string_literal(max_byte_prefix)}));
+}
+
+TEST(ExprZonemapFilterTest, CharZonemapUsesTrimmedLogicalBounds) {
+    auto char_type = std::make_shared<DataTypeString>(10, TYPE_CHAR);
+    auto slot = make_slot(0, char_type);
+
+    std::string padded_alpha = "alpha";
+    padded_alpha.resize(10, '\0');
+    std::string padded_beta = "beta";
+    padded_beta.resize(10, '\0');
+
+    segment_v2::ZoneMapPB zone_map_pb;
+    zone_map_pb.set_has_not_null(true);
+    zone_map_pb.set_min(padded_alpha);
+    zone_map_pb.set_max(padded_beta);
+    segment_v2::ZoneMap zone_map;
+    ASSERT_TRUE(segment_v2::ZoneMap::from_proto(zone_map_pb, char_type, zone_map).ok());
+    EXPECT_EQ(Field::create_field<TYPE_STRING>("alpha"), zone_map.min_value);
+    EXPECT_EQ(Field::create_field<TYPE_STRING>("beta"), zone_map.max_value);
+
+    FunctionComparison<EqualsOp, NameEquals> equals;
+    EXPECT_TRUE(equals.can_evaluate_zonemap_filter({slot, make_string_literal("gamma")}));
+    auto comparison_ctx = make_context(zone_map, char_type);
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              equals.evaluate_zonemap_filter(comparison_ctx, {slot, make_string_literal("gamma")}));
+    EXPECT_EQ(ZoneMapFilterResult::kMayMatch,
+              equals.evaluate_zonemap_filter(comparison_ctx, {slot, make_string_literal("alpha")}));
+
+    auto string_type = std::make_shared<DataTypeString>();
+    auto starts_with = SimpleFunctionFactory::instance().get_function(
+            "starts_with",
+            ColumnsWithTypeAndName {{nullptr, char_type, "slot"}, {nullptr, string_type, "prefix"}},
+            std::make_shared<DataTypeUInt8>());
+    ASSERT_NE(starts_with, nullptr);
+    EXPECT_TRUE(starts_with->can_evaluate_zonemap_filter({slot, make_string_literal("ga")}));
+    auto starts_with_ctx = make_context(zone_map, char_type);
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              starts_with->evaluate_zonemap_filter(starts_with_ctx,
+                                                   {slot, make_string_literal("ga")}));
+
+    auto in_value = Field::create_field<TYPE_STRING>("gamma");
+    std::vector<Field> values {in_value};
+    auto in_ctx = make_context(zone_map, char_type);
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              expr_zonemap::eval_in_zonemap(in_ctx, slot, false, values, in_value, in_value));
+}
+
+TEST(ExprZonemapFilterTest, InZonemapFallsBackToRangeWhenPointListIsLarge) {
+    auto type = int_type();
+    auto slot = make_slot(0, type);
+    auto ctx = make_context(make_int_zonemap(10, 20), type);
+
+    std::vector<Field> values;
+    for (int value = 1; value <= 65; ++value) {
+        values.emplace_back(int_field(value));
+    }
+    EXPECT_EQ(ZoneMapFilterResult::kMayMatch,
+              expr_zonemap::eval_in_zonemap(ctx, slot, false, values, int_field(1), int_field(65)));
+
+    EXPECT_EQ(0, ctx.stats.in_zonemap_point_check_count);
+    EXPECT_EQ(1, ctx.stats.in_zonemap_range_only_count);
+}
+
+TEST(ExprZonemapFilterTest, InZonemapUsesPointChecksUnderThreshold) {
+    auto type = int_type();
+    auto slot = make_slot(0, type);
+    auto ctx = make_context(make_int_zonemap(10, 20), type);
+
+    std::vector<Field> values {int_field(1), int_field(30)};
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              expr_zonemap::eval_in_zonemap(ctx, slot, false, values, int_field(1), int_field(30)));
+    EXPECT_EQ(1, ctx.stats.in_zonemap_point_check_count);
+}
+
+TEST(ExprZonemapFilterTest, InZonemapHandlesEmptyListAndNotInSingleValueRange) {
+    auto type = int_type();
+    auto slot = make_slot(0, type);
+    auto ctx = make_context(make_int_zonemap(10, 20), type);
+
+    std::vector<Field> empty_values;
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              expr_zonemap::eval_in_zonemap(ctx, slot, false, empty_values, {}, {}));
+    EXPECT_EQ(ZoneMapFilterResult::kMayMatch,
+              expr_zonemap::eval_in_zonemap(ctx, slot, true, empty_values, {}, {}));
+
+    auto single_value_ctx = make_context(make_int_zonemap(10, 10), type);
+    std::vector<Field> values {int_field(10)};
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              expr_zonemap::eval_in_zonemap(single_value_ctx, slot, true, values, int_field(10),
+                                            int_field(10)));
+
+    std::vector<Field> other_values {int_field(11)};
+    EXPECT_EQ(ZoneMapFilterResult::kMayMatch,
+              expr_zonemap::eval_in_zonemap(single_value_ctx, slot, true, other_values,
+                                            int_field(11), int_field(11)));
+}
+
+TEST(ExprZonemapFilterTest, UnsupportedSingleSlotExprDoesNotAdvertiseZonemapCapability) {
+    auto type = int_type();
+    auto slot = make_slot(0, type);
+    auto unsupported_expr = std::make_shared<UnsupportedSingleSlotExpr>(slot);
+
+    std::set<int> slot_indexes;
+    unsupported_expr->collect_slot_column_ids(slot_indexes);
+    EXPECT_EQ(std::set<int>({0}), slot_indexes);
+    EXPECT_FALSE(unsupported_expr->can_evaluate_zonemap_filter());
+
+    FunctionComparison<EqualsOp, NameEquals> equals;
+    EXPECT_TRUE(equals.can_evaluate_zonemap_filter({slot, make_int_literal(10)}));
+    EXPECT_FALSE(equals.can_evaluate_zonemap_filter({unsupported_expr, make_int_literal(10)}));
+}
+
+TEST(ExprZonemapFilterTest, VInPredicateMaterializesZonemapValues) {
+    auto type = int_type();
+    ObjectPool obj_pool;
+    DescriptorTbl* desc_tbl = nullptr;
+    auto thrift_desc_tbl = make_k2_scan_desc_tbl();
+    ASSERT_TRUE(DescriptorTbl::create(&obj_pool, thrift_desc_tbl, &desc_tbl).ok());
+
+    RuntimeState runtime_state;
+    runtime_state.set_desc_tbl(desc_tbl);
+    RowDescriptor row_desc(runtime_state.desc_tbl(), {0}, {false});
+
+    auto in_predicate = std::make_shared<VInPredicate>(make_in_predicate_node(false, 3));
+    auto in_slot = make_slot(0, type);
+    std::static_pointer_cast<VSlotRef>(in_slot)->set_slot_id(0);
+    in_predicate->add_child(in_slot);
+    in_predicate->add_child(make_int_literal(1));
+    in_predicate->add_child(make_int_literal(30));
+    VExprContext in_context(in_predicate);
+    ASSERT_TRUE(in_context.prepare(&runtime_state, row_desc).ok());
+    ASSERT_TRUE(in_context.open(&runtime_state).ok());
+
+    auto ctx = make_context(make_int_zonemap(10, 20), type);
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch, in_predicate->evaluate_zonemap_filter(ctx));
+    EXPECT_TRUE(in_predicate->_zonemap_materialized);
+    EXPECT_EQ(int_field(1), in_predicate->_seg_filter_min);
+    EXPECT_EQ(int_field(30), in_predicate->_seg_filter_max);
+
+    auto not_in_with_null = std::make_shared<VInPredicate>(make_in_predicate_node(true, 3));
+    auto not_in_slot = make_slot(0, type);
+    std::static_pointer_cast<VSlotRef>(not_in_slot)->set_slot_id(0);
+    not_in_with_null->add_child(not_in_slot);
+    not_in_with_null->add_child(make_int_literal(10));
+    not_in_with_null->add_child(make_null_int_literal());
+    VExprContext not_in_context(not_in_with_null);
+    ASSERT_TRUE(not_in_context.prepare(&runtime_state, row_desc).ok());
+    ASSERT_TRUE(not_in_context.open(&runtime_state).ok());
+
+    auto may_match_ctx = make_context(make_int_zonemap(11, 11), type);
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              not_in_with_null->evaluate_zonemap_filter(may_match_ctx));
+    EXPECT_TRUE(not_in_with_null->_seg_filter_contains_null);
+}
+
+TEST(ExprZonemapFilterTest, DirectInPredicateMaterializesStringSetForZonemap) {
+    auto type = std::make_shared<DataTypeString>();
+    std::shared_ptr<HybridSetBase> filter(create_set(PrimitiveType::TYPE_STRING, false));
+    StringRef aaa("aaa");
+    filter->insert(&aaa);
+    StringRef zzz("zzz");
+    filter->insert(&zzz);
+
+    auto slot = make_slot(0, type);
+    VDirectInPredicate direct_in_expr(make_in_predicate_node(false, 2), filter, true);
+    direct_in_expr.add_child(slot);
+    ASSERT_TRUE(direct_in_expr._materialize_for_zonemap_filter().ok());
+
+    EXPECT_TRUE(direct_in_expr._zonemap_materialized);
+    EXPECT_EQ(2, direct_in_expr._seg_filter_values.size());
+    EXPECT_EQ(Field::create_field<TYPE_STRING>("aaa"), direct_in_expr._seg_filter_min);
+    EXPECT_EQ(Field::create_field<TYPE_STRING>("zzz"), direct_in_expr._seg_filter_max);
+}
+
+TEST(ExprZonemapFilterTest, DirectInPredicateMaterializesZonemapValuesDuringPrepare) {
+    auto type = int_type();
+    ObjectPool obj_pool;
+    DescriptorTbl* desc_tbl = nullptr;
+    auto thrift_desc_tbl = make_k2_scan_desc_tbl();
+    ASSERT_TRUE(DescriptorTbl::create(&obj_pool, thrift_desc_tbl, &desc_tbl).ok());
+
+    RuntimeState runtime_state;
+    runtime_state.set_desc_tbl(desc_tbl);
+    RowDescriptor row_desc(runtime_state.desc_tbl(), {0}, {false});
+
+    std::shared_ptr<HybridSetBase> filter(create_set(PrimitiveType::TYPE_INT, false));
+    int32_t low_value = 1;
+    int32_t high_value = 30;
+    filter->insert(&low_value);
+    filter->insert(&high_value);
+
+    auto direct_in_expr =
+            std::make_shared<VDirectInPredicate>(make_in_predicate_node(false, 1), filter, true);
+    auto slot = make_slot(0, type);
+    std::static_pointer_cast<VSlotRef>(slot)->set_slot_id(0);
+    direct_in_expr->add_child(slot);
+
+    VExprContext context(direct_in_expr);
+    ASSERT_TRUE(context.prepare(&runtime_state, row_desc).ok());
+
+    EXPECT_TRUE(direct_in_expr->_zonemap_materialized);
+    EXPECT_TRUE(direct_in_expr->can_evaluate_zonemap_filter());
+    EXPECT_EQ(2, direct_in_expr->_seg_filter_values.size());
+    EXPECT_EQ(int_field(1), direct_in_expr->_seg_filter_min);
+    EXPECT_EQ(int_field(30), direct_in_expr->_seg_filter_max);
+}
+
+TEST(ExprZonemapFilterTest, DirectInPredicateRewritesStringSetToInPredicate) {
+    auto type = std::make_shared<DataTypeString>();
+    auto slot = make_slot(0, type);
+    std::shared_ptr<HybridSetBase> filter(create_set(PrimitiveType::TYPE_STRING, false));
+    StringRef value("iceberg");
+    filter->insert(&value);
+
+    VDirectInPredicate direct_in_expr(make_in_predicate_node(false, 1), filter, true);
+    direct_in_expr.add_child(slot);
+
+    VExprSPtr in_expr;
+    ASSERT_TRUE(direct_in_expr.get_slot_in_expr(in_expr));
+    EXPECT_NE(std::string::npos, in_expr->debug_string().find("iceberg"));
+}
+
+TEST(ExprZonemapFilterTest, DirectInPredicateSkipsMaterializationWhenSetTypeDiffersFromChild) {
+    auto string_type = std::make_shared<DataTypeString>();
+    auto slot = make_slot(0, string_type);
+    std::shared_ptr<HybridSetBase> filter(create_set(PrimitiveType::TYPE_INT, false));
+    int dict_code = 1;
+    filter->insert(&dict_code);
+
+    VDirectInPredicate direct_in_expr(make_in_predicate_node(false, 1), filter, false);
+    direct_in_expr.add_child(slot);
+
+    ASSERT_TRUE(direct_in_expr._materialize_for_zonemap_filter().ok());
+    EXPECT_FALSE(direct_in_expr._zonemap_materialized);
+    VExprSPtr in_expr;
+    EXPECT_FALSE(direct_in_expr.get_slot_in_expr(in_expr));
+}
+
+TEST(ExprZonemapFilterTest, RuntimeFilterWrapperNullAwareZonemapKeepsZonesWithNull) {
+    auto type = int_type();
+    auto slot = make_slot(0, type);
+    std::shared_ptr<HybridSetBase> filter(create_set(PrimitiveType::TYPE_INT, true));
+    int32_t low_value = 1;
+    int32_t high_value = 30;
+    filter->insert(&low_value);
+    filter->insert(&high_value);
+
+    auto direct_in_expr =
+            std::make_shared<VDirectInPredicate>(make_in_predicate_node(false, 1), filter, true);
+    direct_in_expr->add_child(slot);
+    ASSERT_TRUE(direct_in_expr->_materialize_for_zonemap_filter().ok());
+
+    auto runtime_filter = VRuntimeFilterWrapper::create_shared(make_in_predicate_node(false, 1),
+                                                               direct_in_expr, 0.0, true, 7);
+    EXPECT_TRUE(runtime_filter->can_evaluate_zonemap_filter());
+
+    auto no_null_ctx = make_context(make_int_zonemap(10, 20), type);
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch, runtime_filter->evaluate_zonemap_filter(no_null_ctx));
+
+    auto with_null_zonemap = make_int_zonemap(10, 20);
+    with_null_zonemap.has_null = true;
+    auto with_null_ctx = make_context(std::move(with_null_zonemap), type);
+    EXPECT_EQ(ZoneMapFilterResult::kMayMatch,
+              runtime_filter->evaluate_zonemap_filter(with_null_ctx));
+
+    segment_v2::ZoneMap only_null_zonemap;
+    only_null_zonemap.has_null = true;
+    auto only_null_ctx = make_context(std::move(only_null_zonemap), type);
+    EXPECT_EQ(ZoneMapFilterResult::kMayMatch,
+              runtime_filter->evaluate_zonemap_filter(only_null_ctx));
+}
+
+TEST(ExprZonemapFilterTest, CompoundPredicateEvaluatesChildrenForZonemap) {
+    ZoneMapEvalContext ctx;
+
+    VCompoundPred and_pred(make_compound_node(TExprOpcode::COMPOUND_AND, 2));
+    and_pred.add_child(make_fixed_zonemap_expr(ZoneMapFilterResult::kMayMatch));
+    and_pred.add_child(make_fixed_zonemap_expr(ZoneMapFilterResult::kNoMatch));
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch, and_pred.evaluate_zonemap_filter(ctx));
+
+    auto type = int_type();
+    auto slot = make_slot(0, type);
+    VCompoundPred and_with_unsupported(make_compound_node(TExprOpcode::COMPOUND_AND, 2));
+    and_with_unsupported.add_child(std::make_shared<UnsupportedSingleSlotExpr>(slot));
+    and_with_unsupported.add_child(make_fixed_zonemap_expr(ZoneMapFilterResult::kNoMatch));
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch, and_with_unsupported.evaluate_zonemap_filter(ctx));
+
+    VCompoundPred or_pred(make_compound_node(TExprOpcode::COMPOUND_OR, 2));
+    or_pred.add_child(make_fixed_zonemap_expr(ZoneMapFilterResult::kNoMatch));
+    or_pred.add_child(make_fixed_zonemap_expr(ZoneMapFilterResult::kMayMatch));
+    EXPECT_EQ(ZoneMapFilterResult::kMayMatch, or_pred.evaluate_zonemap_filter(ctx));
+
+    VCompoundPred or_with_unsupported(make_compound_node(TExprOpcode::COMPOUND_OR, 2));
+    or_with_unsupported.add_child(make_fixed_zonemap_expr(ZoneMapFilterResult::kNoMatch));
+    or_with_unsupported.add_child(std::make_shared<UnsupportedSingleSlotExpr>(slot));
+    EXPECT_FALSE(or_with_unsupported.can_evaluate_zonemap_filter());
+
+    VCompoundPred or_no_match(make_compound_node(TExprOpcode::COMPOUND_OR, 2));
+    or_no_match.add_child(make_fixed_zonemap_expr(ZoneMapFilterResult::kNoMatch));
+    or_no_match.add_child(make_fixed_zonemap_expr(ZoneMapFilterResult::kNoMatch));
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch, or_no_match.evaluate_zonemap_filter(ctx));
+
+    VCompoundPred not_pred(make_compound_node(TExprOpcode::COMPOUND_NOT, 1));
+    not_pred.add_child(make_fixed_zonemap_expr(ZoneMapFilterResult::kNoMatch));
+    EXPECT_EQ(ZoneMapFilterResult::kUnsupported, not_pred.evaluate_zonemap_filter(ctx));
+    EXPECT_EQ(1, ctx.stats.unusable_zonemap_eval_count);
+}
+
+TEST(ExprZonemapFilterTest, ExprContextZonemapEvaluationShortCircuitsOnNoMatch) {
+    auto may_match =
+            VExprContext::create_shared(make_fixed_zonemap_expr(ZoneMapFilterResult::kMayMatch));
+    auto no_match =
+            VExprContext::create_shared(make_fixed_zonemap_expr(ZoneMapFilterResult::kNoMatch));
+
+    ZoneMapEvalContext ctx;
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              VExprContext::evaluate_zonemap_filter({may_match, no_match}, ctx));
+    EXPECT_EQ(ZoneMapFilterResult::kMayMatch,
+              VExprContext::evaluate_zonemap_filter({may_match}, ctx));
+
+    auto type = int_type();
+    auto slot = make_slot(0, type);
+    auto unsupported =
+            VExprContext::create_shared(std::make_shared<UnsupportedSingleSlotExpr>(slot));
+    EXPECT_EQ(ZoneMapFilterResult::kNoMatch,
+              VExprContext::evaluate_zonemap_filter({unsupported, no_match}, ctx));
+    EXPECT_EQ(0, ctx.stats.unusable_zonemap_eval_count);
+}
+
+} // namespace doris
diff --git a/be/test/format/parquet/parquet_expr_test.cpp b/be/test/format/parquet/parquet_expr_test.cpp
index 73441901db7743..0e1774fa634376 100644
--- a/be/test/format/parquet/parquet_expr_test.cpp
+++ b/be/test/format/parquet/parquet_expr_test.cpp
@@ -49,6 +49,7 @@
 #include <utility>
 #include <vector>
 
+#include "common/config.h"
 #include "common/object_pool.h"
 #include "common/status.h"
 #include "core/column/column.h"
@@ -70,6 +71,8 @@
 #include "information_schema/schema_scanner.h"
 #include "io/fs/local_file_system.h"
 #include "runtime/descriptors.h"
+#include "runtime/runtime_state.h"
+#include "storage/index/zone_map/zonemap_eval_context.h"
 #include "storage/predicate/comparison_predicate.h"
 #include "storage/predicate/in_list_predicate.h"
 #include "storage/predicate/null_predicate.h"
@@ -83,6 +86,116 @@ class VExprContext;
 //using namespace iceberg;
 using namespace parquet;
 
+namespace {
+
+class ScopedBoolConfig {
+public:
+    ScopedBoolConfig(bool& config, bool value) : _config(config), _old_value(config) {
+        _config = value;
+    }
+    ~ScopedBoolConfig() { _config = _old_value; }
+
+private:
+    bool& _config;
+    bool _old_value;
+};
+
+class TestPageZonemapExpr final : public VExpr {
+public:
+    enum class Mode {
+        BIGINT_MAX_AT_LEAST,
+        HAS_NOT_NULL,
+        STRING_CONTAINS_VALUE,
+        ALWAYS_NO_MATCH,
+        UNSUPPORTED_CAPABILITY,
+        UNSUPPORTED_RESULT
+    };
+
+    TestPageZonemapExpr(std::vector<int> column_ids, Mode mode, int64_t int_value = 0,
+                        std::string string_value = {})
+            : _column_ids(std::move(column_ids)),
+              _mode(mode),
+              _int_value(int_value),
+              _string_value(std::move(string_value)) {
+        _data_type = std::make_shared<DataTypeUInt8>();
+    }
+
+    const std::string& expr_name() const override { return _expr_name; }
+
+    Status execute_column(VExprContext*, const Block*, Selector*, size_t,
+                          ColumnPtr&) const override {
+        return Status::InternalError("TestPageZonemapExpr is only used by zonemap tests");
+    }
+
+    void collect_slot_column_ids(std::set<int>& column_ids) const override {
+        column_ids.insert(_column_ids.begin(), _column_ids.end());
+    }
+
+    bool can_evaluate_zonemap_filter() const override {
+        return _mode != Mode::UNSUPPORTED_CAPABILITY;
+    }
+
+    ZoneMapFilterResult evaluate_zonemap_filter(const ZoneMapEvalContext& ctx) const override {
+        DORIS_CHECK(_mode != Mode::UNSUPPORTED_CAPABILITY);
+        if (_mode == Mode::ALWAYS_NO_MATCH) {
+            return ZoneMapFilterResult::kNoMatch;
+        }
+        if (_mode == Mode::UNSUPPORTED_RESULT) {
+            return unsupported_zonemap_filter(ctx);
+        }
+
+        DORIS_CHECK(_column_ids.size() == 1);
+        auto zone_map_ref = ctx.zone_map(_column_ids.front());
+        if (zone_map_ref == nullptr) {
+            ++ctx.stats.unusable_zonemap_eval_count;
+            return ZoneMapFilterResult::kUnsupported;
+        }
+        const auto& zone_map = *zone_map_ref;
+
+        if (_mode == Mode::HAS_NOT_NULL) {
+            return zone_map.has_not_null ? ZoneMapFilterResult::kMayMatch
+                                         : ZoneMapFilterResult::kNoMatch;
+        }
+
+        if (!zone_map.has_not_null) {
+            return ZoneMapFilterResult::kNoMatch;
+        }
+
+        if (_mode == Mode::BIGINT_MAX_AT_LEAST) {
+            return zone_map.max_value.get<TYPE_BIGINT>() >= _int_value
+                           ? ZoneMapFilterResult::kMayMatch
+                           : ZoneMapFilterResult::kNoMatch;
+        }
+
+        DORIS_CHECK(_mode == Mode::STRING_CONTAINS_VALUE);
+        const auto& min_value = zone_map.min_value.get<TYPE_STRING>();
+        const auto& max_value = zone_map.max_value.get<TYPE_STRING>();
+        return min_value <= _string_value && _string_value <= max_value
+                       ? ZoneMapFilterResult::kMayMatch
+                       : ZoneMapFilterResult::kNoMatch;
+    }
+
+private:
+    std::vector<int> _column_ids;
+    Mode _mode;
+    int64_t _int_value;
+    std::string _string_value;
+    std::string _expr_name = "test_page_zonemap_expr";
+};
+
+VExprContextSPtr make_page_zonemap_context(std::shared_ptr<TestPageZonemapExpr> expr) {
+    auto ctx = VExprContext::create_shared(std::move(expr));
+    ctx->_prepared = true;
+    ctx->_opened = true;
+    return ctx;
+}
+
+std::string encode_int64(const int64_t value) {
+    return std::string(reinterpret_cast<const char*>(&value), sizeof(value));
+}
+
+} // namespace
+
 class ParquetExprTest : public testing::Test {
 public:
     ParquetExprTest() {}
@@ -275,8 +388,11 @@ class ParquetExprTest : public testing::Test {
             scan_range.size = local_file_reader->size();
         }
 
+        query_options.__set_enable_expr_zonemap_filter(true);
+        runtime_state = std::make_unique<RuntimeState>(query_globals);
+        runtime_state->set_query_options(query_options);
         p_reader = ParquetReader::create_unique(nullptr, scan_params, scan_range, scan_range.size,
-                                                &ctz, nullptr, nullptr);
+                                                &ctz, nullptr, runtime_state.get());
         p_reader->set_file_reader(local_file_reader);
         colname_to_slot_id.emplace("int64_col", 2);
         phmap::flat_hash_map<int, std::vector<std::shared_ptr<ColumnPredicate>>> tmp;
@@ -355,6 +471,74 @@ class ParquetExprTest : public testing::Test {
         return dump;
     }
 
+    static void install_page_index_getter(
+            ParquetPredicate::CachedPageIndexStat* cached_page_index) {
+        cached_page_index->get_stat_func =
+                [cached_page_index](ParquetPredicate::PageIndexStat** stat, int cid) -> bool {
+            auto it = cached_page_index->stats.find(cid);
+            if (it == cached_page_index->stats.end()) {
+                return false;
+            }
+            *stat = &it->second;
+            return it->second.available;
+        };
+    }
+
+    ParquetPredicate::PageIndexStat make_int64_page_index_stat(
+            std::vector<std::tuple<int64_t, int64_t, RowRange>> pages) const {
+        ParquetPredicate::PageIndexStat stat;
+        stat.available = true;
+        stat.num_of_pages = pages.size();
+        stat.col_schema = doris_file_metadata->schema().get_column(2);
+        for (const auto& [min_value, max_value, range] : pages) {
+            stat.encoded_min_value.emplace_back(encode_int64(min_value));
+            stat.encoded_max_value.emplace_back(encode_int64(max_value));
+            stat.has_null.emplace_back(false);
+            stat.is_all_null.emplace_back(false);
+            stat.ranges.emplace_back(range);
+        }
+        return stat;
+    }
+
+    ParquetPredicate::PageIndexStat make_string_page_index_stat(
+            std::vector<std::tuple<std::string, std::string, RowRange>> pages) const {
+        ParquetPredicate::PageIndexStat stat;
+        stat.available = true;
+        stat.num_of_pages = pages.size();
+        stat.col_schema = doris_file_metadata->schema().get_column(5);
+        for (const auto& [min_value, max_value, range] : pages) {
+            stat.encoded_min_value.emplace_back(min_value);
+            stat.encoded_max_value.emplace_back(max_value);
+            stat.has_null.emplace_back(false);
+            stat.is_all_null.emplace_back(false);
+            stat.ranges.emplace_back(range);
+        }
+        return stat;
+    }
+
+    static void assert_single_range(RowRanges* ranges, int64_t from, int64_t to) {
+        ASSERT_EQ(1, ranges->range_size());
+        EXPECT_EQ(from, ranges->get_range_from(0));
+        EXPECT_EQ(to, ranges->get_range_to(0));
+    }
+
+    Status process_expr_zonemap_page_filter(
+            ParquetPredicate::CachedPageIndexStat* cached_page_index,
+            RowRanges* candidate_row_ranges, bool* filtered_row_group_by_expr_zonemap = nullptr) {
+        bool filtered_row_group = false;
+        auto status = p_reader->_process_expr_zonemap_page_filter(
+                cached_page_index, candidate_row_ranges, &filtered_row_group);
+        if (filtered_row_group_by_expr_zonemap != nullptr) {
+            *filtered_row_group_by_expr_zonemap = filtered_row_group;
+        }
+        return status;
+    }
+
+    void set_expr_zonemap_filter_enabled(bool enabled) {
+        query_options.__set_enable_expr_zonemap_filter(enabled);
+        runtime_state->set_query_options(query_options);
+    }
+
     static void create_table_desc(TDescriptorTable& t_desc_table, TTableDescriptor& t_table_desc,
                                   std::vector<std::string> table_column_names,
                                   std::vector<TPrimitiveType::type> types) {
@@ -414,6 +598,9 @@ class ParquetExprTest : public testing::Test {
 
     std::string file_path;
     std::unique_ptr<ParquetReader> p_reader;
+    TQueryOptions query_options;
+    TQueryGlobals query_globals;
+    std::unique_ptr<RuntimeState> runtime_state;
     // create doirs parquet reader.
     TDescriptorTable t_desc_table;
     TTableDescriptor t_table_desc;
@@ -833,6 +1020,232 @@ TEST_F(ParquetExprTest, test_min_max_p) {
     }
 }
 
+TEST_F(ParquetExprTest, test_expr_zonemap_page_filter_prunes_pages_and_intersects_ranges) {
+    ParquetPredicate::CachedPageIndexStat cached_page_index;
+    cached_page_index.ctz = &ctz;
+    cached_page_index.row_group_range = {0, 30};
+    cached_page_index.stats.emplace(
+            2,
+            make_int64_page_index_stat({{0, 9, {0, 10}}, {10, 19, {10, 20}}, {20, 29, {20, 30}}}));
+    install_page_index_getter(&cached_page_index);
+
+    VExprContextSPtrs conjuncts {make_page_zonemap_context(std::make_shared<TestPageZonemapExpr>(
+            std::vector<int> {2}, TestPageZonemapExpr::Mode::BIGINT_MAX_AT_LEAST, 10))};
+    p_reader->set_conjuncts_for_test(conjuncts);
+
+    RowRanges candidate_row_ranges;
+    candidate_row_ranges.add({5, 25});
+    ASSERT_TRUE(process_expr_zonemap_page_filter(&cached_page_index, &candidate_row_ranges).ok());
+
+    assert_single_range(&candidate_row_ranges, 10, 25);
+    EXPECT_EQ(0, p_reader->_reader_statistics.expr_zonemap_unusable_evals);
+}
+
+TEST_F(ParquetExprTest, test_page_index_filter_applies_expr_zonemap_without_pushdown_predicate) {
+    ScopedBoolConfig enable_page_index_guard(config::enable_parquet_page_index, true);
+
+    VExprContextSPtrs conjuncts {make_page_zonemap_context(std::make_shared<TestPageZonemapExpr>(
+            std::vector<int> {2}, TestPageZonemapExpr::Mode::BIGINT_MAX_AT_LEAST, 10000000003))};
+    p_reader->set_conjuncts_for_test(conjuncts);
+
+    RowRanges candidate_row_ranges;
+    std::vector<std::unique_ptr<MutilColumnBlockPredicate>> push_down_pred;
+    const auto& row_group = doris_metadata.row_groups[0];
+    RowGroupReader::RowGroupIndex row_group_index(0, 0, row_group.num_rows);
+    ASSERT_TRUE(p_reader->_process_page_index_filter(row_group, row_group_index, push_down_pred,
+                                                     &candidate_row_ranges)
+                        .ok());
+
+    EXPECT_TRUE(candidate_row_ranges.is_empty());
+    EXPECT_EQ(1, p_reader->_reader_statistics.filtered_row_groups_by_expr_zonemap);
+}
+
+TEST_F(ParquetExprTest, test_page_index_filter_skips_column_index_for_unsupported_expr_zonemap) {
+    ScopedBoolConfig enable_page_index_guard(config::enable_parquet_page_index, true);
+
+    VExprContextSPtrs conjuncts {make_page_zonemap_context(std::make_shared<TestPageZonemapExpr>(
+            std::vector<int> {2}, TestPageZonemapExpr::Mode::UNSUPPORTED_CAPABILITY))};
+    p_reader->set_conjuncts_for_test(conjuncts);
+
+    RowRanges candidate_row_ranges;
+    std::vector<std::unique_ptr<MutilColumnBlockPredicate>> push_down_pred;
+    const auto& row_group = doris_metadata.row_groups[0];
+    RowGroupReader::RowGroupIndex row_group_index(0, 0, row_group.num_rows);
+    const auto read_calls_before = p_reader->_column_statistics.page_index_read_calls;
+    ASSERT_TRUE(p_reader->_process_page_index_filter(row_group, row_group_index, push_down_pred,
+                                                     &candidate_row_ranges)
+                        .ok());
+
+    assert_single_range(&candidate_row_ranges, 0, row_group.num_rows);
+    EXPECT_EQ(read_calls_before + 1, p_reader->_column_statistics.page_index_read_calls);
+    EXPECT_EQ(0, p_reader->_reader_statistics.filtered_row_groups_by_expr_zonemap);
+}
+
+TEST_F(ParquetExprTest, test_expr_zonemap_page_filter_handles_all_null_pages) {
+    ParquetPredicate::PageIndexStat stat;
+    stat.available = true;
+    stat.num_of_pages = 2;
+    stat.col_schema = doris_file_metadata->schema().get_column(2);
+    stat.encoded_min_value = {encode_int64(0), encode_int64(10)};
+    stat.encoded_max_value = {encode_int64(0), encode_int64(10)};
+    stat.has_null = {true, false};
+    stat.is_all_null = {true, false};
+    stat.ranges = {{0, 10}, {10, 20}};
+
+    ParquetPredicate::CachedPageIndexStat cached_page_index;
+    cached_page_index.ctz = &ctz;
+    cached_page_index.row_group_range = {0, 20};
+    cached_page_index.stats.emplace(2, std::move(stat));
+    install_page_index_getter(&cached_page_index);
+
+    VExprContextSPtrs conjuncts {make_page_zonemap_context(std::make_shared<TestPageZonemapExpr>(
+            std::vector<int> {2}, TestPageZonemapExpr::Mode::HAS_NOT_NULL))};
+    p_reader->set_conjuncts_for_test(conjuncts);
+
+    RowRanges candidate_row_ranges;
+    candidate_row_ranges.add({0, 20});
+    ASSERT_TRUE(process_expr_zonemap_page_filter(&cached_page_index, &candidate_row_ranges).ok());
+
+    assert_single_range(&candidate_row_ranges, 10, 20);
+}
+
+TEST_F(ParquetExprTest, test_expr_zonemap_page_filter_intersects_multiple_columns) {
+    ParquetPredicate::CachedPageIndexStat cached_page_index;
+    cached_page_index.ctz = &ctz;
+    cached_page_index.row_group_range = {0, 30};
+    cached_page_index.stats.emplace(
+            2,
+            make_int64_page_index_stat({{0, 9, {0, 10}}, {10, 19, {10, 20}}, {20, 29, {20, 30}}}));
+    cached_page_index.stats.emplace(
+            5, make_string_page_index_stat(
+                       {{"a", "a", {0, 10}}, {"b", "b", {10, 20}}, {"c", "c", {20, 30}}}));
+    install_page_index_getter(&cached_page_index);
+
+    VExprContextSPtrs conjuncts {
+            make_page_zonemap_context(std::make_shared<TestPageZonemapExpr>(
+                    std::vector<int> {2}, TestPageZonemapExpr::Mode::BIGINT_MAX_AT_LEAST, 10)),
+            make_page_zonemap_context(std::make_shared<TestPageZonemapExpr>(
+                    std::vector<int> {5}, TestPageZonemapExpr::Mode::STRING_CONTAINS_VALUE, 0,
+                    "b"))};
+    p_reader->set_conjuncts_for_test(conjuncts);
+
+    RowRanges candidate_row_ranges;
+    candidate_row_ranges.add({0, 30});
+    ASSERT_TRUE(process_expr_zonemap_page_filter(&cached_page_index, &candidate_row_ranges).ok());
+
+    assert_single_range(&candidate_row_ranges, 10, 20);
+}
+
+TEST_F(ParquetExprTest, test_expr_zonemap_page_filter_skips_when_disabled_or_no_candidate) {
+    set_expr_zonemap_filter_enabled(false);
+
+    ParquetPredicate::CachedPageIndexStat cached_page_index;
+    cached_page_index.ctz = &ctz;
+    cached_page_index.row_group_range = {0, 10};
+    cached_page_index.stats.emplace(2, make_int64_page_index_stat({{0, 9, {0, 10}}}));
+    install_page_index_getter(&cached_page_index);
+
+    VExprContextSPtrs conjuncts {make_page_zonemap_context(std::make_shared<TestPageZonemapExpr>(
+            std::vector<int> {2}, TestPageZonemapExpr::Mode::ALWAYS_NO_MATCH))};
+    p_reader->set_conjuncts_for_test(conjuncts);
+
+    RowRanges candidate_row_ranges;
+    candidate_row_ranges.add({0, 10});
+    ASSERT_TRUE(process_expr_zonemap_page_filter(&cached_page_index, &candidate_row_ranges).ok());
+    assert_single_range(&candidate_row_ranges, 0, 10);
+
+    set_expr_zonemap_filter_enabled(true);
+    candidate_row_ranges.clear();
+    ASSERT_TRUE(process_expr_zonemap_page_filter(&cached_page_index, &candidate_row_ranges).ok());
+    EXPECT_TRUE(candidate_row_ranges.is_empty());
+}
+
+TEST_F(ParquetExprTest, test_expr_zonemap_page_filter_skips_unsupported_columns_and_metadata) {
+    ParquetPredicate::CachedPageIndexStat cached_page_index;
+    cached_page_index.ctz = &ctz;
+    cached_page_index.row_group_range = {0, 10};
+    auto unavailable_stat = make_int64_page_index_stat({{0, 9, {0, 10}}});
+    unavailable_stat.available = false;
+    cached_page_index.stats.emplace(2, std::move(unavailable_stat));
+    install_page_index_getter(&cached_page_index);
+
+    VExprContextSPtrs conjuncts {
+            make_page_zonemap_context(std::make_shared<TestPageZonemapExpr>(
+                    std::vector<int> {2}, TestPageZonemapExpr::Mode::ALWAYS_NO_MATCH)),
+            make_page_zonemap_context(std::make_shared<TestPageZonemapExpr>(
+                    std::vector<int> {2, 5}, TestPageZonemapExpr::Mode::ALWAYS_NO_MATCH)),
+            make_page_zonemap_context(std::make_shared<TestPageZonemapExpr>(
+                    std::vector<int> {1000}, TestPageZonemapExpr::Mode::ALWAYS_NO_MATCH))};
+    p_reader->set_conjuncts_for_test(conjuncts);
+
+    RowRanges candidate_row_ranges;
+    candidate_row_ranges.add({0, 10});
+    ASSERT_TRUE(process_expr_zonemap_page_filter(&cached_page_index, &candidate_row_ranges).ok());
+
+    assert_single_range(&candidate_row_ranges, 0, 10);
+}
+
+TEST_F(ParquetExprTest, test_expr_zonemap_page_filter_keeps_unsupported_results_and_counts_stats) {
+    ParquetPredicate::CachedPageIndexStat cached_page_index;
+    cached_page_index.ctz = &ctz;
+    cached_page_index.row_group_range = {0, 20};
+    cached_page_index.stats.emplace(
+            2, make_int64_page_index_stat({{0, 9, {0, 10}}, {10, 19, {10, 20}}}));
+    install_page_index_getter(&cached_page_index);
+
+    VExprContextSPtrs conjuncts {make_page_zonemap_context(std::make_shared<TestPageZonemapExpr>(
+            std::vector<int> {2}, TestPageZonemapExpr::Mode::UNSUPPORTED_RESULT))};
+    p_reader->set_conjuncts_for_test(conjuncts);
+
+    RowRanges candidate_row_ranges;
+    candidate_row_ranges.add({0, 20});
+    ASSERT_TRUE(process_expr_zonemap_page_filter(&cached_page_index, &candidate_row_ranges).ok());
+
+    assert_single_range(&candidate_row_ranges, 0, 20);
+    EXPECT_EQ(1, p_reader->_reader_statistics.expr_zonemap_unusable_evals);
+}
+
+TEST_F(ParquetExprTest, test_expr_zonemap_row_group_filter_skips_complex_parent_column) {
+    auto* col_schema =
+            const_cast<FieldSchema*>(p_reader->_file_metadata->schema().get_column("string_col"));
+    ASSERT_NE(nullptr, col_schema);
+    ASSERT_GE(col_schema->physical_column_index, 0);
+    // Complex parent fields have no physical Parquet column. Force the same schema state here
+    // to verify the row-group expr-zonemap path falls back before indexing row_group.columns.
+    col_schema->physical_column_index = -1;
+
+    VExprContextSPtrs conjuncts {make_page_zonemap_context(std::make_shared<TestPageZonemapExpr>(
+            std::vector<int> {5}, TestPageZonemapExpr::Mode::HAS_NOT_NULL))};
+    p_reader->set_conjuncts_for_test(conjuncts);
+
+    bool filter_group = false;
+    ASSERT_TRUE(p_reader->_process_expr_zonemap_filter(doris_metadata.row_groups[0], &filter_group)
+                        .ok());
+
+    EXPECT_FALSE(filter_group);
+    EXPECT_EQ(0, p_reader->_reader_statistics.filtered_row_groups_by_expr_zonemap);
+    EXPECT_EQ(1, p_reader->_reader_statistics.expr_zonemap_unusable_evals);
+}
+
+TEST_F(ParquetExprTest, test_expr_zonemap_row_group_filter_skips_type_mismatch_column) {
+    auto* col_schema =
+            const_cast<FieldSchema*>(p_reader->_file_metadata->schema().get_column("int64_col"));
+    ASSERT_NE(nullptr, col_schema);
+    col_schema->data_type = std::make_shared<DataTypeString>();
+
+    VExprContextSPtrs conjuncts {make_page_zonemap_context(std::make_shared<TestPageZonemapExpr>(
+            std::vector<int> {2}, TestPageZonemapExpr::Mode::HAS_NOT_NULL))};
+    p_reader->set_conjuncts_for_test(conjuncts);
+
+    bool filter_group = false;
+    ASSERT_TRUE(p_reader->_process_expr_zonemap_filter(doris_metadata.row_groups[0], &filter_group)
+                        .ok());
+
+    EXPECT_FALSE(filter_group);
+    EXPECT_EQ(0, p_reader->_reader_statistics.filtered_row_groups_by_expr_zonemap);
+    EXPECT_EQ(1, p_reader->_reader_statistics.expr_zonemap_unusable_evals);
+}
+
 TEST_F(ParquetExprTest, test_in) {
     int loc = 2;
     auto slot_ref = std::make_shared<MockSlotRef>(loc, std::make_shared<DataTypeInt64>());
diff --git a/be/test/storage/segment/segment_iterator_expr_zonemap_test.cpp b/be/test/storage/segment/segment_iterator_expr_zonemap_test.cpp
new file mode 100644
index 00000000000000..6739cad82e09af
--- /dev/null
+++ b/be/test/storage/segment/segment_iterator_expr_zonemap_test.cpp
@@ -0,0 +1,244 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <gtest/gtest.h>
+
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "core/data_type/data_type_number.h"
+#include "core/field.h"
+#include "exprs/vexpr.h"
+#include "exprs/vexpr_context.h"
+#include "io/fs/file_writer.h"
+#include "io/fs/local_file_system.h"
+#include "runtime/descriptors.h"
+#include "runtime/runtime_state.h"
+#include "storage/index/zone_map/zonemap_eval_context.h"
+#include "storage/iterators.h"
+#include "storage/olap_common.h"
+#include "storage/row_cursor.h"
+#include "storage/segment/row_ranges.h"
+#include "storage/segment/segment.h"
+#include "storage/segment/segment_iterator.h"
+#include "storage/segment/test_segment_writer.h"
+#include "storage/tablet/tablet_schema_helper.h"
+
+namespace doris::segment_v2 {
+namespace {
+
+constexpr auto kTestDir = "./ut_dir/segment_iterator_expr_zonemap_test";
+constexpr int kNumRows = 8192;
+const RowsetId kRowsetId {.version = 1};
+
+Field int_field(int32_t value) {
+    return Field::create_field<TYPE_INT>(value);
+}
+
+class IntMaxAtLeastExpr final : public VExpr {
+public:
+    IntMaxAtLeastExpr(int column_id, int32_t threshold)
+            : _column_id(column_id), _threshold(threshold) {
+        _data_type = std::make_shared<DataTypeUInt8>();
+    }
+
+    const std::string& expr_name() const override { return _expr_name; }
+
+    Status execute_column(VExprContext*, const Block*, Selector*, size_t,
+                          ColumnPtr&) const override {
+        return Status::InternalError("IntMaxAtLeastExpr is only used by zonemap tests");
+    }
+
+    bool can_evaluate_zonemap_filter() const override { return true; }
+
+    bool is_constant() const override { return false; }
+
+    void collect_slot_column_ids(std::set<int>& column_ids) const override {
+        column_ids.insert(_column_id);
+    }
+
+    ZoneMapFilterResult evaluate_zonemap_filter(const ZoneMapEvalContext& ctx) const override {
+        auto zone_map = ctx.zone_map(_column_id);
+        if (zone_map == nullptr) {
+            return unsupported_zonemap_filter(ctx);
+        }
+        if (!zone_map->has_not_null) {
+            return ZoneMapFilterResult::kNoMatch;
+        }
+        return zone_map->max_value.get<TYPE_INT>() >= _threshold ? ZoneMapFilterResult::kMayMatch
+                                                                 : ZoneMapFilterResult::kNoMatch;
+    }
+
+private:
+    int _column_id;
+    int32_t _threshold;
+    std::string _expr_name = "int_max_at_least_expr";
+};
+
+TabletSchemaSPtr make_tablet_schema() {
+    auto tablet_schema = std::make_shared<TabletSchema>();
+    tablet_schema->append_column(*doris::create_int_key(0, false));
+    tablet_schema->append_column(*doris::create_int_key(1, false));
+    tablet_schema->set_storage_page_size(4096);
+    return tablet_schema;
+}
+
+SchemaSPtr make_read_schema(const TabletSchemaSPtr& tablet_schema) {
+    std::vector<ColumnId> read_column_ids(tablet_schema->num_columns());
+    for (uint32_t cid = 0; cid < read_column_ids.size(); ++cid) {
+        read_column_ids[cid] = cid;
+    }
+    return std::make_shared<Schema>(tablet_schema->columns(), read_column_ids);
+}
+
+} // namespace
+
+class SegmentIteratorExprZonemapTest : public testing::Test {
+protected:
+    void SetUp() override {
+        auto st = io::global_local_filesystem()->delete_directory(kTestDir);
+        ASSERT_TRUE(st.ok()) << st;
+        st = io::global_local_filesystem()->create_directory(kTestDir);
+        ASSERT_TRUE(st.ok()) << st;
+        _tablet_schema = make_tablet_schema();
+    }
+
+    void TearDown() override {
+        EXPECT_TRUE(io::global_local_filesystem()->delete_directory(kTestDir).ok());
+    }
+
+    void build_segment(std::shared_ptr<Segment>* segment) {
+        const auto path = std::string(kTestDir) + "/expr_zonemap_segment.dat";
+        auto fs = io::global_local_filesystem();
+        io::FileWriterPtr file_writer;
+        auto st = fs->create_file(path, &file_writer);
+        ASSERT_TRUE(st.ok()) << st;
+
+        SegmentWriterOptions opts;
+        opts.num_rows_per_block = 1024;
+        TestSegmentWriter writer(file_writer.get(), 0, _tablet_schema, nullptr, nullptr, opts,
+                                 nullptr);
+        st = writer.init();
+        ASSERT_TRUE(st.ok()) << st;
+
+        RowCursor row;
+        std::vector<Field> fields(_tablet_schema->num_columns(), Field(PrimitiveType::TYPE_NULL));
+        st = row.init_scan_key(_tablet_schema, std::move(fields));
+        ASSERT_TRUE(st.ok()) << st;
+        for (int rid = 0; rid < kNumRows; ++rid) {
+            row.mutable_field(0) = int_field(rid);
+            row.mutable_field(1) = int_field(rid < kNumRows / 2 ? 0 : 1000);
+            st = writer.append_row(row);
+            ASSERT_TRUE(st.ok()) << st;
+        }
+
+        uint64_t file_size = 0;
+        uint64_t index_size = 0;
+        st = writer.finalize(&file_size, &index_size);
+        ASSERT_TRUE(st.ok()) << st;
+        st = file_writer->close();
+        ASSERT_TRUE(st.ok()) << st;
+
+        st = Segment::open(fs, path, 100, 0, kRowsetId, _tablet_schema, io::FileReaderOptions {},
+                           segment);
+        ASSERT_TRUE(st.ok()) << st;
+        ASSERT_EQ(kNumRows, (*segment)->num_rows());
+    }
+
+    void prepare_expr_context(const VExprContextSPtr& expr_ctx) {
+        RowDescriptor row_desc;
+        auto st = expr_ctx->prepare(&_runtime_state, row_desc);
+        ASSERT_TRUE(st.ok()) << st;
+        st = expr_ctx->open(&_runtime_state);
+        ASSERT_TRUE(st.ok()) << st;
+    }
+
+    TabletSchemaSPtr _tablet_schema;
+    OlapReaderStatistics _stats;
+    RuntimeState _runtime_state;
+};
+
+TEST_F(SegmentIteratorExprZonemapTest, NewIteratorPrunesWholeSegmentByExprZonemap) {
+    std::shared_ptr<Segment> segment;
+    ASSERT_NO_FATAL_FAILURE(build_segment(&segment));
+    auto read_schema = make_read_schema(_tablet_schema);
+
+    auto expr_ctx = std::make_shared<VExprContext>(std::make_shared<IntMaxAtLeastExpr>(1, 2000));
+    ASSERT_NO_FATAL_FAILURE(prepare_expr_context(expr_ctx));
+    StorageReadOptions read_options;
+    read_options.stats = &_stats;
+    read_options.runtime_state = &_runtime_state;
+    read_options.tablet_schema = _tablet_schema;
+    read_options.common_expr_ctxs_push_down = {expr_ctx};
+
+    std::unique_ptr<RowwiseIterator> iter;
+    auto st = segment->new_iterator(read_schema, read_options, &iter);
+    ASSERT_TRUE(st.ok()) << st;
+    ASSERT_NE(nullptr, iter);
+    EXPECT_TRUE(iter->empty());
+    EXPECT_EQ(1, _stats.total_segment_number);
+    EXPECT_EQ(1, _stats.filtered_segment_number);
+    EXPECT_EQ(1, _stats.expr_zonemap_filtered_segments);
+}
+
+TEST_F(SegmentIteratorExprZonemapTest, NewIteratorKeepsSegmentWhenExprZonemapMayMatch) {
+    std::shared_ptr<Segment> segment;
+    ASSERT_NO_FATAL_FAILURE(build_segment(&segment));
+    auto read_schema = make_read_schema(_tablet_schema);
+
+    auto expr_ctx = std::make_shared<VExprContext>(std::make_shared<IntMaxAtLeastExpr>(1, 500));
+    ASSERT_NO_FATAL_FAILURE(prepare_expr_context(expr_ctx));
+    StorageReadOptions read_options;
+    read_options.stats = &_stats;
+    read_options.runtime_state = &_runtime_state;
+    read_options.tablet_schema = _tablet_schema;
+    read_options.common_expr_ctxs_push_down = {expr_ctx};
+
+    std::unique_ptr<RowwiseIterator> iter;
+    auto st = segment->new_iterator(read_schema, read_options, &iter);
+    ASSERT_TRUE(st.ok()) << st;
+    ASSERT_NE(nullptr, iter);
+    EXPECT_FALSE(iter->empty());
+    EXPECT_EQ(1, _stats.total_segment_number);
+    EXPECT_EQ(0, _stats.filtered_segment_number);
+    EXPECT_EQ(0, _stats.expr_zonemap_filtered_segments);
+}
+
+TEST_F(SegmentIteratorExprZonemapTest, ApplyExprZonemapPrunesPageRowRanges) {
+    std::shared_ptr<Segment> segment;
+    ASSERT_NO_FATAL_FAILURE(build_segment(&segment));
+    auto read_schema = make_read_schema(_tablet_schema);
+    SegmentIterator iter(segment, read_schema);
+    iter._file_reader = segment->_file_reader;
+    iter._opts.stats = &_stats;
+    iter._opts.tablet_schema = _tablet_schema;
+
+    auto expr_ctx = std::make_shared<VExprContext>(std::make_shared<IntMaxAtLeastExpr>(1, 500));
+    VExprContextSPtrs conjuncts {expr_ctx};
+    auto row_ranges = RowRanges::create_single(kNumRows);
+
+    auto st = iter._apply_expr_zonemap_to_row_ranges(conjuncts, 0, &row_ranges);
+    ASSERT_TRUE(st.ok()) << st;
+    EXPECT_GT(_stats.expr_zonemap_filtered_pages, 0);
+    EXPECT_GT(row_ranges.from(), 0);
+    EXPECT_LT(row_ranges.count(), kNumRows);
+    EXPECT_EQ(kNumRows, row_ranges.to());
+}
+
+} // namespace doris::segment_v2
diff --git a/fe/fe-core/src/main/java/org/apache/doris/qe/SessionVariable.java b/fe/fe-core/src/main/java/org/apache/doris/qe/SessionVariable.java
index c930696743c94a..f10bb72e21a787 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/qe/SessionVariable.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/qe/SessionVariable.java
@@ -594,6 +594,8 @@ public String toString() {
 
     public static final String ENABLE_ORC_FILTER_BY_MIN_MAX = "enable_orc_filter_by_min_max";
 
+    public static final String ENABLE_EXPR_ZONEMAP_FILTER = "enable_expr_zonemap_filter";
+
     public static final String CHECK_ORC_INIT_SARGS_SUCCESS = "check_orc_init_sargs_success";
 
     public static final String INLINE_CTE_REFERENCED_THRESHOLD = "inline_cte_referenced_threshold";
@@ -2575,6 +2577,15 @@ public static boolean isEagerAggregationOnJoin() {
             needForward = true)
     public boolean enableOrcFilterByMinMax = true;
 
+    @VariableMgr.VarAttr(
+            name = ENABLE_EXPR_ZONEMAP_FILTER,
+            fuzzy = true,
+            description = {"控制 scanner 是否启用表达式 ZoneMap 过滤。默认为 true。",
+                    "Controls whether to enable expression ZoneMap filtering in scanners. "
+                            + "The default value is true."},
+            needForward = true)
+    public boolean enableExprZonemapFilter = true;
+
     @VariableMgr.VarAttr(
             name = CHECK_ORC_INIT_SARGS_SUCCESS,
             description = {"是否检查 orc init sargs 是否成功。默认为 false。",
@@ -4787,6 +4798,14 @@ public void setEnableOrcFilterByMinMax(boolean enableOrcFilterByMinMax) {
         this.enableOrcFilterByMinMax = enableOrcFilterByMinMax;
     }
 
+    public boolean isEnableExprZonemapFilter() {
+        return enableExprZonemapFilter;
+    }
+
+    public void setEnableExprZonemapFilter(boolean enableExprZonemapFilter) {
+        this.enableExprZonemapFilter = enableExprZonemapFilter;
+    }
+
     public boolean isCheckOrcInitSargsSuccess() {
         return checkOrcInitSargsSuccess;
     }
@@ -5507,6 +5526,7 @@ public TQueryOptions toThrift() {
 
         tResult.setEnableParquetFilePageCache(enableParquetFilePageCache);
         tResult.setEnableOrcFilterByMinMax(enableOrcFilterByMinMax);
+        tResult.setEnableExprZonemapFilter(enableExprZonemapFilter);
         tResult.setEnablePaimonCppReader(enablePaimonCppReader);
         tResult.setCheckOrcInitSargsSuccess(checkOrcInitSargsSuccess);
 
diff --git a/gensrc/thrift/PaloInternalService.thrift b/gensrc/thrift/PaloInternalService.thrift
index 71b318f6f0c9b6..7723f919c8f853 100644
--- a/gensrc/thrift/PaloInternalService.thrift
+++ b/gensrc/thrift/PaloInternalService.thrift
@@ -496,6 +496,10 @@ struct TQueryOptions {
   219: optional i64 ann_index_candidate_rows_threshold = 0
   // Candidate row ratio threshold against segment rows. Existing default is 0.3.
   220: optional double ann_index_candidate_rows_percent_threshold = 0.3
+
+  // To control whether BE scan readers may apply expression-based ZoneMap pruning.
+  224: optional bool enable_expr_zonemap_filter = true
+
   // For cloud, to control if the content would be written into file cache
   // In write path, to control if the content would be written into file cache.
   // In read path, read from file cache or remote storage when execute query.
diff --git a/regression-test/suites/query_p0/expr_zonemap/test_expr_zonemap_pruning.groovy b/regression-test/suites/query_p0/expr_zonemap/test_expr_zonemap_pruning.groovy
new file mode 100644
index 00000000000000..9502f840f39a37
--- /dev/null
+++ b/regression-test/suites/query_p0/expr_zonemap/test_expr_zonemap_pruning.groovy
@@ -0,0 +1,227 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+import java.util.regex.Matcher
+import java.util.regex.Pattern
+import org.apache.doris.regression.action.ProfileAction
+
+suite("test_expr_zonemap_pruning") {
+    sql """ set enable_common_expr_pushdown = true """
+    sql """ set enable_profile = true """
+    sql """ set profile_level = 2 """
+
+    sql """ DROP TABLE IF EXISTS test_expr_zonemap_pruning """
+    sql """
+        CREATE TABLE test_expr_zonemap_pruning (
+            id INT,
+            v VARCHAR(32)
+        ) ENGINE=OLAP
+        DUPLICATE KEY(id)
+        DISTRIBUTED BY HASH(id) BUCKETS 1
+        PROPERTIES (
+            "replication_allocation" = "tag.location.default: 1",
+            "disable_auto_compaction" = "true"
+        )
+    """
+
+    sql """
+        INSERT INTO test_expr_zonemap_pruning
+        SELECT CAST(number AS INT), CONCAT('a', CAST(number AS STRING))
+        FROM numbers("number" = "4096")
+    """
+    sql """ sync """
+
+    def profileAction = new ProfileAction(context)
+
+    def getProfileByToken = { String token ->
+        for (int retry = 0; retry < 10; ++retry) {
+            List profileData = profileAction.getProfileList()
+            for (final def profileItem in profileData) {
+                if (profileItem["Sql Statement"].toString().contains(token)) {
+                    return profileAction.getProfile(profileItem["Profile ID"].toString())
+                }
+            }
+            Thread.sleep(500)
+        }
+        throw new IllegalStateException("Missing profile for token: " + token)
+    }
+
+    def counterSum = { String profile, String counterName ->
+        Pattern pattern = Pattern.compile(Pattern.quote(counterName) + ":\\s*([0-9,]+)")
+        Matcher matcher = pattern.matcher(profile)
+        long sum = 0
+        while (matcher.find()) {
+            sum += Long.parseLong(matcher.group(1).replace(",", ""))
+        }
+        return sum
+    }
+
+    def assertExprZonemapPruned = { String token ->
+        String profile = ""
+        long filteredSegments = 0
+        long filteredPages = 0
+        for (int retry = 0; retry < 20; ++retry) {
+            profile = getProfileByToken(token).toString()
+            filteredSegments = counterSum(profile, "ExprZoneMapFilteredSegments")
+            filteredPages = counterSum(profile, "ExprZoneMapFilteredPages")
+            if (filteredSegments + filteredPages > 0) {
+                logger.info("${token} Profile Data: ${profile}")
+                return
+            }
+            Thread.sleep(500)
+        }
+        logger.info("${token} Profile Data: ${profile}")
+        assertTrue(filteredSegments + filteredPages > 0)
+    }
+
+    def assertProfileCounterPositive = { String token, String counterName ->
+        String profile = ""
+        long counterValue = 0
+        for (int retry = 0; retry < 20; ++retry) {
+            profile = getProfileByToken(token).toString()
+            counterValue = counterSum(profile, counterName)
+            if (counterValue > 0) {
+                logger.info("${token} Profile Data: ${profile}")
+                return
+            }
+            Thread.sleep(500)
+        }
+        logger.info("${token} Profile Data: ${profile}")
+        assertTrue(counterValue > 0)
+    }
+
+    def matchedRows = sql """
+        SELECT COUNT(*) FROM test_expr_zonemap_pruning WHERE starts_with(v, 'a')
+    """
+    assertEquals(4096L, matchedRows[0][0] as long)
+
+    def startsWithToken = "expr_zonemap_pruning_starts_with_" + UUID.randomUUID().toString()
+    def startsWithPrunedRows = sql """
+        SELECT '${startsWithToken}', COUNT(*) FROM test_expr_zonemap_pruning WHERE starts_with(v, 'z')
+    """
+    assertEquals(0L, startsWithPrunedRows[0][1] as long)
+    assertExprZonemapPruned(startsWithToken)
+
+    def inToken = "expr_zonemap_pruning_in_" + UUID.randomUUID().toString()
+    def inPrunedRows = sql """
+        SELECT '${inToken}', COUNT(*) FROM test_expr_zonemap_pruning
+        WHERE v IN ('z0', 'z1') OR starts_with(v, 'zz')
+    """
+    assertEquals(0L, inPrunedRows[0][1] as long)
+    assertExprZonemapPruned(inToken)
+
+    def nullToken = "expr_zonemap_pruning_is_null_" + UUID.randomUUID().toString()
+    def nullPrunedRows = sql """
+        SELECT '${nullToken}', COUNT(*) FROM test_expr_zonemap_pruning
+        WHERE v IS NULL OR starts_with(v, 'zz')
+    """
+    assertEquals(0L, nullPrunedRows[0][1] as long)
+    assertExprZonemapPruned(nullToken)
+
+    def comparisonToken = "expr_zonemap_pruning_comparison_" + UUID.randomUUID().toString()
+    def comparisonPrunedRows = sql """
+        SELECT '${comparisonToken}', COUNT(*) FROM test_expr_zonemap_pruning
+        WHERE id > 5000 OR id < 0
+    """
+    assertEquals(0L, comparisonPrunedRows[0][1] as long)
+    assertExprZonemapPruned(comparisonToken)
+
+    sql """ DROP TABLE IF EXISTS test_expr_zonemap_page_reachability """
+    sql """
+        CREATE TABLE test_expr_zonemap_page_reachability (
+            id INT,
+            v VARCHAR(512)
+        ) ENGINE=OLAP
+        DUPLICATE KEY(id)
+        DISTRIBUTED BY HASH(id) BUCKETS 1
+        PROPERTIES (
+            "replication_allocation" = "tag.location.default: 1",
+            "disable_auto_compaction" = "true",
+            "storage_page_size" = "4096",
+            "compression" = "no_compression"
+        )
+    """
+    sql """
+        INSERT INTO test_expr_zonemap_page_reachability
+        SELECT CAST(number AS INT),
+               IF(number < 4096,
+                  CONCAT('a_', LPAD(CAST(number AS STRING), 5, '0'), '_', REPEAT('x', 256)),
+                  CONCAT('m_', LPAD(CAST(number AS STRING), 5, '0'), '_', REPEAT('x', 256)))
+        FROM numbers("number" = "8192")
+    """
+    sql """ sync """
+
+    def pageReachabilityToken = "expr_zonemap_pruning_page_reachability_" + UUID.randomUUID().toString()
+    def pageReachabilityRows = sql """
+        SELECT '${pageReachabilityToken}', COUNT(*) FROM test_expr_zonemap_page_reachability
+        WHERE starts_with(v, 'm_')
+    """
+    assertEquals(4096L, pageReachabilityRows[0][1] as long)
+    assertProfileCounterPositive(pageReachabilityToken, "ExprZoneMapFilteredPages")
+
+    sql """ DROP TABLE IF EXISTS test_expr_zonemap_pruning_char """
+    sql """
+        CREATE TABLE test_expr_zonemap_pruning_char (
+            id INT,
+            c CHAR(10)
+        ) ENGINE=OLAP
+        DUPLICATE KEY(id)
+        DISTRIBUTED BY HASH(id) BUCKETS 1
+        PROPERTIES (
+            "replication_allocation" = "tag.location.default: 1",
+            "disable_auto_compaction" = "true"
+        )
+    """
+    sql """
+        INSERT INTO test_expr_zonemap_pruning_char
+        SELECT CAST(number AS INT), CONCAT('a', CAST(number AS STRING))
+        FROM numbers("number" = "4096")
+    """
+    sql """ sync """
+
+    def charToken = "expr_zonemap_pruning_char_" + UUID.randomUUID().toString()
+    def charPrunedRows = sql """
+        SELECT '${charToken}', COUNT(*) FROM test_expr_zonemap_pruning_char
+        WHERE starts_with(c, 'z') OR c IN ('z0', 'z1') OR c = 'z2'
+    """
+    assertEquals(0L, charPrunedRows[0][1] as long)
+    assertExprZonemapPruned(charToken)
+
+    sql """ DROP TABLE IF EXISTS test_expr_zonemap_pruning_nulls """
+    sql """
+        CREATE TABLE test_expr_zonemap_pruning_nulls (
+            id INT,
+            v VARCHAR(32)
+        ) ENGINE=OLAP
+        DUPLICATE KEY(id)
+        DISTRIBUTED BY HASH(id) BUCKETS 1
+        PROPERTIES (
+            "replication_allocation" = "tag.location.default: 1",
+            "disable_auto_compaction" = "true"
+        )
+    """
+    sql """ INSERT INTO test_expr_zonemap_pruning_nulls VALUES (1, NULL), (2, NULL) """
+    sql """ sync """
+
+    def isNotNullToken = "expr_zonemap_pruning_is_not_null_" + UUID.randomUUID().toString()
+    def isNotNullPrunedRows = sql """
+        SELECT '${isNotNullToken}', COUNT(*) FROM test_expr_zonemap_pruning_nulls
+        WHERE v IS NOT NULL OR starts_with(v, 'zz')
+    """
+    assertEquals(0L, isNotNullPrunedRows[0][1] as long)
+    assertExprZonemapPruned(isNotNullToken)
+}
diff --git a/regression-test/suites/query_p1/expr_zonemap/test_expr_zonemap_pruning_p1.groovy b/regression-test/suites/query_p1/expr_zonemap/test_expr_zonemap_pruning_p1.groovy
new file mode 100644
index 00000000000000..37ac61aed69ddb
--- /dev/null
+++ b/regression-test/suites/query_p1/expr_zonemap/test_expr_zonemap_pruning_p1.groovy
@@ -0,0 +1,157 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+import java.util.regex.Matcher
+import java.util.regex.Pattern
+import org.apache.doris.regression.action.ProfileAction
+
+suite("test_expr_zonemap_pruning_p1") {
+    sql """ set enable_common_expr_pushdown = true """
+    sql """ set enable_profile = true """
+    sql """ set profile_level = 2 """
+
+    sql """ DROP TABLE IF EXISTS test_expr_zonemap_pruning_p1 """
+    sql """
+        CREATE TABLE test_expr_zonemap_pruning_p1 (
+            id INT,
+            k BIGINT,
+            v VARCHAR(32),
+            nullable_v VARCHAR(32) NULL
+        ) ENGINE=OLAP
+        DUPLICATE KEY(id)
+        DISTRIBUTED BY HASH(id) BUCKETS 1
+        PROPERTIES (
+            "replication_allocation" = "tag.location.default: 1",
+            "disable_auto_compaction" = "true"
+        )
+    """
+
+    sql """
+        INSERT INTO test_expr_zonemap_pruning_p1
+        SELECT CAST(number AS INT), CAST(number AS BIGINT),
+               CONCAT('left_', CAST(number AS STRING)), NULL
+        FROM numbers("number" = "2048")
+    """
+    sql """
+        INSERT INTO test_expr_zonemap_pruning_p1
+        SELECT CAST(number + 2048 AS INT), CAST(number + 2048 AS BIGINT),
+               CONCAT('right_', CAST(number + 2048 AS STRING)),
+               CONCAT('not_null_', CAST(number + 2048 AS STRING))
+        FROM numbers("number" = "2048")
+    """
+    sql """ sync """
+
+    def profileAction = new ProfileAction(context)
+
+    def getProfileByToken = { String token ->
+        for (int retry = 0; retry < 10; ++retry) {
+            List profileData = profileAction.getProfileList()
+            for (final def profileItem in profileData) {
+                if (profileItem["Sql Statement"].toString().contains(token)) {
+                    return profileAction.getProfile(profileItem["Profile ID"].toString())
+                }
+            }
+            Thread.sleep(500)
+        }
+        throw new IllegalStateException("Missing profile for token: " + token)
+    }
+
+    def counterSum = { String profile, String counterName ->
+        Pattern pattern = Pattern.compile(Pattern.quote(counterName) + ":\\s*([0-9,]+)")
+        Matcher matcher = pattern.matcher(profile)
+        long sum = 0
+        while (matcher.find()) {
+            sum += Long.parseLong(matcher.group(1).replace(",", ""))
+        }
+        return sum
+    }
+
+    def assertProfileCounterPositive = { String token, String counterName ->
+        String profile = ""
+        long counterValue = 0
+        for (int retry = 0; retry < 20; ++retry) {
+            profile = getProfileByToken(token).toString()
+            counterValue = counterSum(profile, counterName)
+            if (counterValue > 0) {
+                logger.info("${token} Profile Data: ${profile}")
+                return
+            }
+            Thread.sleep(500)
+        }
+        logger.info("${token} Profile Data: ${profile}")
+        assertTrue(counterValue > 0)
+    }
+
+    def assertExprZonemapPruned = { String token ->
+        String profile = ""
+        long filteredSegments = 0
+        long filteredPages = 0
+        for (int retry = 0; retry < 20; ++retry) {
+            profile = getProfileByToken(token).toString()
+            filteredSegments = counterSum(profile, "ExprZoneMapFilteredSegments")
+            filteredPages = counterSum(profile, "ExprZoneMapFilteredPages")
+            if (filteredSegments + filteredPages > 0) {
+                logger.info("${token} Profile Data: ${profile}")
+                return
+            }
+            Thread.sleep(500)
+        }
+        logger.info("${token} Profile Data: ${profile}")
+        assertTrue(filteredSegments + filteredPages > 0)
+    }
+
+    def notNullToken = "expr_zonemap_pruning_p1_is_not_null_" + UUID.randomUUID().toString()
+    def notNullRows = sql """
+        SELECT '${notNullToken}', COUNT(*) FROM test_expr_zonemap_pruning_p1
+        WHERE nullable_v IS NOT NULL OR starts_with(v, 'never_')
+    """
+    assertEquals(2048L, notNullRows[0][1] as long)
+    assertExprZonemapPruned(notNullToken)
+
+    def compoundToken = "expr_zonemap_pruning_p1_compound_" + UUID.randomUUID().toString()
+    def compoundRows = sql """
+        SELECT '${compoundToken}', COUNT(*) FROM test_expr_zonemap_pruning_p1
+        WHERE (starts_with(v, 'never_') OR v IN ('missing_a', 'missing_b')) AND k >= 0
+    """
+    assertEquals(0L, compoundRows[0][1] as long)
+    assertExprZonemapPruned(compoundToken)
+
+    def largeInValues = (100000..100064).collect { "'left_" + it.toString() + "'" }.join(", ")
+    def rangeOnlyToken = "expr_zonemap_pruning_p1_large_in_" + UUID.randomUUID().toString()
+    def rangeOnlyRows = sql """
+        SELECT '${rangeOnlyToken}', COUNT(*) FROM test_expr_zonemap_pruning_p1
+        WHERE v IN (${largeInValues}) OR starts_with(v, 'never_')
+    """
+    assertEquals(0L, rangeOnlyRows[0][1] as long)
+    assertExprZonemapPruned(rangeOnlyToken)
+    assertProfileCounterPositive(rangeOnlyToken, "InZoneMapRangeOnlyCount")
+
+    def pointCheckToken = "expr_zonemap_pruning_p1_small_in_" + UUID.randomUUID().toString()
+    def pointCheckRows = sql """
+        SELECT '${pointCheckToken}', COUNT(*) FROM test_expr_zonemap_pruning_p1
+        WHERE v IN ('left_1', 'missing_left') OR starts_with(v, 'never_')
+    """
+    assertEquals(1L, pointCheckRows[0][1] as long)
+    assertExprZonemapPruned(pointCheckToken)
+    assertProfileCounterPositive(pointCheckToken, "InZoneMapPointCheckCount")
+
+    def supportedMatchRows = sql """
+        SELECT COUNT(*) FROM test_expr_zonemap_pruning_p1
+        WHERE starts_with(v, 'right_409') AND nullable_v IS NOT NULL
+    """
+    assertEquals(6L, supportedMatchRows[0][0] as long)
+}