Replace with graphstore check !

Co-authored-by: Veselin Nikolov <[email protected]>

Author: IoannisPanagiotas

applications/algorithms/similarity/src/test/java/org/neo4j/gds/applications/algorithms/similarity/KnnHookTest.java renamed to algo/src/test/java/org/neo4j/gds/similarity/filteredknn/KnnBaseConfigTest.java

@@ -17,54 +17,64 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-package org.neo4j.gds.applications.algorithms.similarity;
+package org.neo4j.gds.similarity.filteredknn;
 
 import org.junit.jupiter.api.Test;
-import org.neo4j.gds.api.Graph;
-import org.neo4j.gds.api.properties.nodes.LongNodePropertyValues;
+import org.neo4j.gds.api.GraphStore;
+import org.neo4j.gds.similarity.knn.KnnBaseConfig;
 import org.neo4j.gds.similarity.knn.KnnNodePropertySpec;
 
 import java.util.List;
 import java.util.Set;
 
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.mockito.ArgumentMatchers.anyCollection;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doCallRealMethod;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
-class KnnHookTest {
+ class KnnBaseConfigTest {
 
     @Test
     void shouldNotThrowForExistingProperty(){
-        var  graph = mock(Graph.class);
-        var nodeProp = mock(LongNodePropertyValues.class);
-        when(graph.nodeProperties("foo")).thenReturn(nodeProp);
+        var  graphStore = mock(GraphStore.class);
+        when(graphStore.hasNodeProperty("foo")).thenReturn(true);
 
         var knnSpec = mock(KnnNodePropertySpec.class);
         when(knnSpec.name()).thenReturn("foo");
 
-        var hook = new KnnHook(List.of(knnSpec));
+        List<KnnNodePropertySpec> props = List.of(knnSpec);
 
-        assertDoesNotThrow( () -> hook.onGraphLoaded(graph));
+        var config = mock(KnnBaseConfig.class);
+        when(config.nodeProperties()).thenReturn(props);
+
+        doCallRealMethod().when(config).checkPropertiesExist(eq(graphStore),anyCollection(),anyCollection());
+
+        assertDoesNotThrow( () -> config.checkPropertiesExist(graphStore,Set.of(),Set.of()));
     }
 
     @Test
     void shouldThrowForNonExistingProperty(){
-        var  graph = mock(Graph.class);
-        var nodeProp = mock(LongNodePropertyValues.class);
-        when(graph.nodeProperties("foo")).thenReturn(nodeProp);
-        when(graph.nodeProperties("bar")).thenReturn(null);
-        when(graph.availableNodeProperties()).thenReturn(Set.of("foo"));
+        var  graphStore = mock(GraphStore.class);
+        when(graphStore.hasNodeProperty("foo")).thenReturn(true);
+        when(graphStore.hasNodeProperty("bar")).thenReturn(false);
+
+        when(graphStore.nodePropertyKeys(anyCollection())).thenReturn(Set.of("foo"));
 
         var knnSpec1 = mock(KnnNodePropertySpec.class);
         when(knnSpec1.name()).thenReturn("foo");
         var knnSpec2 = mock(KnnNodePropertySpec.class);
         when(knnSpec2.name()).thenReturn("bar");
 
-        var hook = new KnnHook(List.of(knnSpec1, knnSpec2));
+        List<KnnNodePropertySpec> props = List.of(knnSpec1, knnSpec2);
 
-        assertThatThrownBy(() -> hook.onGraphLoaded(graph))
+        var config = mock(KnnBaseConfig.class);
+        when(config.nodeProperties()).thenReturn(props);
+        doCallRealMethod().when(config).checkPropertiesExist(eq(graphStore),anyCollection(),anyCollection());
+
+        assertThatThrownBy(() -> config.checkPropertiesExist(graphStore,Set.of(),Set.of()))
             .hasMessageContaining("The property `bar` has not been loaded. Available properties: ['foo']");
     }
-
 }

applications/algorithms/similarity/build.gradle

@@ -14,13 +14,10 @@ dependencies {
     implementation project(":memory-usage")
     implementation project(":progress-tracking")
     implementation project(":similarity-configs")
-    implementation project(':string-formatting')
     implementation project(":termination")
 
     // this is needed because NodeSimilarity internally calls Wcc
     implementation project(':community-algorithms')
     implementation project(":community-configs")
 
-    testImplementation project(':test-utils')
-
 }

applications/algorithms/similarity/src/main/java/org/neo4j/gds/applications/algorithms/similarity/KnnHook.java

@@ -33,9 +33,7 @@
 import org.neo4j.gds.similarity.nodesim.NodeSimilarityMutateConfig;
 import org.neo4j.gds.similarity.nodesim.NodeSimilarityResult;
 
-import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 
 import static org.neo4j.gds.applications.algorithms.machinery.AlgorithmLabel.FilteredKNN;
 import static org.neo4j.gds.applications.algorithms.machinery.AlgorithmLabel.FilteredNodeSimilarity;
@@ -72,12 +70,9 @@ public <RESULT> RESULT filteredKnn(
             shouldComputeSimilarityDistribution
         );
 
-        return algorithmProcessingTemplateConvenience.processAlgorithmInMutateMode(
-            Optional.empty(),
+        return algorithmProcessingTemplateConvenience.processRegularAlgorithmInMutateMode(
             graphName,
             configuration,
-            Optional.of(List.of(new KnnHook(configuration.nodeProperties()))),
-            Optional.empty(),
             FilteredKNN,
             () -> estimationFacade.filteredKnn(configuration),
             (graph, __) -> similarityAlgorithms.filteredKnn(graph, configuration),
@@ -121,12 +116,9 @@ public <RESULT> RESULT knn(
             shouldComputeSimilarityDistribution
         );
 
-        return algorithmProcessingTemplateConvenience.processAlgorithmInMutateMode(
-           Optional.empty(),
+        return algorithmProcessingTemplateConvenience.processRegularAlgorithmInMutateMode(
             graphName,
             configuration,
-            Optional.of(List.of(new KnnHook(configuration.nodeProperties()))),
-            Optional.empty(),
             KNN,
             () -> estimationFacade.knn(configuration),
             (graph, __) -> similarityAlgorithms.knn(graph, configuration),

applications/algorithms/similarity/src/main/java/org/neo4j/gds/applications/algorithms/similarity/SimilarityAlgorithmsMutateModeBusinessFacade.java

@@ -30,9 +30,6 @@
 import org.neo4j.gds.similarity.nodesim.NodeSimilarityResult;
 import org.neo4j.gds.similarity.nodesim.NodeSimilarityStatsConfig;
 
-import java.util.List;
-import java.util.Optional;
-
 import static org.neo4j.gds.applications.algorithms.machinery.AlgorithmLabel.FilteredKNN;
 import static org.neo4j.gds.applications.algorithms.machinery.AlgorithmLabel.FilteredNodeSimilarity;
 import static org.neo4j.gds.applications.algorithms.machinery.AlgorithmLabel.KNN;
@@ -58,16 +55,13 @@ public <RESULT> RESULT filteredKnn(
         FilteredKnnStatsConfig configuration,
         StatsResultBuilder<FilteredKnnResult, RESULT> resultBuilder
     ) {
-        return algorithmProcessingTemplateConvenience.processAlgorithmInStatsMode(
+        return algorithmProcessingTemplateConvenience.processRegularAlgorithmInStatsMode(
             graphName,
             configuration,
             FilteredKNN,
             () -> estimationFacade.filteredKnn(configuration),
             (graph, __) -> similarityAlgorithms.filteredKnn(graph, configuration),
-            resultBuilder,
-            Optional.of(List.of(new KnnHook(configuration.nodeProperties()))),
-            Optional.empty(),
-            Optional.empty()
+            resultBuilder
         );
     }
 
@@ -91,16 +85,13 @@ public <RESULT> RESULT knn(
         KnnStatsConfig configuration,
         StatsResultBuilder<KnnResult, RESULT> resultBuilder
     ) {
-        return algorithmProcessingTemplateConvenience.processAlgorithmInStatsMode(
+        return algorithmProcessingTemplateConvenience.processRegularAlgorithmInStatsMode(
             graphName,
             configuration,
             KNN,
             () -> estimationFacade.knn(configuration),
             (graph, __) -> similarityAlgorithms.knn(graph, configuration),
-            resultBuilder,
-            Optional.of(List.of(new KnnHook(configuration.nodeProperties()))),
-            Optional.empty(),
-            Optional.empty()
+            resultBuilder
         );
     }
 

applications/algorithms/similarity/src/main/java/org/neo4j/gds/applications/algorithms/similarity/SimilarityAlgorithmsStatsModeBusinessFacade.java

@@ -30,8 +30,6 @@
 import org.neo4j.gds.similarity.nodesim.NodeSimilarityResult;
 import org.neo4j.gds.similarity.nodesim.NodeSimilarityStreamConfig;
 
-import java.util.List;
-import java.util.Optional;
 import java.util.stream.Stream;
 
 import static org.neo4j.gds.applications.algorithms.machinery.AlgorithmLabel.FilteredKNN;
@@ -59,16 +57,13 @@ public <RESULT> Stream<RESULT> filteredKnn(
         FilteredKnnStreamConfig configuration,
         StreamResultBuilder<FilteredKnnResult, RESULT> resultBuilder
     ) {
-        return algorithmProcessingTemplateConvenience.processAlgorithmInStreamMode(
+        return algorithmProcessingTemplateConvenience.processRegularAlgorithmInStreamMode(
             graphName,
             configuration,
             FilteredKNN,
             () -> estimationFacade.filteredKnn(configuration),
             (graph, __) -> similarityAlgorithms.filteredKnn(graph, configuration),
-            resultBuilder,
-            Optional.of(List.of(new KnnHook(configuration.nodeProperties()))),
-            Optional.empty(),
-            Optional.empty()
+            resultBuilder
         );
     }
 
@@ -92,16 +87,13 @@ public <RESULT> Stream<RESULT> knn(
         KnnStreamConfig configuration,
         StreamResultBuilder<KnnResult, RESULT> resultBuilder
     ) {
-        return algorithmProcessingTemplateConvenience.processAlgorithmInStreamMode(
+        return algorithmProcessingTemplateConvenience.processRegularAlgorithmInStreamMode(
             graphName,
             configuration,
             KNN,
             () -> estimationFacade.knn(configuration),
             (graph, __) -> similarityAlgorithms.knn(graph, configuration),
-            resultBuilder,
-            Optional.of(List.of(new KnnHook(configuration.nodeProperties()))),
-            Optional.empty(),
-            Optional.empty()
+            resultBuilder
         );
     }
 

applications/algorithms/similarity/src/main/java/org/neo4j/gds/applications/algorithms/similarity/SimilarityAlgorithmsStreamModeBusinessFacade.java

@@ -33,9 +33,7 @@
 import org.neo4j.gds.similarity.nodesim.NodeSimilarityResult;
 import org.neo4j.gds.similarity.nodesim.NodeSimilarityWriteConfig;
 
-import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 
 import static org.neo4j.gds.applications.algorithms.machinery.AlgorithmLabel.FilteredKNN;
 import static org.neo4j.gds.applications.algorithms.machinery.AlgorithmLabel.FilteredNodeSimilarity;
@@ -72,12 +70,9 @@ public <RESULT> RESULT filteredKnn(
             writeRelationshipService
         );
 
-        return algorithmProcessingTemplateConvenience.processAlgorithmInWriteMode(
-            Optional.empty(),
+        return algorithmProcessingTemplateConvenience.processRegularAlgorithmInWriteMode(
             graphName,
             configuration,
-            Optional.of(List.of(new KnnHook(configuration.nodeProperties()))),
-            Optional.empty(),
             FilteredKNN,
             () -> estimationFacade.filteredKnn(configuration),
             (graph, __) -> similarityAlgorithms.filteredKnn(graph, configuration),
@@ -122,12 +117,9 @@ public <RESULT> RESULT knn(
             writeRelationshipService
         );
 
-        return algorithmProcessingTemplateConvenience.processAlgorithmInWriteMode(
-            Optional.empty(),
+        return algorithmProcessingTemplateConvenience.processRegularAlgorithmInWriteMode(
             graphName,
             configuration,
-            Optional.of(List.of(new KnnHook(configuration.nodeProperties()))),
-            Optional.empty(),
             KNN,
             () -> estimationFacade.knn(configuration),
             (graph, __) -> similarityAlgorithms.knn(graph, configuration),

applications/algorithms/similarity/src/main/java/org/neo4j/gds/applications/algorithms/similarity/SimilarityAlgorithmsWriteModeBusinessFacade.java

@@ -19,13 +19,20 @@
  */
 package org.neo4j.gds.similarity.knn;
 
+import org.neo4j.gds.NodeLabel;
+import org.neo4j.gds.RelationshipType;
 import org.neo4j.gds.annotation.Configuration;
+import org.neo4j.gds.api.GraphStore;
 import org.neo4j.gds.config.AlgoBaseConfig;
 import org.neo4j.gds.config.IterationsConfig;
 import org.neo4j.gds.config.SingleThreadedRandomSeedConfig;
+import org.neo4j.gds.utils.StringJoining;
 
+import java.util.Collection;
 import java.util.List;
 
+import static org.neo4j.gds.utils.StringFormatting.formatWithLocale;
+
 @Configuration
 public interface KnnBaseConfig extends AlgoBaseConfig, IterationsConfig, SingleThreadedRandomSeedConfig {
 
@@ -102,4 +109,22 @@ default KnnParametersSansNodeCount toParameters() {
     default KnnMemoryEstimationParametersBuilder toMemoryEstimationParameters() {
         return new KnnMemoryEstimationParametersBuilder(sampleRate(), topK(), initialSampler());
     }
+
+    @Configuration.GraphStoreValidationCheck
+    default void checkPropertiesExist(
+        GraphStore graphStore,
+        Collection<NodeLabel> selectedLabels,
+        Collection<RelationshipType> selectedRelationshipTypes
+    ) {
+        for (var property : nodeProperties()){
+            var propertyName = property.name();
+            if (!graphStore.hasNodeProperty(propertyName)){
+                throw  new IllegalArgumentException(
+                    formatWithLocale("The property `%s` has not been loaded. Available properties: %s",
+                        propertyName,
+                        StringJoining.join(graphStore.nodePropertyKeys(selectedLabels)))
+                );
+            }
+        }
+    }
 }