You are viewing a plain text version of this content. The canonical link for it is here.
Posted to issues@paimon.apache.org by "SteNicholas (via GitHub)" <gi...@apache.org> on 2026/10/13 11:35:05 UTC

[PR] fix(global-index): apply global top-k to full-text search across shards [paimon-cpp]

SteNicholas opened a new pull request, #431:
URL: https://github.com/apache/paimon-cpp/pull/431

   <!-- PR titles must follow Conventional Commits: <type>(<optional-scope>): <description> -->
   
   ### Purpose
   
   <!-- Linking this pull request to the issue -->
   Linked issue: close #402
   
   <!-- What is the purpose of the change -->
   `UnionGlobalIndexReader::VisitFullTextSearch` ORed shard results, so a full-text search with
   `limit` k over multiple index shards could return up to shards × k rows, and it failed when two
   shards returned the same row id. `OffsetGlobalIndexReader` shifted global `include_row_ids` by the
   shard offset without clipping them, so row ids before a shard became negative local ids, row ids
   past it were kept, and a shard with no included row was still searched.
   
   This PR follows Java `DataEvolutionFullTextRead`, which asks each split for `limit` rows, combines
   them with `ScoredGlobalIndexResult#merge` and applies `#topK(limit)` last.
   
   - **`UnionGlobalIndexReader::VisitFullTextSearch`**: merges shard results, where a duplicate row id
     keeps its first score, and keeps the `limit` highest-scoring rows. Scores are compared as Java
     `Double#compare` does (via `FieldsComparator::CompareFloatingPoint`), and ties among merged rows
     are broken by ascending row id. A null search or a non-positive `limit` is rejected before any
     shard is searched.
   - **`OffsetGlobalIndexReader`**: takes the last row id of its shard and clips `include_row_ids` to
     the shard with `FullTextSearch::OffsetRange(offset, to)`, as Java
     `OffsetGlobalIndexReader(wrapped, offset, to)` does. A shard whose include set becomes empty is
     not searched.
   - **Overlapping index ranges**: as Java `DataEvolutionFullTextScan#chooseIndexRanges`,
     `GlobalIndexScanImpl` ranks a row covered by overlapping ranges of one index type only in the
     first of them in `(from, to)` order. Each `OffsetGlobalIndexReader` is given the last row ranked
     by earlier ranges (`skip_to`) and ranks only the rows after it, so the top `limit` rows of each
     shard include all of its rows that score above the global `limit`-th score. Passing the last
     skipped row instead of the first row to rank does not overflow when a range ends at `INT64_MAX`.
     A fully covered shard is not searched but still rejects a non-positive `limit`.
   
   As in Java, each shard's index engine decides which of its rows tied at its cutoff score it
   returns, so ascending row id order is guaranteed only among the rows the shards return.
   
   ### Tests
   
   <!-- List UT and IT cases to verify this change -->
   UT:
   
   - `src/paimon/common/global_index/union_global_index_reader_test.cpp`:
     `TestVisitFullTextSearchUnion`, `TestVisitFullTextSearchKeepsTopKAcrossReaders` (top-k and ties
     by row id), `TestVisitFullTextSearchDuplicateRowIdKeepsFirstScore`,
     `TestVisitFullTextSearchOrdersSpecialScoresAsJava` (NaN, infinity and signed zeros),
     `TestVisitFullTextSearchAllNullptr`, `TestVisitFullTextSearchErrors`.
   - `src/paimon/common/global_index/offset_global_index_reader_test.cpp`:
     `TestVisitFullTextSearchConvertsIncludeRowIds` (clipping to the shard, and an empty include set
     that is not searched), `TestVisitFullTextSearchRejectsNonPositiveLimit`,
     `TestVisitFullTextSearchSkipsRows`, `TestVisitFullTextSearchEndingAtLargestRowId`. The other
     tests pass the shard end.
   
   IT, `test/inte/global_index_test.cpp`:
   
   - `TestWriteCommitScanReadLuceneIndexWithPartition` and
     `TestWriteCommitScanReadFullTextIndexWithPartition`: global top-k for every `limit` across two
     shards, with and without `include_row_ids`.
   - `TestLuceneSearchOverlappingIndexRanges`: index ranges `[0, 2]`, `[1, 1]` and `[1, 3]`, where the
     best match is covered only by the tail of `[1, 3]`, also with `include_row_ids` and a
     `RowRangeIndex` that prunes `[0, 2]`.
   
   ### API and Format
   
   <!-- Does this change affect API in include dir or storage format or protocol -->
   No signature change in `include/`. The documented behavior changes:
   
   - `GlobalIndexReader::VisitFullTextSearch` (`include/paimon/global_index/global_index_reader.h`)
     returns at most `limit` rows across all index shards.
   - `FullTextSearch::limit` (`include/paimon/predicate/full_text_search.h`) is the maximum number of
     rows returned; each index shard is asked for that many rows before the merge.
   
   No storage format change.
   
   ### Documentation
   
   <!-- Does this change introduce a new feature -->
   Yes. `docs/source/user_guide/global_index.rst` replaces the note that searches across shards return
   the union of shard candidates with the global top-k behavior, tie handling, overlapping index
   ranges and `include_row_ids` clipping.
   
   ### Generative AI tooling
   
   Generated-by: Claude Code 2.1.296 (Claude Opus 5.5)
   
   🤖 Generated with [Claude Code](https://claude.com/claude-code)
   


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: issues-unsubscribe@paimon.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org


Re: [PR] fix(global-index): apply global top-k to full-text search across shards [paimon-cpp]

Posted by "SteNicholas (via GitHub)" <gi...@apache.org>.
SteNicholas commented on code in PR #431:
URL: https://github.com/apache/paimon-cpp/pull/431#discussion_r4310656040


##########
src/paimon/common/global_index/offset_global_index_reader.h:
##########
@@ -31,11 +31,22 @@ namespace paimon {
 /// results. This is used to convert local row IDs into global row IDs.
 class OffsetGlobalIndexReader : public GlobalIndexReader {
  public:
-    /// Constructs an OffsetGlobalIndexReader.
+    /// Constructs an OffsetGlobalIndexReader whose full-text searches rank all rows it covers.
     /// @param wrapped The inner reader to delegate queries to. Its results are expected to
     ///                contain local row ids.
-    /// @param offset  The offset to add to each row id in the results.
-    OffsetGlobalIndexReader(std::shared_ptr<GlobalIndexReader>&& wrapped, int64_t offset);

Review Comment:
   Agreed, it is not specific to full-text search. The constructor comment no longer mentions full-text search: it documents `offset` and `to` as the first and last global row ids covered by the wrapped reader, which every visit uses. How `include_row_ids` is clipped to `[offset, to]` is commented in `VisitFullTextSearch`.
   



##########
src/paimon/common/global_index/offset_global_index_reader.h:
##########
@@ -31,11 +31,22 @@ namespace paimon {
 /// results. This is used to convert local row IDs into global row IDs.
 class OffsetGlobalIndexReader : public GlobalIndexReader {
  public:
-    /// Constructs an OffsetGlobalIndexReader.
+    /// Constructs an OffsetGlobalIndexReader whose full-text searches rank all rows it covers.
     /// @param wrapped The inner reader to delegate queries to. Its results are expected to
     ///                contain local row ids.
-    /// @param offset  The offset to add to each row id in the results.
-    OffsetGlobalIndexReader(std::shared_ptr<GlobalIndexReader>&& wrapped, int64_t offset);
+    /// @param offset  The first global row id covered by the wrapped reader, added to each row id
+    ///                in the results.
+    /// @param to      The last global row id (inclusive) covered by the wrapped reader.
+    OffsetGlobalIndexReader(std::shared_ptr<GlobalIndexReader>&& wrapped, int64_t offset,
+                            int64_t to);
+

Review Comment:
   Removed. `OffsetGlobalIndexReader` now has one constructor, `(wrapped, offset, to)`, the same as Java `OffsetGlobalIndexReader(wrapped, offset, to)`, and `GlobalIndexScanImpl` uses it for every shard.
   
   On `chooseIndexRanges`: as you pointed out, Java passes the rows a shard ranks as `includeRowIds` (`DataEvolutionFullTextRead#includeRowIds`), so `OffsetGlobalIndexReader` no longer keeps them. `GlobalIndexScanImpl` now gives `UnionGlobalIndexReader` the row range of each shard and the rows it ranks; the union reader restricts the shard through `include_row_ids` and skips a shard with no included row left.
   
   The assignment itself stays simpler than Java's. `chooseIndexRanges` splits the coverage of a column at every range boundary and gives each interval to the best active candidate: an index whose primary field is the column first, then by index identity, `from` and `to`. A C++ `UnionGlobalIndexReader` serves one field and one index type, so its candidates share one identity and the choice reduces to the first range covering a row in `(from, to)` order. Each shard then ranks one contiguous tail of its range, `[max(from, covered_to + 1), to]`, where `covered_to` is the largest `to` of earlier ranges, so the multi-segment search ranges that Java merges with `mergeAdjacent` cannot occur. The PR description now says the core semantics align with Java rather than calling this a full port.
   



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: issues-unsubscribe@paimon.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org


Re: [PR] fix(global-index): apply global top-k to full-text search across shards [paimon-cpp]

Posted by "lxy-9602 (via GitHub)" <gi...@apache.org>.
lxy-9602 commented on code in PR #431:
URL: https://github.com/apache/paimon-cpp/pull/431#discussion_r4311134591


##########
src/paimon/common/global_index/union_global_index_reader.h:
##########
@@ -35,8 +37,15 @@ namespace paimon {
 /// collected in submission order. Otherwise, sub-readers are evaluated sequentially.
 class UnionGlobalIndexReader : public GlobalIndexReader {
  public:
+    /// Constructs a UnionGlobalIndexReader.
+    /// @param row_ranges    The global row ids covered by each reader, in the order of `readers`.
+    /// @param search_ranges The global row ids each reader ranks in a full-text search, within its
+    ///                      row range, in the order of `readers`; std::nullopt if it ranks none.
+    ///                      If empty, each reader ranks all of its rows.
     UnionGlobalIndexReader(std::vector<std::shared_ptr<GlobalIndexReader>>&& readers,
-                           const std::shared_ptr<Executor>& executor);
+                           const std::shared_ptr<Executor>& executor,
+                           std::vector<Range>&& row_ranges = {},
+                           std::vector<std::optional<Range>>&& search_ranges = {});

Review Comment:
   Please don’t add default function parameters in the production code. Also, for newly added parameters, could you please place them before `executor`.
   



##########
src/paimon/common/global_index/union_global_index_reader.cpp:
##########
@@ -133,9 +216,74 @@ Result<std::shared_ptr<ScoredGlobalIndexResult>> UnionGlobalIndexReader::VisitVe
 
 Result<std::shared_ptr<ScoredGlobalIndexResult>> UnionGlobalIndexReader::VisitFullTextSearch(
     const std::shared_ptr<FullTextSearch>& full_text_search) {
-    return UnionScored([full_text_search](const std::shared_ptr<GlobalIndexReader>& reader) {
-        return reader->VisitFullTextSearch(full_text_search);
-    });
+    if (!full_text_search) {
+        return Status::Invalid("VisitFullTextSearch: null FullTextSearch pointer");
+    }
+    if (full_text_search->limit <= 0) {
+        return Status::Invalid("full-text search requires a positive limit");
+    }
+    // If the readers rank disjoint rows, the top `limit` rows of each reader include all of its
+    // rows scoring above the `limit`-th highest score of all readers, so merging them loses none
+    // of those rows. Rows tied at that score may already have been cut by a reader's engine.
+    auto reader_searches = std::make_shared<std::vector<std::shared_ptr<FullTextSearch>>>();
+    reader_searches->reserve(readers_.size());
+    for (size_t index = 0; index < readers_.size(); ++index) {
+        reader_searches->push_back(FullTextSearchForReader(index, full_text_search));
+    }
+    auto results = ExecuteAllReadersWithIndex<Result<std::shared_ptr<ScoredGlobalIndexResult>>>(
+        [reader_searches](size_t index, const std::shared_ptr<GlobalIndexReader>& reader)
+            -> Result<std::shared_ptr<ScoredGlobalIndexResult>> {
+            const std::shared_ptr<FullTextSearch>& reader_search = (*reader_searches)[index];
+            if (!reader_search) {
+                return EmptyScoredResult();
+            }
+            return reader->VisitFullTextSearch(reader_search);
+        });
+    std::vector<std::shared_ptr<ScoredGlobalIndexResult>> scored_results;
+    scored_results.reserve(results.size());
+    for (auto& result_or_status : results) {
+        PAIMON_ASSIGN_OR_RAISE(std::shared_ptr<ScoredGlobalIndexResult> result,
+                               std::move(result_or_status));
+        if (result != nullptr) {
+            scored_results.push_back(std::move(result));
+        }
+    }
+    if (scored_results.empty()) {
+        return std::shared_ptr<ScoredGlobalIndexResult>();
+    }

Review Comment:
   I’m a bit curious here: when `scored_results.empty()` happens, Java seems to return `EmptyScoredResult`, but the current code returns `nullptr`. Returning `nullptr` indicate that the index wasn’t actually used, or that we can’t determine the outcome.



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: issues-unsubscribe@paimon.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org


Re: [PR] fix(global-index): apply global top-k to full-text search across shards [paimon-cpp]

Posted by "SteNicholas (via GitHub)" <gi...@apache.org>.
SteNicholas commented on code in PR #431:
URL: https://github.com/apache/paimon-cpp/pull/431#discussion_r4311502121


##########
src/paimon/common/global_index/union_global_index_reader.h:
##########
@@ -35,8 +37,15 @@ namespace paimon {
 /// collected in submission order. Otherwise, sub-readers are evaluated sequentially.
 class UnionGlobalIndexReader : public GlobalIndexReader {
  public:
+    /// Constructs a UnionGlobalIndexReader.
+    /// @param row_ranges    The global row ids covered by each reader, in the order of `readers`.
+    /// @param search_ranges The global row ids each reader ranks in a full-text search, within its
+    ///                      row range, in the order of `readers`; std::nullopt if it ranks none.
+    ///                      If empty, each reader ranks all of its rows.
     UnionGlobalIndexReader(std::vector<std::shared_ptr<GlobalIndexReader>>&& readers,
-                           const std::shared_ptr<Executor>& executor);
+                           const std::shared_ptr<Executor>& executor,
+                           std::vector<Range>&& row_ranges = {},
+                           std::vector<std::optional<Range>>&& search_ranges = {});

Review Comment:
   Done. The constructor is now `UnionGlobalIndexReader(readers, row_ranges, search_ranges, executor)`, with no default arguments. `GlobalIndexScanImpl` passes all four, and tests that don't use full-text ranges pass `/*row_ranges=*/{}, /*search_ranges=*/{}` explicitly.
   



##########
src/paimon/common/global_index/union_global_index_reader.cpp:
##########
@@ -133,9 +216,74 @@ Result<std::shared_ptr<ScoredGlobalIndexResult>> UnionGlobalIndexReader::VisitVe
 
 Result<std::shared_ptr<ScoredGlobalIndexResult>> UnionGlobalIndexReader::VisitFullTextSearch(
     const std::shared_ptr<FullTextSearch>& full_text_search) {
-    return UnionScored([full_text_search](const std::shared_ptr<GlobalIndexReader>& reader) {
-        return reader->VisitFullTextSearch(full_text_search);
-    });
+    if (!full_text_search) {
+        return Status::Invalid("VisitFullTextSearch: null FullTextSearch pointer");
+    }
+    if (full_text_search->limit <= 0) {
+        return Status::Invalid("full-text search requires a positive limit");
+    }
+    // If the readers rank disjoint rows, the top `limit` rows of each reader include all of its
+    // rows scoring above the `limit`-th highest score of all readers, so merging them loses none
+    // of those rows. Rows tied at that score may already have been cut by a reader's engine.
+    auto reader_searches = std::make_shared<std::vector<std::shared_ptr<FullTextSearch>>>();
+    reader_searches->reserve(readers_.size());
+    for (size_t index = 0; index < readers_.size(); ++index) {
+        reader_searches->push_back(FullTextSearchForReader(index, full_text_search));
+    }
+    auto results = ExecuteAllReadersWithIndex<Result<std::shared_ptr<ScoredGlobalIndexResult>>>(
+        [reader_searches](size_t index, const std::shared_ptr<GlobalIndexReader>& reader)
+            -> Result<std::shared_ptr<ScoredGlobalIndexResult>> {
+            const std::shared_ptr<FullTextSearch>& reader_search = (*reader_searches)[index];
+            if (!reader_search) {
+                return EmptyScoredResult();
+            }
+            return reader->VisitFullTextSearch(reader_search);
+        });
+    std::vector<std::shared_ptr<ScoredGlobalIndexResult>> scored_results;
+    scored_results.reserve(results.size());
+    for (auto& result_or_status : results) {
+        PAIMON_ASSIGN_OR_RAISE(std::shared_ptr<ScoredGlobalIndexResult> result,
+                               std::move(result_or_status));
+        if (result != nullptr) {
+            scored_results.push_back(std::move(result));
+        }
+    }
+    if (scored_results.empty()) {
+        return std::shared_ptr<ScoredGlobalIndexResult>();
+    }

Review Comment:
   `scored_results` is empty only when no reader returned a result: the union has no readers, or every reader returned nullptr. The C++ full-text readers (`FullTextGlobalIndexReader`, `LuceneGlobalIndexReader`) always return a result, an empty one if nothing matches. Only readers without full-text support return nullptr, such as the Lumina reader and `FileIndexReaderWrapper`. So nullptr here means what you describe: the index wasn't used. Returning an empty result would tell the caller that no row matched.
   
   Java returns `createEmpty()` when a shard has no rows to search. `NativeFullTextGlobalIndexReader` does this for an empty include set, and `DataEvolutionFullTextRead#evalColumnQuery` merges skipped splits into it. C++ does the same: a shard that ranks none of the rows to search is not visited and adds `EmptyScoredResult()`, so the merge returns an empty result, not nullptr. `TestVisitFullTextSearchSparseIncludeInLargeRanges` and the `{5}` case in `TestVisitFullTextSearchWithinSearchRanges` cover this. The nullptr case matches Java's `UnionGlobalIndexReader#visitVectorSearch`, which returns `Optional.empty()` when no reader returns a result.
   
   I documented this on `VisitFullTextSearch` and commented that branch.
   



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: issues-unsubscribe@paimon.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org


Re: [PR] fix(global-index): apply global top-k to full-text search across shards [paimon-cpp]

Posted by "lxy-9602 (via GitHub)" <gi...@apache.org>.
lxy-9602 merged PR #431:
URL: https://github.com/apache/paimon-cpp/pull/431


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: issues-unsubscribe@paimon.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org


Re: [PR] fix(global-index): apply global top-k to full-text search across shards [paimon-cpp]

Posted by "lxy-9602 (via GitHub)" <gi...@apache.org>.
lxy-9602 commented on code in PR #431:
URL: https://github.com/apache/paimon-cpp/pull/431#discussion_r4290221086


##########
src/paimon/common/global_index/offset_global_index_reader.h:
##########
@@ -31,11 +31,22 @@ namespace paimon {
 /// results. This is used to convert local row IDs into global row IDs.
 class OffsetGlobalIndexReader : public GlobalIndexReader {
  public:
-    /// Constructs an OffsetGlobalIndexReader.
+    /// Constructs an OffsetGlobalIndexReader whose full-text searches rank all rows it covers.
     /// @param wrapped The inner reader to delegate queries to. Its results are expected to
     ///                contain local row ids.
-    /// @param offset  The offset to add to each row id in the results.
-    OffsetGlobalIndexReader(std::shared_ptr<GlobalIndexReader>&& wrapped, int64_t offset);
+    /// @param offset  The first global row id covered by the wrapped reader, added to each row id
+    ///                in the results.
+    /// @param to      The last global row id (inclusive) covered by the wrapped reader.
+    OffsetGlobalIndexReader(std::shared_ptr<GlobalIndexReader>&& wrapped, int64_t offset,
+                            int64_t to);
+

Review Comment:
   It looks like the three-parameter version isn’t used in production code—can we remove it?



##########
src/paimon/common/global_index/offset_global_index_reader.h:
##########
@@ -31,11 +31,22 @@ namespace paimon {
 /// results. This is used to convert local row IDs into global row IDs.
 class OffsetGlobalIndexReader : public GlobalIndexReader {
  public:
-    /// Constructs an OffsetGlobalIndexReader.
+    /// Constructs an OffsetGlobalIndexReader whose full-text searches rank all rows it covers.
     /// @param wrapped The inner reader to delegate queries to. Its results are expected to
     ///                contain local row ids.
-    /// @param offset  The offset to add to each row id in the results.
-    OffsetGlobalIndexReader(std::shared_ptr<GlobalIndexReader>&& wrapped, int64_t offset);
+    /// @param offset  The first global row id covered by the wrapped reader, added to each row id
+    ///                in the results.
+    /// @param to      The last global row id (inclusive) covered by the wrapped reader.
+    OffsetGlobalIndexReader(std::shared_ptr<GlobalIndexReader>&& wrapped, int64_t offset,
+                            int64_t to);
+

Review Comment:
   I checked Java’s `chooseIndexRanges`—it seems more complex than the C++ side, and it passes `includeRowIds` rather than using `OffsetGlobalIndexReader`. I wonder what’s the rationale behind this design?



##########
src/paimon/common/global_index/offset_global_index_reader.h:
##########
@@ -31,11 +31,22 @@ namespace paimon {
 /// results. This is used to convert local row IDs into global row IDs.
 class OffsetGlobalIndexReader : public GlobalIndexReader {
  public:
-    /// Constructs an OffsetGlobalIndexReader.
+    /// Constructs an OffsetGlobalIndexReader whose full-text searches rank all rows it covers.
     /// @param wrapped The inner reader to delegate queries to. Its results are expected to
     ///                contain local row ids.
-    /// @param offset  The offset to add to each row id in the results.
-    OffsetGlobalIndexReader(std::shared_ptr<GlobalIndexReader>&& wrapped, int64_t offset);

Review Comment:
   The comment for `OffsetGlobalIndexReader` seems to fully describe full-text search.
   I think its purpose may be more than just FTS?



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: issues-unsubscribe@paimon.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org


Re: [PR] fix(global-index): apply global top-k to full-text search across shards [paimon-cpp]

Posted by "lxy-9602 (via GitHub)" <gi...@apache.org>.
lxy-9602 commented on code in PR #431:
URL: https://github.com/apache/paimon-cpp/pull/431#discussion_r4290239105


##########
src/paimon/common/global_index/offset_global_index_reader.h:
##########
@@ -31,11 +31,22 @@ namespace paimon {
 /// results. This is used to convert local row IDs into global row IDs.
 class OffsetGlobalIndexReader : public GlobalIndexReader {
  public:
-    /// Constructs an OffsetGlobalIndexReader.
+    /// Constructs an OffsetGlobalIndexReader whose full-text searches rank all rows it covers.
     /// @param wrapped The inner reader to delegate queries to. Its results are expected to
     ///                contain local row ids.
-    /// @param offset  The offset to add to each row id in the results.
-    OffsetGlobalIndexReader(std::shared_ptr<GlobalIndexReader>&& wrapped, int64_t offset);
+    /// @param offset  The first global row id covered by the wrapped reader, added to each row id
+    ///                in the results.
+    /// @param to      The last global row id (inclusive) covered by the wrapped reader.
+    OffsetGlobalIndexReader(std::shared_ptr<GlobalIndexReader>&& wrapped, int64_t offset,
+                            int64_t to);
+

Review Comment:
   I checked Java’s `chooseIndexRanges`—it seems more complex than the C++ side, and it passes `includeRowIds` rather than inside `OffsetGlobalIndexReader`. I wonder what’s the rationale behind this design?



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: issues-unsubscribe@paimon.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org