refactor(avro): keep AppendDefaultToBuilder local to Avro

Row-oriented Avro decode needs per-builder appends, while Parquet uses
batch MakeDefaultArray. Share ToArrowScalar only; don't put the Avro
shape into the shared arrow literal util.

Author: huan233usc

src/iceberg/arrow/literal_util.cc

@@ -22,7 +22,6 @@
 #include <utility>
 #include <vector>
 
-#include <arrow/array/builder_base.h>
 #include <arrow/array/util.h>
 #include <arrow/buffer.h>
 #include <arrow/compute/api.h>
@@ -194,27 +193,4 @@ Result<std::shared_ptr<::arrow::Array>> MakeDefaultArray(
   return array;
 }
 
-Status AppendDefaultToBuilder(const Literal& literal, ::arrow::ArrayBuilder* builder) {
-  // The builder's own memory pool is not exposed, so the small scalar buffer uses the
-  // default pool.
-  ICEBERG_ASSIGN_OR_RAISE(std::shared_ptr<::arrow::Scalar> scalar,
-                          ToArrowScalar(literal, ::arrow::default_memory_pool()));
-
-  // For an extension builder (e.g. `arrow.uuid`) target its storage type: ToArrowScalar
-  // yields the storage scalar (fixed_size_binary(16) for uuid) and Scalar::CastTo has no
-  // kernel that targets an extension type. This mirrors MakeDefaultArray's extension
-  // handling.
-  std::shared_ptr<::arrow::DataType> target_type = builder->type();
-  if (target_type->id() == ::arrow::Type::EXTENSION) {
-    target_type = internal::checked_cast<const ::arrow::ExtensionType&>(*target_type)
-                      .storage_type();
-  }
-
-  if (!scalar->type->Equals(*target_type)) {
-    ICEBERG_ARROW_ASSIGN_OR_RETURN(scalar, scalar->CastTo(target_type));
-  }
-  ICEBERG_ARROW_RETURN_NOT_OK(builder->AppendScalar(*scalar));
-  return {};
-}
-
 }  // namespace iceberg::arrow

src/iceberg/arrow/literal_util_internal.h

@@ -44,8 +44,4 @@ Result<std::shared_ptr<::arrow::Array>> MakeDefaultArray(
     const Literal& literal, const std::shared_ptr<::arrow::DataType>& type,
     int64_t num_rows, ::arrow::MemoryPool* pool);
 
-/// \brief Append the literal value once to `builder`, e.g. to materialize a missing
-/// field with a default value while building rows one at a time.
-Status AppendDefaultToBuilder(const Literal& literal, ::arrow::ArrayBuilder* builder);
-
 }  // namespace iceberg::arrow

src/iceberg/avro/avro_data_util.cc

@@ -23,6 +23,7 @@
 #include <arrow/array/builder_primitive.h>
 #include <arrow/extension_type.h>
 #include <arrow/json/from_string.h>
+#include <arrow/scalar.h>
 #include <arrow/type.h>
 #include <arrow/util/decimal.h>
 #include <avro/Generic.hh>
@@ -90,7 +91,7 @@ Status AppendStructToBuilder(const ::avro::NodePtr& avro_node,
     } else if (field_projection.kind == FieldProjection::Kind::kNull) {
       ICEBERG_ARROW_RETURN_NOT_OK(field_builder->AppendNull());
     } else if (field_projection.kind == FieldProjection::Kind::kDefault) {
-      ICEBERG_RETURN_UNEXPECTED(arrow::AppendDefaultToBuilder(
+      ICEBERG_RETURN_UNEXPECTED(AppendDefaultToBuilder(
           std::get<Literal>(field_projection.from), field_builder));
     } else if (field_projection.kind == FieldProjection::Kind::kMetadata) {
       int32_t field_id = expected_field.field_id();
@@ -471,8 +472,7 @@ Status AppendFieldToBuilder(const ::avro::NodePtr& avro_node,
   }
 
   if (projection.kind == FieldProjection::Kind::kDefault) {
-    return arrow::AppendDefaultToBuilder(std::get<Literal>(projection.from),
-                                         array_builder);
+    return AppendDefaultToBuilder(std::get<Literal>(projection.from), array_builder);
   }
 
   const bool is_row_lineage =
@@ -506,6 +506,29 @@ Status AppendFieldToBuilder(const ::avro::NodePtr& avro_node,
 
 }  // namespace
 
+Status AppendDefaultToBuilder(const Literal& literal, ::arrow::ArrayBuilder* builder) {
+  // The builder's own memory pool is not exposed, so the small scalar buffer uses the
+  // default pool.
+  ICEBERG_ASSIGN_OR_RAISE(std::shared_ptr<::arrow::Scalar> scalar,
+                          arrow::ToArrowScalar(literal, ::arrow::default_memory_pool()));
+
+  // For an extension builder (e.g. `arrow.uuid`) target its storage type: ToArrowScalar
+  // yields the storage scalar (fixed_size_binary(16) for uuid) and Scalar::CastTo has no
+  // kernel that targets an extension type. This mirrors MakeDefaultArray's extension
+  // handling.
+  std::shared_ptr<::arrow::DataType> target_type = builder->type();
+  if (target_type->id() == ::arrow::Type::EXTENSION) {
+    target_type = internal::checked_cast<const ::arrow::ExtensionType&>(*target_type)
+                      .storage_type();
+  }
+
+  if (!scalar->type->Equals(*target_type)) {
+    ICEBERG_ARROW_ASSIGN_OR_RETURN(scalar, scalar->CastTo(target_type));
+  }
+  ICEBERG_ARROW_RETURN_NOT_OK(builder->AppendScalar(*scalar));
+  return {};
+}
+
 Status AppendDatumToBuilder(const ::avro::NodePtr& avro_node,
                             const ::avro::GenericDatum& avro_datum,
                             const SchemaProjection& projection,

src/iceberg/avro/avro_data_util_internal.h

@@ -23,10 +23,18 @@
 #include <avro/GenericDatum.hh>
 
 #include "iceberg/arrow/metadata_column_util_internal.h"
+#include "iceberg/expression/literal.h"
 #include "iceberg/schema_util.h"
 
 namespace iceberg::avro {
 
+/// \brief Append a literal once to `builder` while decoding Avro row-by-row.
+///
+/// Used to materialize `FieldProjection::Kind::kDefault`. Shares `ToArrowScalar` with
+/// Parquet's batch path (`MakeDefaultArray`); the append shape stays Avro-local because
+/// Avro builds Arrow arrays via per-row `ArrayBuilder`s rather than whole-column arrays.
+Status AppendDefaultToBuilder(const Literal& literal, ::arrow::ArrayBuilder* builder);
+
 /// \brief Append an Avro datum to an Arrow array builder.
 ///
 /// This function handles schema evolution by using the provided projection to map

src/iceberg/avro/avro_direct_decoder.cc

@@ -29,7 +29,7 @@
 #include <avro/Types.hh>
 
 #include "iceberg/arrow/arrow_status_internal.h"
-#include "iceberg/arrow/literal_util_internal.h"
+#include "iceberg/avro/avro_data_util_internal.h"
 #include "iceberg/avro/avro_direct_decoder_internal.h"
 #include "iceberg/avro/avro_schema_util_internal.h"
 #include "iceberg/metadata_columns.h"
@@ -211,7 +211,7 @@ Status DecodeStructToBuilder(const ::avro::NodePtr& avro_node, ::avro::Decoder&
     if (field_projection.kind == FieldProjection::Kind::kNull) {
       ICEBERG_ARROW_RETURN_NOT_OK(field_builder->AppendNull());
     } else if (field_projection.kind == FieldProjection::Kind::kDefault) {
-      ICEBERG_RETURN_UNEXPECTED(arrow::AppendDefaultToBuilder(
+      ICEBERG_RETURN_UNEXPECTED(AppendDefaultToBuilder(
           std::get<Literal>(field_projection.from), field_builder));
     } else if (field_projection.kind == FieldProjection::Kind::kMetadata) {
       int32_t field_id = expected_field.field_id();

src/iceberg/test/avro_data_test.cc

@@ -19,6 +19,7 @@
 
 #include <ranges>
 
+#include <arrow/array/builder_primitive.h>
 #include <arrow/c/bridge.h>
 #include <arrow/json/from_string.h>
 #include <arrow/util/decimal.h>
@@ -700,6 +701,31 @@ TEST(AppendDatumToBuilderTest, StructWithMissingDefaultFields) {
                                                      avro_data, expected_json));
 }
 
+TEST(AppendDefaultToBuilderTest, AppendsValue) {
+  ::arrow::Int64Builder builder;
+  ASSERT_THAT(AppendDefaultToBuilder(Literal::Long(42), &builder), IsOk());
+  ASSERT_THAT(AppendDefaultToBuilder(Literal::Long(42), &builder), IsOk());
+
+  std::shared_ptr<::arrow::Array> array;
+  ASSERT_TRUE(builder.Finish(&array).ok());
+  ASSERT_EQ(array->length(), 2);
+  const auto& long_array = static_cast<const ::arrow::Int64Array&>(*array);
+  ASSERT_EQ(long_array.Value(0), 42);
+  ASSERT_EQ(long_array.Value(1), 42);
+}
+
+TEST(AppendDefaultToBuilderTest, CastsToBuilderType) {
+  // The literal's natural type (int32) differs from the builder type (int64); the value
+  // is cast to the builder type.
+  ::arrow::Int64Builder builder;
+  ASSERT_THAT(AppendDefaultToBuilder(Literal::Int(7), &builder), IsOk());
+
+  std::shared_ptr<::arrow::Array> array;
+  ASSERT_TRUE(builder.Finish(&array).ok());
+  ASSERT_EQ(array->length(), 1);
+  ASSERT_EQ(static_cast<const ::arrow::Int64Array&>(*array).Value(0), 7);
+}
+
 TEST(AppendDatumToBuilderTest, NestedStructWithMissingOptionalFields) {
   Schema iceberg_schema({
       SchemaField::MakeRequired(1, "id", iceberg::int32()),

src/iceberg/test/literal_util_test.cc

@@ -25,7 +25,6 @@
 #include <vector>
 
 #include <arrow/array.h>
-#include <arrow/array/builder_primitive.h>
 #include <arrow/buffer.h>
 #include <arrow/extension/uuid.h>
 #include <arrow/scalar.h>
@@ -187,31 +186,6 @@ TEST(LiteralUtilTest, MakeDefaultArrayWrapsExtensionType) {
   }
 }
 
-TEST(LiteralUtilTest, AppendDefaultToBuilderAppendsValue) {
-  ::arrow::Int64Builder builder;
-  ASSERT_THAT(AppendDefaultToBuilder(Literal::Long(42), &builder), IsOk());
-  ASSERT_THAT(AppendDefaultToBuilder(Literal::Long(42), &builder), IsOk());
-
-  std::shared_ptr<::arrow::Array> array;
-  ASSERT_TRUE(builder.Finish(&array).ok());
-  ASSERT_EQ(array->length(), 2);
-  const auto& long_array = static_cast<const ::arrow::Int64Array&>(*array);
-  ASSERT_EQ(long_array.Value(0), 42);
-  ASSERT_EQ(long_array.Value(1), 42);
-}
-
-TEST(LiteralUtilTest, AppendDefaultToBuilderCastsToBuilderType) {
-  // The literal's natural type (int32) differs from the builder type (int64); the value
-  // is cast to the builder type.
-  ::arrow::Int64Builder builder;
-  ASSERT_THAT(AppendDefaultToBuilder(Literal::Int(7), &builder), IsOk());
-
-  std::shared_ptr<::arrow::Array> array;
-  ASSERT_TRUE(builder.Finish(&array).ok());
-  ASSERT_EQ(array->length(), 1);
-  ASSERT_EQ(static_cast<const ::arrow::Int64Array&>(*array).Value(0), 7);
-}
-
 }  // namespace
 
 }  // namespace iceberg::arrow