Don't return relationshipsWritten in new Dijkstra result

Co-Authored-By: Lasse Westh-Nielsen <lassewesth@gmail.com>

Author: adamnsch

applications/algorithms/path-finding/src/main/java/org/neo4j/gds/applications/algorithms/pathfinding/PathFindingAlgorithmsMutateModeBusinessFacade.java

@@ -244,7 +244,7 @@ public <RESULT> RESULT singlePairShortestPathDijkstraWithPaths(
         GraphName graphName,
         ShortestPathDijkstraMutateConfig configuration,
         ResultStore resultStore,
-        ResultBuilder<ShortestPathDijkstraMutateConfig, PathFindingResult, RESULT, RelationshipsWritten> resultBuilder
+        ResultBuilder<ShortestPathDijkstraMutateConfig, PathFindingResult, RESULT, Void> resultBuilder
     ) {
 
         return algorithmProcessingTemplate.processAlgorithmAndAnySideEffects(

applications/algorithms/path-finding/src/main/java/org/neo4j/gds/applications/algorithms/pathfinding/StorePathsSideEffect.java

@@ -38,7 +38,7 @@
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.stream.Stream;
 
-public class StorePathsSideEffect implements SideEffect<PathFindingResult, RelationshipsWritten> {
+public class StorePathsSideEffect implements SideEffect<PathFindingResult, Void> {
     private final ResultStore resultStore;
     private final String relationshipTypeAsString;
     private final List<String> propertyKeys;
@@ -57,25 +57,28 @@ public StorePathsSideEffect(
     }
 
     @Override
-    public Optional<RelationshipsWritten> process(GraphResources graphResources, Optional<PathFindingResult> pathFindingResult) {
-        return pathFindingResult.map(result -> {
-                var relCounter = new AtomicLong(0);
+    public Optional<Void> process(GraphResources graphResources, Optional<PathFindingResult> pathFindingResult) {
+        if (pathFindingResult.isEmpty()) {
+            return Optional.empty();
+        }
+        var actualPathResult  = pathFindingResult.get();
+        Stream<ExportedRelationship> relationshipStream = actualPathResult.mapPaths(
+            pathResult -> new ExportedRelationship(
+                pathResult.sourceNode(),
+                pathResult.targetNode(),
+                createValues(pathResult)
+            ));
 
-                Stream<ExportedRelationship> relationshipStream = result.mapPaths(
-                    pathResult -> {
-                        relCounter.incrementAndGet();
-                        return new ExportedRelationship(
-                            pathResult.sourceNode(),
-                            pathResult.targetNode(),
-                            createValues(pathResult)
-                        );
-                    });
+        ResultStoreEntry.RelationshipStream streamEntry = new ResultStoreEntry.RelationshipStream(
+            relationshipTypeAsString,
+            propertyKeys,
+            propertyTypes,
+            relationshipStream,
+            graphResources.graph()::toOriginalNodeId
+        );
+        resultStore.add(JobId.parse(this.relationshipTypeAsString), streamEntry);
 
-            resultStore.add(JobId.parse(this.relationshipTypeAsString), new ResultStoreEntry.RelationshipStream(
-                relationshipTypeAsString, propertyKeys, propertyTypes, relationshipStream, graphResources.graph()::toOriginalNodeId));
-
-            return new RelationshipsWritten(relCounter.get());
-        });
+        return Optional.empty();
     }
 
     private Value[] createValues(PathResult pathResult) {

procedures/algorithms-facade/src/main/java/org/neo4j/gds/procedures/algorithms/pathfinding/DijkstraWithPathsResultBuilder.java

@@ -0,0 +1,45 @@
+/*
+ * 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.procedures.algorithms.pathfinding;
+
+import org.neo4j.gds.api.Graph;
+import org.neo4j.gds.applications.algorithms.machinery.AlgorithmProcessingTimings;
+import org.neo4j.gds.applications.algorithms.machinery.ResultBuilder;
+import org.neo4j.gds.applications.algorithms.metadata.RelationshipsWritten;
+import org.neo4j.gds.config.ToMapConvertible;
+import org.neo4j.gds.paths.dijkstra.PathFindingResult;
+
+import java.util.Optional;
+
+public class DijkstraWithPathsResultBuilder<CONFIGURATION extends ToMapConvertible> implements ResultBuilder<CONFIGURATION, PathFindingResult, DijkstraWithPathsResult, Void> {
+    @Override
+    public DijkstraWithPathsResult build(
+        Graph graph,
+        CONFIGURATION configuration,
+        Optional<PathFindingResult> pathFindingResult,
+        AlgorithmProcessingTimings timings,
+        Optional<Void> metadata
+    ) {
+        return DijkstraWithPathsResult.create(
+            timings,
+            configuration.toMap()
+        );
+    }
+}

procedures/facade-api/path-finding-facade-api/src/main/java/org/neo4j/gds/procedures/algorithms/pathfinding/DijkstraWithPathsResult.java

@@ -0,0 +1,89 @@
+/*
+ * 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.procedures.algorithms.pathfinding;
+
+import org.neo4j.gds.applications.algorithms.machinery.AlgorithmProcessingTimings;
+import org.neo4j.gds.procedures.algorithms.results.MutateResult;
+
+import java.util.Map;
+
+public class DijkstraWithPathsResult implements MutateResult {
+
+    public final long preProcessingMillis;
+    public final long computeMillis;
+    public final long mutateMillis;
+    public final long postProcessingMillis;
+    public final Map<String, Object> configuration;
+
+    public DijkstraWithPathsResult(
+        long preProcessingMillis,
+        long computeMillis,
+        long mutateMillis,
+        long postProcessingMillis,
+        Map<String, Object> configuration
+    ) {
+        this.preProcessingMillis = preProcessingMillis;
+        this.computeMillis = computeMillis;
+        this.mutateMillis = mutateMillis;
+        this.postProcessingMillis = postProcessingMillis;
+        this.configuration = configuration;
+    }
+
+    public static DijkstraWithPathsResult create(
+        AlgorithmProcessingTimings timings,
+        Map<String, Object> configuration){
+
+        return new DijkstraWithPathsResult(
+            timings.preProcessingMillis,
+            timings.computeMillis,
+            timings.sideEffectMillis,
+            0L,
+            configuration
+        );
+
+
+    }
+
+    //add getters to maintain the interface
+    @Override
+    public long mutateMillis() {
+        return mutateMillis;
+    }
+
+    @Override
+    public long postProcessingMillis() {
+        return postProcessingMillis;
+    }
+
+    @Override
+    public long preProcessingMillis() {
+        return preProcessingMillis;
+    }
+
+    @Override
+    public long computeMillis() {
+        return computeMillis;
+    }
+
+    @Override
+    public Map<String, Object> configuration() {
+        return configuration;
+    }
+}