Project inverse relationships in ScanningRelationshipsImporter

Co-Authored-By: Paul Horn <paul.horn@neotechnology.com>

Author: s1ck

core/src/main/java/org/neo4j/gds/core/loading/ScanningRelationshipsImporter.java

@@ -20,13 +20,17 @@
 package org.neo4j.gds.core.loading;
 
 import org.immutables.builder.Builder;
+import org.neo4j.gds.ImmutableRelationshipProjection;
+import org.neo4j.gds.RelationshipProjection;
+import org.neo4j.gds.RelationshipType;
 import org.neo4j.gds.api.GraphLoaderContext;
 import org.neo4j.gds.api.IdMap;
 import org.neo4j.gds.config.GraphProjectFromStoreConfig;
 import org.neo4j.gds.core.GraphDimensions;
 import org.neo4j.gds.core.loading.SingleTypeRelationshipImporter.SingleTypeRelationshipImportContext;
 import org.neo4j.gds.core.utils.progress.tasks.ProgressTracker;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -84,12 +88,12 @@ public RecordScannerTaskRunner.RecordScannerTaskFactory recordScannerTaskFactory
         ImportSizing sizing,
         StoreScanner<RelationshipReference> storeScanner
     ) {
-        importContexts = graphProjectConfig
+        this.importContexts = graphProjectConfig
             .relationshipProjections()
             .projections()
             .entrySet()
             .stream()
-            .map(
+            .flatMap(
                 entry -> {
                     var relationshipType = entry.getKey();
                     var projection = entry.getValue();
@@ -100,18 +104,26 @@ public RecordScannerTaskRunner.RecordScannerTaskFactory recordScannerTaskFactory
                         dimensions.relationshipPropertyTokens()
                     );
 
-                    var importerFactory = new SingleTypeRelationshipImporterBuilder()
+                    var importer = new SingleTypeRelationshipImporterBuilder()
                         .importMetaData(importMetaData)
                         .nodeCountSupplier(dimensions::nodeCount)
                         .importSizing(sizing)
                         .validateRelationships(graphProjectConfig.validateRelationships())
                         .build();
 
-                    return ImmutableSingleTypeRelationshipImportContext.builder()
+                    var contexts = new ArrayList<SingleTypeRelationshipImportContext>();
+
+                    contexts.add(ImmutableSingleTypeRelationshipImportContext.builder()
                         .relationshipType(relationshipType)
                         .relationshipProjection(projection)
-                        .singleTypeRelationshipImporter(importerFactory)
-                        .build();
+                        .singleTypeRelationshipImporter(importer)
+                        .build());
+
+                    if (projection.indexInverse()) {
+                        contexts.add(createInverseImporterContext(sizing, relationshipType, projection));
+                    }
+
+                    return contexts.stream();
                 }
             ).collect(Collectors.toList());
 
@@ -120,13 +132,45 @@ public RecordScannerTaskRunner.RecordScannerTaskFactory recordScannerTaskFactory
             progressTracker,
             idMap,
             storeScanner,
-            importContexts
+            this.importContexts
                 .stream()
                 .map(SingleTypeRelationshipImportContext::singleTypeRelationshipImporter)
                 .collect(Collectors.toList())
         );
     }
 
+    private SingleTypeRelationshipImportContext createInverseImporterContext(
+        ImportSizing sizing,
+        RelationshipType relationshipType,
+        RelationshipProjection projection
+    ) {
+        var inverseProjection = ImmutableRelationshipProjection
+            .builder()
+            .from(projection)
+            .orientation(projection.orientation().inverse())
+            .build();
+
+        var inverseImportMetaData = SingleTypeRelationshipImporter.ImportMetaData.of(
+            inverseProjection,
+            dimensions.relationshipTypeTokenMapping().get(relationshipType),
+            dimensions.relationshipPropertyTokens()
+        );
+
+        var inverseImporter = new SingleTypeRelationshipImporterBuilder()
+            .importMetaData(inverseImportMetaData)
+            .nodeCountSupplier(dimensions::nodeCount)
+            .importSizing(sizing)
+            .validateRelationships(graphProjectConfig.validateRelationships())
+            .build();
+
+        return ImmutableSingleTypeRelationshipImportContext.builder()
+            .relationshipType(relationshipType)
+            .relationshipProjection(inverseProjection)
+            .inverseOfRelationshipType(relationshipType)
+            .singleTypeRelationshipImporter(inverseImporter)
+            .build();
+    }
+
     @Override
     public RelationshipsAndProperties build() {
         return RelationshipsAndProperties.of(importContexts);

core/src/main/java/org/neo4j/gds/core/loading/SingleTypeRelationshipImporter.java

@@ -214,6 +214,8 @@ private static Aggregation[] aggregations(RelationshipProjection projection) {
     public interface SingleTypeRelationshipImportContext {
         RelationshipType relationshipType();
 
+        Optional<RelationshipType> inverseOfRelationshipType();
+
         RelationshipProjection relationshipProjection();
 
         SingleTypeRelationshipImporter singleTypeRelationshipImporter();