Expose indexInverse in RelationshipProjection

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

Author: s1ck

graph-projection-api/src/main/java/org/neo4j/gds/RelationshipProjection.java

@@ -51,6 +51,11 @@ public Aggregation aggregation() {
         return Aggregation.DEFAULT;
     }
 
+    @Value.Default
+    public boolean indexInverse() {
+        return false;
+    }
+
     @Value.Default
     @Value.Parameter(false)
     @Override
@@ -66,6 +71,7 @@ public boolean projectAll() {
     public static final String TYPE_KEY = "type";
     public static final String ORIENTATION_KEY = "orientation";
     public static final String AGGREGATION_KEY = "aggregation";
+    public static final String INDEX_INVERSE_KEY = "indexInverse";
 
     public static RelationshipProjection fromMap(Map<String, Object> map, RelationshipType relationshipType) {
         RelationshipProjection.Builder builder = RelationshipProjection.builder();
@@ -77,6 +83,10 @@ public static RelationshipProjection fromMap(Map<String, Object> map, Relationsh
         if (map.containsKey(ORIENTATION_KEY)) {
             builder.orientation(Orientation.parse(nonEmptyString(map, ORIENTATION_KEY)));
         }
+        if (map.containsKey(INDEX_INVERSE_KEY)) {
+            boolean indexInverse = (boolean) map.get(INDEX_INVERSE_KEY);
+            builder.indexInverse(indexInverse);
+        }
         if (map.containsKey(AGGREGATION_KEY)) {
             Aggregation aggregation = Aggregation.parse(nonEmptyString(map, AGGREGATION_KEY));
             builder.aggregation(aggregation);
@@ -138,6 +148,7 @@ void writeToObject(Map<String, Object> value) {
         value.put(TYPE_KEY, type());
         value.put(ORIENTATION_KEY, orientation().name());
         value.put(AGGREGATION_KEY, aggregation().name());
+        value.put(INDEX_INVERSE_KEY, indexInverse());
     }
 
     @Override
@@ -170,7 +181,13 @@ private static RelationshipProjection create(
     }
 
     private static void validateConfigKeys(Map<String, Object> map) {
-        ConfigKeyValidation.requireOnlyKeysFrom(List.of(TYPE_KEY, ORIENTATION_KEY, AGGREGATION_KEY, PROPERTIES_KEY), map.keySet());
+        ConfigKeyValidation.requireOnlyKeysFrom(List.of(
+            TYPE_KEY,
+            ORIENTATION_KEY,
+            AGGREGATION_KEY,
+            PROPERTIES_KEY,
+            INDEX_INVERSE_KEY
+        ), map.keySet());
     }
 
     @org.immutables.builder.Builder.AccessibleFields

graph-projection-api/src/test/java/org/neo4j/gds/RelationshipProjectionsTest.java

@@ -38,8 +38,11 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.collection.IsCollectionWithSize.hasSize;
 import static org.hamcrest.text.MatchesPattern.matchesPattern;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.neo4j.gds.ElementProjection.PROPERTIES_KEY;
+import static org.neo4j.gds.RelationshipProjection.INDEX_INVERSE_KEY;
 import static org.neo4j.gds.RelationshipProjection.ORIENTATION_KEY;
 import static org.neo4j.gds.RelationshipProjection.TYPE_KEY;
 import static org.neo4j.gds.RelationshipType.ALL_RELATIONSHIPS;
@@ -54,7 +57,8 @@ void shouldParse() {
             "MY_TYPE", Map.of(
                 "type", "T",
                 "orientation", "NATURAL",
-                "aggregation", "SINGLE"
+                "aggregation", "SINGLE",
+                "indexInverse", true
             ));
         noProperties.put(
             "ANOTHER", Map.of(
@@ -69,13 +73,20 @@ void shouldParse() {
         assertThat(projections.allProjections(), hasSize(2));
         assertThat(
             projections.getFilter(RelationshipType.of("MY_TYPE")),
-            equalTo(RelationshipProjection.of("T", Orientation.NATURAL, SINGLE))
-        );
+            equalTo(RelationshipProjection
+                .builder()
+                .type("T")
+                .aggregation(SINGLE)
+                .orientation(Orientation.NATURAL)
+                .indexInverse(true)
+                .build()
+            ));
         assertThat(
             projections.getFilter(RelationshipType.of("ANOTHER")),
             equalTo(RelationshipProjection
                 .builder()
                 .type("FOO")
+                .indexInverse(false)
                 .properties(PropertyMappings
                     .builder()
                     .addMapping(PropertyMapping.of("prop1", DefaultValue.DEFAULT))
@@ -221,6 +232,19 @@ void shouldSupportCaseInsensitiveConfigKeys() {
         assertThat(projections.typeFilter(), equalTo("T|FOO"));
     }
 
+    @Test
+    void shouldHandleIndexInverse() {
+        // default
+        var projection = RelationshipProjection.fromMap(Map.of(), RelationshipType.of("FOO"));
+        assertFalse(projection.indexInverse());
+        // explicitly set
+        projection = RelationshipProjection.fromMap(Map.of(INDEX_INVERSE_KEY, true), RelationshipType.of("FOO"));
+        assertTrue(projection.indexInverse());
+        // explicitly unset
+        projection = RelationshipProjection.fromMap(Map.of(INDEX_INVERSE_KEY, false), RelationshipType.of("FOO"));
+        assertFalse(projection.indexInverse());
+    }
+
     static Stream<Arguments> syntacticSugarsSimple() {
         return Stream.of(
             Arguments.of(