Skip to content

Commit e3948fd

Browse files
committed
[improvement](be) Reuse Parquet profile counters across external scan files
### What problem does this PR solve? Issue Number: None Problem Summary: External small-file scans repeatedly initialize the same Parquet profile counter hierarchy for each file, contending on the shared RuntimeProfile registration lock. FileReader::init also repeats the concrete reader's initialization. Initialize counters once per scan instance and pass the immutable handles through table-reader wrappers to Parquet readers. Keep distinct scan instances separate. Group the shared Variant counters into one retained bundle so deferred materialization can safely outlive the scanner without copying a shared_ptr for every counter. This change applies to native Parquet reads across Hive, Iceberg, Hudi, Paimon and Fluss table-reader wrappers. It does not add speculative I/O or change the file reader's selection and decoding behavior. ### Release note Reduce profile initialization and counter ownership overhead when scanning many small Parquet files. ### Check List (For Author) - Test: Unit Test and Manual Test - New profile-cache tests cover concurrent initialization, counter aggregation, independent scan instances, no-profile readers and retained Variant counter lifetime - Reader tests cover one initialization per file and sharing across files - run-be-ut.sh: 585 tests across 13 Parquet, ORC, Variant and Hive/Iceberg/Hudi/Paimon/table-reader suites passed with ASAN - Fresh Linux AArch64 build.sh --be -j3 baseline and optimized RELEASE builds passed - clang-format16 and header hygiene passed; preset clang-tidy passed all 19 changed files against the matching ASAN compilation database - Isolated Release SQL results and a comparison with identical FE source are reported below - Behavior changed: No; preserve results and profile counter semantics - Does this need documentation: No ### Performance validation Complete SQL medians in milliseconds, matching Linux AArch64 Release BE, single backend, 6 CPUs, warm footer/data cache. Both settings are fixed: `split_batch_size=1`, `split_queue_capacity=4096`. Each single-query result has 40 measured samples in forward/reverse order after identical warmup. Cold denotes catalog/manifest cache invalidation, not a cold JVM or BE data cache. COUNT and SUM results are checked, and post-timing profiles verify footer/page hits. To isolate the BE change from a pre-existing FE EOF polling race, both columns below use exactly the same FE source containing its notification fix; only the Release BE package changes. | Warm full-scan scenario | Original BE, same fixed FE | This BE, same fixed FE | Reduction | |---|---:|---:|---:| | Hive 1,000 partitions | 60.77 | 16.39 | 73.0% | | Hive 10,000 partitions | 738.04 | 120.15 | 83.7% | | Hive one partition / 10,000 files | 495.15 | 74.42 | 85.0% | | Iceberg 1,000 manifests / 10,000 files | 503.25 | 81.46 | 83.8% | On unchanged baseline FE, independent BE-only single-query medians were 22.89 ms for Hive 1,000 partitions, 230.37 ms for Hive 10,000 partitions, 117.95 ms for Hive one partition with 10,000 files and 138.38 ms for Iceberg 1,000 manifests. The faster BE exposed an existing FE terminal-queue poll: 78 delayed empty requests in a 400-SQL diagnostic; one finished production at 0.148 ms but returned at 100.911 ms. The companion FE scan/scheduling PR fixes terminal notification, verified with zero such delays on replay. Merge the FE notification fix first when assessing concurrent latency; the BE patch has no code dependency on it.
1 parent e0bf487 commit e3948fd

19 files changed

Lines changed: 352 additions & 91 deletions

‎be/src/exec/operator/file_scan_operator.cpp‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -35,6 +35,7 @@
3535
#include "exec/scan/scanner_context.h"
3636
#include "format/format_common.h"
3737
#include "format/table/iceberg_scan_semantics.h"
38+
#include "format_v2/parquet/parquet_profile.h"
3839
#include "storage/storage_engine.h"
3940
#include "storage/tablet/tablet_manager.h"
4041

@@ -69,6 +70,11 @@ int file_scanners_per_instance(RuntimeState* state) {
6970

7071
} // namespace
7172

73+
FileScanLocalState::FileScanLocalState(RuntimeState* state, OperatorXBase* parent)
74+
: ScanLocalState<FileScanLocalState>(state, parent) {}
75+
76+
FileScanLocalState::~FileScanLocalState() = default;
77+
7278
PushDownType FileScanLocalState::_should_push_down_binary_predicate(
7379
VectorizedFnCall* fn_call, VExprContext* expr_ctx, Field& constant_val,
7480
const std::set<std::string> fn_name) const {
@@ -232,6 +238,10 @@ Status FileScanLocalState::_init_scanners(std::list<ScannerSPtr>* scanners) {
232238
"External VARIANT columns require FileScannerV2; the legacy file scanner does "
233239
"not support VARIANT");
234240
}
241+
if (use_file_scanner_v2) {
242+
_parquet_profile_cache =
243+
std::make_unique<format::parquet::ParquetProfileCache>(_scanner_profile.get());
244+
}
235245
for (int i = 0; i < _max_scanners; ++i) {
236246
ScannerSPtr scanner;
237247
if (use_file_scanner_v2) {

‎be/src/exec/operator/file_scan_operator.h‎

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,10 @@
2727
#include "exec/scan/split_source_connector.h"
2828
#include "format/format_common.h"
2929

30+
namespace doris::format::parquet {
31+
class ParquetProfileCache;
32+
}
33+
3034
namespace doris {
3135
class FileScanner;
3236
class FileScannerV2;
@@ -40,8 +44,8 @@ class FileScanLocalState final : public ScanLocalState<FileScanLocalState> {
4044
using Parent = FileScanOperatorX;
4145
using Base = ScanLocalState<FileScanLocalState>;
4246
ENABLE_FACTORY_CREATOR(FileScanLocalState);
43-
FileScanLocalState(RuntimeState* state, OperatorXBase* parent)
44-
: ScanLocalState<FileScanLocalState>(state, parent) {}
47+
FileScanLocalState(RuntimeState* state, OperatorXBase* parent);
48+
~FileScanLocalState() override;
4549

4650
Status init(RuntimeState* state, LocalStateInfo& info) override;
4751

@@ -85,6 +89,7 @@ class FileScanLocalState final : public ScanLocalState<FileScanLocalState> {
8589
VectorizedFnCall* fn_call, VExprContext* expr_ctx, Field& constant_val,
8690
const std::set<std::string> fn_name) const override;
8791
std::shared_ptr<SplitSourceConnector> _split_source = nullptr;
92+
std::unique_ptr<format::parquet::ParquetProfileCache> _parquet_profile_cache;
8893
int _max_scanners;
8994
TupleId _output_tuple_id = -1;
9095
};

‎be/src/exec/scan/file_scanner_v2.cpp‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -400,7 +400,8 @@ FileScannerV2::FileScannerV2(RuntimeState* state, FileScanLocalState* local_stat
400400
const std::unordered_map<std::string, int>* colname_to_slot_id)
401401
: Scanner(state, local_state, limit, profile),
402402
_split_source(std::move(split_source)),
403-
_kv_cache(kv_cache) {
403+
_kv_cache(kv_cache),
404+
_parquet_profile_cache(local_state->_parquet_profile_cache.get()) {
404405
(void)colname_to_slot_id;
405406
if (state->get_query_ctx() != nullptr &&
406407
state->get_query_ctx()->file_scan_range_params_map.count(local_state->parent_id()) > 0) {
@@ -660,6 +661,7 @@ Status FileScannerV2::_init_table_reader(const TFileRangeDesc& range) {
660661
.io_ctx = _io_ctx,
661662
.runtime_state = _state,
662663
.scanner_profile = _local_state != nullptr ? _local_state->scanner_profile() : _profile,
664+
.parquet_profile_cache = _parquet_profile_cache,
663665
.file_slot_descs = &_file_slot_descs,
664666
.push_down_agg_type = _local_state != nullptr ? _local_state->get_push_down_agg_type()
665667
: TPushAggOp::type::NONE,

‎be/src/exec/scan/file_scanner_v2.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -222,6 +222,7 @@ class FileScannerV2 final : public Scanner {
222222
std::unique_ptr<io::FileReaderStats> _file_reader_stats;
223223
std::shared_ptr<io::IOContext> _io_ctx;
224224
ShardedKVCache* _kv_cache = nullptr;
225+
format::parquet::ParquetProfileCache* _parquet_profile_cache = nullptr;
225226

226227
RuntimeProfile::Counter* _scanner_total_timer = nullptr;
227228
RuntimeProfile::Counter* _init_timer = nullptr;

‎be/src/format_v2/file_reader.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -97,7 +97,7 @@ std::string FileScanRequest::debug_string() const {
9797
}
9898

9999
Status FileReader::init(RuntimeState* state) {
100-
_init_profile();
100+
// Concrete readers initialize their counters before starting their lifecycle timers.
101101
SCOPED_RAW_TIMER(&_reader_statistics.file_reader_create_time);
102102
++_reader_statistics.open_file_num;
103103
io::FileReaderOptions reader_options =

‎be/src/format_v2/parquet/parquet_profile.cpp‎

Lines changed: 26 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,11 @@
2222

2323
namespace doris::format::parquet {
2424

25+
const ParquetProfile& ParquetProfileCache::get() {
26+
std::call_once(_initialized, [this] { _counters.init(_profile); });
27+
return _counters;
28+
}
29+
2530
namespace {
2631

2732
std::shared_ptr<RuntimeProfile::Counter> add_persistent_counter(RuntimeProfile* profile,
@@ -107,34 +112,36 @@ void ParquetProfile::init(RuntimeProfile* profile) {
107112
ADD_CHILD_TIMER_WITH_LEVEL(profile, "LevelOnlySkipTime", parquet_profile, 1);
108113
materialization_time =
109114
ADD_CHILD_TIMER_WITH_LEVEL(profile, "MaterializationTime", parquet_profile, 1);
110-
variant_reconstruction_time = add_persistent_counter(profile, "VariantReconstructionTime",
111-
TUnit::TIME_NS, parquet_profile);
112-
variant_reconstructed_rows = add_persistent_counter(profile, "VariantReconstructedRows",
113-
TUnit::UNIT, parquet_profile);
114-
variant_unshredded_direct_import_time = add_persistent_counter(
115+
auto variant = std::make_shared<ParquetVariantProfile>();
116+
variant->variant_reconstruction_time = add_persistent_counter(
117+
profile, "VariantReconstructionTime", TUnit::TIME_NS, parquet_profile);
118+
variant->variant_reconstructed_rows = add_persistent_counter(
119+
profile, "VariantReconstructedRows", TUnit::UNIT, parquet_profile);
120+
variant->variant_unshredded_direct_import_time = add_persistent_counter(
115121
profile, "VariantUnshreddedDirectImportTime", TUnit::TIME_NS, parquet_profile);
116-
variant_unshredded_direct_import_rows = add_persistent_counter(
122+
variant->variant_unshredded_direct_import_rows = add_persistent_counter(
117123
profile, "VariantUnshreddedDirectImportRows", TUnit::UNIT, parquet_profile);
118-
variant_unshredded_direct_import_bytes = add_persistent_counter(
124+
variant->variant_unshredded_direct_import_bytes = add_persistent_counter(
119125
profile, "VariantUnshreddedDirectImportBytes", TUnit::BYTES, parquet_profile);
120-
variant_unshredded_direct_seek_time = add_persistent_counter(
126+
variant->variant_unshredded_direct_seek_time = add_persistent_counter(
121127
profile, "VariantUnshreddedDirectSeekTime", TUnit::TIME_NS, parquet_profile);
122-
variant_unshredded_direct_seek_rows = add_persistent_counter(
128+
variant->variant_unshredded_direct_seek_rows = add_persistent_counter(
123129
profile, "VariantUnshreddedDirectSeekRows", TUnit::UNIT, parquet_profile);
124-
variant_unshredded_direct_seek_bytes = add_persistent_counter(
130+
variant->variant_unshredded_direct_seek_bytes = add_persistent_counter(
125131
profile, "VariantUnshreddedDirectSeekBytes", TUnit::BYTES, parquet_profile);
126-
variant_unshredded_prefix_reuse_rows = add_persistent_counter(
132+
variant->variant_unshredded_prefix_reuse_rows = add_persistent_counter(
127133
profile, "VariantUnshreddedPrefixReuseRows", TUnit::UNIT, parquet_profile);
128-
variant_direct_subtree_rows = add_persistent_counter(profile, "VariantDirectSubtreeRows",
129-
TUnit::UNIT, parquet_profile);
130-
variant_direct_leaf_rows =
134+
variant->variant_direct_subtree_rows = add_persistent_counter(
135+
profile, "VariantDirectSubtreeRows", TUnit::UNIT, parquet_profile);
136+
variant->variant_direct_leaf_rows =
131137
add_persistent_counter(profile, "VariantDirectLeafRows", TUnit::UNIT, parquet_profile);
132-
variant_direct_leaf_path_misses = add_persistent_counter(profile, "VariantDirectLeafPathMisses",
133-
TUnit::UNIT, parquet_profile);
134-
variant_direct_leaf_residual_fallbacks = add_persistent_counter(
138+
variant->variant_direct_leaf_path_misses = add_persistent_counter(
139+
profile, "VariantDirectLeafPathMisses", TUnit::UNIT, parquet_profile);
140+
variant->variant_direct_leaf_residual_fallbacks = add_persistent_counter(
135141
profile, "VariantDirectLeafResidualFallbacks", TUnit::UNIT, parquet_profile);
136-
variant_direct_leaf_unsupported_fallbacks = add_persistent_counter(
142+
variant->variant_direct_leaf_unsupported_fallbacks = add_persistent_counter(
137143
profile, "VariantDirectLeafUnsupportedFallbacks", TUnit::UNIT, parquet_profile);
144+
variant_counters = std::move(variant);
138145
hybrid_selection_batches = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "HybridSelectionBatches",
139146
TUnit::UNIT, parquet_profile, 1);
140147
hybrid_selection_ranges = ADD_CHILD_COUNTER_WITH_LEVEL(profile, "HybridSelectionRanges",
@@ -363,20 +370,7 @@ ParquetColumnReaderProfile ParquetProfile::column_reader_profile() const {
363370
.level_only_read_time = level_only_read_time,
364371
.level_only_skip_time = level_only_skip_time,
365372
.materialization_time = materialization_time,
366-
.variant_reconstruction_time = variant_reconstruction_time,
367-
.variant_reconstructed_rows = variant_reconstructed_rows,
368-
.variant_unshredded_direct_import_time = variant_unshredded_direct_import_time,
369-
.variant_unshredded_direct_import_rows = variant_unshredded_direct_import_rows,
370-
.variant_unshredded_direct_import_bytes = variant_unshredded_direct_import_bytes,
371-
.variant_unshredded_direct_seek_time = variant_unshredded_direct_seek_time,
372-
.variant_unshredded_direct_seek_rows = variant_unshredded_direct_seek_rows,
373-
.variant_unshredded_direct_seek_bytes = variant_unshredded_direct_seek_bytes,
374-
.variant_unshredded_prefix_reuse_rows = variant_unshredded_prefix_reuse_rows,
375-
.variant_direct_subtree_rows = variant_direct_subtree_rows,
376-
.variant_direct_leaf_rows = variant_direct_leaf_rows,
377-
.variant_direct_leaf_path_misses = variant_direct_leaf_path_misses,
378-
.variant_direct_leaf_residual_fallbacks = variant_direct_leaf_residual_fallbacks,
379-
.variant_direct_leaf_unsupported_fallbacks = variant_direct_leaf_unsupported_fallbacks,
373+
.variant_counters = variant_counters,
380374
.hybrid_selection_batches = hybrid_selection_batches,
381375
.hybrid_selection_ranges = hybrid_selection_ranges,
382376
.hybrid_selection_null_fallback_batches = hybrid_selection_null_fallback_batches,

‎be/src/format_v2/parquet/parquet_profile.h‎

Lines changed: 44 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,7 @@
1616
#pragma once
1717

1818
#include <memory>
19+
#include <mutex>
1920

2021
#include "runtime/runtime_profile.h"
2122

@@ -32,14 +33,9 @@ struct ParquetPageSkipProfile {
3233

3334
// ============================================================================
3435
// ============================================================================
35-
struct ParquetColumnReaderProfile {
36-
RuntimeProfile::Counter* reader_read_rows = nullptr; // rows read by read()
37-
RuntimeProfile::Counter* reader_skip_rows = nullptr; // rows skipped by skip()
38-
RuntimeProfile::Counter* reader_select_rows = nullptr; // rows selected by select()
39-
// COUNT(nullable_col) shape-only path; ordinary scans keep both counters zero.
40-
RuntimeProfile::Counter* level_only_read_time = nullptr;
41-
RuntimeProfile::Counter* level_only_skip_time = nullptr;
42-
RuntimeProfile::Counter* materialization_time = nullptr; // value materialization time (ns)
36+
// Deferred Variant columns can outlive the scanner. This bundle retains all their counters,
37+
// while ordinary file/column reader copies only increment one shared reference count.
38+
struct ParquetVariantProfile {
4339
std::shared_ptr<RuntimeProfile::Counter> variant_reconstruction_time;
4440
std::shared_ptr<RuntimeProfile::Counter> variant_reconstructed_rows;
4541
// Complete unshredded roots imported without rebuilding their Variant value tree. Bytes count
@@ -57,6 +53,24 @@ struct ParquetColumnReaderProfile {
5753
std::shared_ptr<RuntimeProfile::Counter> variant_direct_leaf_path_misses;
5854
std::shared_ptr<RuntimeProfile::Counter> variant_direct_leaf_residual_fallbacks;
5955
std::shared_ptr<RuntimeProfile::Counter> variant_direct_leaf_unsupported_fallbacks;
56+
};
57+
58+
struct ParquetColumnReaderProfile {
59+
RuntimeProfile::Counter* reader_read_rows = nullptr; // rows read by read()
60+
RuntimeProfile::Counter* reader_skip_rows = nullptr; // rows skipped by skip()
61+
RuntimeProfile::Counter* reader_select_rows = nullptr; // rows selected by select()
62+
// COUNT(nullable_col) shape-only path; ordinary scans keep both counters zero.
63+
RuntimeProfile::Counter* level_only_read_time = nullptr;
64+
RuntimeProfile::Counter* level_only_skip_time = nullptr;
65+
RuntimeProfile::Counter* materialization_time = nullptr; // value materialization time (ns)
66+
// One ownership reference per profile copy, rather than one per Variant counter.
67+
std::shared_ptr<const ParquetVariantProfile> variant_counters;
68+
69+
const ParquetVariantProfile& variant_profile() const {
70+
static const ParquetVariantProfile disabled;
71+
return variant_counters ? *variant_counters : disabled;
72+
}
73+
6074
RuntimeProfile::Counter* hybrid_selection_batches = nullptr;
6175
RuntimeProfile::Counter* hybrid_selection_ranges = nullptr;
6276
RuntimeProfile::Counter* hybrid_selection_null_fallback_batches = nullptr;
@@ -190,21 +204,14 @@ struct ParquetProfile {
190204
RuntimeProfile::Counter* level_only_read_time = nullptr;
191205
RuntimeProfile::Counter* level_only_skip_time = nullptr;
192206
RuntimeProfile::Counter* materialization_time = nullptr;
193-
std::shared_ptr<RuntimeProfile::Counter> variant_reconstruction_time;
194-
std::shared_ptr<RuntimeProfile::Counter> variant_reconstructed_rows;
195-
// These counters are persistent because direct import can happen after scanner teardown.
196-
std::shared_ptr<RuntimeProfile::Counter> variant_unshredded_direct_import_time;
197-
std::shared_ptr<RuntimeProfile::Counter> variant_unshredded_direct_import_rows;
198-
std::shared_ptr<RuntimeProfile::Counter> variant_unshredded_direct_import_bytes;
199-
std::shared_ptr<RuntimeProfile::Counter> variant_unshredded_direct_seek_time;
200-
std::shared_ptr<RuntimeProfile::Counter> variant_unshredded_direct_seek_rows;
201-
std::shared_ptr<RuntimeProfile::Counter> variant_unshredded_direct_seek_bytes;
202-
std::shared_ptr<RuntimeProfile::Counter> variant_unshredded_prefix_reuse_rows;
203-
std::shared_ptr<RuntimeProfile::Counter> variant_direct_subtree_rows;
204-
std::shared_ptr<RuntimeProfile::Counter> variant_direct_leaf_rows;
205-
std::shared_ptr<RuntimeProfile::Counter> variant_direct_leaf_path_misses;
206-
std::shared_ptr<RuntimeProfile::Counter> variant_direct_leaf_residual_fallbacks;
207-
std::shared_ptr<RuntimeProfile::Counter> variant_direct_leaf_unsupported_fallbacks;
207+
// One ownership reference per profile copy, rather than one per Variant counter.
208+
std::shared_ptr<const ParquetVariantProfile> variant_counters;
209+
210+
const ParquetVariantProfile& variant_profile() const {
211+
static const ParquetVariantProfile disabled;
212+
return variant_counters ? *variant_counters : disabled;
213+
}
214+
208215
RuntimeProfile::Counter* hybrid_selection_batches = nullptr;
209216
RuntimeProfile::Counter* hybrid_selection_ranges = nullptr;
210217
RuntimeProfile::Counter* hybrid_selection_null_fallback_batches = nullptr;
@@ -288,4 +295,18 @@ struct ParquetProfile {
288295
RuntimeProfile::Counter* bloom_filter_read_time = nullptr;
289296
};
290297

298+
// One immutable counter set per scanner RuntimeProfile. Readers copy its handles instead of
299+
// registering every counter again for each file. Lazy initialization keeps other formats' profiles
300+
// free of unused Parquet counters.
301+
class ParquetProfileCache {
302+
public:
303+
explicit ParquetProfileCache(RuntimeProfile* profile) : _profile(profile) {}
304+
const ParquetProfile& get();
305+
306+
private:
307+
RuntimeProfile* _profile;
308+
std::once_flag _initialized;
309+
ParquetProfile _counters;
310+
};
311+
291312
} // namespace doris::format::parquet

‎be/src/format_v2/parquet/parquet_reader.cpp‎

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -575,8 +575,9 @@ ParquetReader::ParquetReader(std::shared_ptr<io::FileSystemProperties>& system_p
575575
std::optional<format::GlobalRowIdContext> global_rowid_context,
576576
bool enable_mapping_timestamp_tz, bool enable_mapping_varbinary,
577577
std::optional<std::string> hive_parquet_time_zone,
578-
bool preserve_binary_uuid)
578+
bool preserve_binary_uuid, ParquetProfileCache* profile_cache)
579579
: FileReader(system_properties, file_description, io_ctx, profile),
580+
_profile_cache(profile_cache),
580581
_global_rowid_context(global_rowid_context),
581582
_enable_mapping_timestamp_tz(enable_mapping_timestamp_tz),
582583
_enable_mapping_varbinary(enable_mapping_varbinary),
@@ -1098,7 +1099,12 @@ Status ParquetReader::close() {
10981099
}
10991100

11001101
void ParquetReader::_init_profile() {
1101-
_parquet_profile.init(_profile);
1102+
if (_profile_cache != nullptr) {
1103+
_parquet_profile = _profile_cache->get();
1104+
} else {
1105+
// Standalone readers do not have a scan instance to own a shared counter set.
1106+
_parquet_profile.init(_profile);
1107+
}
11021108
}
11031109

11041110
} // namespace doris::format::parquet

‎be/src/format_v2/parquet/parquet_reader.h‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -49,7 +49,7 @@ class ParquetReader : public format::FileReader {
4949
std::optional<format::GlobalRowIdContext> global_rowid_context = std::nullopt,
5050
bool enable_mapping_timestamp_tz = false, bool enable_mapping_varbinary = false,
5151
std::optional<std::string> hive_parquet_time_zone = std::nullopt,
52-
bool preserve_binary_uuid = false);
52+
bool preserve_binary_uuid = false, ParquetProfileCache* profile_cache = nullptr);
5353
~ParquetReader() override;
5454

5555
Status init(RuntimeState* state) override;
@@ -93,6 +93,7 @@ class ParquetReader : public format::FileReader {
9393
std::unique_ptr<ParquetReaderScanState>
9494
_state; // complete scan state (file_context + schema + scheduler)
9595
ParquetProfile _parquet_profile; // RuntimeProfile counter set
96+
ParquetProfileCache* _profile_cache;
9697
ParquetPageCacheStats _reported_page_cache_stats;
9798
std::optional<format::GlobalRowIdContext> _global_rowid_context; // global RowId context
9899
size_t _batch_size = ParquetScanScheduler::DEFAULT_READ_BATCH_SIZE;

0 commit comments

Comments
 (0)