Merge pull request #26 from jhorstmann/nested-object-with-jpa-annotations

Fix NullPointerException in ObjectFieldMapper.mapFromDbObjectNode

Author: valgog

src/main/java/de/zalando/typemapper/core/DatabaseFieldDescriptor.java

@@ -4,6 +4,7 @@
 
 import de.zalando.typemapper.annotations.DatabaseField;
 import de.zalando.typemapper.core.fieldMapper.AnyTransformer;
+import de.zalando.typemapper.core.fieldMapper.DefaultObjectMapper;
 import de.zalando.typemapper.core.fieldMapper.ObjectMapper;
 
 public class DatabaseFieldDescriptor {
@@ -23,6 +24,7 @@ public DatabaseFieldDescriptor(final Column column) {
         this.name = column.name();
         this.position = -1;
         this.transformer = AnyTransformer.class;
+        this.mapper = DefaultObjectMapper.class;
     }
 
     public String getName() {

src/main/java/de/zalando/typemapper/core/fieldMapper/ObjectFieldMapper.java

@@ -1,13 +1,15 @@
 package de.zalando.typemapper.core.fieldMapper;
 
+import static de.zalando.typemapper.postgres.PgTypeHelper.getDatabaseFieldDescriptor;
+
 import java.lang.reflect.InvocationTargetException;
 
 import java.util.List;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import de.zalando.typemapper.annotations.DatabaseField;
+import de.zalando.typemapper.core.DatabaseFieldDescriptor;
 import de.zalando.typemapper.core.Mapping;
 import de.zalando.typemapper.core.result.ArrayResultNode;
 import de.zalando.typemapper.core.result.DbResultNode;
@@ -34,13 +36,13 @@ private static boolean isRowWithAllFieldsNull(final ObjectResultNode node) {
     public static final Object mapFromDbObjectNode(final Class classz, final ObjectResultNode node,
             final Mapping mapping) throws InstantiationException, IllegalAccessException, IllegalArgumentException,
         InvocationTargetException, NotsupportedTypeException {
-        DatabaseField databaseField = mapping.getField().getAnnotation(DatabaseField.class);
+        final DatabaseFieldDescriptor descriptor = getDatabaseFieldDescriptor(mapping.getField());
         final Object value;
 
         if (mapping.isOptionalField() && isRowWithAllFieldsNull(node)) {
             value = null;
-        } else if (databaseField.mapper() != DefaultObjectMapper.class) {
-            ObjectMapper mapper = databaseField.mapper().newInstance();
+        } else if (descriptor.getMapper() != DefaultObjectMapper.class) {
+            ObjectMapper mapper = descriptor.getMapper().newInstance();
             value = mapper.unmarshalFromDbNode(node);
         } else {
             value = mapField(mapping.getFieldClass(), node);

src/test/java/de/zalando/typemapper/namedresult/ColumnTestIT.java

@@ -15,21 +15,46 @@
 import de.zalando.typemapper.core.TypeMapper;
 import de.zalando.typemapper.core.TypeMapperFactory;
 import de.zalando.typemapper.namedresult.results.ClassWithColumnDefinition;
+import de.zalando.typemapper.namedresult.results.ClassWithColumnDefinitionWithObject;
 
 @RunWith(SpringJUnit4ClassRunner.class)
 public class ColumnTestIT extends AbstractTest {
 
     @Test
     public void testColumnMappings() throws SQLException {
-        final PreparedStatement ps = connection.prepareStatement("SELECT 2 as l, 'c' as c");
+        final PreparedStatement ps = connection.prepareStatement("SELECT 1 as i, 2 as l, 'c' as c");
         final ResultSet rs = ps.executeQuery();
         final TypeMapper<?> mapper = TypeMapperFactory.createTypeMapper(ClassWithColumnDefinition.class);
         int i = 0;
         while (rs.next()) {
             final ClassWithColumnDefinition result = (ClassWithColumnDefinition) mapper.mapRow(rs, i++);
             Assert.assertNotNull(result);
+            Assert.assertEquals(1, result.getI());
             Assert.assertEquals(2, result.getL());
             Assert.assertEquals('c', result.getC());
         }
     }
+
+    @Test
+    public void testNestedColumnMappings() throws SQLException {
+        final PreparedStatement ps = connection.prepareStatement(
+                "SELECT 'test' AS name, ROW(1, 2, 'c')::tmp.simple_type AS nested");
+        final ResultSet rs = ps.executeQuery();
+        final TypeMapper<?> mapper = TypeMapperFactory.createTypeMapper(ClassWithColumnDefinitionWithObject.class);
+        int i = 0;
+        while (rs.next()) {
+            final ClassWithColumnDefinitionWithObject result = (ClassWithColumnDefinitionWithObject) mapper.mapRow(rs,
+                    i++);
+            Assert.assertNotNull(result);
+            Assert.assertEquals("test", result.getName());
+
+            final ClassWithColumnDefinition nested = result.getNested();
+            Assert.assertNotNull(nested);
+
+            Assert.assertEquals(1, nested.getI());
+            Assert.assertEquals(2, nested.getL());
+            Assert.assertEquals('c', nested.getC());
+        }
+    }
+
 }

src/test/java/de/zalando/typemapper/namedresult/results/ClassWithColumnDefinition.java

@@ -4,12 +4,23 @@
 
 public class ClassWithColumnDefinition {
 
+    @Column(name = "i")
+    public int i;
+
     @Column(name = "l")
     public long l;
 
     @Column
     public char c;
 
+    public int getI() {
+        return i;
+    }
+
+    public void setI(final int i) {
+        this.i = i;
+    }
+
     public long getL() {
         return l;
     }

src/test/java/de/zalando/typemapper/namedresult/results/ClassWithColumnDefinitionWithObject.java

@@ -0,0 +1,28 @@
+package de.zalando.typemapper.namedresult.results;
+
+import javax.persistence.Column;
+
+public class ClassWithColumnDefinitionWithObject {
+
+    @Column(name = "name")
+    public String name;
+
+    @Column(name = "nested")
+    public ClassWithColumnDefinition nested;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(final String name) {
+        this.name = name;
+    }
+
+    public ClassWithColumnDefinition getNested() {
+        return nested;
+    }
+
+    public void setNested(final ClassWithColumnDefinition nested) {
+        this.nested = nested;
+    }
+}