branch-4.0: [fix](test) fix branch-4.0 P0 regression failures (build #198126) (#64525)

## What problem does this PR solve?

Stabilizes the `branch-4.0` P0 / Cloud-P0 regression pipeline. It
started from the
failures in regression build #198126 and has since grown to cover
additional flaky /
failing suites surfaced by subsequent P0 and Cloud-P0 runs.

Most commits are test-only (deflaking, isolation, session-default
pinning, branch-4.0
compatibility, or temporarily skipping cases whose feature is absent /
whose backport
is pending). Two are real product fixes backported from master, plus one
debug-point
gate change with no production impact.

### Product fixes backported from master

- **#64439** `[fix](load) fix empty statistics for forwarded INSERT` — a
forwarded
`INSERT ... SELECT` showed empty `JobDetails` (`ScannedRows=0`,
`LoadBytes=0`, …)
because the regular `Coordinator` / `CloudCoordinator` fallback path was
built without
the insert `jobId`, so `LoadManager` progress was never
initialized/updated. The
`jobId` is now preserved on both fallback paths. Fixes
`load_p0/insert/test_insert_statistic`.
- **#63666** `[fix](ann-index) Fix ANN range search state leakage and
incorrect slot
index tracking` — ANN range-search execution state was stored on the
shared `VExpr`
root, so a segment that ran ANN range search could leak state into a
segment without an
ANN index and wrongly drop the common expression; it also mixed schema
column indexes
with storage column ids. State now flows through the evaluation call and
slot status is
keyed by source column index. Adapted to 4.0 (this branch predates
`enable_result_cache`,
  so that parameter is dropped from the ported signatures).

### Product change behind a debug point (no production impact)

- `[fix](compaction) let time_series_level2_file_count debug point
bypass the level2
freshness gate` — the 24h freshness gate skipped freshly-created level1
rowsets before
  the `time_series_level2_file_count` debug point could collect them, so
`test_time_series_compaction_level2` never forced a level-2 merge
(tablet kept 11
rowsets instead of 2). The debug point now guards the gate; with debug
points disabled
  `is_enable()` returns false, so behavior is unchanged.

### Test suites backported from master

- **#63859** `[test](regression) Add debug point ANN index-only scan
test` — replaces the
fragile `ScanBytes`-profile-based ANN suites (an unreliable index-only
proxy) with
debug-point suites that directly fail if the embedding column is read in
index-only
  scenarios. Fixes `ann_index_p0/ann_index_only_scan_distance_expr` and
  `ann_index_p0/ann_index_only_scan_metric_direction`.
- **partial #64238** — ports only the `scanner_profile` `actualRows`
regex fix
(`PhysicalOlapScan[<id>]` renders the numeric nereids id, not the table
name, so the
old `PhysicalOlapScan[scanner_profile]` regex could never match). The BE
CPU-time
counter rename in #64238 is intentionally NOT backported to a release
branch.

### Aligned with the `enable_insert_strict` / `enable_strict_cast`
decoupling (#63794)

- `insert_p0/insert_group_commit_into_max_filter_ratio` — cherry-pick
from master.
- `external_table_p0/hive/write/test_hive_ctas_to_doris` — set
`enable_strict_cast=true`
  so the CTAS casts behave as the expected output was generated under.

### Deflaking — asynchronous profile-report races

The BE reports the detailed execution profile to FE *after* the query
result returns;
tests that fetched the profile with a fixed sleep raced that report
(empty `MergedProfile`).

- `query_profile/scanner_profile` — poll `getProfileByToken`
(Awaitility) until the scan
operator lands before asserting `MaxScanConcurrency` / backfilled
`actualRows` (sits on
top of the regex fix above; it was the only `query_profile` test with no
wait/retry).
- `query_profile/adaptive_pipeline_task_serial_read_on_limit` — same
fix: poll until
  `MaxScanConcurrency` lands instead of `Thread.sleep(500)`.
- `AutoProfileTest` (FE UT) — the JMockit
`result=System.currentTimeMillis()` froze the
begin-time at record time while the duration was measured against the
real wall clock,
leaving only ~101ms of slack. Drop JMockit + both sleeps and set
`queryBeginTime`
  directly (now / now-60s) for a deterministic ~60s margin.

### Deflaking — CBO / statistics timing

- `nereids_rules_p0/mv/.../partition_curd_union_rewrite` — guard the six
post-insert
`mv_rewrite_success` checks with `is_partition_statistics_ready`
(matching the suite's
own pre-mutation calls); new-partition row-count stats are reported
asynchronously, so
within the fixed sleep CBO costed the union plan above the direct plan
and emitted
  "not chose".
- `nereids_syntax_p0/distribute/prune_bucket_with_bucket_shuffle_join` —
pin
`parallel_pipeline_task_num=1` so the bucket-shuffle downgrade heuristic
(`totalBucketNum < backEndNum*paraNum*0.8`) doesn't fire on a high-core
Cloud-P0 agent
  and downgrade `BUCKET_SHUFFLE` → `PARTITIONED`.
- `correctness_p0/test_colocate_join_of_column_order` — inject column
stats (`set stats`)
before EXPLAIN so the COLOCATE-vs-PARTITIONED cost choice is
deterministic
(freshly-created tables have `rowCountReported=false` until the async
`CloudTabletStatMgr`
  tick).

### Deflaking — cross-FE system-table semantics

- `query_p0/schema_table/test_sql_block_rule_status` — `BLOCKS` is a
cross-FE `SUM` over
each FE's non-replicated in-memory counter, so a stray counter on
another FE makes the
sum exceed 1. Set `fetch_all_fe_for_system_table=false` so the read sees
only the local
  FE that ran the blocked query.
- `nereids_p0/cache/parse_sql_from_sql_cache` — drop the racy cross-FE
`assertNoCache`:
the sql-cache result lives on a shared BE chosen by a deterministic
hash, so a second FE
can legitimately serve the same query from cache. Keep the meaningful
`assertHasCache`.

### Deflaking — routine-load adaptive timeout
(`test_routine_load_adaptive_param` + `RoutineLoadTestUtils`)

The adaptive timeout is only recomputed when a task is scheduled *with*
data, and the
converged value can sit on an idle (`txnId == -1`) task; the old `txnId
!= -1` gate raced
a sub-second live-txn window.

- `RoutineLoadTestUtils.checkTaskTimeout` — skip transient `txnId == -1`
tasks and poll
  until a stable task carries the expected timeout.
- restore phase — `checkTaskTimeoutWithData` feeds a small batch each
round to force the
  timeout to recompute.
- increase phase — drive data each round too, and rewrite the
txn-timeout check to join on
the task UUID and read the persisted timeout from the committed
transaction
  (`SHOW TRANSACTION WHERE label`) instead of catching a live txn.

### Deflaking — publish / delete visibility & file cache

- `fault_injection_p0/.../test_f_delete_publish_skip_read` — replace
`Thread.sleep(12000)`
with a bounded Awaitility poll until the delete (v4) is actually
published and visible
(`k1=2` gone). The storage engine applies the delete correctly; the race
was in publish
timing (the `disable_block` request could queue behind the in-flight
stream load).
- `external_table_p0/cache/test_file_cache_statistics` (and
`test_file_cache_query_limit`)
— `file_cache_statistics` reports one row per `(cache_path, metric)` and
a data file
hashes to exactly one path, so a bare `limit 1` inspected an arbitrary
path. Sum each
metric across paths (`SUM(CAST(METRIC_VALUE AS DOUBLE))`) and replace
fixed sleeps with
  Awaitility.

### Determinism — pin fuzzed session defaults / fix drifted expected
output

- `check_before_quit` — pin the two fuzzed variant session defaults to 0
so the
CREATE → recreate → show-create round-trip is idempotent for
property-less variant columns.
- `variant_p0/.../test_variant_compaction_with_sparse_limit` — pin
`default_variant_max_subcolumns_count=2048` (the FE default the `.out`
was generated
  under) so nested paths stay typed subcolumns.
- `audit/test_audit_log_behavior` — correct the drifted `query_id`
column to `varchar(128)`
  (`Config.label_regex_length`); `stmt_type` stays `varchar(48)`.

### branch-4.0 compatibility — remove unsupported
`enable_condition_cache` variable

`enable_condition_cache` does not exist on branch-4.0, so `set
enable_condition_cache=false`
fails with "Unknown system variable". Removing the line is a semantic
no-op (the branch is
already in the cache-disabled state the tests expect). Applied to the
`ann_index_only_scan`
debug-point cases (from #63859) and the `ann_range_search` cases (from
#63666).

### Test isolation

- `backup_restore/test_backup_restore_reset_index_id` (+
`test_backup_restore_inverted_idx`,
`restore_p0/test_validate_restore_inverted_idx`) — these three suites
mutate the
process-global `restore_reset_index_id` FE config; running in parallel,
one could flip it
between another suite's BACKUP and RESTORE (build #198126). They are now
in the
`nonConcurrent` group so they run serially. The FE reset logic itself is
correct; purely
  a test-isolation fix.

### Temporarily skipped / disabled

- `temp_table_p0/test_temp_table` — **skipped** (the temp-table feature
is no longer
maintained). An earlier commit had hardened its replica-count detection
for build
  #198126, but the suite is now skipped outright.
- `ann_index_p0/ann_range_search_pushdown_regression` — disabled pending
backport of
**#64082**: it builds an under-sized IVF scan that relies on the BE
skipping ANN index
build for segments smaller than `nlist`; without #64082 the single-row
INSERT fails at
  segment finalize with faiss `nx >= k`. Re-enable after picking #64082.
- `external_table_p0/hive/test_parquet_join_runtime_filter` — skipped
(feature not
  supported on 4.0).
- `shape_check/tpcds_sf100/shape/query64` and
`shape_check/tpcds_sf1000/shape/query64` —
  ignored (unstable shape checks).

## Release note

None

## Check List (For Committer)

- [x] Test <!-- regression tests -->

## Check List (For Reviewer who provide ASF feature)

- [ ] Performance regression

---------

Co-authored-by: hui lai <laihui@selectdb.com>
Co-authored-by: zhiqiang <seuhezhiqiang@163.com>
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Co-authored-by: meiyi <meiyi@selectdb.com>

Author: 5 people

be/src/olap/cumulative_compaction_time_series_policy.cpp

@@ -24,6 +24,7 @@
 #include "common/logging.h"
 #include "olap/tablet.h"
 #include "olap/tablet_meta.h"
+#include "util/debug_points.h"
 #include "util/time.h"
 
 namespace doris {
@@ -378,8 +379,14 @@ int32_t TimeSeriesCumulativeCompactionPolicy::pick_input_rowsets(
             if (rs_meta->compaction_level() == 0) {
                 break;
             }
+            // The debug point time_series_level2_file_count lets a test force a level-2
+            // merge by file count regardless of rowset age. Without bypassing this 24h
+            // freshness gate, freshly-created level1 rowsets are all skipped and the debug
+            // point below can never collect them. No effect in production: the debug point
+            // is disabled there, so the added condition is always true.
             if (rs_meta->compaction_level() == 1 &&
-                (now - rs_meta->creation_time()) <= MAX_LEVEL2_COMPACTION_TIMEOUT) {
+                (now - rs_meta->creation_time()) <= MAX_LEVEL2_COMPACTION_TIMEOUT &&
+                !DebugPoints::instance()->is_enable("time_series_level2_file_count")) {
                 continue;
             }
             level1_rowsets.push_back(rowset);

be/src/olap/rowset/segment_v2/segment_iterator.cpp

@@ -1110,9 +1110,14 @@ Status SegmentIterator::_apply_index_expr() {
     segment_v2::AnnIndexStats ann_index_stats;
     for (const auto& expr_ctx : _common_expr_ctxs_push_down) {
         size_t origin_rows = _row_bitmap.cardinality();
+        bool ann_range_search_executed = false;
         RETURN_IF_ERROR(expr_ctx->evaluate_ann_range_search(
                 _index_iterators, _schema->column_ids(), _column_iterators,
-                _common_expr_to_slotref_map, _row_bitmap, ann_index_stats));
+                _common_expr_to_slotref_map, _row_bitmap, ann_index_stats,
+                &ann_range_search_executed));
+        if (ann_range_search_executed) {
+            _opts.stats->ann_index_range_search_cnt++;
+        }
         _opts.stats->rows_ann_index_range_filtered += (origin_rows - _row_bitmap.cardinality());
         _opts.stats->ann_index_load_ns += ann_index_stats.load_index_costs_ns.value();
         _opts.stats->ann_index_range_search_ns += ann_index_stats.search_costs_ns.value();
@@ -1122,16 +1127,6 @@ Status SegmentIterator::_apply_index_expr() {
         _opts.stats->ann_range_pre_process_ns += ann_index_stats.engine_prepare_ns.value();
     }
 
-    for (auto it = _common_expr_ctxs_push_down.begin(); it != _common_expr_ctxs_push_down.end();) {
-        if ((*it)->root()->ann_range_search_executedd()) {
-            _opts.stats->ann_index_range_search_cnt++;
-            it = _common_expr_ctxs_push_down.erase(it);
-        } else {
-            ++it;
-        }
-    }
-    // TODO：Do we need to remove these expr root from _remaining_conjunct_roots?
-
     return Status::OK();
 }
 

be/src/vec/exprs/vectorized_fn_call.cpp

@@ -534,7 +534,9 @@ Status VectorizedFnCall::evaluate_ann_range_search(
         const std::vector<std::unique_ptr<segment_v2::IndexIterator>>& cid_to_index_iterators,
         const std::vector<ColumnId>& idx_to_cid,
         const std::vector<std::unique_ptr<segment_v2::ColumnIterator>>& column_iterators,
-        roaring::Roaring& row_bitmap, segment_v2::AnnIndexStats& ann_index_stats) {
+        roaring::Roaring& row_bitmap, segment_v2::AnnIndexStats& ann_index_stats,
+        AnnRangeSearchEvaluationResult& evaluation_result) {
+    evaluation_result = {};
     if (range_search_runtime.is_ann_range_search == false) {
         return Status::OK();
     }
@@ -543,8 +545,8 @@ Status VectorizedFnCall::evaluate_ann_range_search(
                               range_search_runtime.to_string());
     size_t origin_num = row_bitmap.cardinality();
 
-    int idx_in_block = static_cast<int>(range_search_runtime.src_col_idx);
-    DCHECK(idx_in_block < idx_to_cid.size())
+    const auto idx_in_block = range_search_runtime.src_col_idx;
+    DCHECK_LT(idx_in_block, idx_to_cid.size())
             << "idx_in_block: " << idx_in_block << ", idx_to_cid.size(): " << idx_to_cid.size();
 
     ColumnId src_col_cid = idx_to_cid[idx_in_block];
@@ -611,6 +613,7 @@ Status VectorizedFnCall::evaluate_ann_range_search(
     row_bitmap = *result.roaring;
 
     // Process virtual column
+    bool dist_fulfilled = false;
     if (range_search_runtime.dst_col_idx >= 0) {
         // Prepare materialization if we can use result from index.
         // Typical situation: range search and operator is LE or LT.
@@ -634,7 +637,7 @@ Status VectorizedFnCall::evaluate_ann_range_search(
             }
             virtual_column_iterator->prepare_materialization(std::move(distance_col),
                                                              std::move(result.row_ids));
-            _virtual_column_is_fulfilled = true;
+            dist_fulfilled = true;
         } else {
             // Whether the ANN index should have produced distance depends on metric and operator:
             //  - L2: distance is produced for LE/LT; not produced for GE/GT
@@ -648,17 +651,17 @@ Status VectorizedFnCall::evaluate_ann_range_search(
             // If we expected distance but didn't get it, assert in debug to catch logic errors.
             DCHECK(!should_have_distance) << "Expected distance from ANN index but got none";
 #endif
-            _virtual_column_is_fulfilled = false;
         }
     } else {
         // Dest is not virtual column.
-        _virtual_column_is_fulfilled = true;
+        dist_fulfilled = true;
     }
 
-    _has_been_executed = true;
+    evaluation_result.executed = true;
+    evaluation_result.dist_fulfilled = dist_fulfilled;
     VLOG_DEBUG << fmt::format(
             "Ann range search filtered {} rows, origin {} rows, virtual column is full-filled: {}",
-            origin_num - row_bitmap.cardinality(), origin_num, _virtual_column_is_fulfilled);
+            origin_num - row_bitmap.cardinality(), origin_num, dist_fulfilled);
 
     ann_index_stats = *stats;
     return Status::OK();

be/src/vec/exprs/vectorized_fn_call.h

@@ -91,7 +91,8 @@ class VectorizedFnCall : public VExpr {
             const std::vector<std::unique_ptr<segment_v2::IndexIterator>>& cid_to_index_iterators,
             const std::vector<ColumnId>& idx_to_cid,
             const std::vector<std::unique_ptr<segment_v2::ColumnIterator>>& column_iterators,
-            roaring::Roaring& row_bitmap, segment_v2::AnnIndexStats& ann_index_stats) override;
+            roaring::Roaring& row_bitmap, segment_v2::AnnIndexStats& ann_index_stats,
+            AnnRangeSearchEvaluationResult& result) override;
 
     void prepare_ann_range_search(const doris::VectorSearchUserParams& params,
                                   segment_v2::AnnRangeSearchRuntime& runtime,

be/src/vec/exprs/vexpr.cpp

@@ -991,7 +991,9 @@ Status VExpr::evaluate_ann_range_search(
         const std::vector<std::unique_ptr<segment_v2::IndexIterator>>& index_iterators,
         const std::vector<ColumnId>& idx_to_cid,
         const std::vector<std::unique_ptr<segment_v2::ColumnIterator>>& column_iterators,
-        roaring::Roaring& row_bitmap, AnnIndexStats& ann_index_stats) {
+        roaring::Roaring& row_bitmap, AnnIndexStats& ann_index_stats,
+        AnnRangeSearchEvaluationResult& result) {
+    result = {};
     return Status::OK();
 }
 
@@ -1009,14 +1011,6 @@ void VExpr::prepare_ann_range_search(const doris::VectorSearchUserParams& params
     }
 }
 
-bool VExpr::ann_range_search_executedd() {
-    return _has_been_executed;
-}
-
-bool VExpr::ann_dist_is_fulfilled() const {
-    return _virtual_column_is_fulfilled;
-}
-
 Status VExpr::execute_filter(VExprContext* context, const Block* block,
                              uint8_t* __restrict result_filter_data, size_t rows, bool accept_null,
                              bool* can_filter_all) const {

be/src/vec/exprs/vexpr.h

@@ -84,6 +84,15 @@ namespace vectorized {
 
 using Selector = IColumn::Selector;
 
+struct AnnRangeSearchEvaluationResult {
+    // Indicates whether the expr row_bitmap has been updated.
+    bool executed = false;
+    // Indicates whether the virtual column is fulfilled.
+    // NOTE, if there is no virtual column in the expr tree, and expr
+    // is evaluated by ann index, this flag is still true.
+    bool dist_fulfilled = false;
+};
+
 class VExpr {
 public:
     // resize inserted param column to make sure column size equal to block.rows() and return param column index
@@ -342,7 +351,8 @@ class VExpr {
             const std::vector<std::unique_ptr<segment_v2::IndexIterator>>& cid_to_index_iterators,
             const std::vector<ColumnId>& idx_to_cid,
             const std::vector<std::unique_ptr<segment_v2::ColumnIterator>>& column_iterators,
-            roaring::Roaring& row_bitmap, segment_v2::AnnIndexStats& ann_index_stats);
+            roaring::Roaring& row_bitmap, segment_v2::AnnIndexStats& ann_index_stats,
+            AnnRangeSearchEvaluationResult& result);
 
     // Prepare the runtime for ANN range search.
     // AnnRangeSearchRuntime is used to store the runtime information of ann range search.
@@ -352,10 +362,6 @@ class VExpr {
                                           segment_v2::AnnRangeSearchRuntime& range_search_runtime,
                                           bool& suitable_for_ann_index);
 
-    bool ann_range_search_executedd();
-
-    bool ann_dist_is_fulfilled() const;
-
 protected:
     /// Simple debug string that provides no expr subclass-specific information
     std::string debug_string(const std::string& expr_name) const {
@@ -436,13 +442,6 @@ class VExpr {
     // ensuring uniqueness during index traversal
     uint32_t _index_unique_id = 0;
     bool _enable_inverted_index_query = true;
-
-    // Indicates whether the expr row_bitmap has been updated.
-    bool _has_been_executed = false;
-    // Indicates whether the virtual column is fulfilled.
-    // NOTE, if there is no virtual column in the expr tree, and expr
-    // is evaluated by ann index, this flag is still true.
-    bool _virtual_column_is_fulfilled = false;
 };
 
 } // namespace vectorized

be/src/vec/exprs/vexpr_context.cpp

@@ -433,41 +433,58 @@ Status VExprContext::evaluate_ann_range_search(
         const std::unordered_map<vectorized::VExprContext*,
                                  std::unordered_map<ColumnId, vectorized::VExpr*>>&
                 common_expr_to_slotref_map,
-        roaring::Roaring& row_bitmap, segment_v2::AnnIndexStats& ann_index_stats) {
+        roaring::Roaring& row_bitmap, segment_v2::AnnIndexStats& ann_index_stats,
+        bool* ann_range_search_executed) {
+    if (ann_range_search_executed != nullptr) {
+        *ann_range_search_executed = false;
+    }
     if (_root == nullptr) {
         return Status::OK();
     }
 
+    AnnRangeSearchEvaluationResult evaluation_result;
     RETURN_IF_ERROR(_root->evaluate_ann_range_search(
             _ann_range_search_runtime, cid_to_index_iterators, idx_to_cid, column_iterators,
-            row_bitmap, ann_index_stats));
+            row_bitmap, ann_index_stats, evaluation_result));
 
-    if (!_root->ann_range_search_executedd()) {
+    if (!evaluation_result.executed) {
         return Status::OK();
     }
+    if (ann_range_search_executed != nullptr) {
+        *ann_range_search_executed = true;
+    }
+
+    DCHECK(_index_context != nullptr);
+    _index_context->set_index_result_for_expr(
+            _root.get(),
+            segment_v2::InvertedIndexResultBitmap(std::make_shared<roaring::Roaring>(row_bitmap),
+                                                  std::make_shared<roaring::Roaring>()));
 
-    if (!_root->ann_dist_is_fulfilled()) {
+    if (!evaluation_result.dist_fulfilled) {
         // Do not perform index scan in this case.
         return Status::OK();
     }
 
-    auto src_col_idx = _ann_range_search_runtime.src_col_idx;
+    DCHECK_LT(_ann_range_search_runtime.src_col_idx, idx_to_cid.size());
+    const auto src_col_idx = cast_set<int>(_ann_range_search_runtime.src_col_idx);
+    const auto src_col_key = cast_set<ColumnId>(_ann_range_search_runtime.src_col_idx);
     auto slot_ref_map_it = common_expr_to_slotref_map.find(this);
     if (slot_ref_map_it == common_expr_to_slotref_map.end()) {
         return Status::OK();
     }
     auto& slot_ref_map = slot_ref_map_it->second;
-    ColumnId cid = idx_to_cid[src_col_idx];
-    if (slot_ref_map.find(cid) == slot_ref_map.end()) {
+    auto slot_ref_it = slot_ref_map.find(src_col_key);
+    if (slot_ref_it == slot_ref_map.end()) {
         return Status::OK();
     }
-    const VExpr* slot_ref_expr_addr = slot_ref_map.find(cid)->second;
-    _index_context->set_true_for_index_status(slot_ref_expr_addr, idx_to_cid[cid]);
+    const VExpr* slot_ref_expr_addr = slot_ref_it->second;
+    _index_context->set_true_for_index_status(slot_ref_expr_addr, src_col_idx);
 
     VLOG_DEBUG << fmt::format(
             "Evaluate ann range search for expr {}, src_col_idx {}, cid {}, row_bitmap "
             "cardinality {}",
-            _root->debug_string(), src_col_idx, cid, row_bitmap.cardinality());
+            _root->debug_string(), src_col_idx, idx_to_cid[_ann_range_search_runtime.src_col_idx],
+            row_bitmap.cardinality());
     return Status::OK();
 }
 

be/src/vec/exprs/vexpr_context.h

@@ -358,7 +358,8 @@ class VExprContext {
             const std::unordered_map<vectorized::VExprContext*,
                                      std::unordered_map<ColumnId, vectorized::VExpr*>>&
                     common_expr_to_slotref_map,
-            roaring::Roaring& row_bitmap, segment_v2::AnnIndexStats& ann_index_stats);
+            roaring::Roaring& row_bitmap, segment_v2::AnnIndexStats& ann_index_stats,
+            bool* ann_range_search_executed);
 
 private:
     // Close method is called in vexpr context dector, not need call expicility

be/src/vec/exprs/virtual_slot_ref.cpp

@@ -234,12 +234,11 @@ Status VirtualSlotRef::evaluate_ann_range_search(
         const std::vector<std::unique_ptr<segment_v2::IndexIterator>>& cid_to_index_iterators,
         const std::vector<ColumnId>& idx_to_cid,
         const std::vector<std::unique_ptr<segment_v2::ColumnIterator>>& column_iterators,
-        roaring::Roaring& row_bitmap, segment_v2::AnnIndexStats& ann_index_stats) {
+        roaring::Roaring& row_bitmap, segment_v2::AnnIndexStats& ann_index_stats,
+        AnnRangeSearchEvaluationResult& result) {
     return _virtual_column_expr->evaluate_ann_range_search(
             range_search_runtime, cid_to_index_iterators, idx_to_cid, column_iterators, row_bitmap,
-            ann_index_stats);
-
-    return Status::OK();
+            ann_index_stats, result);
 }
 #include "common/compile_check_end.h"
 } // namespace doris::vectorized

be/src/vec/exprs/virtual_slot_ref.h

@@ -107,7 +107,8 @@ class VirtualSlotRef MOCK_REMOVE(final) : public VExpr {
             const std::vector<std::unique_ptr<segment_v2::IndexIterator>>& cid_to_index_iterators,
             const std::vector<ColumnId>& idx_to_cid,
             const std::vector<std::unique_ptr<segment_v2::ColumnIterator>>& column_iterators,
-            roaring::Roaring& row_bitmap, segment_v2::AnnIndexStats& ann_index_stats) override;
+            roaring::Roaring& row_bitmap, segment_v2::AnnIndexStats& ann_index_stats,
+            AnnRangeSearchEvaluationResult& result) override;
 
 #ifdef BE_TEST
     // Test-only setter methods for unit testing