validate decimal default fits the field precision

Author: huan233usc

src/iceberg/schema_field.cc

@@ -22,9 +22,12 @@
 #include <format>
 #include <string_view>
 #include <utility>
+#include <variant>
 
 #include "iceberg/expression/literal.h"
 #include "iceberg/type.h"
+#include "iceberg/util/checked_cast.h"
+#include "iceberg/util/decimal.h"
 #include "iceberg/util/formatter.h"  // IWYU pragma: keep
 #include "iceberg/util/macros.h"
 
@@ -124,6 +127,18 @@ Status ValidateDefault(const SchemaField& field, const Literal& value,
     return InvalidSchema("{} of field {} has type {} but expected {}", kind, field.name(),
                          *value.type(), *field.type());
   }
+  // A decimal literal carries a precision in its type but stores only an unscaled value,
+  // so a value that does not fit the field precision would pass the type check above yet
+  // be rejected when the metadata is parsed back. Reject it here to keep the default
+  // consistent with what the reader accepts.
+  if (field.type()->type_id() == TypeId::kDecimal &&
+      std::holds_alternative<Decimal>(value.value())) {
+    const auto& decimal_type = internal::checked_cast<const DecimalType&>(*field.type());
+    if (!std::get<Decimal>(value.value()).FitsInPrecision(decimal_type.precision())) {
+      return InvalidSchema("{} of field {} does not fit precision {}", kind, field.name(),
+                           decimal_type.precision());
+    }
+  }
   return {};
 }
 

src/iceberg/test/schema_field_test.cc

@@ -24,6 +24,8 @@
 
 #include <gtest/gtest.h>
 
+#include "iceberg/expression/literal.h"
+#include "iceberg/test/matchers.h"
 #include "iceberg/type.h"
 #include "iceberg/util/formatter.h"  // IWYU pragma: keep
 
@@ -107,4 +109,22 @@ TEST(SchemaFieldTest, WithDoc) {
   }
 }
 
+TEST(SchemaFieldTest, ValidateRejectsDecimalDefaultExceedingPrecision) {
+  // A decimal default whose unscaled value needs more digits than the field precision has
+  // the matching literal type (decimal(2, 1)) but does not fit; Validate must reject it
+  // so it is never serialized to metadata the reader would later refuse to parse.
+  SchemaField field(/*field_id=*/1, /*name=*/"d", decimal(2, 1),
+                    /*optional=*/true, /*doc=*/"",
+                    std::make_shared<const Literal>(Literal::Decimal(999, 2, 1)));
+  EXPECT_THAT(field.Validate(), IsError(ErrorKind::kInvalidSchema));
+  EXPECT_THAT(field.Validate(), HasErrorMessage("does not fit precision"));
+}
+
+TEST(SchemaFieldTest, ValidateAcceptsDecimalDefaultWithinPrecision) {
+  SchemaField field(/*field_id=*/1, /*name=*/"d", decimal(4, 1),
+                    /*optional=*/true, /*doc=*/"",
+                    std::make_shared<const Literal>(Literal::Decimal(999, 4, 1)));
+  EXPECT_THAT(field.Validate(), IsOk());
+}
+
 }  // namespace iceberg