Optimized the read performance of the table when have multi versions - #4958

…d export apache#55392 (apache#4958)

… segment iterators

### What problem does this PR solve?

Issue Number: N/A

Related PR: apache#4958, apache#7785, apache#35432

Problem Summary:

Between BlockReader and SegmentIterator a read went through seven objects of four kinds, and
the merge of the rows was done twice: BetaRowsetReader merged the overlapping segments of each
rowset with a VMergeIterator, then VCollectIterator merged the rowsets with a two-level heap
(the rowset with the most rows against a sub-heap of the others, PR apache#4958, a row-storage era
optimization). Every layer had its own way of saying "same key as the previous row" (the
segment merge set it on the loser of a comparison and handed it up as a BlockWithSameBit; the
rowset merge set it again; Level0Iterator carried it across Blocks), its own tie-break between
versions of a key (data_id in the segment merge, the rowset version in the rowset merge), its
own end-of-data signal (EndOfFile with rows still in the Block, OK with no rows, row_pos == -1,
_rs_reader == nullptr, _cur_child == nullptr) and its own mode flags (Level0Iterator read by
Block or by BlockView depending on the child, Level1Iterator merged or concatenated depending
on a flag). The three bugs fixed by the overlapping-segments PR all sat on the hand-overs
between these layers.

The read path is now one iterator per layer, each with one contract:

  BlockReader                 captures the rowsets, builds the rows of the read, picks the
                              TabletBlockIterator of the read mode
   └ TabletBlockIterator      folds the rows into output Blocks: Direct, UniqueKey,
                              SequenceMap, AggKey, ChangelogMinDelta, ChangelogDetail, TopN
      └ VMergeIterator        one heap over the segment iterators of every rowset (each
        or VUnionIterator     segment of an overlapping rowset, one VUnionIterator for a
                              rowset whose segments do not overlap), in (rowset version,
                              segment) order
         └ LazyInitSegmentIterator -> SegmentIterator

- RowwiseIterator has two ways to read: next_batch(Block*) and next_row(IteratorRowRef*).
  next_batch returns OK only with rows and EndOfFile only with none; next_row hands out one
  row whose reference lives until the next call, with is_same set when the key repeats the
  previous row's. BlockWithSameBit, BlockView, is_merge_iterator(), data_id() and empty()
  are gone.
- VMergeIterator is rewritten: a flat binary heap of child indexes, the child order
  (rowset version, then segment) as the only tie-break after the sequence column, and run
  detection: the top child advances without touching the heap while its next row still sorts
  before the best row of any other child. The same-key bit and skip_same are computed in one
  place, against the row handed out before. next_batch copies runs with insert_range_from.
- VCollectIterator, Level0Iterator and Level1Iterator are deleted. The scanner-local TopN
  read moves into TopNBlockIterator, reading one key-ordered iterator per rowset; the best n
  rows seen so far live in its Candidates helper (offer a batch, trim to n, worst value for
  the TopN runtime predicate), the same logic as _topn_next had.
- RowsetReader is a factory of segment iterators (get_segment_iterators, new_iterator);
  the per-rowset fields it wrote into the shared RowsetReaderContext (rowset_id, merged_rows)
  are gone. next_batch stays for the readers of one rowset (schema change).
- SegmentIterator keeps the batch limit of the adaptive batch size in its own member instead
  of rewriting _opts.block_row_max, reads on over batches a predicate filtered completely so
  next_batch never returns OK without rows (checking for cancellation on the way), and
  asserts it is not read after EndOfFile.
- TabletReader::next_block_with_aggregation sets eof only with an empty Block; the scanner's
  workaround for an eof with rows is removed.

Every read returns the same rows in the same order. What changes around them: the byte
budget of an output Block is checked after every copied run and every 64 rows instead of
being predicted per row, so a Block may end a little later; eof is reported with an empty
Block instead of together with the last rows; a LazyInitSegmentIterator opens its segment with
the io context of its rowset reader. The profile counters keep their names.

### Release note

None

### Check List (For Author)

- Test: Unit Test / Regression test
    - BE UT: 531 tests of the storage read path (BlockReader*, VGenericIteratorsTest*,
      *Changelog*, VerticalBlockReaderTest*, VerticalCompactionTest*, SegCompactionTest*,
      TestRowIdConversion*, BetaRowsetTest*, *SchemaChange*, CumulativeCompaction*,
      TabletReaderTest*, SegmentIterator*, SegmentsKeyBoundsTruncation*, IndexBuilder*, ...).
      Rewritten: vgeneric_iterators_test (merge/union tests on the new interfaces, plus
      next_row, skip_same, row-limit and union next_row tests), block_reader_changelog_merge_test
      (a real VMergeIterator of two rowsets under the changelog iterators),
      block_reader_change_next_block_test (fake rows through next_row, eof only with an empty
      Block). Kept: block_reader_table_models_test (every table model and read mode on real
      segments), block_reader_overlapping_segments_test, agg_value_aggregator_test and the
      compaction, schema change, rowid conversion and segcompaction suites. The key bounds,
      expr zone map and index builder tests follow the renamed or removed members.
    - Regression on a one-BE cluster with the p0 pipeline settings: fault_injection_p0
      (test_overlapping_segments_merge, test_topn_pruned_struct_overlapping_segments),
      unique_with_mor_p0, unique_seq_map_p0, topn_optimize, delete_p0, data_model_p0,
      changelog_p0 (25/25), schema_change_p0 (125/126), compaction (56/58), unique_with_mow_p0
      (107/109); the 6 suites not passed all need an S3 bucket for a broker load or for cold
      storage, which this environment has no access to.
- Behavior changed: No
- Does this need documentation: No

Co-Authored-By: Claude Fable 5.1 <[email protected]>

… segment iterators

Issue Number: N/A

Related PR: apache#4958, apache#7785, apache#35432

Problem Summary:

Between BlockReader and SegmentIterator a read went through seven objects of four kinds, and
the merge of the rows was done twice: BetaRowsetReader merged the overlapping segments of each
rowset with a VMergeIterator, then VCollectIterator merged the rowsets with a two-level heap
(the rowset with the most rows against a sub-heap of the others, PR apache#4958, a row-storage era
optimization). Every layer had its own way of saying "same key as the previous row" (the
segment merge set it on the loser of a comparison and handed it up as a BlockWithSameBit; the
rowset merge set it again; Level0Iterator carried it across Blocks), its own tie-break between
versions of a key (data_id in the segment merge, the rowset version in the rowset merge), its
own end-of-data signal (EndOfFile with rows still in the Block, OK with no rows, row_pos == -1,
_rs_reader == nullptr, _cur_child == nullptr) and its own mode flags (Level0Iterator read by
Block or by BlockView depending on the child, Level1Iterator merged or concatenated depending
on a flag). The three bugs fixed by the overlapping-segments PR all sat on the hand-overs
between these layers.

The read path is now one iterator per layer, each with one contract:

  BlockReader                 captures the rowsets, builds the rows of the read, picks the
                              TabletBlockIterator of the read mode
   └ TabletBlockIterator      folds the rows into output Blocks: Direct, UniqueKey,
                              SequenceMap, AggKey, ChangelogMinDelta, ChangelogDetail, TopN
      └ VMergeIterator        one heap over the segment iterators of every rowset (each
        or VUnionIterator     segment of an overlapping rowset, one VUnionIterator for a
                              rowset whose segments do not overlap), in (rowset version,
                              segment) order
         └ LazyInitSegmentIterator -> SegmentIterator

- RowwiseIterator has two ways to read: next_batch(Block*) and next_row(IteratorRowRef*).
  next_batch returns OK only with rows and EndOfFile only with none; next_row hands out one
  row whose reference lives until the next call, with is_same set when the key repeats the
  previous row's. BlockWithSameBit, BlockView, is_merge_iterator(), data_id() and empty()
  are gone.
- VMergeIterator is rewritten: a flat binary heap of child indexes, the child order
  (rowset version, then segment) as the only tie-break after the sequence column, and run
  detection: the top child advances without touching the heap while its next row still sorts
  before the best row of any other child. The same-key bit and skip_same are computed in one
  place, against the row handed out before. next_batch copies runs with insert_range_from.
- VCollectIterator, Level0Iterator and Level1Iterator are deleted. The scanner-local TopN
  read moves into TopNBlockIterator, reading one key-ordered iterator per rowset; the best n
  rows seen so far live in its Candidates helper (offer a batch, trim to n, worst value for
  the TopN runtime predicate), the same logic as _topn_next had.
- RowsetReader is a factory of segment iterators (get_segment_iterators, new_iterator);
  the per-rowset fields it wrote into the shared RowsetReaderContext (rowset_id, merged_rows)
  are gone. next_batch stays for the readers of one rowset (schema change).
- SegmentIterator keeps the batch limit of the adaptive batch size in its own member instead
  of rewriting _opts.block_row_max, reads on over batches a predicate filtered completely so
  next_batch never returns OK without rows (checking for cancellation on the way), and
  asserts it is not read after EndOfFile.
- TabletReader::next_block_with_aggregation sets eof only with an empty Block; the scanner's
  workaround for an eof with rows is removed.

Every read returns the same rows in the same order. What changes around them: the byte
budget of an output Block is checked after every copied run and every 64 rows instead of
being predicted per row, so a Block may end a little later; eof is reported with an empty
Block instead of together with the last rows; a LazyInitSegmentIterator opens its segment with
the io context of its rowset reader. The profile counters keep their names.

None

- Test: Unit Test / Regression test
    - BE UT: 531 tests of the storage read path (BlockReader*, VGenericIteratorsTest*,
      *Changelog*, VerticalBlockReaderTest*, VerticalCompactionTest*, SegCompactionTest*,
      TestRowIdConversion*, BetaRowsetTest*, *SchemaChange*, CumulativeCompaction*,
      TabletReaderTest*, SegmentIterator*, SegmentsKeyBoundsTruncation*, IndexBuilder*, ...).
      Rewritten: vgeneric_iterators_test (merge/union tests on the new interfaces, plus
      next_row, skip_same, row-limit and union next_row tests), block_reader_changelog_merge_test
      (a real VMergeIterator of two rowsets under the changelog iterators),
      block_reader_change_next_block_test (fake rows through next_row, eof only with an empty
      Block). Kept: block_reader_table_models_test (every table model and read mode on real
      segments), block_reader_overlapping_segments_test, agg_value_aggregator_test and the
      compaction, schema change, rowid conversion and segcompaction suites. The key bounds,
      expr zone map and index builder tests follow the renamed or removed members.
    - Regression on a one-BE cluster with the p0 pipeline settings: fault_injection_p0
      (test_overlapping_segments_merge, test_topn_pruned_struct_overlapping_segments),
      unique_with_mor_p0, unique_seq_map_p0, topn_optimize, delete_p0, data_model_p0,
      changelog_p0 (25/25), schema_change_p0 (125/126), compaction (56/58), unique_with_mow_p0
      (107/109); the 6 suites not passed all need an S3 bucket for a broker load or for cold
      storage, which this environment has no access to.
- Behavior changed: No
- Does this need documentation: No

Co-Authored-By: Claude Fable 5.1 <[email protected]>

… segment iterators

Issue Number: N/A

Related PR: apache#4958, apache#7785, apache#35432

Problem Summary:

Between BlockReader and SegmentIterator a read went through seven objects of four kinds, and
the merge of the rows was done twice: BetaRowsetReader merged the overlapping segments of each
rowset with a VMergeIterator, then VCollectIterator merged the rowsets with a two-level heap
(the rowset with the most rows against a sub-heap of the others, PR apache#4958, a row-storage era
optimization). Every layer had its own way of saying "same key as the previous row" (the
segment merge set it on the loser of a comparison and handed it up as a BlockWithSameBit; the
rowset merge set it again; Level0Iterator carried it across Blocks), its own tie-break between
versions of a key (data_id in the segment merge, the rowset version in the rowset merge), its
own end-of-data signal (EndOfFile with rows still in the Block, OK with no rows, row_pos == -1,
_rs_reader == nullptr, _cur_child == nullptr) and its own mode flags (Level0Iterator read by
Block or by BlockView depending on the child, Level1Iterator merged or concatenated depending
on a flag). The three bugs fixed by the overlapping-segments PR all sat on the hand-overs
between these layers.

The read path is now one iterator per layer, each with one contract:

  BlockReader                 captures the rowsets, builds the rows of the read, picks the
                              TabletBlockIterator of the read mode
   └ TabletBlockIterator      folds the rows into output Blocks: Direct, UniqueKey,
                              SequenceMap, AggKey, ChangelogMinDelta, ChangelogDetail, TopN
      └ VMergeIterator        one heap over the segment iterators of every rowset (each
        or VUnionIterator     segment of an overlapping rowset, one VUnionIterator for a
                              rowset whose segments do not overlap), in (rowset version,
                              segment) order
         └ LazyInitSegmentIterator -> SegmentIterator

- RowwiseIterator has two ways to read: next_batch(Block*) and next_row(IteratorRowRef*).
  next_batch returns OK only with rows and EndOfFile only with none; next_row hands out one
  row whose reference lives until the next call, with is_same set when the key repeats the
  previous row's. BlockWithSameBit, BlockView, is_merge_iterator(), data_id() and empty()
  are gone.
- VMergeIterator is rewritten: a flat binary heap of child indexes, the child order
  (rowset version, then segment) as the only tie-break after the sequence column, and run
  detection: the top child advances without touching the heap while its next row still sorts
  before the best row of any other child. The same-key bit and skip_same are computed in one
  place, against the row handed out before. next_batch copies runs with insert_range_from.
- VCollectIterator, Level0Iterator and Level1Iterator are deleted. The scanner-local TopN
  read moves into TopNBlockIterator, reading one key-ordered iterator per rowset; the best n
  rows seen so far live in its Candidates helper (offer a batch, trim to n, worst value for
  the TopN runtime predicate), the same logic as _topn_next had.
- RowsetReader is a factory of segment iterators (get_segment_iterators, new_iterator);
  the per-rowset fields it wrote into the shared RowsetReaderContext (rowset_id, merged_rows)
  are gone. next_batch stays for the readers of one rowset (schema change).
- SegmentIterator keeps the batch limit of the adaptive batch size in its own member instead
  of rewriting _opts.block_row_max, reads on over batches a predicate filtered completely so
  next_batch never returns OK without rows (checking for cancellation on the way), and
  asserts it is not read after EndOfFile.
- TabletReader::next_block_with_aggregation sets eof only with an empty Block; the scanner's
  workaround for an eof with rows is removed.

Every read returns the same rows in the same order. What changes around them: the byte
budget of an output Block is checked after every copied run and every 64 rows instead of
being predicted per row, so a Block may end a little later; eof is reported with an empty
Block instead of together with the last rows; a LazyInitSegmentIterator opens its segment with
the io context of its rowset reader. The profile counters keep their names.

None

- Test: Unit Test / Regression test
    - BE UT: 531 tests of the storage read path (BlockReader*, VGenericIteratorsTest*,
      *Changelog*, VerticalBlockReaderTest*, VerticalCompactionTest*, SegCompactionTest*,
      TestRowIdConversion*, BetaRowsetTest*, *SchemaChange*, CumulativeCompaction*,
      TabletReaderTest*, SegmentIterator*, SegmentsKeyBoundsTruncation*, IndexBuilder*, ...).
      Rewritten: vgeneric_iterators_test (merge/union tests on the new interfaces, plus
      next_row, skip_same, row-limit and union next_row tests), block_reader_changelog_merge_test
      (a real VMergeIterator of two rowsets under the changelog iterators),
      block_reader_change_next_block_test (fake rows through next_row, eof only with an empty
      Block). Kept: block_reader_table_models_test (every table model and read mode on real
      segments), block_reader_overlapping_segments_test, agg_value_aggregator_test and the
      compaction, schema change, rowid conversion and segcompaction suites. The key bounds,
      expr zone map and index builder tests follow the renamed or removed members.
    - Regression on a one-BE cluster with the p0 pipeline settings: fault_injection_p0
      (test_overlapping_segments_merge, test_topn_pruned_struct_overlapping_segments),
      unique_with_mor_p0, unique_seq_map_p0, topn_optimize, delete_p0, data_model_p0,
      changelog_p0 (25/25), schema_change_p0 (125/126), compaction (56/58), unique_with_mow_p0
      (107/109); the 6 suites not passed all need an S3 bucket for a broker load or for cold
      storage, which this environment has no access to.
- Behavior changed: No
- Does this need documentation: No

Co-Authored-By: Claude Fable 5.1 <[email protected]>