Consider case without label, but properties

Author: s1ck

core/src/main/java/org/neo4j/gds/api/CSRGraphStoreFactory.java

@@ -42,10 +42,7 @@ public CSRGraphStoreFactory(
         super(graphProjectConfig, capabilities, loadingContext, dimensions);
     }
 
-    protected CSRGraphStore createGraphStore(
-        Nodes nodes,
-        RelationshipImportResult relationshipImportResult
-    ) {
+    protected CSRGraphStore createGraphStore(Nodes nodes, RelationshipImportResult relationshipImportResult) {
         return new GraphStoreBuilder()
             .databaseId(DatabaseId.of(loadingContext.graphDatabaseService()))
             .capabilities(capabilities)

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

@@ -148,7 +148,7 @@ public CSRGraphStore build() {
                 progressTracker
             ).load(ktx.internalTransaction());
 
-            var relationshipsAndProperties = new CypherRelationshipLoader(
+            var relationshipImportResult = new CypherRelationshipLoader(
                 relationshipQuery(),
                 nodes.idMap(),
                 cypherConfig,
@@ -158,7 +158,7 @@ public CSRGraphStore build() {
 
             var graphStore = createGraphStore(
                 nodes,
-                relationshipsAndProperties
+                relationshipImportResult
             );
 
             progressTracker.endSubTask("Loading");

core/src/main/java/org/neo4j/gds/core/loading/construction/NodeLabelTokenToPropertyKeys.java

@@ -29,6 +29,7 @@
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 abstract class NodeLabelTokenToPropertyKeys {
 
@@ -57,6 +58,11 @@ static NodeLabelTokenToPropertyKeys fixed(NodeSchema nodeSchema) {
      */
     abstract void add(NodeLabelToken nodeLabelToken, Iterable<String> propertyKeys);
 
+    /**
+     * Returns all node labels in this mapping.
+     */
+    abstract Set<NodeLabel> nodeLabels();
+
     /**
      * Return the property schemas for the given node label.
      */
@@ -78,6 +84,11 @@ void add(NodeLabelToken nodeLabelToken, Iterable<String> propertyKeys) {
             // silence is golden
         }
 
+        @Override
+        Set<NodeLabel> nodeLabels() {
+            return nodeSchema.availableLabels();
+        }
+
         @Override
         Map<String, PropertySchema> propertySchemas(
             NodeLabel nodeLabel,
@@ -120,7 +131,6 @@ Map<String, PropertySchema> propertySchemas(
                 );
             }
 
-
             return userDefinedPropertySchemas;
         }
     }
@@ -140,7 +150,16 @@ void add(NodeLabelToken nodeLabelToken, Iterable<String> propertyKeys) {
                 propertyKeys.forEach(keys::add);
                 return keys;
             });
+        }
 
+        @Override
+        Set<NodeLabel> nodeLabels() {
+            return labelToPropertyKeys
+                .keySet()
+                .stream()
+                .map(nodeLabelToken -> nodeLabelToken.isEmpty() ? NodeLabelTokens.ofNodeLabel(NodeLabel.ALL_NODES) : nodeLabelToken)
+                .flatMap(nodeLabelToken -> IntStream.range(0, nodeLabelToken.size()).mapToObj(nodeLabelToken::get))
+                .collect(Collectors.toSet());
         }
 
         @Override
@@ -150,7 +169,11 @@ Map<String, PropertySchema> propertySchemas(
         ) {
             return labelToPropertyKeys.keySet().stream()
                 .filter(nodeLabelToken -> {
-                    for (int i = 0; i < nodeLabelToken.size(); i++) {
+                    if (nodeLabelToken.isEmpty() && nodeLabel == NodeLabel.ALL_NODES) {
+                        return true;
+                    }
+                    var nodeLabelTokenCount = nodeLabelToken.size();
+                    for (int i = 0; i < nodeLabelTokenCount; i++) {
                         if (nodeLabelToken.get(i).equals(nodeLabel)) {
                             return true;
                         }
@@ -162,7 +185,7 @@ Map<String, PropertySchema> propertySchemas(
                     propertyKey -> propertyKey,
                     importPropertySchemas::get,
                     (lhs, rhs) -> lhs
-                    ));
+                ));
         }
     }
 }

core/src/main/java/org/neo4j/gds/core/loading/construction/NodesBuilder.java

@@ -50,6 +50,7 @@
 import org.neo4j.values.virtual.MapValue;
 
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -223,9 +224,18 @@ private NodeSchema buildNodeSchema(IdMap idMap, Map<String, NodeProperty> nodePr
             .stream()
             .collect(Collectors.toMap(Map.Entry::getKey, entry -> entry.getValue().propertySchema()));
 
-        idMap.availableNodeLabels().forEach(label -> {
-            nodeSchema.addLabel(label, this.nodeLabelTokenToPropertyKeys.propertySchemas(label, importPropertySchemas));
+        // consider node labels without properties
+        var nodeLabels = new HashSet<>(idMap.availableNodeLabels());
+        // and also node labels with associated properties
+        nodeLabels.addAll(nodeLabelTokenToPropertyKeys.nodeLabels());
+
+        nodeLabels.forEach(nodeLabel -> {
+            nodeSchema.addLabel(
+                nodeLabel,
+                this.nodeLabelTokenToPropertyKeys.propertySchemas(nodeLabel, importPropertySchemas)
+            );
         });
+
         return nodeSchema;
     }
 

core/src/test/java/org/neo4j/gds/core/loading/construction/NodeLabelTokenToPropertyKeysTest.java

@@ -160,5 +160,54 @@ void testDuplicatePropertyKeys() {
             "bar", PropertySchema.of("bar", ValueType.DOUBLE, DefaultValue.forDouble(), PropertyState.PERSISTENT)
         ));
     }
+
+    @Test
+    void testEmptyNodeLabelTokenResolvesToAllNodes() {
+        var mapping = NodeLabelTokenToPropertyKeys.lazy();
+        mapping.add(NodeLabelTokens.empty(), List.of("foo", "bar"));
+
+        var importPropertySchemas = Map.of(
+            "foo", PropertySchema.of("foo", ValueType.LONG, DefaultValue.forLong(), PropertyState.TRANSIENT),
+            "bar", PropertySchema.of("bar", ValueType.DOUBLE, DefaultValue.forDouble(), PropertyState.PERSISTENT)
+        );
+
+        assertThat(mapping.propertySchemas(NodeLabel.ALL_NODES, importPropertySchemas)).isEqualTo(Map.of(
+            "foo", PropertySchema.of("foo", ValueType.LONG, DefaultValue.forLong(), PropertyState.TRANSIENT),
+            "bar", PropertySchema.of("bar", ValueType.DOUBLE, DefaultValue.forDouble(), PropertyState.PERSISTENT)
+        ));
+    }
+
+    @Test
+    void testNodeLabelsLazily() {
+        var mapping = NodeLabelTokenToPropertyKeys.lazy();
+        mapping.add(NodeLabelTokens.empty(), List.of("foo"));
+        mapping.add(NodeLabelTokens.of("A"), List.of("bar"));
+        mapping.add(NodeLabelTokens.ofStrings("A", "B"), List.of("baz"));
+        mapping.add(NodeLabelTokens.ofStrings("B", "C"), List.of("buz"));
+
+        assertThat(mapping.nodeLabels()).containsExactlyInAnyOrder(
+            NodeLabel.ALL_NODES,
+            NodeLabel.of("A"),
+            NodeLabel.of("B"),
+            NodeLabel.of("C")
+        );
+    }
+
+    @Test
+    void testNodeLabelsFixed() {
+        var mapping = NodeLabelTokenToPropertyKeys.fixed(NodeSchema.empty()
+            .addLabel(NodeLabel.ALL_NODES)
+            .addLabel(NodeLabel.of("A"))
+            .addLabel(NodeLabel.of("B"))
+            .addLabel(NodeLabel.of("C"))
+        );
+
+        assertThat(mapping.nodeLabels()).containsExactlyInAnyOrder(
+            NodeLabel.ALL_NODES,
+            NodeLabel.of("A"),
+            NodeLabel.of("B"),
+            NodeLabel.of("C")
+        );
+    }
 }