This is an automated email from the ASF dual-hosted git repository.

morrysnow pushed a commit to branch branch-3.1
in repository https://gitbox.apache.org/repos/asf/doris.git


The following commit(s) were added to refs/heads/branch-3.1 by this push:
     new 2a3c0a89aef branch-3.1: [opt](inverted index) enhance inverted index 
query profiling for better performance monitoring #54154 (#54677)
2a3c0a89aef is described below

commit 2a3c0a89aefdedd4d5e689ceb24c9212a41b17ad
Author: zzzxl <[email protected]>
AuthorDate: Thu Aug 14 17:32:16 2025 +0800

    branch-3.1: [opt](inverted index) enhance inverted index query profiling 
for better performance monitoring #54154 (#54677)
    
    picked from #54154
---
 be/src/olap/olap_common.h                          |   2 +
 .../inverted_index/analyzer/analyzer.cpp           |   1 +
 .../segment_v2/inverted_index/analyzer/analyzer.h  |   1 +
 .../inverted_index/query/phrase_query.cpp          |  10 +-
 .../segment_v2/inverted_index/query/phrase_query.h |   3 +-
 .../rowset/segment_v2/inverted_index_reader.cpp    |  14 +-
 .../olap/rowset/segment_v2/inverted_index_reader.h |   8 +-
 be/src/pipeline/exec/olap_scan_operator.cpp        |   2 +
 be/src/pipeline/exec/olap_scan_operator.h          |   2 +
 be/src/vec/exec/scan/new_olap_scanner.cpp          | 194 +++++++++++----------
 10 files changed, 133 insertions(+), 104 deletions(-)

diff --git a/be/src/olap/olap_common.h b/be/src/olap/olap_common.h
index f792e3ac6f9..2034f1f25bb 100644
--- a/be/src/olap/olap_common.h
+++ b/be/src/olap/olap_common.h
@@ -379,6 +379,8 @@ struct OlapReaderStatistics {
     int64_t inverted_index_searcher_cache_hit = 0;
     int64_t inverted_index_searcher_cache_miss = 0;
     int64_t inverted_index_downgrade_count = 0;
+    int64_t inverted_index_analyzer_timer = 0;
+    int64_t inverted_index_lookup_timer = 0;
     InvertedIndexStatistics inverted_index_stats;
 
     int64_t output_index_result_column_timer = 0;
diff --git a/be/src/olap/rowset/segment_v2/inverted_index/analyzer/analyzer.cpp 
b/be/src/olap/rowset/segment_v2/inverted_index/analyzer/analyzer.cpp
index 2be2677f1a9..eea8e20ab9c 100644
--- a/be/src/olap/rowset/segment_v2/inverted_index/analyzer/analyzer.cpp
+++ b/be/src/olap/rowset/segment_v2/inverted_index/analyzer/analyzer.cpp
@@ -34,6 +34,7 @@
 #include 
"olap/rowset/segment_v2/inverted_index/char_filter/char_filter_factory.h"
 #include "runtime/exec_env.h"
 #include "runtime/index_policy/index_policy_mgr.h"
+#include "util/runtime_profile.h"
 
 namespace doris::segment_v2::inverted_index {
 
diff --git a/be/src/olap/rowset/segment_v2/inverted_index/analyzer/analyzer.h 
b/be/src/olap/rowset/segment_v2/inverted_index/analyzer/analyzer.h
index d09b1ff3198..756aa93aae3 100644
--- a/be/src/olap/rowset/segment_v2/inverted_index/analyzer/analyzer.h
+++ b/be/src/olap/rowset/segment_v2/inverted_index/analyzer/analyzer.h
@@ -21,6 +21,7 @@
 #include <vector>
 
 #include "olap/inverted_index_parser.h"
+#include "olap/olap_common.h"
 #include "olap/rowset/segment_v2/inverted_index/query/query.h"
 #include "olap/rowset/segment_v2/inverted_index_query_type.h"
 
diff --git 
a/be/src/olap/rowset/segment_v2/inverted_index/query/phrase_query.cpp 
b/be/src/olap/rowset/segment_v2/inverted_index/query/phrase_query.cpp
index 9630130d8a4..904df1e1719 100644
--- a/be/src/olap/rowset/segment_v2/inverted_index/query/phrase_query.cpp
+++ b/be/src/olap/rowset/segment_v2/inverted_index/query/phrase_query.cpp
@@ -24,6 +24,7 @@
 #include "CLucene/index/Terms.h"
 #include "olap/rowset/segment_v2/inverted_index/analyzer/analyzer.h"
 #include "olap/rowset/segment_v2/inverted_index/util/term_position_iterator.h"
+#include "util/runtime_profile.h"
 
 namespace doris::segment_v2 {
 
@@ -229,12 +230,15 @@ void PhraseQuery::parser_slop(std::string& query, 
InvertedIndexQueryInfo& query_
     }
 }
 
-void PhraseQuery::parser_info(std::string& query,
+void PhraseQuery::parser_info(OlapReaderStatistics* stats, std::string& query,
                               const std::map<std::string, std::string>& 
properties,
                               InvertedIndexQueryInfo& query_info) {
     parser_slop(query, query_info);
-    query_info.term_infos =
-            inverted_index::InvertedIndexAnalyzer::get_analyse_result(query, 
properties);
+    {
+        SCOPED_RAW_TIMER(&stats->inverted_index_analyzer_timer);
+        query_info.term_infos =
+                
inverted_index::InvertedIndexAnalyzer::get_analyse_result(query, properties);
+    }
 }
 
 } // namespace doris::segment_v2
\ No newline at end of file
diff --git a/be/src/olap/rowset/segment_v2/inverted_index/query/phrase_query.h 
b/be/src/olap/rowset/segment_v2/inverted_index/query/phrase_query.h
index cc75e2b0186..aee50a5a5a8 100644
--- a/be/src/olap/rowset/segment_v2/inverted_index/query/phrase_query.h
+++ b/be/src/olap/rowset/segment_v2/inverted_index/query/phrase_query.h
@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include "olap/olap_common.h"
 #include "olap/rowset/segment_v2/inverted_index/query/disjunction_query.h"
 #include 
"olap/rowset/segment_v2/inverted_index/query/phrase_query/exact_phrase_matcher.h"
 #include 
"olap/rowset/segment_v2/inverted_index/query/phrase_query/ordered_sloppy_phrase_matcher.h"
@@ -58,7 +59,7 @@ private:
 
 public:
     static void parser_slop(std::string& query, InvertedIndexQueryInfo& 
query_info);
-    static void parser_info(std::string& query,
+    static void parser_info(OlapReaderStatistics* stats, std::string& query,
                             const std::map<std::string, std::string>& 
properties,
                             InvertedIndexQueryInfo& query_info);
 
diff --git a/be/src/olap/rowset/segment_v2/inverted_index_reader.cpp 
b/be/src/olap/rowset/segment_v2/inverted_index_reader.cpp
index 9ca556fd1ec..121ca81e69d 100644
--- a/be/src/olap/rowset/segment_v2/inverted_index_reader.cpp
+++ b/be/src/olap/rowset/segment_v2/inverted_index_reader.cpp
@@ -131,8 +131,15 @@ Status InvertedIndexReader::handle_searcher_cache(
         OlapReaderStatistics* stats) {
     auto index_file_key = 
_inverted_index_file_reader->get_index_file_cache_key(&_index_meta);
     InvertedIndexSearcherCache::CacheKey searcher_cache_key(index_file_key);
-    if (InvertedIndexSearcherCache::instance()->lookup(searcher_cache_key,
-                                                       
inverted_index_cache_handle)) {
+
+    bool cache_hit = false;
+    {
+        SCOPED_RAW_TIMER(&stats->inverted_index_lookup_timer);
+        cache_hit = 
InvertedIndexSearcherCache::instance()->lookup(searcher_cache_key,
+                                                                   
inverted_index_cache_handle);
+    }
+
+    if (cache_hit) {
         stats->inverted_index_searcher_cache_hit++;
         return Status::OK();
     } else {
@@ -265,8 +272,9 @@ Status FullTextIndexReader::query(const io::IOContext* 
io_ctx, OlapReaderStatist
         if (query_type == InvertedIndexQueryType::MATCH_REGEXP_QUERY) {
             query_info.term_infos.emplace_back(search_str, 0);
         } else if (query_type == InvertedIndexQueryType::MATCH_PHRASE_QUERY) {
-            PhraseQuery::parser_info(search_str, _index_meta.properties(), 
query_info);
+            PhraseQuery::parser_info(stats, search_str, 
_index_meta.properties(), query_info);
         } else {
+            SCOPED_RAW_TIMER(&stats->inverted_index_analyzer_timer);
             query_info.term_infos = 
inverted_index::InvertedIndexAnalyzer::get_analyse_result(
                     search_str, _index_meta.properties());
         }
diff --git a/be/src/olap/rowset/segment_v2/inverted_index_reader.h 
b/be/src/olap/rowset/segment_v2/inverted_index_reader.h
index 96ba52adab2..d3db13e2f14 100644
--- a/be/src/olap/rowset/segment_v2/inverted_index_reader.h
+++ b/be/src/olap/rowset/segment_v2/inverted_index_reader.h
@@ -213,7 +213,13 @@ public:
                                       InvertedIndexQueryCacheHandle* 
cache_handler,
                                       OlapReaderStatistics* stats,
                                       std::shared_ptr<roaring::Roaring>& 
bit_map) {
-        if (cache->lookup(cache_key, cache_handler)) {
+        bool cache_hit = false;
+        {
+            SCOPED_RAW_TIMER(&stats->inverted_index_lookup_timer);
+            cache_hit = cache->lookup(cache_key, cache_handler);
+        }
+
+        if (cache_hit) {
             stats->inverted_index_query_cache_hit++;
             SCOPED_RAW_TIMER(&stats->inverted_index_query_bitmap_copy_timer);
             bit_map = cache_handler->get_bitmap();
diff --git a/be/src/pipeline/exec/olap_scan_operator.cpp 
b/be/src/pipeline/exec/olap_scan_operator.cpp
index e4df1528f75..64437641d4e 100644
--- a/be/src/pipeline/exec/olap_scan_operator.cpp
+++ b/be/src/pipeline/exec/olap_scan_operator.cpp
@@ -191,6 +191,8 @@ Status OlapScanLocalState::_init_profile() {
             ADD_COUNTER(_segment_profile, "InvertedIndexSearcherCacheMiss", 
TUnit::UNIT);
     _inverted_index_downgrade_count_counter =
             ADD_COUNTER(_segment_profile, "InvertedIndexDowngradeCount", 
TUnit::UNIT);
+    _inverted_index_analyzer_timer = ADD_TIMER(_segment_profile, 
"InvertedIndexAnalyzerTime");
+    _inverted_index_lookup_timer = ADD_TIMER(_segment_profile, 
"InvertedIndexLookupTimer");
 
     _output_index_result_column_timer = ADD_TIMER(_segment_profile, 
"OutputIndexResultColumnTime");
     _filtered_segment_counter = ADD_COUNTER(_segment_profile, 
"NumSegmentFiltered", TUnit::UNIT);
diff --git a/be/src/pipeline/exec/olap_scan_operator.h 
b/be/src/pipeline/exec/olap_scan_operator.h
index 5ed5e53748f..5c3d0f38b84 100644
--- a/be/src/pipeline/exec/olap_scan_operator.h
+++ b/be/src/pipeline/exec/olap_scan_operator.h
@@ -207,6 +207,8 @@ private:
     RuntimeProfile::Counter* _inverted_index_searcher_cache_hit_counter = 
nullptr;
     RuntimeProfile::Counter* _inverted_index_searcher_cache_miss_counter = 
nullptr;
     RuntimeProfile::Counter* _inverted_index_downgrade_count_counter = nullptr;
+    RuntimeProfile::Counter* _inverted_index_analyzer_timer = nullptr;
+    RuntimeProfile::Counter* _inverted_index_lookup_timer = nullptr;
 
     RuntimeProfile::Counter* _output_index_result_column_timer = nullptr;
 
diff --git a/be/src/vec/exec/scan/new_olap_scanner.cpp 
b/be/src/vec/exec/scan/new_olap_scanner.cpp
index adc44ffc68c..19dcf5d1976 100644
--- a/be/src/vec/exec/scan/new_olap_scanner.cpp
+++ b/be/src/vec/exec/scan/new_olap_scanner.cpp
@@ -598,102 +598,104 @@ void NewOlapScanner::_collect_profile_before_close() {
     VScanner::_collect_profile_before_close();
 
 #ifndef INCR_COUNTER
-#define INCR_COUNTER(Parent)                                                   
                 \
-    COUNTER_UPDATE(Parent->_io_timer, stats.io_ns);                            
                 \
-    COUNTER_UPDATE(Parent->_read_compressed_counter, 
stats.compressed_bytes_read);              \
-    COUNTER_UPDATE(Parent->_scan_bytes, stats.uncompressed_bytes_read);        
                 \
-    COUNTER_UPDATE(Parent->_decompressor_timer, stats.decompress_ns);          
                 \
-    COUNTER_UPDATE(Parent->_read_uncompressed_counter, 
stats.uncompressed_bytes_read);          \
-    COUNTER_UPDATE(Parent->_block_load_timer, stats.block_load_ns);            
                 \
-    COUNTER_UPDATE(Parent->_block_load_counter, stats.blocks_load);            
                 \
-    COUNTER_UPDATE(Parent->_block_fetch_timer, stats.block_fetch_ns);          
                 \
-    COUNTER_UPDATE(Parent->_delete_bitmap_get_agg_timer, 
stats.delete_bitmap_get_agg_ns);       \
-    COUNTER_UPDATE(Parent->_scan_rows, stats.raw_rows_read);                   
                 \
-    COUNTER_UPDATE(Parent->_vec_cond_timer, stats.vec_cond_ns);                
                 \
-    COUNTER_UPDATE(Parent->_short_cond_timer, stats.short_cond_ns);            
                 \
-    COUNTER_UPDATE(Parent->_expr_filter_timer, stats.expr_filter_ns);          
                 \
-    COUNTER_UPDATE(Parent->_block_init_timer, stats.block_init_ns);            
                 \
-    COUNTER_UPDATE(Parent->_block_init_seek_timer, stats.block_init_seek_ns);  
                 \
-    COUNTER_UPDATE(Parent->_block_init_seek_counter, 
stats.block_init_seek_num);                \
-    COUNTER_UPDATE(Parent->_segment_generate_row_range_by_keys_timer,          
                 \
-                   stats.generate_row_ranges_by_keys_ns);                      
                 \
-    
COUNTER_UPDATE(Parent->_segment_generate_row_range_by_column_conditions_timer,  
            \
-                   stats.generate_row_ranges_by_column_conditions_ns);         
                 \
-    COUNTER_UPDATE(Parent->_segment_generate_row_range_by_bf_timer,            
                 \
-                   stats.generate_row_ranges_by_bf_ns);                        
                 \
-    COUNTER_UPDATE(Parent->_collect_iterator_merge_next_timer,                 
                 \
-                   stats.collect_iterator_merge_next_timer);                   
                 \
-    COUNTER_UPDATE(Parent->_segment_generate_row_range_by_zonemap_timer,       
                 \
-                   stats.generate_row_ranges_by_zonemap_ns);                   
                 \
-    COUNTER_UPDATE(Parent->_segment_generate_row_range_by_dict_timer,          
                 \
-                   stats.generate_row_ranges_by_dict_ns);                      
                 \
-    COUNTER_UPDATE(Parent->_predicate_column_read_timer, 
stats.predicate_column_read_ns);       \
-    COUNTER_UPDATE(Parent->_non_predicate_column_read_timer, 
stats.non_predicate_read_ns);      \
-    COUNTER_UPDATE(Parent->_predicate_column_read_seek_timer,                  
                 \
-                   stats.predicate_column_read_seek_ns);                       
                 \
-    COUNTER_UPDATE(Parent->_predicate_column_read_seek_counter,                
                 \
-                   stats.predicate_column_read_seek_num);                      
                 \
-    COUNTER_UPDATE(Parent->_lazy_read_timer, stats.lazy_read_ns);              
                 \
-    COUNTER_UPDATE(Parent->_lazy_read_seek_timer, 
stats.block_lazy_read_seek_ns);               \
-    COUNTER_UPDATE(Parent->_lazy_read_seek_counter, 
stats.block_lazy_read_seek_num);            \
-    COUNTER_UPDATE(Parent->_output_col_timer, stats.output_col_ns);            
                 \
-    COUNTER_UPDATE(Parent->_rows_vec_cond_filtered_counter, 
stats.rows_vec_cond_filtered);      \
-    COUNTER_UPDATE(Parent->_rows_short_circuit_cond_filtered_counter,          
                 \
-                   stats.rows_short_circuit_cond_filtered);                    
                 \
-    COUNTER_UPDATE(Parent->_rows_vec_cond_input_counter, 
stats.vec_cond_input_rows);            \
-    COUNTER_UPDATE(Parent->_rows_short_circuit_cond_input_counter,             
                 \
-                   stats.short_circuit_cond_input_rows);                       
                 \
-    for (auto& [id, info] : stats.filter_info) {                               
                 \
-        Parent->add_filter_info(id, info);                                     
                 \
-    }                                                                          
                 \
-    COUNTER_UPDATE(Parent->_stats_filtered_counter, 
stats.rows_stats_filtered);                 \
-    COUNTER_UPDATE(Parent->_stats_rp_filtered_counter, 
stats.rows_stats_rp_filtered);           \
-    COUNTER_UPDATE(Parent->_dict_filtered_counter, stats.rows_dict_filtered);  
                 \
-    COUNTER_UPDATE(Parent->_bf_filtered_counter, stats.rows_bf_filtered);      
                 \
-    COUNTER_UPDATE(Parent->_del_filtered_counter, stats.rows_del_filtered);    
                 \
-    COUNTER_UPDATE(Parent->_del_filtered_counter, stats.rows_del_by_bitmap);   
                 \
-    COUNTER_UPDATE(Parent->_del_filtered_counter, 
stats.rows_vec_del_cond_filtered);            \
-    COUNTER_UPDATE(Parent->_conditions_filtered_counter, 
stats.rows_conditions_filtered);       \
-    COUNTER_UPDATE(Parent->_key_range_filtered_counter, 
stats.rows_key_range_filtered);         \
-    COUNTER_UPDATE(Parent->_total_pages_num_counter, stats.total_pages_num);   
                 \
-    COUNTER_UPDATE(Parent->_cached_pages_num_counter, stats.cached_pages_num); 
                 \
-    COUNTER_UPDATE(Parent->_bitmap_index_filter_counter, 
stats.rows_bitmap_index_filtered);     \
-    COUNTER_UPDATE(Parent->_bitmap_index_filter_timer, 
stats.bitmap_index_filter_timer);        \
-    COUNTER_UPDATE(Parent->_inverted_index_filter_counter, 
stats.rows_inverted_index_filtered); \
-    COUNTER_UPDATE(Parent->_inverted_index_filter_timer, 
stats.inverted_index_filter_timer);    \
-    COUNTER_UPDATE(Parent->_inverted_index_query_cache_hit_counter,            
                 \
-                   stats.inverted_index_query_cache_hit);                      
                 \
-    COUNTER_UPDATE(Parent->_inverted_index_query_cache_miss_counter,           
                 \
-                   stats.inverted_index_query_cache_miss);                     
                 \
-    COUNTER_UPDATE(Parent->_inverted_index_query_timer, 
stats.inverted_index_query_timer);      \
-    COUNTER_UPDATE(Parent->_inverted_index_query_null_bitmap_timer,            
                 \
-                   stats.inverted_index_query_null_bitmap_timer);              
                 \
-    COUNTER_UPDATE(Parent->_inverted_index_query_bitmap_copy_timer,            
                 \
-                   stats.inverted_index_query_bitmap_copy_timer);              
                 \
-    COUNTER_UPDATE(Parent->_inverted_index_searcher_open_timer,                
                 \
-                   stats.inverted_index_searcher_open_timer);                  
                 \
-    COUNTER_UPDATE(Parent->_inverted_index_searcher_search_timer,              
                 \
-                   stats.inverted_index_searcher_search_timer);                
                 \
-    COUNTER_UPDATE(Parent->_inverted_index_searcher_search_init_timer,         
                 \
-                   stats.inverted_index_searcher_search_init_timer);           
                 \
-    COUNTER_UPDATE(Parent->_inverted_index_searcher_search_exec_timer,         
                 \
-                   stats.inverted_index_searcher_search_exec_timer);           
                 \
-    COUNTER_UPDATE(Parent->_inverted_index_searcher_cache_hit_counter,         
                 \
-                   stats.inverted_index_searcher_cache_hit);                   
                 \
-    COUNTER_UPDATE(Parent->_inverted_index_searcher_cache_miss_counter,        
                 \
-                   stats.inverted_index_searcher_cache_miss);                  
                 \
-    COUNTER_UPDATE(Parent->_inverted_index_downgrade_count_counter,            
                 \
-                   stats.inverted_index_downgrade_count);                      
                 \
-    InvertedIndexProfileReporter inverted_index_profile;                       
                 \
-    inverted_index_profile.update(Parent->_index_filter_profile.get(),         
                 \
-                                  &stats.inverted_index_stats);                
                 \
-    if (config::enable_file_cache) {                                           
                 \
-        io::FileCacheProfileReporter 
cache_profile(Parent->_segment_profile.get());             \
-        cache_profile.update(&stats.file_cache_stats);                         
                 \
-    }                                                                          
                 \
-    COUNTER_UPDATE(Parent->_output_index_result_column_timer,                  
                 \
-                   stats.output_index_result_column_timer);                    
                 \
-    COUNTER_UPDATE(Parent->_filtered_segment_counter, 
stats.filtered_segment_number);           \
+#define INCR_COUNTER(Parent)                                                   
                  \
+    COUNTER_UPDATE(Parent->_io_timer, stats.io_ns);                            
                  \
+    COUNTER_UPDATE(Parent->_read_compressed_counter, 
stats.compressed_bytes_read);               \
+    COUNTER_UPDATE(Parent->_scan_bytes, stats.uncompressed_bytes_read);        
                  \
+    COUNTER_UPDATE(Parent->_decompressor_timer, stats.decompress_ns);          
                  \
+    COUNTER_UPDATE(Parent->_read_uncompressed_counter, 
stats.uncompressed_bytes_read);           \
+    COUNTER_UPDATE(Parent->_block_load_timer, stats.block_load_ns);            
                  \
+    COUNTER_UPDATE(Parent->_block_load_counter, stats.blocks_load);            
                  \
+    COUNTER_UPDATE(Parent->_block_fetch_timer, stats.block_fetch_ns);          
                  \
+    COUNTER_UPDATE(Parent->_delete_bitmap_get_agg_timer, 
stats.delete_bitmap_get_agg_ns);        \
+    COUNTER_UPDATE(Parent->_scan_rows, stats.raw_rows_read);                   
                  \
+    COUNTER_UPDATE(Parent->_vec_cond_timer, stats.vec_cond_ns);                
                  \
+    COUNTER_UPDATE(Parent->_short_cond_timer, stats.short_cond_ns);            
                  \
+    COUNTER_UPDATE(Parent->_expr_filter_timer, stats.expr_filter_ns);          
                  \
+    COUNTER_UPDATE(Parent->_block_init_timer, stats.block_init_ns);            
                  \
+    COUNTER_UPDATE(Parent->_block_init_seek_timer, stats.block_init_seek_ns);  
                  \
+    COUNTER_UPDATE(Parent->_block_init_seek_counter, 
stats.block_init_seek_num);                 \
+    COUNTER_UPDATE(Parent->_segment_generate_row_range_by_keys_timer,          
                  \
+                   stats.generate_row_ranges_by_keys_ns);                      
                  \
+    
COUNTER_UPDATE(Parent->_segment_generate_row_range_by_column_conditions_timer,  
             \
+                   stats.generate_row_ranges_by_column_conditions_ns);         
                  \
+    COUNTER_UPDATE(Parent->_segment_generate_row_range_by_bf_timer,            
                  \
+                   stats.generate_row_ranges_by_bf_ns);                        
                  \
+    COUNTER_UPDATE(Parent->_collect_iterator_merge_next_timer,                 
                  \
+                   stats.collect_iterator_merge_next_timer);                   
                  \
+    COUNTER_UPDATE(Parent->_segment_generate_row_range_by_zonemap_timer,       
                  \
+                   stats.generate_row_ranges_by_zonemap_ns);                   
                  \
+    COUNTER_UPDATE(Parent->_segment_generate_row_range_by_dict_timer,          
                  \
+                   stats.generate_row_ranges_by_dict_ns);                      
                  \
+    COUNTER_UPDATE(Parent->_predicate_column_read_timer, 
stats.predicate_column_read_ns);        \
+    COUNTER_UPDATE(Parent->_non_predicate_column_read_timer, 
stats.non_predicate_read_ns);       \
+    COUNTER_UPDATE(Parent->_predicate_column_read_seek_timer,                  
                  \
+                   stats.predicate_column_read_seek_ns);                       
                  \
+    COUNTER_UPDATE(Parent->_predicate_column_read_seek_counter,                
                  \
+                   stats.predicate_column_read_seek_num);                      
                  \
+    COUNTER_UPDATE(Parent->_lazy_read_timer, stats.lazy_read_ns);              
                  \
+    COUNTER_UPDATE(Parent->_lazy_read_seek_timer, 
stats.block_lazy_read_seek_ns);                \
+    COUNTER_UPDATE(Parent->_lazy_read_seek_counter, 
stats.block_lazy_read_seek_num);             \
+    COUNTER_UPDATE(Parent->_output_col_timer, stats.output_col_ns);            
                  \
+    COUNTER_UPDATE(Parent->_rows_vec_cond_filtered_counter, 
stats.rows_vec_cond_filtered);       \
+    COUNTER_UPDATE(Parent->_rows_short_circuit_cond_filtered_counter,          
                  \
+                   stats.rows_short_circuit_cond_filtered);                    
                  \
+    COUNTER_UPDATE(Parent->_rows_vec_cond_input_counter, 
stats.vec_cond_input_rows);             \
+    COUNTER_UPDATE(Parent->_rows_short_circuit_cond_input_counter,             
                  \
+                   stats.short_circuit_cond_input_rows);                       
                  \
+    for (auto& [id, info] : stats.filter_info) {                               
                  \
+        Parent->add_filter_info(id, info);                                     
                  \
+    }                                                                          
                  \
+    COUNTER_UPDATE(Parent->_stats_filtered_counter, 
stats.rows_stats_filtered);                  \
+    COUNTER_UPDATE(Parent->_stats_rp_filtered_counter, 
stats.rows_stats_rp_filtered);            \
+    COUNTER_UPDATE(Parent->_dict_filtered_counter, stats.rows_dict_filtered);  
                  \
+    COUNTER_UPDATE(Parent->_bf_filtered_counter, stats.rows_bf_filtered);      
                  \
+    COUNTER_UPDATE(Parent->_del_filtered_counter, stats.rows_del_filtered);    
                  \
+    COUNTER_UPDATE(Parent->_del_filtered_counter, stats.rows_del_by_bitmap);   
                  \
+    COUNTER_UPDATE(Parent->_del_filtered_counter, 
stats.rows_vec_del_cond_filtered);             \
+    COUNTER_UPDATE(Parent->_conditions_filtered_counter, 
stats.rows_conditions_filtered);        \
+    COUNTER_UPDATE(Parent->_key_range_filtered_counter, 
stats.rows_key_range_filtered);          \
+    COUNTER_UPDATE(Parent->_total_pages_num_counter, stats.total_pages_num);   
                  \
+    COUNTER_UPDATE(Parent->_cached_pages_num_counter, stats.cached_pages_num); 
                  \
+    COUNTER_UPDATE(Parent->_bitmap_index_filter_counter, 
stats.rows_bitmap_index_filtered);      \
+    COUNTER_UPDATE(Parent->_bitmap_index_filter_timer, 
stats.bitmap_index_filter_timer);         \
+    COUNTER_UPDATE(Parent->_inverted_index_filter_counter, 
stats.rows_inverted_index_filtered);  \
+    COUNTER_UPDATE(Parent->_inverted_index_filter_timer, 
stats.inverted_index_filter_timer);     \
+    COUNTER_UPDATE(Parent->_inverted_index_query_cache_hit_counter,            
                  \
+                   stats.inverted_index_query_cache_hit);                      
                  \
+    COUNTER_UPDATE(Parent->_inverted_index_query_cache_miss_counter,           
                  \
+                   stats.inverted_index_query_cache_miss);                     
                  \
+    COUNTER_UPDATE(Parent->_inverted_index_query_timer, 
stats.inverted_index_query_timer);       \
+    COUNTER_UPDATE(Parent->_inverted_index_query_null_bitmap_timer,            
                  \
+                   stats.inverted_index_query_null_bitmap_timer);              
                  \
+    COUNTER_UPDATE(Parent->_inverted_index_query_bitmap_copy_timer,            
                  \
+                   stats.inverted_index_query_bitmap_copy_timer);              
                  \
+    COUNTER_UPDATE(Parent->_inverted_index_searcher_open_timer,                
                  \
+                   stats.inverted_index_searcher_open_timer);                  
                  \
+    COUNTER_UPDATE(Parent->_inverted_index_searcher_search_timer,              
                  \
+                   stats.inverted_index_searcher_search_timer);                
                  \
+    COUNTER_UPDATE(Parent->_inverted_index_searcher_search_init_timer,         
                  \
+                   stats.inverted_index_searcher_search_init_timer);           
                  \
+    COUNTER_UPDATE(Parent->_inverted_index_searcher_search_exec_timer,         
                  \
+                   stats.inverted_index_searcher_search_exec_timer);           
                  \
+    COUNTER_UPDATE(Parent->_inverted_index_searcher_cache_hit_counter,         
                  \
+                   stats.inverted_index_searcher_cache_hit);                   
                  \
+    COUNTER_UPDATE(Parent->_inverted_index_searcher_cache_miss_counter,        
                  \
+                   stats.inverted_index_searcher_cache_miss);                  
                  \
+    COUNTER_UPDATE(Parent->_inverted_index_downgrade_count_counter,            
                  \
+                   stats.inverted_index_downgrade_count);                      
                  \
+    COUNTER_UPDATE(Parent->_inverted_index_analyzer_timer, 
stats.inverted_index_analyzer_timer); \
+    COUNTER_UPDATE(Parent->_inverted_index_lookup_timer, 
stats.inverted_index_lookup_timer);     \
+    InvertedIndexProfileReporter inverted_index_profile;                       
                  \
+    inverted_index_profile.update(Parent->_index_filter_profile.get(),         
                  \
+                                  &stats.inverted_index_stats);                
                  \
+    if (config::enable_file_cache) {                                           
                  \
+        io::FileCacheProfileReporter 
cache_profile(Parent->_segment_profile.get());              \
+        cache_profile.update(&stats.file_cache_stats);                         
                  \
+    }                                                                          
                  \
+    COUNTER_UPDATE(Parent->_output_index_result_column_timer,                  
                  \
+                   stats.output_index_result_column_timer);                    
                  \
+    COUNTER_UPDATE(Parent->_filtered_segment_counter, 
stats.filtered_segment_number);            \
     COUNTER_UPDATE(Parent->_total_segment_counter, stats.total_segment_number);
 
     // Update counters for NewOlapScanner


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to