test: add pk compaction inte test (alibaba#203)

lxy-9602 · web-flow · commit 84e0e8e0ab93 · 2026-03-31T16:33:46.000+08:00
diff --git a/include/paimon/defs.h b/include/paimon/defs.h
@@ -398,6 +398,10 @@ struct PAIMON_EXPORT Options {
     /// conf like this:  'file.format.per.level' = '0:avro,3:parquet', if the file format for level
     /// is not provided, the default format which set by FILE_FORMAT will be used.
     static const char FILE_FORMAT_PER_LEVEL[];
+    /// "file.compression.per.level" - Define different compression policies for different level,
+    /// you can add the conf like this: 'file.compression.per.level' = '0:lz4,1:zstd'.
+    /// If a level is not configured, the default compression set by FILE_COMPRESSION will be used.
+    static const char FILE_COMPRESSION_PER_LEVEL[];
 };
 
 static constexpr int64_t BATCH_WRITE_COMMIT_IDENTIFIER = std::numeric_limits<int64_t>::max();
diff --git a/src/paimon/common/defs.cpp b/src/paimon/common/defs.cpp
@@ -102,6 +102,7 @@ const char Options::LOOKUP_CACHE_SPILL_COMPRESSION[] = "lookup.cache-spill-compr
 const char Options::SPILL_COMPRESSION_ZSTD_LEVEL[] = "spill-compression.zstd-level";
 const char Options::CACHE_PAGE_SIZE[] = "cache-page-size";
 const char Options::FILE_FORMAT_PER_LEVEL[] = "file.format.per.level";
+const char Options::FILE_COMPRESSION_PER_LEVEL[] = "file.compression.per.level";
 const char Options::COMPACTION_MAX_SIZE_AMPLIFICATION_PERCENT[] =
     "compaction.max-size-amplification-percent";
 const char Options::COMPACTION_SIZE_RATIO[] = "compaction.size-ratio";
diff --git a/src/paimon/core/core_options.cpp b/src/paimon/core/core_options.cpp
@@ -296,6 +296,34 @@ class ConfigParser {
         return Status::OK();
     }
 
+    // parse file.compression.per.level
+    Status ParseFileCompressionPerLevel(
+        std::map<int32_t, std::string>* file_compression_per_level_ptr) const {
+        auto& file_compression_per_level = *file_compression_per_level_ptr;
+        std::string file_compression_per_level_str;
+        PAIMON_RETURN_NOT_OK(
+            ParseString(Options::FILE_COMPRESSION_PER_LEVEL, &file_compression_per_level_str));
+        if (!file_compression_per_level_str.empty()) {
+            auto level2compression = StringUtils::Split(file_compression_per_level_str,
+                                                        std::string(","), std::string(":"));
+            for (const auto& single_level : level2compression) {
+                if (single_level.size() != 2) {
+                    return Status::Invalid(fmt::format(
+                        "fail to parse key {}, value {} (usage example: 0:lz4,1:zstd)",
+                        Options::FILE_COMPRESSION_PER_LEVEL, file_compression_per_level_str));
+                }
+                auto level = StringUtils::StringToValue<int32_t>(single_level[0]);
+                if (!level || level.value() < 0) {
+                    return Status::Invalid(
+                        fmt::format("fail to parse level {} from string to int in {}",
+                                    single_level[0], Options::FILE_COMPRESSION_PER_LEVEL));
+                }
+                file_compression_per_level[level.value()] = single_level[1];
+            }
+        }
+        return Status::OK();
+    }
+
     bool ContainsKey(const std::string& key) const {
         return config_map_.find(key) != config_map_.end();
     }
@@ -395,6 +423,7 @@ struct CoreOptions::Impl {
     CompressOptions lookup_compress_options{"zstd", 1};
     int64_t cache_page_size = 64 * 1024;  // 64KB
     std::map<int32_t, std::shared_ptr<FileFormat>> file_format_per_level;
+    std::map<int32_t, std::string> file_compression_per_level;
 };
 
 // Parse configurations from a map and return a populated CoreOptions object
@@ -663,6 +692,9 @@ Result<CoreOptions> CoreOptions::FromMap(
     // parse file.format.per.level
     PAIMON_RETURN_NOT_OK(parser.ParseFileFormatPerLevel(&impl->file_format_per_level));
 
+    // parse file.compression.per.level
+    PAIMON_RETURN_NOT_OK(parser.ParseFileCompressionPerLevel(&impl->file_compression_per_level));
+
     PAIMON_RETURN_NOT_OK(parser.Parse<int32_t>(Options::COMPACTION_MAX_SIZE_AMPLIFICATION_PERCENT,
                                                &impl->compaction_max_size_amplification_percent));
     PAIMON_RETURN_NOT_OK(
@@ -718,6 +750,14 @@ const std::string& CoreOptions::GetFileCompression() const {
     return impl_->file_compression;
 }
 
+const std::string& CoreOptions::GetWriteFileCompression(int32_t level) const {
+    auto iter = impl_->file_compression_per_level.find(level);
+    if (iter != impl_->file_compression_per_level.end()) {
+        return iter->second;
+    }
+    return impl_->file_compression;
+}
+
 int32_t CoreOptions::GetFileCompressionZstdLevel() const {
     return impl_->file_compression_zstd_level;
 }
diff --git a/src/paimon/core/core_options.h b/src/paimon/core/core_options.h
@@ -59,6 +59,7 @@ class PAIMON_EXPORT CoreOptions {
     std::shared_ptr<FileFormat> GetWriteFileFormat(int32_t level) const;
     std::shared_ptr<FileSystem> GetFileSystem() const;
     const std::string& GetFileCompression() const;
+    const std::string& GetWriteFileCompression(int32_t level) const;
     int32_t GetFileCompressionZstdLevel() const;
     int64_t GetPageSize() const;
     int64_t GetTargetFileSize(bool has_primary_key) const;
diff --git a/src/paimon/core/core_options_test.cpp b/src/paimon/core/core_options_test.cpp
@@ -48,6 +48,8 @@ TEST(CoreOptionsTest, TestDefaultValue) {
     ASSERT_EQ("__DEFAULT_PARTITION__", core_options.GetPartitionDefaultName());
     ASSERT_EQ(std::nullopt, core_options.GetScanSnapshotId());
     ASSERT_EQ("zstd", core_options.GetFileCompression());
+    ASSERT_EQ("zstd", core_options.GetWriteFileCompression(0));
+    ASSERT_EQ("zstd", core_options.GetWriteFileCompression(3));
     ASSERT_EQ("zstd", core_options.GetManifestCompression());
     ASSERT_EQ(1, core_options.GetFileCompressionZstdLevel());
     ASSERT_EQ(StartupMode::LatestFull(), core_options.GetStartupMode());
@@ -207,7 +209,8 @@ TEST(CoreOptionsTest, TestFromMap) {
         {Options::LOOKUP_CACHE_SPILL_COMPRESSION, "lz4"},
         {Options::SPILL_COMPRESSION_ZSTD_LEVEL, "2"},
         {Options::CACHE_PAGE_SIZE, "6MB"},
-        {Options::FILE_FORMAT_PER_LEVEL, "0:AVRO,3:parquet"}};
+        {Options::FILE_FORMAT_PER_LEVEL, "0:AVRO,3:parquet"},
+        {Options::FILE_COMPRESSION_PER_LEVEL, "0:lz4,3:none"}};
 
     ASSERT_OK_AND_ASSIGN(CoreOptions core_options, CoreOptions::FromMap(options));
     auto fs = core_options.GetFileSystem();
@@ -278,6 +281,10 @@ TEST(CoreOptionsTest, TestFromMap) {
               std::optional<std::string>("FILE:///tmp/index"));
     ASSERT_EQ(core_options.GetExternalPathStrategy(), ExternalPathStrategy::ROUND_ROBIN);
     ASSERT_EQ("snappy", core_options.GetFileCompression());
+    ASSERT_EQ("lz4", core_options.GetWriteFileCompression(0));
+    ASSERT_EQ("snappy", core_options.GetWriteFileCompression(1));
+    ASSERT_EQ("none", core_options.GetWriteFileCompression(3));
+    ASSERT_EQ("snappy", core_options.GetWriteFileCompression(5));
     ASSERT_EQ("zlib", core_options.GetManifestCompression());
     ASSERT_EQ(2, core_options.GetFileCompressionZstdLevel());
     ASSERT_FALSE(core_options.EnableAdaptivePrefetchStrategy());
@@ -426,6 +433,13 @@ TEST(CoreOptionsTest, TestInvalidFileFormatPerLevel) {
                         "fail to parse level aaa from string to int in file.format.per.level");
 }
 
+TEST(CoreOptionsTest, TestInvalidFileCompressionPerLevel) {
+    ASSERT_NOK_WITH_MSG(CoreOptions::FromMap({{Options::FILE_COMPRESSION_PER_LEVEL, "0:lz4:zstd"}}),
+                        "fail to parse key file.compression.per.level, value 0:lz4:zstd");
+    ASSERT_NOK_WITH_MSG(CoreOptions::FromMap({{Options::FILE_COMPRESSION_PER_LEVEL, "abc:lz4"}}),
+                        "fail to parse level abc from string to int in file.compression.per.level");
+}
+
 TEST(CoreOptionsTest, TestCreateExternalPath) {
     std::map<std::string, std::string> options = {
         {Options::DATA_FILE_EXTERNAL_PATHS,
diff --git a/src/paimon/core/global_index/global_index_scan_impl.cpp b/src/paimon/core/global_index/global_index_scan_impl.cpp
@@ -51,7 +51,6 @@ Result<std::shared_ptr<RowRangeGlobalIndexScanner>> GlobalIndexScanImpl::CreateR
             if (!partition) {
                 partition = entry.partition;
             } else if (!(partition.value() == entry.partition)) {
-                // TODO(xinyu.lxy): add inte case
                 return Status::Invalid(
                     "input range contain multiple partitions, fail to create range scan");
             }
diff --git a/src/paimon/core/io/data_file_writer.cpp b/src/paimon/core/io/data_file_writer.cpp
@@ -54,7 +54,7 @@ Result<std::shared_ptr<DataFileMeta>> DataFileWriter::GetResult() {
     PAIMON_ASSIGN_OR_RAISE(std::vector<std::shared_ptr<ColumnStats>> field_stats, GetFieldStats());
     PAIMON_ASSIGN_OR_RAISE(SimpleStats stats,
                            SimpleStatsConverter::ToBinary(field_stats, pool_.get()));
-    // TODO(xinyu.lxy): do not support write value stats cols & first_row_id for now
+    // TODO(xinyu.lxy): do not support write value stats cols for now
     std::optional<std::string> final_path;
     if (is_external_path_) {
         PAIMON_ASSIGN_OR_RAISE(Path external_path, PathUtil::ToPath(path_));
diff --git a/src/paimon/core/io/key_value_data_file_writer.cpp b/src/paimon/core/io/key_value_data_file_writer.cpp
@@ -95,7 +95,7 @@ Result<std::shared_ptr<DataFileMeta>> KeyValueDataFileWriter::GetResult() {
     } else {
         PAIMON_RETURN_NOT_OK(GenerateKeyStatsWithAllNull(&key_stats));
     }
-    // TODO(xinyu.lxy): do not support write value stats cols & first_row_id & write_cols for now
+    // TODO(xinyu.lxy): do not support write value stats cols for now
     std::optional<std::string> final_path;
     if (is_external_path_) {
         PAIMON_ASSIGN_OR_RAISE(Path external_path, PathUtil::ToPath(path_));
diff --git a/src/paimon/core/mergetree/compact/compact_strategy.h b/src/paimon/core/mergetree/compact/compact_strategy.h
@@ -33,7 +33,7 @@ class CompactStrategy {
     virtual Result<std::optional<CompactUnit>> Pick(int32_t num_levels,
                                                     const std::vector<LevelSortedRun>& runs) = 0;
     /// Pick a compaction unit consisting of all existing files.
-    // TODO(xinyu.lxy): support RecordLevelExpire and BucketedDvMaintainer
+    // TODO(xinyu.lxy): support RecordLevelExpire
     static std::optional<CompactUnit> PickFullCompaction(
         int32_t num_levels, const std::vector<LevelSortedRun>& runs,
         const std::shared_ptr<BucketedDvMaintainer>& dv_maintainer, bool force_rewrite_all_files) {
diff --git a/src/paimon/core/mergetree/compact/lookup_merge_tree_compact_rewriter.cpp b/src/paimon/core/mergetree/compact/lookup_merge_tree_compact_rewriter.cpp
@@ -62,7 +62,10 @@ LookupMergeTreeCompactRewriter<T>::Create(
 
     // TODO(xinyu.lxy): set executor
     ReadContextBuilder read_context_builder(path_factory_cache->RootPath());
-    read_context_builder.SetOptions(options.ToMap()).EnablePrefetch(true).WithMemoryPool(pool);
+    read_context_builder.SetOptions(options.ToMap())
+        .EnablePrefetch(true)
+        .SetPrefetchMaxParallelNum(1)
+        .WithMemoryPool(pool);
     PAIMON_ASSIGN_OR_RAISE(std::shared_ptr<ReadContext> read_context,
                            read_context_builder.Finish());
 
diff --git a/src/paimon/core/mergetree/compact/merge_tree_compact_rewriter.cpp b/src/paimon/core/mergetree/compact/merge_tree_compact_rewriter.cpp
@@ -71,7 +71,10 @@ Result<std::unique_ptr<MergeTreeCompactRewriter>> MergeTreeCompactRewriter::Crea
 
     // TODO(xinyu.lxy): set executor
     ReadContextBuilder read_context_builder(path_factory_cache->RootPath());
-    read_context_builder.SetOptions(options.ToMap()).EnablePrefetch(true).WithMemoryPool(pool);
+    read_context_builder.SetOptions(options.ToMap())
+        .EnablePrefetch(true)
+        .SetPrefetchMaxParallelNum(1)
+        .WithMemoryPool(pool);
     PAIMON_ASSIGN_OR_RAISE(std::shared_ptr<ReadContext> read_context,
                            read_context_builder.Finish());
 
@@ -141,8 +144,8 @@ MergeTreeCompactRewriter::CreateRollingRowWriter(int32_t level) {
                                CreateDataFilePathFactory(format->Identifier()));
 
         auto writer = std::make_unique<KeyValueDataFileWriter>(
-            options_.GetFileCompression(), converter, schema_id_, level, FileSource::Compact(),
-            trimmed_primary_keys_, stats_extractor, write_schema_,
+            options_.GetWriteFileCompression(level), converter, schema_id_, level,
+            FileSource::Compact(), trimmed_primary_keys_, stats_extractor, write_schema_,
             data_file_path_factory->IsExternalPath(), pool_);
         PAIMON_RETURN_NOT_OK(writer->Init(options_.GetFileSystem(),
                                           data_file_path_factory->NewPath(), writer_builder));
diff --git a/src/paimon/core/mergetree/compact/merge_tree_compact_rewriter_test.cpp b/src/paimon/core/mergetree/compact/merge_tree_compact_rewriter_test.cpp
@@ -295,11 +295,3 @@ TEST_F(MergeTreeCompactRewriterTest, TestIOException) {
 }
 
 }  // namespace paimon::test
-// TODO(xinyu.lxy): e2e test
-// test multiple MergeFunction
-// test multiple RowKind
-// test external path
-// test branch
-// test with parititon
-// test key appears before value
-// test compact multiple times, reuse rewriter
diff --git a/src/paimon/core/mergetree/levels.h b/src/paimon/core/mergetree/levels.h
@@ -86,6 +86,6 @@ class Levels {
     std::shared_ptr<FieldsComparator> key_comparator_;
     std::set<std::shared_ptr<DataFileMeta>, Level0Comparator> level0_;
     std::vector<SortedRun> levels_;
-    // TODO(lisizhuo.lsz): DropFileCallback?
+    // TODO(lisizhuo.lsz): DropFileCallback
 };
 }  // namespace paimon
diff --git a/src/paimon/core/mergetree/lookup_file.h b/src/paimon/core/mergetree/lookup_file.h
@@ -103,6 +103,6 @@ class LookupFile {
     int64_t request_count_ = 0;
     int64_t hit_count_ = 0;
     bool closed_ = false;
-    // TODO(lisizhuo.lsz): callback?
+    // TODO(lisizhuo.lsz): callback
 };
 }  // namespace paimon
diff --git a/src/paimon/core/mergetree/lookup_levels.cpp b/src/paimon/core/mergetree/lookup_levels.cpp
@@ -52,7 +52,10 @@ Result<std::unique_ptr<LookupLevels<T>>> LookupLevels<T>::Create(
 
     // TODO(xinyu.lxy): set executor
     ReadContextBuilder read_context_builder(path_factory->RootPath());
-    read_context_builder.SetOptions(options.ToMap()).EnablePrefetch(true).WithMemoryPool(pool);
+    read_context_builder.SetOptions(options.ToMap())
+        .EnablePrefetch(true)
+        .SetPrefetchMaxParallelNum(1)
+        .WithMemoryPool(pool);
     PAIMON_ASSIGN_OR_RAISE(std::shared_ptr<ReadContext> read_context,
                            read_context_builder.Finish());
     PAIMON_ASSIGN_OR_RAISE(
diff --git a/src/paimon/core/mergetree/merge_tree_writer.cpp b/src/paimon/core/mergetree/merge_tree_writer.cpp
@@ -343,9 +343,9 @@ MergeTreeWriter::CreateRollingRowWriter() const {
             return Status::OK();
         };
         auto writer = std::make_unique<KeyValueDataFileWriter>(
-            options_.GetFileCompression(), converter, schema_id_, /*level=*/0, FileSource::Append(),
-            trimmed_primary_keys_, stats_extractor, write_schema_, path_factory_->IsExternalPath(),
-            pool_);
+            options_.GetWriteFileCompression(0), converter, schema_id_, /*level=*/0,
+            FileSource::Append(), trimmed_primary_keys_, stats_extractor, write_schema_,
+            path_factory_->IsExternalPath(), pool_);
         PAIMON_RETURN_NOT_OK(
             writer->Init(options_.GetFileSystem(), path_factory_->NewPath(), writer_builder));
         return writer;
diff --git a/src/paimon/core/operation/key_value_file_store_scan.h b/src/paimon/core/operation/key_value_file_store_scan.h
@@ -73,7 +73,7 @@ class KeyValueFileStoreScan : public FileStoreScan {
 
  private:
     KeyValueFileStoreScan* WithKeyFilter(const std::shared_ptr<PredicateFilter>& predicate) {
-        // TODO(yonghao.fyh): support bucket select converter
+        // TODO(xinyu.lxy): support bucket select converter
         key_filter_ = predicate;
         return this;
     }
diff --git a/src/paimon/core/operation/merge_file_split_read_test.cpp b/src/paimon/core/operation/merge_file_split_read_test.cpp
@@ -410,6 +410,7 @@ TEST_F(MergeFileSplitReadTest, TestGenerateKeyValueReadSchema) {
         EXPECT_EQ(result_fields[i], expected_fields[i]);
         EXPECT_OK_AND_ASSIGN(std::string result_str, result_fields[i].ToJsonString());
         EXPECT_OK_AND_ASSIGN(std::string expected_str, expected_fields[i].ToJsonString());
+        EXPECT_EQ(result_str, expected_str);
     }
     ASSERT_TRUE(value_schema->Equals(*expected_value_schema));
 
@@ -493,6 +494,55 @@ TEST_F(MergeFileSplitReadTest, TestGenerateKeyValueReadSchema1) {
     ASSERT_FALSE(sequence_fields_comparator);
 }
 
+// test GenerateKeyValueReadSchema with compaction mode that raw_read_schema equals table_schema
+TEST_F(MergeFileSplitReadTest, TestGenerateKeyValueReadSchema2) {
+    std::string table_path =
+        paimon::test::GetDataDir() + "parquet/pk_table_with_mor.db/pk_table_with_mor";
+    auto schema_manager = std::make_unique<SchemaManager>(fs_, table_path);
+    ASSERT_OK_AND_ASSIGN(auto table_schema, schema_manager->ReadSchema(/*schema_id=*/0));
+    ASSERT_OK_AND_ASSIGN(CoreOptions options,
+                         CoreOptions::FromMap({{Options::SEQUENCE_FIELD, "s0,s1"},
+                                               {Options::MERGE_ENGINE, "deduplicate"},
+                                               {Options::SORT_ENGINE, "min-heap"},
+                                               {Options::IGNORE_DELETE, "true"}}));
+    auto raw_read_schema = DataField::ConvertDataFieldsToArrowSchema(table_schema->Fields());
+    ASSERT_TRUE(raw_read_schema);
+
+    std::shared_ptr<arrow::Schema> value_schema;
+    std::shared_ptr<arrow::Schema> read_schema;
+    std::shared_ptr<FieldsComparator> key_comparator;
+    std::shared_ptr<FieldsComparator> sequence_fields_comparator;
+    ASSERT_OK(MergeFileSplitRead::GenerateKeyValueReadSchema(
+        *table_schema, options, raw_read_schema, &value_schema, &read_schema, &key_comparator,
+        &sequence_fields_comparator));
+
+    // check result
+    auto expected_value_schema = DataField::ConvertDataFieldsToArrowSchema(table_schema->Fields());
+    ASSERT_OK_AND_ASSIGN(auto result_fields,
+                         DataField::ConvertArrowSchemaToDataFields(value_schema));
+    ASSERT_OK_AND_ASSIGN(auto expected_fields,
+                         DataField::ConvertArrowSchemaToDataFields(expected_value_schema));
+    for (size_t i = 0; i < expected_fields.size(); i++) {
+        EXPECT_EQ(result_fields[i], expected_fields[i]);
+        EXPECT_OK_AND_ASSIGN(std::string result_str, result_fields[i].ToJsonString());
+        EXPECT_OK_AND_ASSIGN(std::string expected_str, expected_fields[i].ToJsonString());
+        EXPECT_EQ(result_str, expected_str);
+    }
+    ASSERT_TRUE(value_schema->Equals(*expected_value_schema));
+
+    auto expected_read_schema =
+        SpecialFields::CompleteSequenceAndValueKindField(expected_value_schema);
+    ASSERT_TRUE(read_schema->Equals(*expected_read_schema));
+
+    std::vector<int32_t> expected_sort_key_fields = {0, 1};
+    ASSERT_EQ(key_comparator->sort_fields_, expected_sort_key_fields);
+    ASSERT_EQ(key_comparator->is_ascending_order_, true);
+
+    std::vector<int32_t> expected_sort_seq_fields = {4, 5};
+    ASSERT_EQ(sequence_fields_comparator->sort_fields_, expected_sort_seq_fields);
+    ASSERT_EQ(sequence_fields_comparator->is_ascending_order_, true);
+}
+
 // test no predicate
 TEST_F(MergeFileSplitReadTest, TestGenerateKeyPredicates) {
     std::string table_path =
diff --git a/src/paimon/core/postpone/postpone_bucket_writer.cpp b/src/paimon/core/postpone/postpone_bucket_writer.cpp
@@ -253,8 +253,8 @@ PostponeBucketWriter::CreateRollingRowWriter() const {
             return Status::OK();
         };
         auto writer = std::make_unique<KeyValueDataFileWriter>(
-            options_.GetFileCompression(), converter, schema_id_, /*level=*/0, FileSource::Append(),
-            trimmed_primary_keys_, /*stats_extractor=*/nullptr, write_schema_,
+            options_.GetWriteFileCompression(0), converter, schema_id_, /*level=*/0,
+            FileSource::Append(), trimmed_primary_keys_, /*stats_extractor=*/nullptr, write_schema_,
             path_factory_->IsExternalPath(), pool_);
         PAIMON_RETURN_NOT_OK(
             writer->Init(options_.GetFileSystem(), path_factory_->NewPath(), writer_builder));
diff --git a/src/paimon/format/avro/avro_writer_builder.h b/src/paimon/format/avro/avro_writer_builder.h
@@ -78,7 +78,7 @@ class AvroWriterBuilder : public WriterBuilder {
             return ::avro::Codec::ZSTD_CODEC;
         } else if (file_compression == "snappy") {
             return ::avro::Codec::SNAPPY_CODEC;
-        } else if (file_compression == "null") {
+        } else if (file_compression == "null" || file_compression == "none") {
             return ::avro::Codec::NULL_CODEC;
         } else if (file_compression == "deflate") {
             return ::avro::Codec::DEFLATE_CODEC;
diff --git a/src/paimon/format/orc/orc_format_writer.cpp b/src/paimon/format/orc/orc_format_writer.cpp
@@ -257,6 +257,8 @@ Result<::orc::CompressionKind> OrcFormatWriter::ToOrcCompressionKind(
         return ::orc::CompressionKind_ZLIB;
     } else if (file_compression == "lzo") {
         return ::orc::CompressionKind_LZO;
+    } else if (file_compression == "none") {
+        return ::orc::CompressionKind_NONE;
     } else {
         return Status::Invalid("unknown compression " + file_compression);
     }
diff --git a/test/inte/pk_compaction_inte_test.cpp b/test/inte/pk_compaction_inte_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,6 @@ Result<std::shared_ptr<RowRangeGlobalIndexScanner>> GlobalIndexScanImpl::CreateR`
`51`	`51`	`if (!partition) {`
`52`	`52`	`partition = entry.partition;`
`53`	`53`	`} else if (!(partition.value() == entry.partition)) {`
`54`		`- // TODO(xinyu.lxy): add inte case`
`55`	`54`	`return Status::Invalid(`
`56`	`55`	`"input range contain multiple partitions, fail to create range scan");`
`57`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ Result<std::shared_ptr<DataFileMeta>> KeyValueDataFileWriter::GetResult() {`
`95`	`95`	`} else {`
`96`	`96`	`PAIMON_RETURN_NOT_OK(GenerateKeyStatsWithAllNull(&key_stats));`
`97`	`97`	`}`
`98`		`- // TODO(xinyu.lxy): do not support write value stats cols & first_row_id & write_cols for now`
	`98`	`+ // TODO(xinyu.lxy): do not support write value stats cols for now`
`99`	`99`	`std::optional<std::string> final_path;`
`100`	`100`	`if (is_external_path_) {`
`101`	`101`	`PAIMON_ASSIGN_OR_RAISE(Path external_path, PathUtil::ToPath(path_));`