Make undirected relationship types configurable in CypherAggregation

Author: DarthMax

cypher-aggregation/src/main/java/org/neo4j/gds/projection/CypherAggregation.java

@@ -82,6 +82,7 @@
 import java.util.function.Supplier;
 
 import static org.neo4j.gds.Orientation.NATURAL;
+import static org.neo4j.gds.Orientation.UNDIRECTED;
 import static org.neo4j.gds.utils.StringFormatting.formatWithLocale;
 
 public final class CypherAggregation {
@@ -192,7 +193,7 @@ public void update(
                 }
             }
 
-            var relImporter = this.relImporters.computeIfAbsent(relationshipType, type -> newRelImporter());
+            var relImporter = this.relImporters.computeIfAbsent(relationshipType, this::newRelImporter);
 
             var intermediateSourceId = loadNode(sourceNode, sourceNodeLabels, sourceNodePropertyValues);
 
@@ -386,12 +387,17 @@ private RelationshipType typeConfig(
             ));
         }
 
-        private RelationshipsBuilder newRelImporter() {
+        private RelationshipsBuilder newRelImporter(RelationshipType relType) {
             assert this.idMapBuilder != null;
 
+            var undirectedTypes = config.undirectedRelationshipTypes();
+            var orientation = undirectedTypes.contains(relType.name) || undirectedTypes.contains("*")
+                ? UNDIRECTED
+                : NATURAL;
+
             var relationshipsBuilderBuilder = GraphFactory.initRelationshipsBuilder()
                 .nodes(this.idMapBuilder)
-                .orientation(NATURAL)
+                .orientation(orientation)
                 .aggregation(Aggregation.NONE)
                 .concurrency(config.readConcurrency());
 
@@ -692,6 +698,12 @@ default Aggregation aggregation() {
             return Aggregation.NONE;
         }
 
+        @org.immutables.value.Value.Default
+        @NotNull
+        default List<String> undirectedRelationshipTypes() {
+            return List.of();
+        }
+
         @Configuration.Ignore
         @Override
         default GraphStoreFactory.Supplier graphStoreFactory() {

cypher-aggregation/src/test/java/org/neo4j/gds/projection/CypherAggregationTest.java

@@ -24,7 +24,9 @@
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.junit.jupiter.params.provider.ValueSource;
 import org.neo4j.gds.BaseProcTest;
 import org.neo4j.gds.BaseTest;
@@ -49,6 +51,7 @@
 import java.util.Optional;
 import java.util.stream.Collectors;
 import java.util.stream.LongStream;
+import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -578,6 +581,48 @@ void testRelationshipPropertiesAggregation() {
         });
     }
 
+    @ParameterizedTest
+    @MethodSource("undirectedTypes")
+    void testRespectUndirectedTypes(List<String> undirectedConfig, List<String> expectedUndirectedTypes) {
+        runQuery(
+            "UNWIND [" +
+            " {s: 0, t: 1, type: 'UNDIRECTED'}, " +
+            " {s: 1, t: 2, type: 'DIRECTED'} " +
+            "] as d" +
+            " RETURN gds.alpha.graph.project('g', d.s, d.t, null, {relationshipType: d.type}, {undirectedRelationshipTypes: $undirected})",
+            Map.of("undirected", undirectedConfig)
+        );
+
+        assertThat(GraphStoreCatalog.exists("", db.databaseName(), "g")).isTrue();
+        var graphStore = GraphStoreCatalog.get("", db.databaseName(), "g").graphStore();
+
+
+        graphStore
+            .schema()
+            .relationshipSchema()
+            .entries()
+            .forEach(entry -> {
+                var expectedDirection = expectedUndirectedTypes.contains(entry.identifier.name) ? org.neo4j.gds.api.schema.Direction.UNDIRECTED : org.neo4j.gds.api.schema.Direction.DIRECTED;
+                assertThat(entry.direction()).isEqualTo(expectedDirection);
+            });
+    }
+    static Stream<Arguments> undirectedTypes() {
+        return Stream.of(
+            Arguments.of(
+                List.of("UNDIRECTED"),
+                List.of("UNDIRECTED")
+            ),
+            Arguments.of(
+                List.of("UNDIRECTED", "DIRECTED"),
+                List.of("UNDIRECTED", "DIRECTED")
+            ),
+            Arguments.of(
+                List.of("*"),
+                List.of("UNDIRECTED", "DIRECTED")
+            )
+        );
+    }
+
     @Test
     void testPipelinePseudoAnonymous() {
         assertCypherResult(