linkedin · jcastagno · Jan 27, 2026
diff --git a/...-common/src/test/java/com/linkedin/avro/fastserde/FastGenericSerializerGeneratorTest.java b/...-common/src/test/java/com/linkedin/avro/fastserde/FastGenericSerializerGeneratorTest.java
@@ -442,6 +442,137 @@ record = decodeRecord(recordSchema, dataAsBinaryDecoder(builder));
     Assert.assertEquals(1, record.get("union"));
   }
 
+  @Test(groups = {"serializationTest"})
+  public void shouldWriteArrayOfUnionPrimitives() {
+    // given - this tests the fix for the bug where union types in arrays
+    // caused invalid Java variable names to be generated (e.g., "union[null, string]0")
+    Schema unionSchema = Schema.createUnion(Arrays.asList(
+        Schema.create(Schema.Type.NULL),
+        Schema.create(Schema.Type.STRING)
+    ));
+    Schema arrayOfUnionSchema = Schema.createArray(unionSchema);
+
+    GenericData.Array<CharSequence> unionArray = new GenericData.Array<>(0, arrayOfUnionSchema);
+    unionArray.add(new Utf8("test1"));
+    unionArray.add(null);
+    unionArray.add(new Utf8("test2"));
+
+    // when
+    List<CharSequence> result = decodeRecord(arrayOfUnionSchema, dataAsBinaryDecoder(unionArray));
+
+    // then
+    Assert.assertEquals(result.size(), 3);
+    Assert.assertEquals(result.get(0).toString(), "test1");
+    Assert.assertNull(result.get(1));
+    Assert.assertEquals(result.get(2).toString(), "test2");
+  }
+
+  @Test(groups = {"serializationTest"})
+  public void shouldWriteMapOfUnionPrimitives() {
+    // given - this tests the fix for the bug where union types in map values
+    // caused invalid Java variable names to be generated
+    Schema unionSchema = Schema.createUnion(Arrays.asList(
+        Schema.create(Schema.Type.NULL),
+        Schema.create(Schema.Type.STRING)
+    ));
+    Schema mapOfUnionSchema = Schema.createMap(unionSchema);
+
+    Map<String, CharSequence> unionMap = new HashMap<>();
+    unionMap.put("key1", new Utf8("value1"));
+    unionMap.put("key2", null);
+    unionMap.put("key3", new Utf8("value3"));
+
+    // when
+    Map<Utf8, CharSequence> result = decodeRecord(mapOfUnionSchema, dataAsBinaryDecoder(unionMap, mapOfUnionSchema));
+
+    // then
+    Assert.assertEquals(result.size(), 3);
+    Assert.assertEquals(result.get(new Utf8("key1")).toString(), "value1");
+    Assert.assertNull(result.get(new Utf8("key2")));
+    Assert.assertEquals(result.get(new Utf8("key3")).toString(), "value3");
+  }
+
+  @Test(groups = {"serializationTest"})
+  public void shouldWriteRecordWithArrayOfUnionPrimitives() {
+    // given - this tests the exact schema that triggered the original bug report
+    String schemaJson = "{\n" +
+        "  \"type\": \"record\",\n" +
+        "  \"name\": \"TestRecord\",\n" +
+        "  \"namespace\": \"com.linkedin.avro.fastserde.test\",\n" +
+        "  \"fields\": [\n" +
+        "    {\"name\": \"fields\", \"type\": {\"type\": \"array\", \"items\": [\"null\", \"string\"]}}\n" +
+        "  ]\n" +
+        "}";
+    Schema recordSchema = Schema.parse(schemaJson);
+
+    GenericData.Record record = new GenericData.Record(recordSchema);
+    GenericData.Array<CharSequence> fieldsArray = new GenericData.Array<>(0, recordSchema.getField("fields").schema());
+    fieldsArray.add(new Utf8("value1"));
+    fieldsArray.add(null);
+    fieldsArray.add(new Utf8("value2"));
+    record.put("fields", fieldsArray);
+
+    // when
+    GenericRecord result = decodeRecord(recordSchema, dataAsBinaryDecoder(record));
+
+    // then
+    @SuppressWarnings("unchecked")
+    List<CharSequence> resultFields = (List<CharSequence>) result.get("fields");
+    Assert.assertEquals(resultFields.size(), 3);
+    Assert.assertEquals(resultFields.get(0).toString(), "value1");
+    Assert.assertNull(resultFields.get(1));
+    Assert.assertEquals(resultFields.get(2).toString(), "value2");
+  }
+
+  @Test(groups = {"serializationTest"})
+  public void shouldWriteArrayOfMultiTypeUnion() {
+    // given - this tests multi-type unions (not just nullable) to ensure
+    // the naming generates valid identifiers like "union_INT_STRING_DOUBLE"
+    Schema unionSchema = Schema.createUnion(Arrays.asList(
+        Schema.create(Schema.Type.INT),
+        Schema.create(Schema.Type.STRING),
+        Schema.create(Schema.Type.DOUBLE)
+    ));
+    Schema arrayOfUnionSchema = Schema.createArray(unionSchema);
+
+    GenericData.Array<Object> unionArray = new GenericData.Array<>(0, arrayOfUnionSchema);
+    unionArray.add(42);
+    unionArray.add(new Utf8("test"));
+    unionArray.add(3.14);
+
+    // when
+    List<Object> result = decodeRecord(arrayOfUnionSchema, dataAsBinaryDecoder(unionArray));
+
+    // then
+    Assert.assertEquals(result.size(), 3);
+    Assert.assertEquals(result.get(0), 42);
+    Assert.assertEquals(result.get(1).toString(), "test");
+    Assert.assertEquals((Double) result.get(2), 3.14, 0.0001);
+  }
+
+  @Test(groups = {"serializationTest"})
+  public void shouldWriteMapOfMultiTypeUnion() {
+    // given - this tests multi-type unions in map values to ensure
+    // proper variable naming in generated code
+    Schema unionSchema = Schema.createUnion(Arrays.asList(
+        Schema.create(Schema.Type.INT),
+        Schema.create(Schema.Type.STRING)
+    ));
+    Schema mapOfUnionSchema = Schema.createMap(unionSchema);
+
+    Map<String, Object> unionMap = new HashMap<>();
+    unionMap.put("int_value", 100);
+    unionMap.put("string_value", new Utf8("hello"));
+
+    // when
+    Map<Utf8, Object> result = decodeRecord(mapOfUnionSchema, dataAsBinaryDecoder(unionMap, mapOfUnionSchema));
+
+    // then
+    Assert.assertEquals(result.size(), 2);
+    Assert.assertEquals(result.get(new Utf8("int_value")), 100);
+    Assert.assertEquals(result.get(new Utf8("string_value")).toString(), "hello");
+  }
+
   @Test(groups = {"serializationTest"})
   public void shouldWriteArrayOfRecords() {
     // given

diff --git a/...icDeserializer_1277939469_1277939469.java → ...icDeserializer_1277939469_1277939469.java b/...icDeserializer_1277939469_1277939469.java → ...icDeserializer_1277939469_1277939469.java
@@ -29,13 +29,13 @@
 import org.apache.avro.io.Decoder;
 import org.apache.avro.util.Utf8;
 
-public class Array_of_UNION_SpecificDeserializer_1277939469_1277939469
+public class Array_of_union_NULL_TestRecord_SpecificDeserializer_1277939469_1277939469
     implements FastDeserializer<List<TestRecord>>
 {
 
     private final Schema readerSchema;
 
-    public Array_of_UNION_SpecificDeserializer_1277939469_1277939469(Schema readerSchema) {
+    public Array_of_union_NULL_TestRecord_SpecificDeserializer_1277939469_1277939469(Schema readerSchema) {
         this.readerSchema = readerSchema;
     }
 

diff --git a/...ericDeserializer_777827233_777827233.java → ...ericDeserializer_777827233_777827233.java b/...ericDeserializer_777827233_777827233.java → ...ericDeserializer_777827233_777827233.java
@@ -11,7 +11,7 @@
 import org.apache.avro.io.Decoder;
 import org.apache.avro.util.Utf8;
 
-public class Array_of_UNION_GenericDeserializer_777827233_777827233
+public class Array_of_union_NULL_record_GenericDeserializer_777827233_777827233
     implements FastDeserializer<List<IndexedRecord>>
 {
 
@@ -20,7 +20,7 @@ public class Array_of_UNION_GenericDeserializer_777827233_777827233
     private final Schema arrayElemOptionSchema0;
     private final Schema field0;
 
-    public Array_of_UNION_GenericDeserializer_777827233_777827233(Schema readerSchema) {
+    public Array_of_union_NULL_record_GenericDeserializer_777827233_777827233(Schema readerSchema) {
         this.readerSchema = readerSchema;
         this.arrayArrayElemSchema0 = readerSchema.getElementType();
         this.arrayElemOptionSchema0 = arrayArrayElemSchema0 .getTypes().get(1);

diff --git a/...ificDeserializer_971650236_971650236.java → ...ificDeserializer_971650236_971650236.java b/...ificDeserializer_971650236_971650236.java → ...ificDeserializer_971650236_971650236.java
@@ -29,13 +29,13 @@
 import org.apache.avro.io.Decoder;
 import org.apache.avro.util.Utf8;
 
-public class Map_of_UNION_SpecificDeserializer_971650236_971650236
+public class Map_of_union_NULL_TestRecord_SpecificDeserializer_971650236_971650236
     implements FastDeserializer<Map<Utf8, TestRecord>>
 {
 
     private final Schema readerSchema;
 
-    public Map_of_UNION_SpecificDeserializer_971650236_971650236(Schema readerSchema) {
+    public Map_of_union_NULL_TestRecord_SpecificDeserializer_971650236_971650236(Schema readerSchema) {
         this.readerSchema = readerSchema;
     }
 

diff --git a/...icDeserializer_2140000109_2140000109.java → ...icDeserializer_2140000109_2140000109.java b/...icDeserializer_2140000109_2140000109.java → ...icDeserializer_2140000109_2140000109.java
@@ -10,7 +10,7 @@
 import org.apache.avro.io.Decoder;
 import org.apache.avro.util.Utf8;
 
-public class Map_of_UNION_GenericDeserializer_2140000109_2140000109
+public class Map_of_union_NULL_record_GenericDeserializer_2140000109_2140000109
     implements FastDeserializer<Map<Utf8, IndexedRecord>>
 {
 
@@ -19,7 +19,7 @@ public class Map_of_UNION_GenericDeserializer_2140000109_2140000109
     private final Schema mapValueOptionSchema0;
     private final Schema field0;
 
-    public Map_of_UNION_GenericDeserializer_2140000109_2140000109(Schema readerSchema) {
+    public Map_of_union_NULL_record_GenericDeserializer_2140000109_2140000109(Schema readerSchema) {
         this.readerSchema = readerSchema;
         this.mapMapValueSchema0 = readerSchema.getValueType();
         this.mapValueOptionSchema0 = mapMapValueSchema0 .getTypes().get(1);

diff --git a/...icDeserializer_2018567528_1606337179.java → ...icDeserializer_2018567528_1606337179.java b/...icDeserializer_2018567528_1606337179.java → ...icDeserializer_2018567528_1606337179.java
@@ -10,15 +10,15 @@
 import org.apache.avro.generic.IndexedRecord;
 import org.apache.avro.io.Decoder;
 
-public class UNION_GenericDeserializer_2018567528_1606337179
+public class union_NULL_Array_of_record_GenericDeserializer_2018567528_1606337179
     implements FastDeserializer<List<IndexedRecord>>
 {
 
     private final Schema readerSchema;
     private final Schema arrayArraySchema0;
     private final Schema arrayArrayElemSchema0;
 
-    public UNION_GenericDeserializer_2018567528_1606337179(Schema readerSchema) {
+    public union_NULL_Array_of_record_GenericDeserializer_2018567528_1606337179(Schema readerSchema) {
         this.readerSchema = readerSchema;
         this.arrayArraySchema0 = readerSchema.getTypes().get(1);
         this.arrayArrayElemSchema0 = arrayArraySchema0 .getElementType();

diff --git a/...ricDeserializer_568621313_1223705675.java → ...ricDeserializer_568621313_1223705675.java b/...ricDeserializer_568621313_1223705675.java → ...ricDeserializer_568621313_1223705675.java
@@ -10,15 +10,15 @@
 import org.apache.avro.io.Decoder;
 import org.apache.avro.util.Utf8;
 
-public class UNION_GenericDeserializer_568621313_1223705675
+public class union_NULL_Map_of_record_GenericDeserializer_568621313_1223705675
     implements FastDeserializer<Map<Utf8, IndexedRecord>>
 {
 
     private final Schema readerSchema;
     private final Schema mapMapSchema0;
     private final Schema mapMapValueSchema0;
 
-    public UNION_GenericDeserializer_568621313_1223705675(Schema readerSchema) {
+    public union_NULL_Map_of_record_GenericDeserializer_568621313_1223705675(Schema readerSchema) {
         this.readerSchema = readerSchema;
         this.mapMapSchema0 = readerSchema.getTypes().get(1);
         this.mapMapValueSchema0 = mapMapSchema0 .getValueType();

diff --git a/...icDeserializer_1971822364_1672473580.java → ...icDeserializer_1971822364_1672473580.java b/...icDeserializer_1971822364_1672473580.java → ...icDeserializer_1971822364_1672473580.java
@@ -8,14 +8,14 @@
 import org.apache.avro.generic.IndexedRecord;
 import org.apache.avro.io.Decoder;
 
-public class UNION_GenericDeserializer_1971822364_1672473580
+public class union_NULL_record_GenericDeserializer_1971822364_1672473580
     implements FastDeserializer<IndexedRecord>
 {
 
     private final Schema readerSchema;
     private final Schema recordRecordSchema0;
 
-    public UNION_GenericDeserializer_1971822364_1672473580(Schema readerSchema) {
+    public union_NULL_record_GenericDeserializer_1971822364_1672473580(Schema readerSchema) {
         this.readerSchema = readerSchema;
         this.recordRecordSchema0 = readerSchema.getTypes().get(1);
     }

diff --git a/...serialization/AVRO_1_11/Array_of_union_INT_STRING_DOUBLE_GenericSerializer_895888951.java b/...serialization/AVRO_1_11/Array_of_union_INT_STRING_DOUBLE_GenericSerializer_895888951.java
@@ -0,0 +1,51 @@
+
+package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_11;
+
+import java.io.IOException;
+import java.util.List;
+import com.linkedin.avro.fastserde.FastSerializer;
+import com.linkedin.avro.fastserde.customized.DatumWriterCustomization;
+import org.apache.avro.io.Encoder;
+import org.apache.avro.util.Utf8;
+
+public class Array_of_union_INT_STRING_DOUBLE_GenericSerializer_895888951
+    implements FastSerializer<List<Object>>
+{
+
+
+    public void serialize(List<Object> data, Encoder encoder, DatumWriterCustomization customization)
+        throws IOException
+    {
+        (encoder).writeArrayStart();
+        if ((data == null)||data.isEmpty()) {
+            (encoder).setItemCount(0);
+        } else {
+            (encoder).setItemCount(data.size());
+            for (int counter0 = 0; (counter0 <data.size()); counter0 ++) {
+                (encoder).startItem();
+                Object union_INT_STRING_DOUBLE0 = null;
+                union_INT_STRING_DOUBLE0 = ((List<Object> ) data).get(counter0);
+                if (union_INT_STRING_DOUBLE0 instanceof Integer) {
+                    (encoder).writeIndex(0);
+                    (encoder).writeInt(((Integer) union_INT_STRING_DOUBLE0));
+                } else {
+                    if (union_INT_STRING_DOUBLE0 instanceof CharSequence) {
+                        (encoder).writeIndex(1);
+                        if (((CharSequence) union_INT_STRING_DOUBLE0) instanceof Utf8) {
+                            (encoder).writeString(((Utf8)((CharSequence) union_INT_STRING_DOUBLE0)));
+                        } else {
+                            (encoder).writeString(((CharSequence) union_INT_STRING_DOUBLE0).toString());
+                        }
+                    } else {
+                        if (union_INT_STRING_DOUBLE0 instanceof Double) {
+                            (encoder).writeIndex(2);
+                            (encoder).writeDouble(((Double) union_INT_STRING_DOUBLE0));
+                        }
+                    }
+                }
+            }
+        }
+        (encoder).writeArrayEnd();
+    }
+
+}
diff --git a/...rated/serialization/AVRO_1_11/Array_of_union_NULL_STRING_GenericSerializer_317583799.java b/...rated/serialization/AVRO_1_11/Array_of_union_NULL_STRING_GenericSerializer_317583799.java
@@ -0,0 +1,44 @@
+
+package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_11;
+
+import java.io.IOException;
+import java.util.List;
+import com.linkedin.avro.fastserde.FastSerializer;
+import com.linkedin.avro.fastserde.customized.DatumWriterCustomization;
+import org.apache.avro.io.Encoder;
+import org.apache.avro.util.Utf8;
+
+public class Array_of_union_NULL_STRING_GenericSerializer_317583799
+    implements FastSerializer<List<CharSequence>>
+{
+
+
+    public void serialize(List<CharSequence> data, Encoder encoder, DatumWriterCustomization customization)
+        throws IOException
+    {
+        (encoder).writeArrayStart();
+        if ((data == null)||data.isEmpty()) {
+            (encoder).setItemCount(0);
+        } else {
+            (encoder).setItemCount(data.size());
+            for (int counter0 = 0; (counter0 <data.size()); counter0 ++) {
+                (encoder).startItem();
+                CharSequence union_NULL_STRING0 = null;
+                union_NULL_STRING0 = ((List<CharSequence> ) data).get(counter0);
+                if (union_NULL_STRING0 == null) {
+                    (encoder).writeIndex(0);
+                    (encoder).writeNull();
+                } else {
+                    (encoder).writeIndex(1);
+                    if (((CharSequence) union_NULL_STRING0) instanceof Utf8) {
+                        (encoder).writeString(((Utf8)((CharSequence) union_NULL_STRING0)));
+                    } else {
+                        (encoder).writeString(((CharSequence) union_NULL_STRING0).toString());
+                    }
+                }
+            }
+        }
+        (encoder).writeArrayEnd();
+    }
+
+}
diff --git a/...of_UNION_GenericSerializer_777827233.java → ...L_record_GenericSerializer_777827233.java b/...of_UNION_GenericSerializer_777827233.java → ...L_record_GenericSerializer_777827233.java
@@ -9,7 +9,7 @@
 import org.apache.avro.io.Encoder;
 import org.apache.avro.util.Utf8;
 
-public class Array_of_UNION_GenericSerializer_777827233
+public class Array_of_union_NULL_record_GenericSerializer_777827233
     implements FastSerializer<List<IndexedRecord>>
 {
 
@@ -24,15 +24,15 @@ public void serialize(List<IndexedRecord> data, Encoder encoder, DatumWriterCust
             (encoder).setItemCount(data.size());
             for (int counter0 = 0; (counter0 <data.size()); counter0 ++) {
                 (encoder).startItem();
-                IndexedRecord union0 = null;
-                union0 = ((List<IndexedRecord> ) data).get(counter0);
-                if (union0 == null) {
+                IndexedRecord union_NULL_record0 = null;
+                union_NULL_record0 = ((List<IndexedRecord> ) data).get(counter0);
+                if (union_NULL_record0 == null) {
                     (encoder).writeIndex(0);
                     (encoder).writeNull();
                 } else {
-                    if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record".equals(((IndexedRecord) union0).getSchema().getFullName())) {
+                    if ((union_NULL_record0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record".equals(((IndexedRecord) union_NULL_record0).getSchema().getFullName())) {
                         (encoder).writeIndex(1);
-                        serializeRecord0(((IndexedRecord) union0), (encoder), (customization));
+                        serializeRecord0(((IndexedRecord) union_NULL_record0), (encoder), (customization));
                     }
                 }
             }