fix

Author: lszskye

src/paimon/core/global_index/indexed_split_impl.h

@@ -91,7 +91,7 @@ class IndexedSplitImpl : public IndexedSplit {
     Status Validate() const {
         if ((row_ranges_.empty() && !data_split_->DataFiles().empty()) ||
             (!row_ranges_.empty() && data_split_->DataFiles().empty())) {
-            return Status::Invalid("invalid IndexedSplit: row ranges mismatch data files");
+            return Status::Invalid("Invalid IndexedSplit: row ranges mismatch data files.");
         }
         if (!scores_.empty()) {
             size_t row_count = 0;

src/paimon/core/global_index/indexed_split_test.cpp

@@ -169,5 +169,24 @@ TEST(IndexedSplitTest, TestValidate) {
         ASSERT_NOK_WITH_MSG(split.Validate(),
                             "Scores length does not match row ranges in indexed split.");
     }
+    {
+        std::vector<Range> row_ranges = {};
+        IndexedSplitImpl split(data_split, row_ranges);
+        ASSERT_NOK_WITH_MSG(split.Validate(),
+                            "Invalid IndexedSplit: row ranges mismatch data files.");
+    }
+    {
+        std::vector<Range> row_ranges = {Range(10, 12)};
+        DataSplitImpl::Builder empty_builder(
+            /*partition=*/BinaryRow::EmptyRow(),
+            /*bucket=*/0, /*bucket_path=*/
+            "data/test_table/bucket-0", std::vector<std::shared_ptr<DataFileMeta>>({}));
+        auto empty_data_split = std::dynamic_pointer_cast<DataSplitImpl>(
+            empty_builder.WithSnapshot(1).IsStreaming(false).RawConvertible(true).Build().value());
+
+        IndexedSplitImpl split(empty_data_split, row_ranges);
+        ASSERT_NOK_WITH_MSG(split.Validate(),
+                            "Invalid IndexedSplit: row ranges mismatch data files.");
+    }
 }
 }  // namespace paimon::test

src/paimon/core/schema/table_schema.cpp

@@ -200,6 +200,7 @@ Result<DataField> TableSchema::GetField(int32_t field_id) const {
 Result<std::vector<DataField>> TableSchema::GetFields(
     const std::vector<std::string>& field_names) const {
     std::vector<DataField> data_fields;
+    data_fields.reserve(field_names.size());
     for (const auto& name : field_names) {
         PAIMON_ASSIGN_OR_RAISE(DataField field, GetField(name));
         data_fields.emplace_back(field);

src/paimon/core/table/source/data_evolution_batch_scan.cpp

@@ -37,22 +37,25 @@ DataEvolutionBatchScan::DataEvolutionBatchScan(
 
 Result<std::shared_ptr<Plan>> DataEvolutionBatchScan::CreatePlan() {
     std::optional<std::vector<Range>> row_ranges;
-    if (!global_index_result_) {
+    std::shared_ptr<GlobalIndexResult> final_global_index_result = global_index_result_;
+    if (!final_global_index_result) {
         PAIMON_ASSIGN_OR_RAISE(std::optional<std::shared_ptr<GlobalIndexResult>> index_result,
                                EvalGlobalIndex());
         if (index_result) {
+            final_global_index_result = index_result.value();
             PAIMON_ASSIGN_OR_RAISE(row_ranges, index_result.value()->ToRanges());
         }
     } else {
-        PAIMON_ASSIGN_OR_RAISE(row_ranges, global_index_result_->ToRanges());
+        PAIMON_ASSIGN_OR_RAISE(row_ranges, final_global_index_result->ToRanges());
     }
     if (!row_ranges) {
         return batch_scan_->CreatePlan();
     }
     batch_scan_->WithRowRanges(row_ranges.value());
     PAIMON_ASSIGN_OR_RAISE(std::shared_ptr<Plan> data_plan, batch_scan_->CreatePlan());
     std::map<int64_t, float> id_to_score;
-    if (auto topk_result = std::dynamic_pointer_cast<TopKGlobalIndexResult>(global_index_result_)) {
+    if (auto topk_result =
+            std::dynamic_pointer_cast<TopKGlobalIndexResult>(final_global_index_result)) {
         PAIMON_ASSIGN_OR_RAISE(std::unique_ptr<TopKGlobalIndexResult::TopKIterator> topk_iter,
                                topk_result->CreateTopKIterator());
         while (topk_iter->HasNext()) {
@@ -68,8 +71,10 @@ Result<std::shared_ptr<Plan>> DataEvolutionBatchScan::WrapToIndexedSplits(
     const std::map<int64_t, float>& id_to_score) const {
     std::vector<Range> sorted_row_ranges =
         Range::SortAndMergeOverlap(row_ranges, /*adjacent=*/true);
+    auto data_splits = data_plan->Splits();
     std::vector<std::shared_ptr<Split>> indexed_splits;
-    for (const auto& split : data_plan->Splits()) {
+    indexed_splits.reserve(data_splits.size());
+    for (const auto& split : data_splits) {
         auto data_split = std::dynamic_pointer_cast<DataSplitImpl>(split);
         if (!data_split) {
             return Status::Invalid("Cannot cast split to DataSplit when create IndexedSplit");

test/inte/global_index_test.cpp

@@ -1505,7 +1505,7 @@ TEST_P(GlobalIndexTest, TestDataEvolutionBatchScanWithPartitionWithTwoFields) {
 
     auto src_array1 = std::dynamic_pointer_cast<arrow::StructArray>(
         arrow::ipc::internal::json::ArrayFromJSON(arrow::struct_(fields_), R"([
-["Alice", 10, 1, 11.1], 
+["Alice", 10, 1, 11.1],
 ["Bob", 10, 1, 12.1],
 ["Bob", 10, 1, 16.1]
    ])")
@@ -1575,7 +1575,7 @@ TEST_P(GlobalIndexTest, TestDataEvolutionBatchScanWithPartitionWithTwoFields) {
         ASSERT_OK_AND_ASSIGN(auto plan, ScanGlobalIndexAndData(table_path, predicate));
         auto expected_array = std::dynamic_pointer_cast<arrow::StructArray>(
             arrow::ipc::internal::json::ArrayFromJSON(arrow::struct_(result_fields), R"([
-[0, "Alice", 10, 1, 11.1], 
+[0, "Alice", 10, 1, 11.1],
 [0, "Bob", 10, 1, 12.1],
 [0, "Bob", 10, 1, 16.1],
 [0, "Lucy", 20, 1, 15.1]