Find and solve the issue

Co-authored-by: Veselin Nikolov <veselin.nikolov@neotechnology.com>

Author: IoannisPanagiotas

algo/src/main/java/org/neo4j/gds/paths/dijkstra/Dijkstra.java

@@ -217,6 +217,7 @@ private PathResult next(TraversalPredicate traversalPredicate, ImmutablePathResu
                 return pathResult(node, pathResultBuilder);
             }
         }
+
         return PathResult.EMPTY;
     }
 

algo/src/main/java/org/neo4j/gds/paths/yens/MutablePathResult.java

@@ -131,10 +131,10 @@ boolean matches(MutablePathResult path, int index) {
      */
     boolean matchesExactly(MutablePathResult path, int index) {
 
-        if (relationshipIds == null || path.relationshipIds == null) {
+        if (relationshipIds.length == 0 || path.relationshipIds.length == 0) {
             return matches(path, index);
         }
-
+        //System.out.println(Arrays.toString(Arrays.stream(relationshipIds).toArray()));
         for (int i = 0; i < index; i++) {
             if (nodeIds[i] != path.nodeIds[i]) {
                 return false;
@@ -157,7 +157,7 @@ boolean matchesExactly(MutablePathResult path, int index) {
      * The cost value associated with the last value in this path, is added to
      * the costs for each node in the second path.
      */
-    void append(MutablePathResult path) {
+    void append(MutablePathResult path, boolean shouldstore) {
         // spur node is end of first and beginning of second path
         assert nodeIds[nodeIds.length - 1] == path.nodeIds[0];
 
@@ -186,7 +186,7 @@ void append(MutablePathResult path) {
         }
 
         this.nodeIds = newNodeIds;
-        this.relationshipIds = newRelationshipIds;
+        this.relationshipIds = shouldstore ? newRelationshipIds : new long[0];
         this.costs = newCosts;
     }
 

algo/src/main/java/org/neo4j/gds/paths/yens/Yens.java

@@ -65,6 +65,16 @@ public static Yens sourceTarget(
         // If the input graph is a multi-graph, we need to track
         // parallel relationships. This is necessary since shortest
         // paths can visit the same nodes via different relationships.
+
+        System.out.println(graph.schema().relationshipSchema().toMap());
+        graph.forEachNode(nodeId -> {
+            graph.forEachRelationship(nodeId, 1.0, (s, t, w) -> {
+                System.out.println(s + "-[" + w + "]->" + t);
+                return true;
+            });
+            return true;
+        });
+
         var newConfig = ImmutableShortestPathYensBaseConfig
             .builder()
             .from(config)
@@ -101,10 +111,11 @@ private Yens(Graph graph, Dijkstra dijkstra, ShortestPathYensBaseConfig config,
         this.dijkstra = dijkstra;
         dijkstra.withRelationshipFilter((source, target, relationshipId) ->
             !nodeBlackList.contains(target) &&
-            !(relationshipBlackList.getOrDefault(source, EMPTY_SET).contains(relationshipId))
-        );
+            !(relationshipBlackList.getOrDefault(source, EMPTY_SET).contains(relationshipId)) &&
+            !(relationshipBlackList.getOrDefault(source, EMPTY_SET).contains(-target - 1)));
     }
 
+
     @Override
     public DijkstraResult compute() {
         progressTracker.beginSubTask();
@@ -139,7 +150,8 @@ public DijkstraResult compute() {
                     // Filter relationships that are part of the previous
                     // shortest paths which share the same root path.
                     if (rootPath.matchesExactly(path, n + 1)) {
-                        var relationshipId = path.relationship(n);
+                        System.out.println(i + ": " + rootPath + " |" + prevPath);
+                        var relationshipId = graph.isMultiGraph() ? path.relationship(n) : -(1 + path.node(n + 1));
 
                         var neighbors = relationshipBlackList.get(spurNode);
 
@@ -171,7 +183,7 @@ public DijkstraResult compute() {
                 }
 
                 // Entire path is made up of the root path and spur path.
-                rootPath.append(MutablePathResult.of(spurPath.get()));
+                rootPath.append(MutablePathResult.of(spurPath.get()), graph.isMultiGraph());
                 // Add the potential k-shortest path to the heap.
                 if (!candidates.contains(rootPath)) {
                     candidates.add(rootPath);
@@ -189,7 +201,10 @@ public DijkstraResult compute() {
         progressTracker.endSubTask();
 
         progressTracker.endSubTask();
-
+        System.out.println("----");
+        for (var path : kShortestPaths) {
+            System.out.println(path);
+        }
         return new DijkstraResult(kShortestPaths.stream().map(MutablePathResult::toPathResult));
     }
 

algo/src/test/java/org/neo4j/gds/paths/yens/MutablePathResultTest.java

@@ -170,7 +170,7 @@ void append() {
         var path1 = testPath(0, 1, 2);
         var path2 = testPath(2, 3, 4);
 
-        path1.append(path2);
+        path1.append(path2, true);
         var expected = testPath(0, 1, 2, 3, 4);
 
         assertEquals(expected, path1);
@@ -184,7 +184,7 @@ void appendWithOffset() {
         var expected = MutablePathResult.of(ImmutablePathResult.builder().nodeIds(0, 1, 2, 3, 4).relationshipIds(0, 1, 2, 3).costs(0, 1, 42, 55, 79).sourceNode(0).targetNode(2).index(2).build());
         //@formatter:on
 
-        p1.append(p2);
+        p1.append(p2, true);
 
         assertEquals(expected, p1);
         assertEquals(expected.totalCost(), p1.totalCost());
@@ -195,6 +195,6 @@ void appendFailedAssertion() {
         var path1 = testPath(0, 1, 2);
         var path2 = testPath(4, 3, 5);
 
-        assertThatThrownBy(() -> path1.append(path2)).isInstanceOf(AssertionError.class);
+        assertThatThrownBy(() -> path1.append(path2, true)).isInstanceOf(AssertionError.class);
     }
 }

proc/path-finding/src/test/java/org/neo4j/gds/paths/sourcetarget/ShortestPathYensProc2Test.java

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.gds.paths.sourcetarget;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.neo4j.gds.BaseProcTest;
+import org.neo4j.gds.GdsCypher;
+import org.neo4j.gds.RelationshipProjection;
+import org.neo4j.gds.catalog.GraphProjectProc;
+import org.neo4j.gds.core.Aggregation;
+import org.neo4j.gds.extension.Neo4jGraph;
+
+class ShortestPathYensProc2Tes  extends  BaseProcTest{
+
+ @Neo4jGraph
+ private static final String DB_CYPHER =
+     "CREATE (a:CITY), " +
+     "(b:CITY), " +
+     "(c:CITY), " +
+     "(d:CITY), " +
+     "(e:CITY), " +
+     "(f:CITY), " +
+     "(a)-[:ROAD]->(b), " +
+     "(a)-[:ROAD]->(b), " +
+     "(b)-[:ROAD]->(c), " +
+     "(b)-[:ROAD]->(d), " +
+     "(c)-[:ROAD]->(f), " +
+     "(d)-[:ROAD]->(e), " +
+     "(e)-[:ROAD]->(c), " +
+     "(e)-[:ROAD]->(f), " +
+     "(a)-[:PATH]->(b), " +
+     "(d)-[:PATH]->(e), " +
+     "(d)-[:PATH]->(e)";
+
+ @BeforeEach
+ void setup() throws Exception {
+  registerProcedures(
+      ShortestPathYensStreamProc.class,
+      GraphProjectProc.class
+  );
+
+  runQuery(GdsCypher.call("graph")
+      .graphProject()
+      .withAnyLabel()
+      .withRelationshipType("TYPE", RelationshipProjection.builder().type("*").aggregation(Aggregation.SINGLE).build())
+      .yields());
+ }
+
+ @Test
+ void foo() {
+  runQuery("" +
+           "MATCH (source), (target) " +
+           "WHERE id(source)=0 AND id(target)=5 " +
+           "CALL gds.shortestPath.yens.stream(" +
+           "  'graph', " +
+           "  {sourceNode:source, targetNode:target, k:3} " +
+           ") " +
+           "YIELD sourceNode " +
+           "RETURN *"
+  );
+
+
+
+ }
+ @Test
+ void bar() {
+  runQuery("CALL gds.graph.project.cypher(\n" +
+           "  'graphSingleType_NP',\n" +
+           "  'MATCH (n) RETURN id(n) AS id',\n" +
+           "  'MATCH (n)-[r]->(m) RETURN DISTINCT id(n) AS source, id(m) AS target'\n" +
+           ")");
+
+  runQuery("" +
+           "MATCH (source), (target) " +
+           "WHERE id(source)=0 AND id(target)=5 " +
+           "CALL gds.shortestPath.yens.stream(" +
+           "  'graphSingleType_NP', " +
+           "  {sourceNode:source, targetNode:target, k:3} " +
+           ") " +
+           "YIELD sourceNode " +
+           "RETURN *"
+  );
+ }
+}
+