Merge pull request #6600 from DarthMax/cypher-agg-undirected

CypherAggregation undirected

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(

doc/modules/ROOT/pages/management-ops/projections/graph-project-cypher-aggregation.adoc

@@ -68,8 +68,9 @@ RETURN gds.alpha.graph.project(
 .Configuration
 [opts="header",cols="1,1,1,4"]
 |===
-| Name                   | Type                  | Default              | Description
-| readConcurrency        | Integer               | 4                    | The number of concurrent threads used for creating the graph.
+| Name                          | Type                  | Default              | Description
+| readConcurrency               | Integer               | 4                    | The number of concurrent threads used for creating the graph.
+| undirectedRelationshipTypes   | List of String        | []                   | Declare a number of relationship types as undirected. Relationships with the specified types will be imported as undirected. `*` can be used to declare all relationship types as undirected.
 |===
 
 

proc/catalog/src/test/java/org/neo4j/gds/catalog/GraphListProcTest.java

@@ -414,9 +414,10 @@ void listCypherAggregation() {
                 "configuration", new Condition<>(config -> {
                     assertThat(config)
                         .asInstanceOf(stringObjectMapAssertFactory())
-                        .hasSize(2)
+                        .hasSize(3)
                         .hasEntrySatisfying("creationTime", creationTimeAssertConsumer())
-                        .hasEntrySatisfying("jobId", jobId -> assertThat(jobId).isNotNull());
+                        .hasEntrySatisfying("jobId", jobId -> assertThat(jobId).isNotNull())
+                        .hasEntrySatisfying("undirectedRelationshipTypes", t -> assertThat(t).isEqualTo(List.of()));
 
                     return true;
                 }, "Assert Cypher Aggregation `configuration` map"),