Coverage Report

Created: 2026-07-28 18:36

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
be/src/format_v2/parquet/parquet_profile.cpp
Line
Count
Source
1
// Licensed to the Apache Software Foundation (ASF) under one
2
// or more contributor license agreements.  See the NOTICE file
3
// distributed with this work for additional information
4
// regarding copyright ownership.  The ASF licenses this file
5
// to you under the Apache License, Version 2.0 (the
6
// "License"); you may not use this file except in compliance
7
// with the License.  You may obtain a copy of the License at
8
//
9
//   http://www.apache.org/licenses/LICENSE-2.0
10
//
11
// Unless required by applicable law or agreed to in writing,
12
// software distributed under the License is distributed on an
13
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14
// KIND, either express or implied.  See the License for the
15
// specific language governing permissions and limitations
16
// under the License.
17
18
#include "format_v2/parquet/parquet_profile.h"
19
20
#include "format_v2/parquet/parquet_statistics.h"
21
#include "runtime/file_scan_profile.h"
22
23
namespace doris::format::parquet {
24
25
474
void ParquetProfile::init(RuntimeProfile* profile) {
26
474
    if (profile == nullptr) {
27
206
        return;
28
206
    }
29
30
268
    file_scan_profile::ensure_hierarchy(profile);
31
268
    static const char* parquet_profile = "ParquetReader";
32
268
    total_time =
33
268
            ADD_CHILD_TIMER_WITH_LEVEL(profile, parquet_profile, file_scan_profile::FILE_READER, 1);
34
35
    // Row-group counters are part of the long-standing ParquetReader profile contract. Keep them
36
    // below the format node so profile parsers and operators can attribute pruning to Parquet.
37
268
    filtered_row_groups = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "RowGroupsFiltered", TUnit::UNIT,
38
268
                                                       parquet_profile, 1);
39
268
    filtered_row_groups_by_min_max = ADD_CHILD_COUNTER_WITH_LEVEL(
40
268
            profile, "RowGroupsFilteredByMinMax", TUnit::UNIT, parquet_profile, 1);
41
268
    filtered_row_groups_by_dictionary = ADD_CHILD_COUNTER_WITH_LEVEL(
42
268
            profile, "RowGroupsFilteredByDictionary", TUnit::UNIT, parquet_profile, 1);
43
268
    filtered_row_groups_by_bloom_filter = ADD_CHILD_COUNTER_WITH_LEVEL(
44
268
            profile, "RowGroupsFilteredByBloomFilter", TUnit::UNIT, parquet_profile, 1);
45
268
    filtered_row_groups_by_page_index = ADD_CHILD_COUNTER_WITH_LEVEL(
46
268
            profile, "RowGroupsFilteredByPageIndex", TUnit::UNIT, parquet_profile, 1);
47
268
    to_read_row_groups = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "RowGroupsReadNum", TUnit::UNIT,
48
268
                                                      parquet_profile, 1);
49
268
    total_row_groups = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "RowGroupsTotalNum", TUnit::UNIT,
50
268
                                                    parquet_profile, 1);
51
268
    selected_row_ranges = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "SelectedRowRanges", TUnit::UNIT,
52
268
                                                       parquet_profile, 1);
53
268
    filtered_group_rows = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "FilteredRowsByGroup", TUnit::UNIT,
54
268
                                                       parquet_profile, 1);
55
268
    filtered_page_rows = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "FilteredRowsByPage", TUnit::UNIT,
56
268
                                                      parquet_profile, 1);
57
268
    pages_skipped_by_data_page_filter = ADD_CHILD_COUNTER_WITH_LEVEL(
58
268
            profile, "PagesSkippedByDataPageFilter", TUnit::UNIT, parquet_profile, 1);
59
268
    data_page_filter_skip_bytes = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "DataPageFilterSkipBytes",
60
268
                                                               TUnit::BYTES, parquet_profile, 1);
61
268
    selected_rows =
62
268
            ADD_CHILD_COUNTER_WITH_LEVEL(profile, "SelectedRows", TUnit::UNIT, parquet_profile, 1);
63
    // Keep every Parquet scan metric below the format node: profile consumers extract that
64
    // subtree and otherwise silently lose this counter even though filtering happened.
65
268
    rows_filtered_by_conjunct = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "RowsFilteredByConjunct",
66
268
                                                             TUnit::UNIT, parquet_profile, 1);
67
268
    total_batches =
68
268
            ADD_CHILD_COUNTER_WITH_LEVEL(profile, "TotalBatches", TUnit::UNIT, parquet_profile, 1);
69
268
    dense_batches =
70
268
            ADD_CHILD_COUNTER_WITH_LEVEL(profile, "DenseBatches", TUnit::UNIT, parquet_profile, 1);
71
268
    selected_batches = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "SelectedBatches", TUnit::UNIT,
72
268
                                                    parquet_profile, 1);
73
268
    empty_selection_batches = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "EmptySelectionBatches",
74
268
                                                           TUnit::UNIT, parquet_profile, 1);
75
268
    range_gap_skipped_rows = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "RangeGapSkippedRows",
76
268
                                                          TUnit::UNIT, parquet_profile, 1);
77
268
    reader_read_rows = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "ReaderReadRows", TUnit::UNIT,
78
268
                                                    parquet_profile, 1);
79
268
    reader_skip_rows = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "ReaderSkipRows", TUnit::UNIT,
80
268
                                                    parquet_profile, 1);
81
268
    reader_select_rows = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "ReaderSelectRows", TUnit::UNIT,
82
268
                                                      parquet_profile, 1);
83
268
    level_only_read_time =
84
268
            ADD_CHILD_TIMER_WITH_LEVEL(profile, "LevelOnlyReadTime", parquet_profile, 1);
85
268
    level_only_skip_time =
86
268
            ADD_CHILD_TIMER_WITH_LEVEL(profile, "LevelOnlySkipTime", parquet_profile, 1);
87
268
    materialization_time =
88
268
            ADD_CHILD_TIMER_WITH_LEVEL(profile, "MaterializationTime", parquet_profile, 1);
89
268
    hybrid_selection_batches = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "HybridSelectionBatches",
90
268
                                                            TUnit::UNIT, parquet_profile, 1);
91
268
    hybrid_selection_ranges = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "HybridSelectionRanges",
92
268
                                                           TUnit::UNIT, parquet_profile, 1);
93
268
    hybrid_selection_null_fallback_batches = ADD_CHILD_COUNTER_WITH_LEVEL(
94
268
            profile, "HybridSelectionNullFallbackBatches", TUnit::UNIT, parquet_profile, 1);
95
268
    native_read_calls = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "NativeReadCalls", TUnit::UNIT,
96
268
                                                     parquet_profile, 1);
97
268
    native_page_fragments = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "NativePageFragments",
98
268
                                                         TUnit::UNIT, parquet_profile, 1);
99
268
    page_crossing_batches = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "PageCrossingBatches",
100
268
                                                         TUnit::UNIT, parquet_profile, 1);
101
268
    nested_batches =
102
268
            ADD_CHILD_COUNTER_WITH_LEVEL(profile, "NestedBatches", TUnit::UNIT, parquet_profile, 1);
103
268
    lazy_read_filtered_rows = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "FilteredRowsByLazyRead",
104
268
                                                           TUnit::UNIT, parquet_profile, 1);
105
    // Format-specific counters stay below ParquetReader so subtree consumers cannot silently
106
    // attribute them to a different file format initialized on the same RuntimeProfile.
107
268
    filtered_bytes = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "FilteredBytes", TUnit::BYTES,
108
268
                                                  parquet_profile, 1);
109
268
    raw_rows_read =
110
268
            ADD_CHILD_COUNTER_WITH_LEVEL(profile, "RawRowsRead", TUnit::UNIT, parquet_profile, 1);
111
268
    column_read_time = ADD_CHILD_TIMER_WITH_LEVEL(profile, "ColumnReadTime", parquet_profile, 1);
112
268
    parse_meta_time = ADD_CHILD_TIMER_WITH_LEVEL(profile, "ParseMetaTime", parquet_profile, 1);
113
268
    parse_footer_time = ADD_CHILD_TIMER_WITH_LEVEL(profile, "ParseFooterTime", parquet_profile, 1);
114
268
    file_reader_create_time =
115
268
            ADD_CHILD_TIMER_WITH_LEVEL(profile, "FileReaderCreateTime", parquet_profile, 1);
116
268
    open_file_num =
117
268
            ADD_CHILD_COUNTER_WITH_LEVEL(profile, "FileNum", TUnit::UNIT, parquet_profile, 1);
118
268
    page_index_read_calls = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "PageIndexReadCalls", TUnit::UNIT,
119
268
                                                         parquet_profile, 1);
120
268
    page_index_filter_time =
121
268
            ADD_CHILD_TIMER_WITH_LEVEL(profile, "PageIndexFilterTime", parquet_profile, 1);
122
268
    read_page_index_time =
123
268
            ADD_CHILD_TIMER_WITH_LEVEL(profile, "PageIndexReadTime", parquet_profile, 1);
124
268
    parse_page_index_time =
125
268
            ADD_CHILD_TIMER_WITH_LEVEL(profile, "PageIndexParseTime", parquet_profile, 1);
126
268
    expr_zonemap_unusable = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "ExprZoneMapUnusableEvals",
127
268
                                                         TUnit::UNIT, parquet_profile, 1);
128
268
    in_zonemap_point_check = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "InZoneMapPointCheckCount",
129
268
                                                          TUnit::UNIT, parquet_profile, 1);
130
268
    in_zonemap_range_only = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "InZoneMapRangeOnlyCount",
131
268
                                                         TUnit::UNIT, parquet_profile, 1);
132
268
    row_group_filter_time =
133
268
            ADD_CHILD_TIMER_WITH_LEVEL(profile, "RowGroupFilterTime", parquet_profile, 1);
134
268
    file_footer_read_calls = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "FileFooterReadCalls",
135
268
                                                          TUnit::UNIT, parquet_profile, 1);
136
268
    file_footer_hit_cache = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "FileFooterHitCache", TUnit::UNIT,
137
268
                                                         parquet_profile, 1);
138
268
    decompress_time = ADD_CHILD_TIMER_WITH_LEVEL(profile, "DecompressTime", parquet_profile, 1);
139
268
    decompress_cnt = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "DecompressCount", TUnit::UNIT,
140
268
                                                  parquet_profile, 1);
141
268
    page_read_counter =
142
268
            ADD_CHILD_COUNTER_WITH_LEVEL(profile, "PageReadCount", TUnit::UNIT, parquet_profile, 1);
143
268
    page_cache_write_counter = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "PageCacheWriteCount",
144
268
                                                            TUnit::UNIT, parquet_profile, 1);
145
268
    page_cache_compressed_write_counter = ADD_CHILD_COUNTER_WITH_LEVEL(
146
268
            profile, "PageCacheCompressedWriteCount", TUnit::UNIT, parquet_profile, 1);
147
268
    page_cache_decompressed_write_counter = ADD_CHILD_COUNTER_WITH_LEVEL(
148
268
            profile, "PageCacheDecompressedWriteCount", TUnit::UNIT, parquet_profile, 1);
149
268
    page_cache_hit_counter = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "PageCacheHitCount", TUnit::UNIT,
150
268
                                                          parquet_profile, 1);
151
268
    page_cache_missing_counter = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "PageCacheMissingCount",
152
268
                                                              TUnit::UNIT, parquet_profile, 1);
153
268
    page_cache_compressed_hit_counter = ADD_CHILD_COUNTER_WITH_LEVEL(
154
268
            profile, "PageCacheCompressedHitCount", TUnit::UNIT, parquet_profile, 1);
155
268
    page_cache_decompressed_hit_counter = ADD_CHILD_COUNTER_WITH_LEVEL(
156
268
            profile, "PageCacheDecompressedHitCount", TUnit::UNIT, parquet_profile, 1);
157
268
    decode_header_time =
158
268
            ADD_CHILD_TIMER_WITH_LEVEL(profile, "PageHeaderDecodeTime", parquet_profile, 1);
159
268
    read_page_header_time =
160
268
            ADD_CHILD_TIMER_WITH_LEVEL(profile, "PageHeaderReadTime", parquet_profile, 1);
161
268
    decode_value_time = ADD_CHILD_TIMER_WITH_LEVEL(profile, "DecodeValueTime", parquet_profile, 1);
162
268
    decode_dict_time = ADD_CHILD_TIMER_WITH_LEVEL(profile, "DecodeDictTime", parquet_profile, 1);
163
268
    decode_level_time = ADD_CHILD_TIMER_WITH_LEVEL(profile, "DecodeLevelTime", parquet_profile, 1);
164
268
    decode_null_map_time =
165
268
            ADD_CHILD_TIMER_WITH_LEVEL(profile, "DecodeNullMapTime", parquet_profile, 1);
166
268
    skip_page_header_num = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "SkipPageHeaderNum", TUnit::UNIT,
167
268
                                                        parquet_profile, 1);
168
268
    parse_page_header_num = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "ParsePageHeaderNum", TUnit::UNIT,
169
268
                                                         parquet_profile, 1);
170
268
    predicate_filter_time =
171
268
            ADD_CHILD_TIMER_WITH_LEVEL(profile, "PredicateFilterTime", parquet_profile, 1);
172
268
    predicate_compaction_time =
173
268
            ADD_CHILD_TIMER_WITH_LEVEL(profile, "PredicateCompactionTime", parquet_profile, 1);
174
268
    predicate_compaction_bytes = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "PredicateCompactionBytes",
175
268
                                                              TUnit::BYTES, parquet_profile, 1);
176
268
    predicate_compaction_count = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "PredicateCompactionCount",
177
268
                                                              TUnit::UNIT, parquet_profile, 1);
178
268
    predicate_alignment_columns = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "PredicateAlignmentColumns",
179
268
                                                               TUnit::UNIT, parquet_profile, 1);
180
268
    fixed_width_predicate_direct_batches = ADD_CHILD_COUNTER_WITH_LEVEL(
181
268
            profile, "FixedWidthPredicateDirectBatches", TUnit::UNIT, parquet_profile, 1);
182
268
    fixed_width_predicate_direct_rows = ADD_CHILD_COUNTER_WITH_LEVEL(
183
268
            profile, "FixedWidthPredicateDirectRows", TUnit::UNIT, parquet_profile, 1);
184
268
    dictionary_predicate_direct_batches = ADD_CHILD_COUNTER_WITH_LEVEL(
185
268
            profile, "DictionaryPredicateDirectBatches", TUnit::UNIT, parquet_profile, 1);
186
268
    dictionary_predicate_direct_rows = ADD_CHILD_COUNTER_WITH_LEVEL(
187
268
            profile, "DictionaryPredicateDirectRows", TUnit::UNIT, parquet_profile, 1);
188
268
    dictionary_predicate_projected_rows = ADD_CHILD_COUNTER_WITH_LEVEL(
189
268
            profile, "DictionaryPredicateProjectedRows", TUnit::UNIT, parquet_profile, 1);
190
268
    dictionary_predicate_fused_projected_rows = ADD_CHILD_COUNTER_WITH_LEVEL(
191
268
            profile, "DictionaryPredicateFusedProjectedRows", TUnit::UNIT, parquet_profile, 1);
192
268
    dict_filter_rewrite_time =
193
268
            ADD_CHILD_TIMER_WITH_LEVEL(profile, "DictFilterRewriteTime", parquet_profile, 1);
194
268
    dict_filter_expr_rewrite_time =
195
268
            ADD_CHILD_TIMER_WITH_LEVEL(profile, "DictFilterExprRewriteTime", parquet_profile, 1);
196
268
    dict_filter_read_dict_time =
197
268
            ADD_CHILD_TIMER_WITH_LEVEL(profile, "DictFilterReadDictTime", parquet_profile, 1);
198
268
    dict_filter_build_time =
199
268
            ADD_CHILD_TIMER_WITH_LEVEL(profile, "DictFilterBuildTime", parquet_profile, 1);
200
268
    dict_filter_candidate_columns = ADD_CHILD_COUNTER_WITH_LEVEL(
201
268
            profile, "DictFilterCandidateColumns", TUnit::UNIT, parquet_profile, 1);
202
268
    dict_filter_columns = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "DictFilterColumns", TUnit::UNIT,
203
268
                                                       parquet_profile, 1);
204
268
    dict_filter_typed_compare_columns = ADD_CHILD_COUNTER_WITH_LEVEL(
205
268
            profile, "DictFilterTypedCompareColumns", TUnit::UNIT, parquet_profile, 1);
206
268
    dict_filter_string_compare_columns = ADD_CHILD_COUNTER_WITH_LEVEL(
207
268
            profile, "DictFilterStringCompareColumns", TUnit::UNIT, parquet_profile, 1);
208
268
    dict_filter_unsupported_columns = ADD_CHILD_COUNTER_WITH_LEVEL(
209
268
            profile, "DictFilterUnsupportedColumns", TUnit::UNIT, parquet_profile, 1);
210
268
    dict_filter_read_failures = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "DictFilterReadFailures",
211
268
                                                             TUnit::UNIT, parquet_profile, 1);
212
268
    rows_filtered_by_dict_filter = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "RowsFilteredByDictFilter",
213
268
                                                                TUnit::UNIT, parquet_profile, 1);
214
268
    bloom_filter_read_time =
215
268
            ADD_CHILD_TIMER_WITH_LEVEL(profile, "BloomFilterReadTime", parquet_profile, 1);
216
268
}
217
218
128
void ParquetProfile::update_pruning_stats(const ParquetPruningStats& pruning_stats) const {
219
128
    COUNTER_UPDATE(filtered_row_groups,
220
128
                   pruning_stats.total_row_groups - pruning_stats.selected_row_groups);
221
128
    COUNTER_UPDATE(filtered_row_groups_by_min_max, pruning_stats.filtered_row_groups_by_statistics);
222
128
    COUNTER_UPDATE(filtered_row_groups_by_dictionary,
223
128
                   pruning_stats.filtered_row_groups_by_dictionary);
224
128
    COUNTER_UPDATE(filtered_row_groups_by_bloom_filter,
225
128
                   pruning_stats.filtered_row_groups_by_bloom_filter);
226
128
    COUNTER_UPDATE(filtered_row_groups_by_page_index,
227
128
                   pruning_stats.filtered_row_groups_by_page_index);
228
128
    COUNTER_UPDATE(to_read_row_groups, pruning_stats.selected_row_groups);
229
128
    COUNTER_UPDATE(total_row_groups, pruning_stats.total_row_groups);
230
128
    COUNTER_UPDATE(selected_row_ranges, pruning_stats.selected_row_ranges);
231
128
    COUNTER_UPDATE(filtered_group_rows, pruning_stats.filtered_group_rows);
232
128
    COUNTER_UPDATE(filtered_bytes, pruning_stats.filtered_bytes);
233
128
    COUNTER_UPDATE(filtered_page_rows, pruning_stats.filtered_page_rows);
234
128
    COUNTER_UPDATE(page_index_read_calls, pruning_stats.page_index_read_calls);
235
128
    COUNTER_UPDATE(bloom_filter_read_time, pruning_stats.bloom_filter_read_time);
236
128
    COUNTER_UPDATE(row_group_filter_time, pruning_stats.row_group_filter_time);
237
128
    COUNTER_UPDATE(page_index_filter_time, pruning_stats.page_index_filter_time);
238
128
    COUNTER_UPDATE(read_page_index_time, pruning_stats.read_page_index_time);
239
128
    COUNTER_UPDATE(parse_page_index_time, pruning_stats.parse_page_index_time);
240
128
    COUNTER_UPDATE(expr_zonemap_unusable, pruning_stats.expr_zonemap_unusable_evals);
241
128
    COUNTER_UPDATE(in_zonemap_point_check, pruning_stats.in_zonemap_point_check_count);
242
128
    COUNTER_UPDATE(in_zonemap_range_only, pruning_stats.in_zonemap_range_only_count);
243
128
}
244
245
void ParquetProfile::update_deferred_pruning_stats(const ParquetPruningStats& pruning_stats,
246
144
                                                   bool selected) const {
247
144
    const int64_t filtered = selected ? 0 : 1;
248
144
    COUNTER_UPDATE(filtered_row_groups, filtered);
249
144
    COUNTER_UPDATE(filtered_row_groups_by_dictionary,
250
144
                   pruning_stats.filtered_row_groups_by_dictionary);
251
144
    COUNTER_UPDATE(filtered_row_groups_by_bloom_filter,
252
144
                   pruning_stats.filtered_row_groups_by_bloom_filter);
253
144
    COUNTER_UPDATE(filtered_row_groups_by_page_index,
254
144
                   pruning_stats.filtered_row_groups_by_page_index);
255
    // Initial footer planning counts every surviving candidate as readable. Lazy probes correct
256
    // that estimate only when a later dictionary, Bloom, or page-index check removes the group.
257
144
    COUNTER_UPDATE(to_read_row_groups, -filtered);
258
144
    COUNTER_UPDATE(selected_row_ranges, pruning_stats.selected_row_ranges);
259
144
    COUNTER_UPDATE(filtered_group_rows, pruning_stats.filtered_group_rows);
260
144
    COUNTER_UPDATE(filtered_bytes, pruning_stats.filtered_bytes);
261
144
    COUNTER_UPDATE(filtered_page_rows, pruning_stats.filtered_page_rows);
262
144
    COUNTER_UPDATE(page_index_read_calls, pruning_stats.page_index_read_calls);
263
144
    COUNTER_UPDATE(bloom_filter_read_time, pruning_stats.bloom_filter_read_time);
264
144
    COUNTER_UPDATE(row_group_filter_time, pruning_stats.row_group_filter_time);
265
144
    COUNTER_UPDATE(page_index_filter_time, pruning_stats.page_index_filter_time);
266
144
    COUNTER_UPDATE(read_page_index_time, pruning_stats.read_page_index_time);
267
144
    COUNTER_UPDATE(parse_page_index_time, pruning_stats.parse_page_index_time);
268
144
    COUNTER_UPDATE(expr_zonemap_unusable, pruning_stats.expr_zonemap_unusable_evals);
269
144
    COUNTER_UPDATE(in_zonemap_point_check, pruning_stats.in_zonemap_point_check_count);
270
144
    COUNTER_UPDATE(in_zonemap_range_only, pruning_stats.in_zonemap_range_only_count);
271
144
}
272
273
225
ParquetPageSkipProfile ParquetProfile::page_skip_profile() const {
274
225
    return {
275
225
            .skipped_pages = pages_skipped_by_data_page_filter,
276
225
            .skipped_bytes = data_page_filter_skip_bytes,
277
225
    };
278
225
}
279
280
485
ParquetColumnReaderProfile ParquetProfile::column_reader_profile() const {
281
485
    return {
282
485
            .reader_read_rows = reader_read_rows,
283
485
            .reader_skip_rows = reader_skip_rows,
284
485
            .reader_select_rows = reader_select_rows,
285
485
            .level_only_read_time = level_only_read_time,
286
485
            .level_only_skip_time = level_only_skip_time,
287
485
            .materialization_time = materialization_time,
288
485
            .hybrid_selection_batches = hybrid_selection_batches,
289
485
            .hybrid_selection_ranges = hybrid_selection_ranges,
290
485
            .hybrid_selection_null_fallback_batches = hybrid_selection_null_fallback_batches,
291
485
            .dictionary_predicate_fused_projected_rows = dictionary_predicate_fused_projected_rows,
292
485
            .decompress_time = decompress_time,
293
485
            .decompress_count = decompress_cnt,
294
485
            .decode_header_time = decode_header_time,
295
485
            .decode_value_time = decode_value_time,
296
485
            .decode_dictionary_time = decode_dict_time,
297
485
            .decode_level_time = decode_level_time,
298
485
            .decode_null_map_time = decode_null_map_time,
299
485
            .page_index_read_calls = page_index_read_calls,
300
485
            .skip_page_header_count = skip_page_header_num,
301
485
            .parse_page_header_count = parse_page_header_num,
302
485
            .read_page_header_time = read_page_header_time,
303
485
            .page_read_count = page_read_counter,
304
485
            .page_cache_write_count = page_cache_write_counter,
305
485
            .page_cache_compressed_write_count = page_cache_compressed_write_counter,
306
485
            .page_cache_decompressed_write_count = page_cache_decompressed_write_counter,
307
485
            .page_cache_hit_count = page_cache_hit_counter,
308
485
            .page_cache_miss_count = page_cache_missing_counter,
309
485
            .page_cache_compressed_hit_count = page_cache_compressed_hit_counter,
310
485
            .page_cache_decompressed_hit_count = page_cache_decompressed_hit_counter,
311
485
            .native_read_calls = native_read_calls,
312
485
            .native_page_fragments = native_page_fragments,
313
485
            .page_crossing_batches = page_crossing_batches,
314
485
            .nested_batches = nested_batches,
315
485
    };
316
485
}
317
318
232
ParquetScanProfile ParquetProfile::scan_profile() const {
319
232
    return {
320
232
            .raw_rows_read = raw_rows_read,
321
232
            .selected_rows = selected_rows,
322
232
            .rows_filtered_by_conjunct = rows_filtered_by_conjunct,
323
232
            .lazy_read_filtered_rows = lazy_read_filtered_rows,
324
232
            .total_batches = total_batches,
325
232
            .dense_batches = dense_batches,
326
232
            .selected_batches = selected_batches,
327
232
            .empty_selection_batches = empty_selection_batches,
328
232
            .range_gap_skipped_rows = range_gap_skipped_rows,
329
232
            .column_read_time = column_read_time,
330
232
            .predicate_filter_time = predicate_filter_time,
331
232
            .predicate_compaction_time = predicate_compaction_time,
332
232
            .predicate_compaction_bytes = predicate_compaction_bytes,
333
232
            .predicate_compaction_count = predicate_compaction_count,
334
232
            .predicate_alignment_columns = predicate_alignment_columns,
335
232
            .fixed_width_predicate_direct_batches = fixed_width_predicate_direct_batches,
336
232
            .fixed_width_predicate_direct_rows = fixed_width_predicate_direct_rows,
337
232
            .dictionary_predicate_direct_batches = dictionary_predicate_direct_batches,
338
232
            .dictionary_predicate_direct_rows = dictionary_predicate_direct_rows,
339
232
            .dictionary_predicate_projected_rows = dictionary_predicate_projected_rows,
340
232
            .dict_filter_rewrite_time = dict_filter_rewrite_time,
341
232
            .dict_filter_expr_rewrite_time = dict_filter_expr_rewrite_time,
342
232
            .dict_filter_read_dict_time = dict_filter_read_dict_time,
343
232
            .dict_filter_build_time = dict_filter_build_time,
344
232
            .dict_filter_candidate_columns = dict_filter_candidate_columns,
345
232
            .dict_filter_columns = dict_filter_columns,
346
232
            .dict_filter_typed_compare_columns = dict_filter_typed_compare_columns,
347
232
            .dict_filter_string_compare_columns = dict_filter_string_compare_columns,
348
232
            .dict_filter_unsupported_columns = dict_filter_unsupported_columns,
349
232
            .dict_filter_read_failures = dict_filter_read_failures,
350
232
            .rows_filtered_by_dict_filter = rows_filtered_by_dict_filter,
351
232
            .column_reader_profile = column_reader_profile(),
352
232
    };
353
232
}
354
355
} // namespace doris::format::parquet