fix clang

Author: lxy-9602

include/paimon/format/format_writer.h

@@ -22,10 +22,7 @@
 #include "paimon/type_fwd.h"
 
 struct ArrowArray;
-
-namespace arrow {
-class Schema;
-}  // namespace arrow
+struct ArrowSchema;
 
 namespace paimon {
 /// File format writer, each writer corresponds to a data file.
@@ -74,9 +71,9 @@ class PAIMON_EXPORT FormatWriter {
 
     /// Updates the schema used for serialization in the file footer.
     /// Must be called before Finish(). This allows per-field metadata
-    /// (e.g., extend MAP metadata) to be written into the file.
+    /// (e.g., shared-shredding MAP metadata) to be written into the file.
     /// The default implementation returns NotImplemented.
-    virtual Status UpdateSchema(const std::shared_ptr<arrow::Schema>& /*schema*/) {
+    virtual Status UpdateSchema(::ArrowSchema* /*schema*/) {
         return Status::NotImplemented("UpdateSchema is not supported by this format writer.");
     }
 };

src/paimon/common/data/shredding/map_shared_shredding_batch_converter.cpp

@@ -32,11 +32,12 @@
 namespace paimon {
 
 MapSharedShreddingBatchConverter::MapSharedShreddingBatchConverter(
-    std::shared_ptr<arrow::Schema> logical_schema, std::shared_ptr<arrow::Schema> physical_schema,
+    const std::shared_ptr<arrow::Schema>& logical_schema,
+    const std::shared_ptr<arrow::Schema>& physical_schema,
     const std::map<int32_t, int32_t>& column_to_num_columns,
     const std::shared_ptr<MemoryPool>& pool)
-    : logical_schema_(std::move(logical_schema)),
-      physical_schema_(std::move(physical_schema)),
+    : logical_schema_(logical_schema),
+      physical_schema_(physical_schema),
       pool_(GetArrowPool(pool)) {
     for (const auto& [col_index, num_columns] : column_to_num_columns) {
         contexts_.emplace_back(col_index, num_columns);
@@ -106,18 +107,17 @@ Result<std::shared_ptr<arrow::Array>> MapSharedShreddingBatchConverter::ConvertO
     // Create StructBuilder from physical struct type — it owns all child builders.
     PAIMON_ASSIGN_OR_RAISE_FROM_ARROW(std::unique_ptr<arrow::ArrayBuilder> struct_builder_base,
                                       arrow::MakeBuilder(physical_struct_type, pool_.get()));
-    arrow::StructBuilder* struct_builder =
-        dynamic_cast<arrow::StructBuilder*>(struct_builder_base.get());
+    auto* struct_builder = dynamic_cast<arrow::StructBuilder*>(struct_builder_base.get());
     PAIMON_CHECK_NOT_NULL(struct_builder,
                           "MapSharedShreddingBatchConverter: failed to create StructBuilder");
     PAIMON_RETURN_NOT_OK_FROM_ARROW(struct_builder->Reserve(num_rows));
 
     // Extract child builders: [field_mapping, col_0..K-1, overflow]
-    arrow::ListBuilder* field_mapping_builder =
+    auto* field_mapping_builder =
         dynamic_cast<arrow::ListBuilder*>(struct_builder->field_builder(0));
     PAIMON_CHECK_NOT_NULL(field_mapping_builder,
                           "MapSharedShreddingBatchConverter: field_mapping is not a ListBuilder");
-    arrow::Int32Builder* field_mapping_value_builder =
+    auto* field_mapping_value_builder =
         dynamic_cast<arrow::Int32Builder*>(field_mapping_builder->value_builder());
     PAIMON_CHECK_NOT_NULL(
         field_mapping_value_builder,
@@ -135,11 +135,11 @@ Result<std::shared_ptr<arrow::Array>> MapSharedShreddingBatchConverter::ConvertO
     }
 
     int32_t overflow_field_idx = 1 + num_cols;
-    arrow::MapBuilder* overflow_builder =
+    auto* overflow_builder =
         dynamic_cast<arrow::MapBuilder*>(struct_builder->field_builder(overflow_field_idx));
     PAIMON_CHECK_NOT_NULL(overflow_builder,
                           "MapSharedShreddingBatchConverter: overflow is not a MapBuilder");
-    arrow::Int32Builder* overflow_key_builder =
+    auto* overflow_key_builder =
         dynamic_cast<arrow::Int32Builder*>(overflow_builder->key_builder());
     PAIMON_CHECK_NOT_NULL(overflow_key_builder,
                           "MapSharedShreddingBatchConverter: overflow key is not Int32Builder");
@@ -257,13 +257,6 @@ Status MapSharedShreddingBatchConverter::AppendOverflow(
     return Status::OK();
 }
 
-void MapSharedShreddingBatchConverter::Reset() {
-    for (auto& context : contexts_) {
-        context.dict.Reset();
-        context.allocator.Reset();
-    }
-}
-
 MapSharedShreddingFieldMeta MapSharedShreddingBatchConverter::BuildFieldMeta(
     int32_t logical_col_index) const {
     for (const auto& context : contexts_) {

src/paimon/common/data/shredding/map_shared_shredding_batch_converter.h

@@ -59,8 +59,8 @@ class MapSharedShreddingBatchConverter {
     /// @param physical_schema The physical schema (MAP columns replaced with STRUCT).
     /// @param column_to_num_columns Map from logical column index to K.
     /// @param pool Paimon memory pool for Arrow allocations.
-    MapSharedShreddingBatchConverter(std::shared_ptr<arrow::Schema> logical_schema,
-                                     std::shared_ptr<arrow::Schema> physical_schema,
+    MapSharedShreddingBatchConverter(const std::shared_ptr<arrow::Schema>& logical_schema,
+                                     const std::shared_ptr<arrow::Schema>& physical_schema,
                                      const std::map<int32_t, int32_t>& column_to_num_columns,
                                      const std::shared_ptr<MemoryPool>& pool);
 
@@ -69,10 +69,6 @@ class MapSharedShreddingBatchConverter {
     /// @return Owned physical ArrowArray (C ABI) with physical schema.
     Result<std::unique_ptr<ArrowArray>> Convert(ArrowArray* logical_batch);
 
-    /// Resets dict and allocator state for all shredding columns.
-    /// Called when rolling to a new file.
-    void Reset();
-
     /// Builds MapSharedShreddingFieldMeta for one shredding column (by logical index).
     /// Called at file close to serialize metadata.
     MapSharedShreddingFieldMeta BuildFieldMeta(int32_t logical_col_index) const;

src/paimon/common/data/shredding/map_shared_shredding_batch_converter_test.cpp

@@ -105,75 +105,6 @@ TEST_F(MapSharedShreddingBatchConverterTest, BasicConversion) {
     ASSERT_EQ(expected_meta, converter.BuildFieldMeta(1));
 }
 
-TEST_F(MapSharedShreddingBatchConverterTest, MultiConvertResetAndFileMeta) {
-    auto logical_schema = arrow::schema({
-        arrow::field("id", arrow::int32()),
-        arrow::field("tags", arrow::map(arrow::utf8(), arrow::int64())),
-    });
-    std::map<int32_t, int32_t> column_to_num_columns = {{1, 3}};
-    ASSERT_OK_AND_ASSIGN(auto physical_schema, MapSharedShreddingUtils::LogicalToPhysicalSchema(
-                                                   logical_schema, column_to_num_columns));
-    MapSharedShreddingBatchConverter converter(logical_schema, physical_schema,
-                                               column_to_num_columns, pool_);
-
-    auto logical_type = arrow::struct_(logical_schema->fields());
-    auto physical_type = arrow::struct_(physical_schema->fields());
-
-    // --- File 1: two batches ---
-    // Batch1: {x:1, y:2}
-    RunConvert(&converter, logical_type, physical_type, R"([
-        [1, [["x", 1], ["y", 2]]]
-    ])");
-    // Batch2: {y:3, z:4, w:5, v:6} — 4 fields, K=3 -> 1 overflow
-    auto actual2 = RunConvert(&converter, logical_type, physical_type, R"([
-        [2, [["y", 3], ["z", 4], ["w", 5], ["v", 6]]]
-    ])");
-
-    // Verify batch2 output: y=fid1->col0, z=fid2->col1, w=fid3->col2, v=fid4->overflow
-    auto expected2 = ArrayFromJSON(physical_type, R"([
-        [2, [[1, 2, 3], 3, 4, 5, [[4, 6]]]]
-    ])")
-                         .ValueOrDie();
-    AssertArrayEquals(expected2, actual2);
-
-    // File1 meta: x=0,y=1,z=2,w=3,v=4; K=3, max_row_width=4; v overflowed
-    MapSharedShreddingFieldMeta expected_meta1;
-    expected_meta1.name_to_id = {{"x", 0}, {"y", 1}, {"z", 2}, {"w", 3}, {"v", 4}};
-    expected_meta1.field_to_columns = {{0, {0}}, {1, {0, 1}}, {2, {1}}, {3, {2}}};
-    expected_meta1.overflow_field_set = {4};
-    expected_meta1.num_columns = 3;
-    expected_meta1.max_row_width = 4;
-    ASSERT_EQ(expected_meta1, converter.BuildFieldMeta(1));
-
-    // --- Reset for File 2 ---
-    converter.Reset();
-
-    // After reset, meta should be empty except num_columns (K is preserved)
-    MapSharedShreddingFieldMeta empty_meta;
-    empty_meta.num_columns = 3;
-    ASSERT_EQ(empty_meta, converter.BuildFieldMeta(1));
-
-    // File 2: single batch with new keys — field_ids restart from 0
-    auto actual3 = RunConvert(&converter, logical_type, physical_type, R"([
-        [10, [["p", 100], ["q", 200]]]
-    ])");
-    auto expected3 = ArrayFromJSON(physical_type, R"([
-        [10, [[0, 1, -1], 100, 200, null, []]]
-    ])")
-                         .ValueOrDie();
-    AssertArrayEquals(expected3, actual3);
-
-    MapSharedShreddingFieldMeta expected_meta2;
-    expected_meta2.name_to_id = {{"p", 0}, {"q", 1}};
-    expected_meta2.field_to_columns = {{0, {0}}, {1, {1}}};
-    expected_meta2.num_columns = 3;
-    expected_meta2.max_row_width = 2;
-    ASSERT_EQ(expected_meta2, converter.BuildFieldMeta(1));
-
-    // GetShreddingColumnIndices unchanged across resets
-    ASSERT_EQ(std::vector<int32_t>({1}), converter.GetShreddingColumnIndices());
-}
-
 TEST_F(MapSharedShreddingBatchConverterTest, NestedValueStruct) {
     // MAP<STRING, STRUCT<x:INT32, y:DOUBLE>>, K=2
     auto value_type = arrow::struct_({

src/paimon/common/data/shredding/map_shared_shredding_column_allocator.cpp

@@ -46,12 +46,6 @@ RowAllocation MapSharedShreddingColumnAllocator::AllocateRow(
     return result;
 }
 
-void MapSharedShreddingColumnAllocator::Reset() {
-    field_to_columns_.clear();
-    overflow_field_set_.clear();
-    max_row_width_ = 0;
-}
-
 const std::map<int32_t, std::set<int32_t>>& MapSharedShreddingColumnAllocator::GetFieldToColumns()
     const {
     return field_to_columns_;

src/paimon/common/data/shredding/map_shared_shredding_column_allocator.h

@@ -38,8 +38,9 @@ struct RowAllocation {
 /// Allocates MAP field ids to K physical columns on a per-row basis,
 /// and accumulates file-level metadata (field_to_columns, overflow_field_set, max_row_width).
 ///
-/// This is a fake (trivial) implementation: each row simply assigns columns 0..min(N,K)-1
+/// This is a trivial implementation: each row simply assigns columns 0..min(N,K)-1
 /// in order, with no LRU eviction. The real strategy will be implemented separately.
+/// TODO(jinli.zjw): support LRU
 class MapSharedShreddingColumnAllocator {
  public:
     /// @param num_columns Number of physical columns K for this shared-shredding MAP column.
@@ -50,9 +51,6 @@ class MapSharedShreddingColumnAllocator {
     /// @return Allocation result with column assignments and overflow list.
     RowAllocation AllocateRow(const std::vector<int32_t>& field_ids);
 
-    /// Resets all state. Called when rolling to a new file.
-    void Reset();
-
     /// Returns accumulated field_id -> set of column indices (for MapSharedShreddingFileMeta).
     const std::map<int32_t, std::set<int32_t>>& GetFieldToColumns() const;
 

src/paimon/common/data/shredding/map_shared_shredding_column_allocator_test.cpp

@@ -108,26 +108,6 @@ TEST(MapSharedShreddingColumnAllocatorTest, OverflowFieldSetAccumulated) {
     ASSERT_EQ(std::set<int32_t>({3, 6, 7}), overflow_set);
 }
 
-TEST(MapSharedShreddingColumnAllocatorTest, ResetClearsAll) {
-    MapSharedShreddingColumnAllocator allocator(2);
-
-    allocator.AllocateRow({1, 2, 3});
-    ASSERT_EQ(3, allocator.GetMaxRowWidth());
-    ASSERT_FALSE(allocator.GetFieldToColumns().empty());
-    ASSERT_FALSE(allocator.GetOverflowFieldSet().empty());
-
-    allocator.Reset();
-    ASSERT_EQ(0, allocator.GetMaxRowWidth());
-    ASSERT_TRUE(allocator.GetFieldToColumns().empty());
-    ASSERT_TRUE(allocator.GetOverflowFieldSet().empty());
-
-    // Works correctly after reset
-    auto result = allocator.AllocateRow({10});
-    ASSERT_EQ(2u, result.col_to_field.size());
-    ASSERT_EQ(10, result.col_to_field[0]);
-    ASSERT_EQ(-1, result.col_to_field[1]);
-}
-
 TEST(MapSharedShreddingColumnAllocatorTest, GetNumColumns) {
     MapSharedShreddingColumnAllocator allocator(5);
     ASSERT_EQ(5, allocator.GetNumColumns());

src/paimon/common/data/shredding/map_shared_shredding_context.cpp

@@ -17,12 +17,12 @@
 #include "paimon/common/data/shredding/map_shared_shredding_context.h"
 
 #include <algorithm>
-#include <utility>
 
 namespace paimon {
 
-MapSharedShreddingContext::MapSharedShreddingContext(std::map<int32_t, int32_t> column_to_k_max)
-    : column_to_k_max_(std::move(column_to_k_max)) {}
+MapSharedShreddingContext::MapSharedShreddingContext(
+    const std::map<int32_t, int32_t>& column_to_k_max)
+    : column_to_k_max_(column_to_k_max) {}
 
 std::map<int32_t, int32_t> MapSharedShreddingContext::ComputeNextK() const {
     std::map<int32_t, int32_t> result;

src/paimon/common/data/shredding/map_shared_shredding_context.h

@@ -33,7 +33,7 @@ namespace paimon {
 class MapSharedShreddingContext {
  public:
     /// @param column_to_k_max Map from logical column index to its K_max (from options).
-    explicit MapSharedShreddingContext(std::map<int32_t, int32_t> column_to_k_max);
+    explicit MapSharedShreddingContext(const std::map<int32_t, int32_t>& column_to_k_max);
 
     /// Returns the K to use for each extend column in the next file.
     /// First file returns K_max for all columns; subsequent files adapt

src/paimon/common/data/shredding/map_shared_shredding_field_dict.h

@@ -52,12 +52,6 @@ class MapSharedShreddingFieldDict {
         return next_id_;
     }
 
-    /// Resets all state. Called when rolling to a new file.
-    void Reset() {
-        name_to_id_.clear();
-        next_id_ = 0;
-    }
-
  private:
     std::map<std::string, int32_t> name_to_id_;
     int32_t next_id_ = 0;