@Decimal annotation created. Avro schema for a field annotated with @Decimal is created with logical type decimal and type either bytes (by default) or fixed.

MichalFoksa · MichalFoksa · commit 52705c850a1b · 2025-01-01T23:07:01.000+01:00
diff --git a/avro/src/main/java/com/fasterxml/jackson/dataformat/avro/annotation/Decimal.java b/avro/src/main/java/com/fasterxml/jackson/dataformat/avro/annotation/Decimal.java
@@ -0,0 +1,34 @@
+package com.fasterxml.jackson.dataformat.avro.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Instructs the {@link com.fasterxml.jackson.dataformat.avro.schema.AvroSchemaGenerator AvroSchemaGenerator}
+ * to declare the annotated property's logical type as "decimal" ({@link org.apache.avro.LogicalTypes.Decimal}).
+ * By default, the Avro type is "bytes" ({@link org.apache.avro.Schema.Type#BYTES}), unless the field is also
+ * annotated with {@link com.fasterxml.jackson.dataformat.avro.AvroFixedSize}, in which case the Avro type
+ * will be "fixed" ({@link org.apache.avro.Schema.Type#FIXED}).
+ * <p>
+ * This annotation is only used during Avro schema generation and does not affect data serialization
+ * or deserialization.
+ *
+ * @since 2.19
+ */
+@Target({ElementType.ANNOTATION_TYPE, ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Decimal {
+
+    /**
+     * Maximum precision of decimals stored in this type.
+     */
+    int precision();
+
+    /**
+     * Scale must be zero or a positive integer less than or equal to the precision.
+     */
+    int scale() default 0;
+
+}
diff --git a/avro/src/main/java/com/fasterxml/jackson/dataformat/avro/schema/RecordVisitor.java b/avro/src/main/java/com/fasterxml/jackson/dataformat/avro/schema/RecordVisitor.java
@@ -4,6 +4,8 @@
 import java.util.List;
 import java.util.Map;
 
+import com.fasterxml.jackson.dataformat.avro.annotation.Decimal;
+import org.apache.avro.LogicalTypes;
 import org.apache.avro.Schema;
 import org.apache.avro.Schema.Type;
 import org.apache.avro.reflect.AvroMeta;
@@ -141,17 +143,26 @@ public void optionalProperty(String name, JsonFormatVisitable handler,
 
     protected Schema.Field schemaFieldForWriter(BeanProperty prop, boolean optional) throws JsonMappingException
     {
-        Schema writerSchema;
+        Schema writerSchema = null;
         // Check if schema for property is overridden
         AvroSchema schemaOverride = prop.getAnnotation(AvroSchema.class);
         if (schemaOverride != null) {
             Schema.Parser parser = new Schema.Parser();
             writerSchema = parser.parse(schemaOverride.value());
         } else {
-            AvroFixedSize fixedSize = prop.getAnnotation(AvroFixedSize.class);
-            if (fixedSize != null) {
+            if (prop.getAnnotation(AvroFixedSize.class) != null) {
+                AvroFixedSize fixedSize = prop.getAnnotation(AvroFixedSize.class);
                 writerSchema = Schema.createFixed(fixedSize.typeName(), null, fixedSize.typeNamespace(), fixedSize.size());
-            } else {
+            }
+            if (_visitorWrapper.isLogicalTypesEnabled() && prop.getAnnotation(Decimal.class) != null) {
+                if (writerSchema == null) {
+                    writerSchema = Schema.create(Type.BYTES);
+                }
+                Decimal decimal = prop.getAnnotation(Decimal.class);
+                writerSchema = LogicalTypes.decimal(decimal.precision(), decimal.scale())
+                        .addToSchema(writerSchema);
+            }
+            if (writerSchema == null) {
                 JsonSerializer<?> ser = null;
 
                 // 23-Nov-2012, tatu: Ideally shouldn't need to do this but...
@@ -204,7 +215,7 @@ protected Schema.Field schemaFieldForWriter(BeanProperty prop, boolean optional)
 
     /**
      * A union schema with a default value must always have the schema branch corresponding to the default value first, or Avro will print a
-     * warning complaining that the default value is not compatible. If {@code schema} is a {@link Schema.Type#UNION UNION} schema and
+     * warning complaining that the default value is not compatible. If {@code schema} is a {@link Type#UNION UNION} schema and
      * {@code defaultValue} is non-{@code null}, this finds the appropriate branch in the union and reorders the union so that it is first.
      *
      * @param schema
diff --git a/avro/src/test/java/com/fasterxml/jackson/dataformat/avro/BigDecimalTest.java b/avro/src/test/java/com/fasterxml/jackson/dataformat/avro/BigDecimalTest.java
@@ -2,11 +2,85 @@
 
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.dataformat.avro.annotation.Decimal;
+import com.fasterxml.jackson.dataformat.avro.schema.AvroSchemaGenerator;
+import org.apache.avro.LogicalTypes;
+import org.apache.avro.Schema;
+import org.junit.Test;
 
 import java.math.BigDecimal;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 public class BigDecimalTest extends AvroTestBase
 {
+    private static final AvroMapper MAPPER = new AvroMapper();
+
+    static class BigDecimalWithDecimalAnnotationToBytesWrapper {
+        @JsonProperty(required = true) // field is made required only to have simpler avro schema
+        @Decimal(precision = 10, scale = 2)
+        public BigDecimal bigDecimalValue;
+
+        public BigDecimalWithDecimalAnnotationToBytesWrapper(BigDecimal bigDecimalValue) {
+            this.bigDecimalValue = bigDecimalValue;
+        }
+    }
+
+    @Test
+    public void testSchemaCreationOnBigDecimalWithDecimalAnnotationToBytes() throws JsonMappingException {
+        // GIVEN
+        AvroSchemaGenerator gen = new AvroSchemaGenerator()
+                .enableLogicalTypes();
+
+        // WHEN
+        MAPPER.acceptJsonFormatVisitor(BigDecimalWithDecimalAnnotationToBytesWrapper.class, gen);
+        final Schema actualSchema = gen.getGeneratedSchema().getAvroSchema();
+
+        System.out.println(BigDecimalWithDecimalAnnotationToBytesWrapper.class.getSimpleName() + " schema:\n" + actualSchema.toString(true));
+
+        // THEN
+        assertThat(actualSchema.getField("bigDecimalValue")).isNotNull();
+
+        Schema bigDecimalValue = actualSchema.getField("bigDecimalValue").schema();
+        assertThat(bigDecimalValue.getType()).isEqualTo(Schema.Type.BYTES);
+        assertThat(bigDecimalValue.getLogicalType()).isEqualTo(LogicalTypes.decimal(10, 2));
+        assertThat(bigDecimalValue.getProp("java-class")).isNull();
+    }
+
+    static class BigDecimalWithDecimalAnnotationToFixedWrapper {
+        @JsonProperty(required = true) // field is made required only to have simpler avro schema
+        @AvroFixedSize(typeName = "BigDecimalWithDecimalAnnotationToFixedWrapper", size = 10)
+        @Decimal(precision = 6, scale = 3)
+        public BigDecimal bigDecimalValue;
+
+        public BigDecimalWithDecimalAnnotationToFixedWrapper(BigDecimal bigDecimalValue) {
+            this.bigDecimalValue = bigDecimalValue;
+        }
+    }
+
+    @Test
+    public void testSchemaCreationOnBigDecimalWithDecimalAnnotationToFixed() throws JsonMappingException {
+        // GIVEN
+        AvroSchemaGenerator gen = new AvroSchemaGenerator()
+                .enableLogicalTypes();
+
+        // WHEN
+        MAPPER.acceptJsonFormatVisitor(BigDecimalWithDecimalAnnotationToFixedWrapper.class, gen);
+        final Schema actualSchema = gen.getGeneratedSchema().getAvroSchema();
+
+        System.out.println(BigDecimalWithDecimalAnnotationToFixedWrapper.class.getSimpleName() + " schema:\n" + actualSchema.toString(true));
+
+        // THEN
+        assertThat(actualSchema.getField("bigDecimalValue")).isNotNull();
+
+        Schema bigDecimalValue = actualSchema.getField("bigDecimalValue").schema();
+        assertThat(bigDecimalValue.getType()).isEqualTo(Schema.Type.FIXED);
+        assertThat(bigDecimalValue.getFixedSize()).isEqualTo(10);
+        assertThat(bigDecimalValue.getLogicalType()).isEqualTo(LogicalTypes.decimal(6, 3));
+                assertThat(bigDecimalValue.getProp("java-class")).isNull();
+    }
+
     public static class NamedAmount {
         public final String name;
         public final BigDecimal amount;
@@ -20,13 +94,12 @@ public NamedAmount(@JsonProperty("name") String name,
     }
 
     public void testSerializeBigDecimal() throws Exception {
-        AvroMapper mapper = newMapper();
-        AvroSchema schema = mapper.schemaFor(NamedAmount.class);
+        AvroSchema schema = MAPPER.schemaFor(NamedAmount.class);
 
-        byte[] bytes = mapper.writer(schema)
+        byte[] bytes = MAPPER.writer(schema)
                 .writeValueAsBytes(new NamedAmount("peter", 42.0));
 
-        NamedAmount result = mapper.reader(schema).forType(NamedAmount.class).readValue(bytes);
+        NamedAmount result = MAPPER.reader(schema).forType(NamedAmount.class).readValue(bytes);
 
         assertEquals("peter", result.name);
         assertEquals(BigDecimal.valueOf(42.0), result.amount);
