GH-2858 - Add re-population of properties and relationships during mapping.

Prior to this, an incomplete loaded entity, due to projection, was never
touched again to add missing properties loaded via a different relationship
and projection definition.

Author: meistermeier

src/main/java/org/springframework/data/neo4j/core/mapping/DefaultNeo4jEntityConverter.java

@@ -334,6 +334,7 @@ private <ET> ET map(MapAccessor queryResult, Neo4jPersistentEntity<ET> nodeDescr
 
 			// save final state of the bean
 			knownObjects.storeObject(internalId, bean);
+			knownObjects.mappedWithQueryResult(internalId, queryResult);
 			return bean;
 		};
 
@@ -342,7 +343,8 @@ private <ET> ET map(MapAccessor queryResult, Neo4jPersistentEntity<ET> nodeDescr
 		if (mappedObject == null) {
 			mappedObject = mappedObjectSupplier.get();
 			knownObjects.storeObject(internalId, mappedObject);
-		} else if (knownObjects.alreadyMappedInPreviousRecord(internalId)) {
+			knownObjects.mappedWithQueryResult(internalId, queryResult);
+		} else if (knownObjects.alreadyMappedInPreviousRecord(internalId) || hasMoreFields(queryResult.asMap(), knownObjects.getQueryResultsFor(internalId))) {
 			// If the object were created in a run before, it _could_ have missing relationships
 			// (e.g. due to incomplete fetching by a custom query)
 			// in such cases we will add the additional data from the next record.
@@ -357,6 +359,20 @@ private <ET> ET map(MapAccessor queryResult, Neo4jPersistentEntity<ET> nodeDescr
 		return getMostCurrentInstance(internalId, mappedObject);
 	}
 
+	private boolean hasMoreFields(Map<String, Object> currentQueryResult, Set<Map<String, Object>> savedQueryResults) {
+		if (savedQueryResults.isEmpty()) {
+			return true;
+		}
+		Set<String> currentFields = new HashSet<>(currentQueryResult.keySet());
+		Set<String> alreadyProcessedFields = new HashSet<>();
+
+		for (Map<String, Object> savedQueryResult : savedQueryResults) {
+			alreadyProcessedFields.addAll(savedQueryResult.keySet());
+		}
+		currentFields.removeAll(alreadyProcessedFields);
+		return !currentFields.isEmpty();
+	}
+
 	@Nullable
 	private <ET> ET getMostCurrentInstance(String internalId, ET fallbackInstance) {
 		return (ET) (knownObjects.getObject(internalId) != null ? knownObjects.getObject(internalId) : fallbackInstance);
@@ -383,21 +399,19 @@ private <ET> void populateProperties(MapAccessor queryResult, Neo4jPersistentEnt
 		Predicate<Neo4jPersistentProperty> isConstructorParameter = concreteNodeDescription
 				.getInstanceCreatorMetadata()::isCreatorParameter;
 
-		// if the object were mapped before, we assume that at least all properties are populated
-		if (!objectAlreadyMapped) {
-			boolean isKotlinType = KotlinDetector.isKotlinType(concreteNodeDescription.getType());
-			// Fill simple properties
-			PropertyHandler<Neo4jPersistentProperty> handler = populateFrom(queryResult, propertyAccessor,
-					isConstructorParameter, nodeDescriptionAndLabels.getDynamicLabels(), lastMappedEntity, isKotlinType);
-			PropertyHandlerSupport.of(concreteNodeDescription).doWithProperties(handler);
-		}
+		boolean isKotlinType = KotlinDetector.isKotlinType(concreteNodeDescription.getType());
+		// Fill simple properties
+		PropertyHandler<Neo4jPersistentProperty> handler = populateFrom(queryResult, propertyAccessor,
+				isConstructorParameter, nodeDescriptionAndLabels.getDynamicLabels(), lastMappedEntity, isKotlinType, objectAlreadyMapped);
+		PropertyHandlerSupport.of(concreteNodeDescription).doWithProperties(handler);
 		// in a cyclic graph / with bidirectional relationships, we could end up in a state in which we
 		// reference the start again. Because it is getting still constructed, it won't be in the knownObjects
 		// store unless we temporarily put it there.
 		knownObjects.storeObject(internalId, propertyAccessor.getBean());
+		knownObjects.mappedWithQueryResult(internalId, queryResult);
 
 		AssociationHandlerSupport.of(concreteNodeDescription).doWithAssociations(
-				populateFrom(queryResult, baseNodeDescription, propertyAccessor, isConstructorParameter, objectAlreadyMapped, relationshipsFromResult, nodesFromResult));
+				populateFrom(queryResult, baseNodeDescription, propertyAccessor, isConstructorParameter, objectAlreadyMapped, relationshipsFromResult, nodesFromResult, internalId));
 	}
 
 	@NonNull
@@ -499,22 +513,25 @@ public <T> T getParameterValue(Parameter<T, Neo4jPersistentProperty> parameter)
 
 	private PropertyHandler<Neo4jPersistentProperty> populateFrom(MapAccessor queryResult,
 			  PersistentPropertyAccessor<?> propertyAccessor, Predicate<Neo4jPersistentProperty> isConstructorParameter,
-			  Collection<String> surplusLabels, @Nullable Object targetNode, boolean ownerIsKotlinType) {
+			  Collection<String> surplusLabels, @Nullable Object targetNode, boolean ownerIsKotlinType, boolean objectAlreadyMapped) {
 
 		return property -> {
 			if (isConstructorParameter.test(property)) {
 				return;
 			}
 
 			TypeInformation<?> typeInformation = property.getTypeInformation();
-			if (property.isDynamicLabels()) {
-				propertyAccessor.setProperty(property,
-						createDynamicLabelsProperty(typeInformation, surplusLabels));
-			} else if (property.isAnnotationPresent(TargetNode.class)) {
-				if (queryResult instanceof Relationship) {
-					propertyAccessor.setProperty(property, targetNode);
+			if (!objectAlreadyMapped) {
+				if (property.isDynamicLabels()) {
+					propertyAccessor.setProperty(property,
+							createDynamicLabelsProperty(typeInformation, surplusLabels));
+				} else if (property.isAnnotationPresent(TargetNode.class)) {
+					if (queryResult instanceof Relationship) {
+						propertyAccessor.setProperty(property, targetNode);
+					}
 				}
-			} else {
+			}
+			if (!property.isDynamicLabels() && !property.isAnnotationPresent(TargetNode.class)) {
 				Object value = conversionService.readValue(extractValueOf(property, queryResult), typeInformation, property.getOptionalConverter());
 				if (value != null) {
 					Class<?> rawType = typeInformation.getType();
@@ -532,7 +549,7 @@ private static Object getValueOrDefault(boolean ownerIsKotlinType, Class<?> rawT
 
 	private AssociationHandler<Neo4jPersistentProperty> populateFrom(MapAccessor queryResult, NodeDescription<?> baseDescription,
 			PersistentPropertyAccessor<?> propertyAccessor, Predicate<Neo4jPersistentProperty> isConstructorParameter,
-		    boolean objectAlreadyMapped, Collection<Relationship> relationshipsFromResult, Collection<Node> nodesFromResult) {
+		    boolean objectAlreadyMapped, Collection<Relationship> relationshipsFromResult, Collection<Node> nodesFromResult, String internalId) {
 
 		return association -> {
 
@@ -555,15 +572,15 @@ private AssociationHandler<Neo4jPersistentProperty> populateFrom(MapAccessor que
 
 			boolean propertyValueNotNull = propertyValue != null;
 
-			boolean populatedCollection = persistentProperty.isCollectionLike()
+			boolean populatedCollection = objectAlreadyMapped && persistentProperty.isCollectionLike()
 					&& propertyValueNotNull
 					&& !((Collection<?>) propertyValue).isEmpty();
 
-			boolean populatedMap = persistentProperty.isMap()
+			boolean populatedMap = objectAlreadyMapped && persistentProperty.isMap()
 					&& propertyValueNotNull
 					&& !((Map<?, ?>) propertyValue).isEmpty();
 
-			boolean populatedScalarValue = !persistentProperty.isCollectionLike() && !persistentProperty.isMap()
+			boolean populatedScalarValue = objectAlreadyMapped && !persistentProperty.isCollectionLike() && !persistentProperty.isMap()
 					&& propertyValueNotNull;
 
 			if (populatedCollection) {
@@ -592,6 +609,7 @@ private AssociationHandler<Neo4jPersistentProperty> populateFrom(MapAccessor que
 
 			createInstanceOfRelationships(persistentProperty, queryResult, (RelationshipDescription) association, baseDescription, relationshipsFromResult, nodesFromResult)
 					.ifPresent(value -> propertyAccessor.setProperty(persistentProperty, value));
+
 		};
 	}
 
@@ -903,6 +921,7 @@ static class KnownObjects {
 		private final Set<String> idsInCreation = new HashSet<>();
 
 		private final Map<String, Integer> processedRelationships = new HashMap<>();
+		private final Map<Map<String, Object>, String> dings = new HashMap<>();
 
 		private void storeObject(@Nullable String internalId, Object object) {
 			if (internalId == null) {
@@ -1029,5 +1048,39 @@ private void nextRecord() {
 			previousRecords.addAll(internalCurrentRecord.keySet());
 			internalCurrentRecord.clear();
 		}
+
+		public void mappedWithQueryResult(String internalId, MapAccessor queryResult) {
+			try {
+				write.lock();
+				dings.put(queryResult.asMap(), internalId);
+			} finally {
+				write.unlock();
+			}
+		}
+
+		public boolean wasMappedWithQueryResult(String internalId, MapAccessor queryResult) {
+			try {
+				read.lock();
+				String potentialId = dings.get(queryResult.asMap());
+                return potentialId != null && potentialId.equals(internalId);
+			} finally {
+				read.unlock();
+			}
+		}
+
+		public Set<Map<String, Object>> getQueryResultsFor(String internalId) {
+			try {
+				Set<Map<String, Object>> matchingQueryResults = new HashSet<>();
+				read.lock();
+				for (Map.Entry<Map<String, Object>, String> queryResultsForInternalId : dings.entrySet()) {
+					if (queryResultsForInternalId.getValue().equals(internalId)) {
+						matchingQueryResults.add(queryResultsForInternalId.getKey());
+					}
+				}
+				return matchingQueryResults;
+			} finally {
+				read.unlock();
+			}
+		}
 	}
 }