Handle analytical mode in community_detection during parallel changes

cpp/community_detection_module/community_detection_module.cpp

@@ -1,3 +1,4 @@
+#include <cstdint>
 #include <mg_exceptions.hpp>
 #include <mg_utils.hpp>
 
@@ -24,10 +25,20 @@ const double kDefaultWeight = 1.0;
 
 void InsertLouvainRecord(mgp_graph *graph, mgp_result *result, mgp_memory *memory, const std::uint64_t node_id,
                          const std::uint64_t community) {
+  auto *vertex = mgp::graph_get_vertex_by_id(graph, mgp_vertex_id{.as_int = static_cast<int64_t>(node_id)}, memory);
+  if (!vertex) {
+    if (mgp::graph_is_transactional(graph)) {
+      throw mg_exception::InvalidIDException();
+    }
+    // For Analytical mode it's possible that some vertices/edges are missing
+    // because of changes in parallel transactions.
+    return;
+  }
+
   mgp_result_record *record = mgp::result_new_record(result);
   if (record == nullptr) throw mg_exception::NotEnoughMemoryException();
 
-  mg_utility::InsertNodeValueResult(graph, record, kFieldNode, node_id, memory);
+  mg_utility::InsertNodeValueResult(record, kFieldNode, vertex, memory);
   mg_utility::InsertIntValueResult(record, kFieldCommunity, community, memory);
 }
 

cpp/mg_utility/data_structures/graph_view.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cstdint>
+#include <optional>
 #include <vector>
 
 #include "graph_data.hpp"
@@ -97,9 +98,18 @@ class GraphView {
   ///
   ///@param memgraph_id Memgraph's internal ID
   ///@return TSize
+  ///@throws mg_exception::InvalidIDException if vertex does not exist
   ///
   virtual TSize GetInnerNodeId(std::uint64_t memgraph_id) const = 0;
 
+  ///
+  ///@brief Get the Inner Node ID from Memgraph ID
+  ///
+  ///@param memgraph_id Memgraph's internal ID
+  ///@return std::optional<TSize>, which is null if vertex does not exist
+  ///
+  virtual std::optional<TSize> GetInnerNodeIdOpt(std::uint64_t memgraph_id) const = 0;
+
   ///
   ///@brief Get the Memgraph Edge Id from the inner renumbered node ID
   ///

cpp/mg_utility/mg_graph.hpp

@@ -199,8 +199,14 @@ class Graph : public GraphView<TSize> {
       return std::nullopt;
     }
 
-    auto from = GetInnerNodeId(memgraph_id_from);
-    auto to = GetInnerNodeId(memgraph_id_to);
+    auto fromOpt = GetInnerNodeIdOpt(memgraph_id_from);
+    auto toOpt = GetInnerNodeIdOpt(memgraph_id_to);
+    if (!fromOpt || !toOpt) {
+      return std::nullopt;
+    }
+
+    auto from = *fromOpt;
+    auto to = *toOpt;
 
     auto id = edges_.size();
     inner_to_memgraph_edge_id_.emplace(id, edge_id);
@@ -314,6 +320,21 @@ class Graph : public GraphView<TSize> {
     return memgraph_to_inner_id_.at(memgraph_id);
   }
 
+  ///
+  /// Returns the GraphView ID from Memgraph's internal ID
+  ///
+  /// @param node_id Memgraphs's inner ID
+  ///
+  std::optional<TSize> GetInnerNodeIdOpt(std::uint64_t memgraph_id) const override {
+    if (memgraph_to_inner_id_.find(memgraph_id) == memgraph_to_inner_id_.end()) {
+      if (IsTransactional()) {
+        throw mg_exception::InvalidIDException();
+      }
+      return std::nullopt;
+    }
+    return memgraph_to_inner_id_.at(memgraph_id);
+  }
+
   ///
   /// Returns the Memgraph database ID from graph view
   ///
@@ -381,6 +402,10 @@ class Graph : public GraphView<TSize> {
     nodes_to_edge_.clear();
   }
 
+  void SetIsTransactional(bool is_transactional) { is_transactional_ = is_transactional; }
+
+  bool IsTransactional() const { return is_transactional_; }
+
  private:
   // Constant is used for marking deleted edges.
   // If edge id is equal to constant, edge is deleted.
@@ -402,5 +427,7 @@ class Graph : public GraphView<TSize> {
   std::unordered_map<std::uint64_t, TSize> memgraph_to_inner_edge_id_;
 
   std::multimap<std::pair<TSize, TSize>, TSize> nodes_to_edge_;
+
+  bool is_transactional_;
 };
 }  // namespace mg_graph

cpp/mg_utility/mg_utils.hpp

@@ -9,9 +9,9 @@
 #include <memory>
 #include <unordered_set>
 
+#include "_mgp.hpp"
 #include "mg_graph.hpp"
 #include "mgp.hpp"
-#include "_mgp.hpp"
 
 namespace mg_graph {
 
@@ -119,6 +119,8 @@ std::unique_ptr<mg_graph::Graph<TSize>> GetGraphView(mgp_graph *memgraph_graph,
                                                      const char *weight_property = nullptr,
                                                      double default_weight = 1.0) {
   auto graph = std::make_unique<mg_graph::Graph<TSize>>();
+  bool isTransactionalStorage = mgp::graph_is_transactional(memgraph_graph);
+  graph->SetIsTransactional(isTransactionalStorage);
 
   ///
   /// Mapping Memgraph in-memory vertices into the graph view
@@ -281,10 +283,15 @@ void InsertNodeValueResult(mgp_result_record *record, const char *field_name, mg
 
 /// Inserts a node with its ID node_id to create a vertex and insert
 /// the node to the field field_name of the record mgp_result_record record.
-void InsertNodeValueResult(mgp_graph *graph, mgp_result_record *record, const char *field_name, const int node_id,
+/// Returns true is insert is successful, false otherwise
+bool InsertNodeValueResult(mgp_graph *graph, mgp_result_record *record, const char *field_name, const int node_id,
                            mgp_memory *memory) {
   auto *vertex = mgp::graph_get_vertex_by_id(graph, mgp_vertex_id{.as_int = node_id}, memory);
+  if (!vertex) {
+    return false;
+  }
   InsertNodeValueResult(record, field_name, vertex, memory);
+  return true;
 }
 
 /// Inserts a relationship of value edge_value to the field field_name of