Skip to content

Commit 93a3cec

Browse files
committed
[improvement](be) Prune rowsets by TSO before row binlog scans
### What problem does this PR solve? Issue Number: None Problem Summary: Bounded ROW binlog queries initialize readers and open segment footers for historical rowsets before their TSO predicates can reject them. Initialization work therefore grows with retained history even for narrow windows. After capturing a version-consistent read source, remove rowsets whose inclusive commit TSO range cannot intersect the query's half-open interval. For example, rowset [10,99] is excluded from query [100,200). Preserve unknown TSO metadata, overlapping compaction output, and separately captured delete predicates. Skip scanners when only empty rowsets remain so an empty source is not recaptured. Expose pruning time and rowset, segment, and tablet counts in the query profile. ### Release note Reduce reader initialization and segment footer IO for bounded ROW binlog queries. ### Check List (For Author) - Test: Unit Test / Regression test / Manual test - ASAN BE and FE build completed with build.sh. - 8 OlapScanOperatorTsoPruningTest and OlapScanOperatorBinlogPushDownTest tests passed. - test_binlog_rowset_tso_pruning and test_binlog_changes_syntax passed. - Generated the new regression output and reran it in comparison mode. - An empty-window profile pruned 2 rowsets / 2 segments and created 0 scanners. - clang-format 16, header hygiene, and clang-tidy passed. - Behavior changed: No (query results are unchanged; profile counters are added) - Does this need documentation: No
1 parent af7902c commit 93a3cec

5 files changed

Lines changed: 385 additions & 0 deletions

File tree

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

Lines changed: 50 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,7 @@
1919

2020
#include <fmt/format.h>
2121

22+
#include <algorithm>
2223
#include <memory>
2324
#include <numeric>
2425
#include <optional>
@@ -140,6 +141,13 @@ Status OlapScanLocalState::_init_profile() {
140141
// 2. init timer and counters
141142
_reader_init_timer = ADD_TIMER(_scanner_profile, "ReaderInitTime");
142143
_scanner_init_timer = ADD_TIMER(_scanner_profile, "ScannerInitTime");
144+
_rowset_tso_prune_timer = ADD_TIMER(custom_profile(), "RowsetTsoPruneTime");
145+
_rowsets_pruned_by_tso_counter =
146+
ADD_COUNTER(custom_profile(), "RowsetsPrunedByTso", TUnit::UNIT);
147+
_segments_pruned_by_tso_counter =
148+
ADD_COUNTER(custom_profile(), "SegmentsPrunedByTso", TUnit::UNIT);
149+
_tablets_pruned_by_tso_counter =
150+
ADD_COUNTER(custom_profile(), "TabletsPrunedByTso", TUnit::UNIT);
143151
_process_conjunct_timer = ADD_TIMER(custom_profile(), "ProcessConjunctTime");
144152
_read_compressed_counter = ADD_COUNTER(_segment_profile, "CompressedBytesRead", TUnit::BYTES);
145153
_read_uncompressed_counter =
@@ -635,6 +643,32 @@ bool OlapScanLocalState::_is_binlog_merge_scan() const {
635643
return scan_type == TBinlogScanType::MIN_DELTA || scan_type == TBinlogScanType::DETAIL;
636644
}
637645

646+
void OlapScanLocalState::_prune_rowsets_by_tso(const TPaloScanRange& scan_range,
647+
TabletReadSource& read_source) {
648+
SCOPED_TIMER(_rowset_tso_prune_timer);
649+
int64_t pruned_segments = 0;
650+
const auto pruned_rowsets = std::erase_if(read_source.rs_splits, [&](const auto& split) {
651+
const auto& rowset = split.rs_reader->rowset();
652+
const auto tso = rowset->commit_tso();
653+
// Old rowsets can lack commit TSO metadata, including compaction inputs with an
654+
// unknown endpoint. Keep them for the existing segment/row-level predicates.
655+
if (tso.start_tso() < 0 || tso.end_tso() < 0) {
656+
return false;
657+
}
658+
DCHECK_LE(tso.start_tso(), tso.end_tso());
659+
// Rowset metadata is inclusive [min, max]; the query is half-open [start, end).
660+
const bool outside_window =
661+
(scan_range.__isset.start_tso && tso.end_tso() < scan_range.start_tso) ||
662+
(scan_range.__isset.end_tso && tso.start_tso() >= scan_range.end_tso);
663+
if (outside_window) {
664+
pruned_segments += rowset->num_segments();
665+
}
666+
return outside_window;
667+
});
668+
COUNTER_UPDATE(_rowsets_pruned_by_tso_counter, pruned_rowsets);
669+
COUNTER_UPDATE(_segments_pruned_by_tso_counter, pruned_segments);
670+
}
671+
638672
Status OlapScanLocalState::_init_scanners(std::list<ScannerSPtr>* scanners) {
639673
if (_scan_ranges.empty()) {
640674
_eos = true;
@@ -795,6 +829,22 @@ Status OlapScanLocalState::_init_scanners(std::list<ScannerSPtr>* scanners) {
795829
int scanners_per_tablet = std::max(1, 64 / (int)_scan_ranges.size());
796830
for (size_t scan_range_idx = 0; scan_range_idx < _scan_ranges.size(); scan_range_idx++) {
797831
const auto& palo_scan_range = *_scan_ranges[scan_range_idx];
832+
if (read_row_binlog &&
833+
(palo_scan_range.__isset.start_tso || palo_scan_range.__isset.end_tso)) {
834+
auto& read_source = _read_sources[scan_range_idx];
835+
// The version-consistent read source and delete predicates have already been
836+
// captured. Prune before cloning readers or opening any segment footers.
837+
_prune_rowsets_by_tso(palo_scan_range, read_source);
838+
if (std::all_of(read_source.rs_splits.begin(), read_source.rs_splits.end(),
839+
[](const auto& split) {
840+
return split.rs_reader->rowset()->num_rows() == 0;
841+
})) {
842+
// Empty bootstrap rowsets may have no TSO. Skip the tablet even if those
843+
// remain, and do not let OlapScanner recapture an empty read source.
844+
COUNTER_UPDATE(_tablets_pruned_by_tso_counter, 1);
845+
continue;
846+
}
847+
}
798848
int64_t version = 0;
799849
std::from_chars(palo_scan_range.version.data(),
800850
palo_scan_range.version.data() + palo_scan_range.version.size(), version);

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

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -135,6 +135,8 @@ class OlapScanLocalState final : public ScanLocalState<OlapScanLocalState> {
135135

136136
Status _init_scanners(std::list<ScannerSPtr>* scanners) override;
137137

138+
void _prune_rowsets_by_tso(const TPaloScanRange& scan_range, TabletReadSource& read_source);
139+
138140
Status _build_key_ranges_and_filters();
139141

140142
bool _is_tablet_pruned_by_runtime_filter(int64_t partition_id, int32_t bucket_seq,
@@ -165,6 +167,10 @@ class OlapScanLocalState final : public ScanLocalState<OlapScanLocalState> {
165167
RuntimeProfile::Counter* _key_range_counter = nullptr;
166168
RuntimeProfile::Counter* _reader_init_timer = nullptr;
167169
RuntimeProfile::Counter* _scanner_init_timer = nullptr;
170+
RuntimeProfile::Counter* _rowset_tso_prune_timer = nullptr;
171+
RuntimeProfile::Counter* _rowsets_pruned_by_tso_counter = nullptr;
172+
RuntimeProfile::Counter* _segments_pruned_by_tso_counter = nullptr;
173+
RuntimeProfile::Counter* _tablets_pruned_by_tso_counter = nullptr;
168174
RuntimeProfile::Counter* _process_conjunct_timer = nullptr;
169175

170176
RuntimeProfile::Counter* _io_timer = nullptr;

‎be/test/exec/operator/olap_scan_operator_test.cpp‎

Lines changed: 168 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -20,11 +20,13 @@
2020
#include <gtest/gtest.h>
2121

2222
#include <memory>
23+
#include <optional>
2324

2425
#include "common/object_pool.h"
2526
#include "core/data_type/data_type_number.h"
2627
#include "gen_cpp/PlanNodes_types.h"
2728
#include "gen_cpp/QueryCache_types.h"
29+
#include "storage/rowset/beta_rowset.h"
2830
#include "testutil/desc_tbl_builder.h"
2931
#include "testutil/mock/mock_runtime_state.h"
3032

@@ -93,4 +95,170 @@ TEST_F(OlapScanOperatorBinlogPushDownTest, AppendOnlyKeepsValuePredicatePushDown
9395
EXPECT_TRUE(_local_state->can_push_down_column_predicate(_value_slot));
9496
}
9597

98+
class OlapScanOperatorTsoPruningTest : public OlapScanOperatorBinlogPushDownTest {
99+
protected:
100+
void SetUp() override {
101+
OlapScanOperatorBinlogPushDownTest::SetUp();
102+
_parent->_olap_scan_node.__set_read_row_binlog(true);
103+
_profile = std::make_unique<RuntimeProfile>("TsoPruningTest");
104+
_local_state->_scanner_init_timer = ADD_TIMER(_profile, "ScannerInitTime");
105+
_local_state->_rowset_tso_prune_timer = ADD_TIMER(_profile, "RowsetTsoPruneTime");
106+
_local_state->_rowsets_pruned_by_tso_counter =
107+
ADD_COUNTER(_profile, "RowsetsPrunedByTso", TUnit::UNIT);
108+
_local_state->_segments_pruned_by_tso_counter =
109+
ADD_COUNTER(_profile, "SegmentsPrunedByTso", TUnit::UNIT);
110+
_local_state->_tablets_pruned_by_tso_counter =
111+
ADD_COUNTER(_profile, "TabletsPrunedByTso", TUnit::UNIT);
112+
_local_state->_scan_dependency = Dependency::create_shared(0, 0, "Scan", false);
113+
}
114+
115+
RowsetReaderSharedPtr make_reader(std::optional<TsoRange> tso, int64_t segments = 1,
116+
int64_t rows = 1) {
117+
auto meta = std::make_shared<RowsetMeta>();
118+
meta->set_version(tso && tso->start_tso() == tso->end_tso() ? Version(2, 2)
119+
: Version(2, 4));
120+
meta->set_num_segments(segments);
121+
meta->set_num_rows(rows);
122+
if (tso) {
123+
meta->set_commit_tso(*tso);
124+
}
125+
auto rowset = std::make_shared<BetaRowset>(std::make_shared<TabletSchema>(), meta,
126+
"/nonexistent/tso_pruning_test");
127+
RowsetReaderSharedPtr reader;
128+
EXPECT_TRUE(rowset->create_reader(&reader).ok());
129+
return reader;
130+
}
131+
132+
std::unique_ptr<RuntimeProfile> _profile;
133+
};
134+
135+
TEST_F(OlapScanOperatorTsoPruningTest, HalfOpenBoundsPreserveOverlappingAndUnknownRowsets) {
136+
TPaloScanRange range;
137+
range.__set_start_tso(100);
138+
range.__set_end_tso(200);
139+
140+
auto before = make_reader(TsoRange {99, 99}, 2);
141+
auto lower = make_reader(TsoRange {100, 100});
142+
auto inside = make_reader(TsoRange {199, 199}, 3);
143+
auto upper = make_reader(TsoRange {200, 200}, 4);
144+
auto compacted_before = make_reader(TsoRange {10, 99}, 2);
145+
auto touches_lower = make_reader(TsoRange {90, 100}, 3);
146+
auto compacted_inside = make_reader(TsoRange {120, 170}, 2);
147+
auto spans_window = make_reader(TsoRange {0, 250}, 6);
148+
auto compacted_after = make_reader(TsoRange {200, 250}, 5);
149+
auto missing = make_reader(std::nullopt, 2);
150+
auto unknown_lower = make_reader(TsoRange {-1, 170});
151+
auto unknown_upper = make_reader(TsoRange {100, -1});
152+
153+
TabletReadSource source;
154+
for (const auto& reader :
155+
{before, lower, inside, upper, compacted_before, touches_lower, compacted_inside,
156+
spans_window, compacted_after, missing, unknown_lower, unknown_upper}) {
157+
source.rs_splits.emplace_back(reader);
158+
}
159+
// Pruning the data source must not discard separately captured delete predicates.
160+
source.delete_predicates.push_back(before->rowset()->rowset_meta());
161+
_local_state->_prune_rowsets_by_tso(range, source);
162+
163+
const std::vector<RowsetReaderSharedPtr> expected {
164+
lower, inside, touches_lower, compacted_inside,
165+
spans_window, missing, unknown_lower, unknown_upper};
166+
ASSERT_EQ(source.rs_splits.size(), expected.size());
167+
for (size_t i = 0; i < expected.size(); ++i) {
168+
EXPECT_EQ(source.rs_splits[i].rs_reader, expected[i]);
169+
}
170+
ASSERT_EQ(source.delete_predicates.size(), 1);
171+
EXPECT_EQ(source.delete_predicates.front(), before->rowset()->rowset_meta());
172+
EXPECT_EQ(_local_state->_rowsets_pruned_by_tso_counter->value(), 4);
173+
EXPECT_EQ(_local_state->_segments_pruned_by_tso_counter->value(), 13);
174+
}
175+
176+
TEST_F(OlapScanOperatorTsoPruningTest, LowerBoundOnly) {
177+
TPaloScanRange range;
178+
range.__set_start_tso(100);
179+
TabletReadSource source;
180+
auto at_lower = make_reader(TsoRange {100, 100});
181+
auto later = make_reader(TsoRange {200, 200});
182+
source.rs_splits.emplace_back(make_reader(TsoRange {99, 99}));
183+
source.rs_splits.emplace_back(at_lower);
184+
source.rs_splits.emplace_back(later);
185+
186+
_local_state->_prune_rowsets_by_tso(range, source);
187+
188+
ASSERT_EQ(source.rs_splits.size(), 2);
189+
EXPECT_EQ(source.rs_splits[0].rs_reader, at_lower);
190+
EXPECT_EQ(source.rs_splits[1].rs_reader, later);
191+
EXPECT_EQ(_local_state->_rowsets_pruned_by_tso_counter->value(), 1);
192+
}
193+
194+
TEST_F(OlapScanOperatorTsoPruningTest, UpperBoundOnly) {
195+
TPaloScanRange range;
196+
range.__set_end_tso(100);
197+
TabletReadSource source;
198+
auto earlier = make_reader(TsoRange {99, 99});
199+
source.rs_splits.emplace_back(earlier);
200+
source.rs_splits.emplace_back(make_reader(TsoRange {100, 100}));
201+
source.rs_splits.emplace_back(make_reader(TsoRange {200, 200}));
202+
203+
_local_state->_prune_rowsets_by_tso(range, source);
204+
205+
ASSERT_EQ(source.rs_splits.size(), 1);
206+
EXPECT_EQ(source.rs_splits.front().rs_reader, earlier);
207+
EXPECT_EQ(_local_state->_rowsets_pruned_by_tso_counter->value(), 2);
208+
}
209+
210+
TEST_F(OlapScanOperatorTsoPruningTest, NoBoundsPreservesAllRowsets) {
211+
TPaloScanRange range;
212+
TabletReadSource source;
213+
source.rs_splits.emplace_back(make_reader(TsoRange {100, 100}));
214+
source.rs_splits.emplace_back(make_reader(std::nullopt));
215+
216+
_local_state->_prune_rowsets_by_tso(range, source);
217+
218+
EXPECT_EQ(source.rs_splits.size(), 2);
219+
EXPECT_EQ(_local_state->_rowsets_pruned_by_tso_counter->value(), 0);
220+
EXPECT_EQ(_local_state->_segments_pruned_by_tso_counter->value(), 0);
221+
}
222+
223+
TEST_F(OlapScanOperatorTsoPruningTest, EmptyWindowSkipsScannersAndSignalsEos) {
224+
auto& range = *_local_state->_scan_ranges.front();
225+
range.__set_binlog_scan_type(TBinlogScanType::DETAIL);
226+
range.__set_start_tso(100);
227+
range.__set_end_tso(200);
228+
_local_state->_read_sources.resize(1);
229+
auto& source = _local_state->_read_sources.front();
230+
source.rs_splits.emplace_back(make_reader(TsoRange {99, 99}, 2));
231+
source.rs_splits.emplace_back(make_reader(TsoRange {200, 200}, 3));
232+
233+
// There are no tablet or segment files. Successful preparation proves that the
234+
// fully pruned source is not recaptured or passed to a scanner for initialization.
235+
EXPECT_TRUE(_local_state->_prepare_scanners().ok());
236+
237+
EXPECT_TRUE(_local_state->_scanners.empty());
238+
EXPECT_TRUE(_local_state->_eos);
239+
EXPECT_EQ(_local_state->_scan_dependency->is_blocked_by(nullptr), nullptr);
240+
EXPECT_EQ(_local_state->_rowsets_pruned_by_tso_counter->value(), 2);
241+
EXPECT_EQ(_local_state->_segments_pruned_by_tso_counter->value(), 5);
242+
EXPECT_EQ(_local_state->_tablets_pruned_by_tso_counter->value(), 1);
243+
}
244+
245+
TEST_F(OlapScanOperatorTsoPruningTest, EmptyBootstrapDoesNotStartMinDeltaScanner) {
246+
auto& range = *_local_state->_scan_ranges.front();
247+
range.__set_start_tso(100);
248+
range.__set_end_tso(200);
249+
_local_state->_read_sources.resize(1);
250+
auto& source = _local_state->_read_sources.front();
251+
source.rs_splits.emplace_back(make_reader(std::nullopt, 0, 0));
252+
source.rs_splits.emplace_back(make_reader(TsoRange {99, 99}, 2));
253+
254+
EXPECT_TRUE(_local_state->_prepare_scanners().ok());
255+
256+
EXPECT_TRUE(_local_state->_scanners.empty());
257+
EXPECT_TRUE(_local_state->_eos);
258+
EXPECT_EQ(_local_state->_scan_dependency->is_blocked_by(nullptr), nullptr);
259+
EXPECT_EQ(_local_state->_rowsets_pruned_by_tso_counter->value(), 1);
260+
EXPECT_EQ(_local_state->_segments_pruned_by_tso_counter->value(), 2);
261+
EXPECT_EQ(_local_state->_tablets_pruned_by_tso_counter->value(), 1);
262+
}
263+
96264
} // namespace doris
Lines changed: 59 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,59 @@
1+
-- This file is automatically generated. You should know what you did if you want to edit this
2+
-- !detail --
3+
1 10 2
4+
1 11 2
5+
1 11 3
6+
1 12 3
7+
2 20 1
8+
4 40 0
9+
10+
-- !min_delta --
11+
1 10 2
12+
1 12 3
13+
2 20 1
14+
4 40 0
15+
16+
-- !start_only --
17+
1 10 2
18+
1 11 2
19+
1 11 3
20+
1 12 3
21+
2 20 1
22+
4 40 0
23+
5 50 0
24+
25+
-- !end_only --
26+
1 10 0
27+
2 20 0
28+
3 30 0
29+
30+
-- !empty_detail --
31+
32+
-- !empty_min_delta --
33+
34+
-- !snapshot --
35+
1 12
36+
3 30
37+
4 40
38+
5 50
39+
40+
-- !compacted_detail --
41+
1 10 2
42+
1 11 2
43+
1 11 3
44+
1 12 3
45+
2 20 1
46+
4 40 0
47+
48+
-- !compacted_min_delta --
49+
1 10 2
50+
1 12 3
51+
2 20 1
52+
4 40 0
53+
54+
-- !compacted_snapshot --
55+
1 12
56+
3 30
57+
4 40
58+
5 50
59+

0 commit comments

Comments
 (0)