chore: add isFieldNull method to flat record traversal nodes (#754)

Author: eduardoramirez

hollow/src/main/java/com/netflix/hollow/core/write/HollowObjectWriteRecord.java

@@ -86,6 +86,15 @@ public void reset() {
         }
     }
 
+    /**
+     * !!WARNING!! There is a bug in HollowObjectWriteRecord.writeDataTo(ByteDataArray buf)
+     * that causes it to incorrectly serialize variable-length fields (e.g. STRING, BYTES) that
+     * have been set to null using this method. These fields are written out as a byte array of
+     * `[1, 0x80]` instead of the expected `[0x80]`. In non-null values, the leading byte
+     * indicates the length of the field. It is incorrectly written as `1` for null values. This
+     * only affects use case that copy HollowObjectWriteRecord data to another buffer, it DOES NOT
+     * affect typical Hollow Producer based mechanisms.
+     */
     public void setNull(String fieldName) {
         int fieldIndex = getSchema().getPosition(fieldName);
 

hollow/src/main/java/com/netflix/hollow/core/write/objectmapper/flatrecords/FlatRecordOrdinalReader.java

@@ -249,6 +249,39 @@ public byte[] readFieldBytes(int ordinal, String field) {
     return b;
   }
 
+  public boolean isNull(int ordinal, String field) {
+    HollowSchema schema = readSchema(ordinal);
+    if (schema.getSchemaType() != HollowSchema.SchemaType.OBJECT) {
+      throw new IllegalArgumentException(String.format("Ordinal %d is not an OBJECT type (found %s)", ordinal, schema.getSchemaType()));
+    }
+
+    HollowObjectSchema.FieldType fieldType = ((HollowObjectSchema) schema).getFieldType(field);
+    if (fieldType == null) {
+      return true; // Field does not exist
+    }
+
+    int offset = skipToField(ordinal, fieldType, field);
+    if (offset == -1) {
+      return true; // Field does not exist
+    }
+
+    switch (fieldType) {
+      case BOOLEAN:
+      case INT:
+      case LONG:
+      case REFERENCE:
+      case BYTES:
+      case STRING:
+        return VarInt.readVNull(record.data, offset);
+      case FLOAT:
+        return record.data.readIntBits(offset) == HollowObjectWriteRecord.NULL_FLOAT_BITS;
+      case DOUBLE:
+        return record.data.readLongBits(offset) == HollowObjectWriteRecord.NULL_DOUBLE_BITS;
+      default:
+        throw new IllegalArgumentException("Unsupported field type: " + fieldType);
+    }
+  }
+
   private int skipToField(int ordinal, HollowObjectSchema.FieldType fieldType, String field) {
     int offset = getOrdinalOffset(ordinal);
 

hollow/src/main/java/com/netflix/hollow/core/write/objectmapper/flatrecords/traversal/FlatRecordTraversalObjectNode.java

@@ -58,6 +58,10 @@ public FlatRecordTraversalMapNode getMapFieldNode(String field) {
     return (FlatRecordTraversalMapNode) getFieldNode(field);
   }
 
+  public boolean isFieldNull(String field) {
+    return reader.isNull(ordinal, field);
+  }
+
   public FlatRecordTraversalNode getFieldNode(String field) {
     HollowObjectSchema.FieldType fieldType = schema.getFieldType(field);
     if (fieldType == null) {

hollow/src/test/java/com/netflix/hollow/core/write/objectmapper/flatrecords/traversal/FlatRecordTraversalNodeTest.java

@@ -1,7 +1,9 @@
 package com.netflix.hollow.core.write.objectmapper.flatrecords.traversal;
 
+import com.netflix.hollow.core.schema.HollowObjectSchema;
 import com.netflix.hollow.core.schema.SimpleHollowDataset;
 import com.netflix.hollow.core.util.HollowWriteStateCreator;
+import com.netflix.hollow.core.write.HollowObjectWriteRecord;
 import com.netflix.hollow.core.write.objectmapper.HollowObjectMapper;
 import com.netflix.hollow.core.write.objectmapper.flatrecords.FakeHollowSchemaIdentifierMapper;
 import com.netflix.hollow.core.write.objectmapper.flatrecords.FlatRecord;
@@ -18,6 +20,7 @@
 import org.junit.Test;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
@@ -455,6 +458,33 @@ public void testWalkKitchenSinkFlatRecordUsingSchemaHints() {
             tuple(70, 72, 73L, 74.0f));
   }
 
+  @Test
+  public void testObjectNodeFieldNullability() {
+    HollowObjectSchema schema = new HollowObjectSchema("TestSchema", 8);
+    schema.addField("f1", HollowObjectSchema.FieldType.REFERENCE, "TestReference");
+    schema.addField("f2", HollowObjectSchema.FieldType.INT);
+    schema.addField("f3", HollowObjectSchema.FieldType.LONG);
+    schema.addField("f4", HollowObjectSchema.FieldType.BOOLEAN);
+    schema.addField("f5", HollowObjectSchema.FieldType.FLOAT);
+    schema.addField("f6", HollowObjectSchema.FieldType.DOUBLE);
+    schema.addField("f7", HollowObjectSchema.FieldType.STRING);
+    schema.addField("f8", HollowObjectSchema.FieldType.BYTES);
+
+    HollowObjectWriteRecord record = new HollowObjectWriteRecord(schema);
+
+    SimpleHollowDataset dataset = new SimpleHollowDataset(Collections.singletonList(schema));
+    FlatRecordWriter flatRecordWriter = new FlatRecordWriter(dataset, new FakeHollowSchemaIdentifierMapper(dataset));
+    flatRecordWriter.write(schema, record);
+    FlatRecord flatRecord = flatRecordWriter.generateFlatRecord();
+
+    FlatRecordTraversalObjectNode node = new FlatRecordTraversalObjectNode(flatRecord);
+    for (int i = 0; i < schema.numFields(); i++) {
+      String fieldName = schema.getFieldName(i);
+      assertThat(node.isFieldNull(fieldName))
+        .as("Field '%s' should be null", fieldName)
+        .isTrue();
+    }
+  }
 
   private FlatRecord createMovieFlatRecord() {
     Movie movie1 = new Movie();

hollow/src/test/java/com/netflix/hollow/test/dto/kitchensink/KitchenSink.java

@@ -63,7 +63,6 @@ public class KitchenSink {
   public Map<MapKey, SubType> subTypeMap;
   public Map<ComplexMapKey, SubType> complexMapKeyMap;
 
-
   @HollowHashKey(fields = {"value1"})
   public Set<HashableKey> hashableSet;
   @HollowHashKey(fields = {"value1"})