DATAGRAPH-1392 - Optimize loading of cyclic data.

Currently the data for a model that forms a cycle containing
same node labels will be cut off on a certain level.
This commit changes the query creation and mapping to make use
of the path functionality in Neo4j.

Author: meistermeier

pom.xml

@@ -79,7 +79,7 @@
 		<cdi>2.0</cdi>
 		<changelist>-SNAPSHOT</changelist>
 		<checkstyle.version>8.29</checkstyle.version>
-		<cypher-dsl.version>2020.1.0</cypher-dsl.version>
+		<cypher-dsl.version>2020.1.1</cypher-dsl.version>
 		<dist.id>spring-data-neo4j</dist.id>
 		<dist.key>SDNEO4J</dist.key>
 		<flatten-maven-plugin.version>1.2.1</flatten-maven-plugin.version>

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

@@ -40,6 +40,7 @@ public final class Constants {
 	public static final String NAME_OF_PROPERTIES_PARAM = "__properties__";
 	public static final String NAME_OF_STATIC_LABELS_PARAM = "__staticLabels__";
 	public static final String NAME_OF_ENTITY_LIST_PARAM = "__entities__";
+	public static final String NAME_OF_PATHS = "__paths__";
 
 	public static final String FROM_ID_PARAMETER_NAME = "fromId";
 

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

@@ -25,8 +25,9 @@
 
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
 
@@ -37,6 +38,7 @@
 import org.neo4j.cypherdsl.core.Expression;
 import org.neo4j.cypherdsl.core.Functions;
 import org.neo4j.cypherdsl.core.MapProjection;
+import org.neo4j.cypherdsl.core.NamedPath;
 import org.neo4j.cypherdsl.core.Node;
 import org.neo4j.cypherdsl.core.Parameter;
 import org.neo4j.cypherdsl.core.Relationship;
@@ -70,8 +72,6 @@ public enum CypherGenerator {
 
 	private static final SymbolicName RELATIONSHIP_NAME = Cypher.name("relProps");
 
-	private static final int RELATIONSHIP_DEPTH_LIMIT = 2;
-
 	/**
 	 * @param nodeDescription The node description for which a match clause should be generated
 	 * @return An ongoing match
@@ -327,28 +327,101 @@ public Expression createReturnStatementForMatch(NodeDescription<?> nodeDescripti
 		Predicate<String> includeField = s -> inputProperties == null || inputProperties.isEmpty()
 				|| inputProperties.contains(s);
 
+		SymbolicName nodeName = Constants.NAME_OF_ROOT_NODE;
 		List<RelationshipDescription> processedRelationships = new ArrayList<>();
+		boolean containsPossibleCircles = containsPossibleCircles(nodeDescription);
 
-		return projectPropertiesAndRelationships(nodeDescription, Constants.NAME_OF_ROOT_NODE, includeField,
-				processedRelationships);
+		return projectPropertiesAndRelationships(nodeDescription, nodeName, includeField,
+				processedRelationships, containsPossibleCircles);
 	}
 
+	// recursive entry point for relationships in return statement
 	private MapProjection projectAllPropertiesAndRelationships(NodeDescription<?> nodeDescription, SymbolicName nodeName,
 			List<RelationshipDescription> processedRelationships) {
 
 		Predicate<String> includeAllFields = (field) -> true;
-		return projectPropertiesAndRelationships(nodeDescription, nodeName, includeAllFields, processedRelationships);
+		// Because we are getting called recursive, there cannot be any circle
+		return projectPropertiesAndRelationships(nodeDescription, nodeName, includeAllFields, processedRelationships,
+				false);
 	}
 
 	private MapProjection projectPropertiesAndRelationships(NodeDescription<?> nodeDescription, SymbolicName nodeName,
-			Predicate<String> includeProperty, List<RelationshipDescription> processedRelationships) {
+			Predicate<String> includeProperty, List<RelationshipDescription> processedRelationships,
+			boolean containsPossibleCircles) {
+
+		List<Object> propertiesProjection = projectNodeProperties(nodeDescription, nodeName, includeProperty);
+		List<Object> contentOfProjection = new ArrayList<>(propertiesProjection);
+		if (containsPossibleCircles) {
+			Relationship pattern = anyNode(nodeName).relationshipBetween(anyNode(),
+					collectAllRelationshipTypes(nodeDescription)).unbounded();
+			NamedPath p = Cypher.path("p").definedBy(pattern);
+			contentOfProjection.add(Constants.NAME_OF_PATHS);
+			contentOfProjection.add(Cypher.listBasedOn(p).returning(p));
+		} else {
+			contentOfProjection.addAll(
+					generateListsFor(nodeDescription.getRelationships(), nodeName, includeProperty, processedRelationships));
+		}
+		return Cypher.anyNode(nodeName).project(contentOfProjection);
+	}
 
-		List<Object> contentOfProjection = new ArrayList<>();
-		contentOfProjection.addAll(projectNodeProperties(nodeDescription, nodeName, includeProperty));
-		contentOfProjection.addAll(
-				generateListsFor(nodeDescription.getRelationships(), nodeName, includeProperty, processedRelationships));
+	private boolean containsPossibleCircles(NodeDescription<?> nodeDescription) {
+		Collection<RelationshipDescription> relationships = nodeDescription.getRelationships();
 
-		return Cypher.anyNode(nodeName).project(contentOfProjection);
+		Set<RelationshipDescription> processedRelationships = new HashSet<>();
+		for (RelationshipDescription relationship : relationships) {
+			if (processedRelationships.contains(relationship)) {
+				return true;
+			}
+			processedRelationships.add(relationship);
+			if (containsPossibleCircles(relationship.getTarget(), processedRelationships)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private boolean containsPossibleCircles(NodeDescription<?> nodeDescription, Set<RelationshipDescription> processedRelationships) {
+		Collection<RelationshipDescription> relationships = nodeDescription.getRelationships();
+
+		for (RelationshipDescription relationship : relationships) {
+			if (processedRelationships.contains(relationship)) {
+				return true;
+			}
+			processedRelationships.add(relationship);
+			if (containsPossibleCircles(relationship.getTarget(), processedRelationships)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private String[] collectAllRelationshipTypes(NodeDescription<?> nodeDescription) {
+		Set<String> relationshipTypes = new HashSet<>();
+
+		for (RelationshipDescription relationshipDescription : nodeDescription.getRelationships()) {
+			String relationshipType = relationshipDescription.getType();
+			if (relationshipTypes.contains(relationshipType)) {
+				break;
+			}
+			if (relationshipDescription.isDynamic()) {
+				relationshipTypes.clear();
+				break;
+			}
+			relationshipTypes.add(relationshipType);
+			collectAllRelationshipTypes(relationshipDescription.getTarget(), relationshipTypes);
+		}
+		return relationshipTypes.toArray(new String[0]);
+	}
+
+	private void collectAllRelationshipTypes(NodeDescription<?> nodeDescription, Set<String> processedRelationshipTypes) {
+
+		for (RelationshipDescription relationshipDescription : nodeDescription.getRelationships()) {
+			String relationshipType = relationshipDescription.getType();
+			if (processedRelationshipTypes.contains(relationshipType)) {
+				continue;
+			}
+			processedRelationshipTypes.add(relationshipType);
+		}
 	}
 
 	/**
@@ -400,10 +473,6 @@ private List<Object> generateListsFor(Collection<RelationshipDescription> relati
 				continue;
 			}
 
-			if (Collections.frequency(processedRelationships, relationshipDescription) > RELATIONSHIP_DEPTH_LIMIT) {
-				return mapProjectionLists;
-			}
-
 			generateListFor(relationshipDescription, nodeName, processedRelationships, fieldName, mapProjectionLists);
 		}