Merge branch 'fix-mg-assert-pool-error' into performance-improvements

* Add --storage-mode flag

.github/workflows/daily_benchmark.yaml

@@ -67,7 +67,11 @@ jobs:
       - name: Run mgbench
         run: |
           cd tests/mgbench
-          ./benchmark.py vendor-native --num-workers-for-benchmark 12 --export-results benchmark_result.json pokec/medium/*/*
+          ./benchmark.py vendor-native --num-workers-for-benchmark 12 --export-results benchmark_pokec.json pokec/medium/*/*
+
+          ./benchmark.py vendor-native --num-workers-for-benchmark 1 --export-results benchmark_supernode.json supernode
+
+          ./benchmark.py vendor-native --num-workers-for-benchmark 1 --export-results benchmark_high_write_set_property.json high_write_set_property
 
       - name: Upload mgbench results
         run: |
@@ -76,7 +80,19 @@ jobs:
           source ve3/bin/activate
           pip install -r requirements.txt
           ./main.py --benchmark-name "mgbench" \
-                    --benchmark-results-path "../../tests/mgbench/benchmark_result.json" \
+                    --benchmark-results-path "../../tests/mgbench/benchmark_pokec.json" \
+                    --github-run-id "${{ github.run_id }}" \
+                    --github-run-number "${{ github.run_number }}" \
+                    --head-branch-name "${{ env.BRANCH_NAME }}"
+
+          ./main.py --benchmark-name "supernode" \
+                    --benchmark-results-path "../../tests/mgbench/benchmark_supernode.json" \
+                    --github-run-id "${{ github.run_id }}" \
+                    --github-run-number "${{ github.run_number }}" \
+                    --head-branch-name "${{ env.BRANCH_NAME }}"
+
+          ./main.py --benchmark-name "high_write_set_property" \
+                    --benchmark-results-path "../../tests/mgbench/benchmark_high_write_set_property.json" \
                     --github-run-id "${{ github.run_id }}" \
                     --github-run-number "${{ github.run_number }}" \
                     --head-branch-name "${{ env.BRANCH_NAME }}"

.github/workflows/diff.yaml

@@ -101,7 +101,7 @@ jobs:
             echo ${file}
             if [[ ${file} == *.py ]]; then
               python3 -m black --check --diff ${file}
-              python3 -m isort --check-only --diff ${file}
+              python3 -m isort --profile black --check-only --diff ${file}
             fi
           done
 
@@ -229,6 +229,11 @@ jobs:
           # branches and tags. (default: 1)
           fetch-depth: 0
 
+      - name: Check e2e service dependencies
+        run: |
+          cd tests/e2e
+          ./dependency_check.sh
+
       - name: Build release binaries
         run: |
           # Activate toolchain.
@@ -275,11 +280,13 @@ jobs:
       - name: Run stress test (plain)
         run: |
           cd tests/stress
+          source ve3/bin/activate
           ./continuous_integration
 
       - name: Run stress test (SSL)
         run: |
           cd tests/stress
+          source ve3/bin/activate
           ./continuous_integration --use-ssl
 
       - name: Run durability test

.github/workflows/performance_benchmarks.yaml

@@ -0,0 +1,77 @@
+name: Run performance benchmarks manually
+
+on:
+  workflow_dispatch:
+
+jobs:
+  performance_benchmarks:
+    name: "Performance benchmarks"
+    runs-on: [self-hosted, Linux, X64, Diff, Gen7]
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+
+    steps:
+      - name: Set up repository
+        uses: actions/checkout@v3
+        with:
+          # Number of commits to fetch. `0` indicates all history for all
+          # branches and tags. (default: 1)
+          fetch-depth: 0
+
+      - name: Build release binaries
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v4/activate
+
+          # Initialize dependencies.
+          ./init
+
+          # Build only memgraph release binaries.
+          cd build
+          cmake -DCMAKE_BUILD_TYPE=Release ..
+          make -j$THREADS
+
+      - name: Get branch name (merge)
+        if: github.event_name != 'pull_request'
+        shell: bash
+        run: echo "BRANCH_NAME=$(echo ${GITHUB_REF#refs/heads/} | tr / -)" >> $GITHUB_ENV
+
+      - name: Get branch name (pull request)
+        if: github.event_name == 'pull_request'
+        shell: bash
+        run: echo "BRANCH_NAME=$(echo ${GITHUB_HEAD_REF} | tr / -)" >> $GITHUB_ENV
+
+      - name: Run benchmarks
+        run: |
+          cd tests/mgbench
+          ./benchmark.py vendor-native --num-workers-for-benchmark 12 --export-results benchmark_result.json pokec/medium/*/*
+
+          ./benchmark.py vendor-native --num-workers-for-benchmark 1 --export-results benchmark_supernode.json supernode
+
+          ./benchmark.py vendor-native --num-workers-for-benchmark 1 --export-results benchmark_high_write_set_property.json high_write_set_property
+
+      - name: Upload benchmark results
+        run: |
+          cd tools/bench-graph-client
+          virtualenv -p python3 ve3
+          source ve3/bin/activate
+          pip install -r requirements.txt
+          ./main.py --benchmark-name "mgbench" \
+                    --benchmark-results-path "../../tests/mgbench/benchmark_result.json" \
+                    --github-run-id "${{ github.run_id }}" \
+                    --github-run-number "${{ github.run_number }}" \
+                    --head-branch-name "${{ env.BRANCH_NAME }}"
+
+          ./main.py --benchmark-name "supernode" \
+                    --benchmark-results-path "../../tests/mgbench/benchmark_supernode.json" \
+                    --github-run-id "${{ github.run_id }}" \
+                    --github-run-number "${{ github.run_number }}" \
+                    --head-branch-name "${{ env.BRANCH_NAME }}"
+
+          ./main.py --benchmark-name "high_write_set_property" \
+                    --benchmark-results-path "../../tests/mgbench/benchmark_high_write_set_property.json" \
+                    --github-run-id "${{ github.run_id }}" \
+                    --github-run-number "${{ github.run_number }}" \
+                    --head-branch-name "${{ env.BRANCH_NAME }}"

.gitignore

@@ -16,8 +16,7 @@
 .ycm_extra_conf.pyc
 .temp/
 Testing/
-build
-build/
+/build*/
 release/examples/build
 cmake-build-*
 cmake/DownloadProject/

.pre-commit-config.yaml

@@ -15,6 +15,7 @@ repos:
     hooks:
       - id: isort
         name: isort (python)
+        args: ["--profile", "black"]
   - repo: https://github.com/pre-commit/mirrors-clang-format
     rev: v13.0.0
     hooks:

CMakeLists.txt

@@ -42,6 +42,10 @@ endif()
 
 project(memgraph LANGUAGES C CXX)
 
+# NOTE: once in a while this needs to be toggled to check headers are
+#       correct and PCH isn't masking any include issues
+set(CMAKE_DISABLE_PRECOMPILE_HEADERS OFF)
+
 #TODO: upgrade to cmake 3.24 + CheckIPOSupported
 #cmake_policy(SET CMP0138 NEW)
 #include(CheckIPOSupported)
@@ -64,7 +68,7 @@ option(MG_ENTERPRISE "Build Memgraph Enterprise Edition" ON)
 # Set the current version here to override the automatic version detection. The
 # version must be specified as `X.Y.Z`. Primarily used when building new patch
 # versions.
-set(MEMGRAPH_OVERRIDE_VERSION "2.10.1")
+set(MEMGRAPH_OVERRIDE_VERSION "")
 
 # Custom suffix that this version should have. The suffix can be any arbitrary
 # string. Primarily used when building a version for a specific customer.

README.md

@@ -175,7 +175,6 @@ license](./licenses/BSL.txt).</br> Memgraph Enterprise is available under the
 
 - :purple_heart: [**Discord**](https://discord.gg/memgraph)
 - :ocean: [**Stack Overflow**](https://stackoverflow.com/questions/tagged/memgraphdb)
-- :busts_in_silhouette: [**Discourse forum**](https://discourse.memgraph.com/)
 - :bird: [**Twitter**](https://twitter.com/memgraphdb)
 - :movie_camera:
   [**YouTube**](https://www.youtube.com/channel/UCZ3HOJvHGxtQ_JHxOselBYg)

config/flags.yaml

@@ -99,6 +99,10 @@ modifications:
     value: "SNAPSHOT_ISOLATION"
     override: true
 
+  - name: "storage_mode"
+    value: "IN_MEMORY_TRANSACTIONAL"
+    override: true
+
   - name: "allow_load_csv"
     value: "true"
     override: false
@@ -107,6 +111,10 @@ modifications:
     value: "false"
     override: true
 
+  - name: "query_callable_mappings_path"
+    value: "/etc/memgraph/apoc_compatibility_mappings.json"
+    override: true
+
 undocumented:
   - "flag_file"
   - "also_log_to_stderr"

config/mappings.json

@@ -0,0 +1,27 @@
+{
+    "dbms.components": "mgps.components",
+    "apoc.util.validate": "mgps.validate",
+    "db.schema.nodeTypeProperties":"schema.node_type_properties",
+    "db.schema.relTypeProperties":"schema.rel_type_properties",
+    "apoc.coll.contains": "collections.contains",
+    "apoc.coll.partition": "collections.partition",
+    "apoc.coll.toSet": "collections.to_set",
+    "apoc.coll.unionAll": "collections.unionAll",
+    "apoc.coll.removeAll": "collections.remove_all",
+    "apoc.coll.union": "collections.union",
+    "apoc.coll.sum": "collections.sum",
+    "apoc.coll.pairs": "collections.pairs",
+    "apoc.map.fromLists": "map.from_lists",
+    "apoc.map.removeKeys": "map.remove_keys",
+    "apoc.map.merge": "map.merge",
+    "apoc.create.nodes": "create.nodes",
+    "apoc.create.removeProperties": "create.remove_properties",
+    "apoc.create.node": "create.node",
+    "apoc.create.removeLabel": "create.remove_label",
+    "apoc.refactor.invert": "refactor.invert",
+    "apoc.refactor.cloneNode": "refactor.clone_node",
+    "apoc.refactor.cloneSubgraph": "refactor.clone_subgraph",
+    "apoc.refactor.cloneSubgraphFromPath": "refactor.clone_subgraph_from_path",
+    "apoc.label.exists": "label.exists"
+
+}

include/_mgp.hpp

@@ -255,6 +255,16 @@ inline mgp_edge *graph_create_edge(mgp_graph *graph, mgp_vertex *from, mgp_verte
   return MgInvoke<mgp_edge *>(mgp_graph_create_edge, graph, from, to, type, memory);
 }
 
+inline mgp_edge *graph_edge_set_from(struct mgp_graph *graph, struct mgp_edge *e, struct mgp_vertex *new_from,
+                                     mgp_memory *memory) {
+  return MgInvoke<mgp_edge *>(mgp_graph_edge_set_from, graph, e, new_from, memory);
+}
+
+inline mgp_edge *graph_edge_set_to(struct mgp_graph *graph, struct mgp_edge *e, struct mgp_vertex *new_to,
+                                   mgp_memory *memory) {
+  return MgInvoke<mgp_edge *>(mgp_graph_edge_set_to, graph, e, new_to, memory);
+}
+
 inline void graph_delete_edge(mgp_graph *graph, mgp_edge *edge) { MgInvokeVoid(mgp_graph_delete_edge, graph, edge); }
 
 inline mgp_vertex *graph_get_vertex_by_id(mgp_graph *g, mgp_vertex_id id, mgp_memory *memory) {
@@ -367,6 +377,10 @@ inline mgp_map_item *map_items_iterator_next(mgp_map_items_iterator *it) {
 
 inline mgp_vertex_id vertex_get_id(mgp_vertex *v) { return MgInvoke<mgp_vertex_id>(mgp_vertex_get_id, v); }
 
+inline size_t vertex_get_in_degree(mgp_vertex *v) { return MgInvoke<size_t>(mgp_vertex_get_in_degree, v); }
+
+inline size_t vertex_get_out_degree(mgp_vertex *v) { return MgInvoke<size_t>(mgp_vertex_get_out_degree, v); }
+
 inline mgp_vertex *vertex_copy(mgp_vertex *v, mgp_memory *memory) {
   return MgInvoke<mgp_vertex *>(mgp_vertex_copy, v, memory);
 }
@@ -401,6 +415,10 @@ inline void vertex_set_property(mgp_vertex *v, const char *property_name, mgp_va
   MgInvokeVoid(mgp_vertex_set_property, v, property_name, property_value);
 }
 
+inline void vertex_set_properties(mgp_vertex *v, struct mgp_map *properties) {
+  MgInvokeVoid(mgp_vertex_set_properties, v, properties);
+}
+
 inline mgp_properties_iterator *vertex_iter_properties(mgp_vertex *v, mgp_memory *memory) {
   return MgInvoke<mgp_properties_iterator *>(mgp_vertex_iter_properties, v, memory);
 }
@@ -437,6 +455,10 @@ inline void edge_set_property(mgp_edge *e, const char *property_name, mgp_value
   MgInvokeVoid(mgp_edge_set_property, e, property_name, property_value);
 }
 
+inline void edge_set_properties(mgp_edge *e, struct mgp_map *properties) {
+  MgInvokeVoid(mgp_edge_set_properties, e, properties);
+}
+
 inline mgp_properties_iterator *edge_iter_properties(mgp_edge *e, mgp_memory *memory) {
   return MgInvoke<mgp_properties_iterator *>(mgp_edge_iter_properties, e, memory);
 }
@@ -455,6 +477,8 @@ inline void path_destroy(mgp_path *path) { mgp_path_destroy(path); }
 
 inline void path_expand(mgp_path *path, mgp_edge *edge) { MgInvokeVoid(mgp_path_expand, path, edge); }
 
+inline void path_pop(mgp_path *path) { MgInvokeVoid(mgp_path_pop, path); }
+
 inline size_t path_size(mgp_path *path) { return MgInvoke<size_t>(mgp_path_size, path); }
 
 inline mgp_vertex *path_vertex_at(mgp_path *path, size_t index) {

include/_mgp_mock.py

@@ -333,6 +333,13 @@ class Path:
         self._vertices.append(edge.end_id)
         self._edges.append((edge.start_id, edge.end_id, edge.id))
 
+    def pop(self):
+        if not self._edges:
+            raise IndexError("Path contains no relationships.")
+
+        self._vertices.pop()
+        self._edges.pop()
+
     def vertex_at(self, index: int) -> Vertex:
         return Vertex(self._vertices[index], self._graph)
 

include/mg_procedure.h

@@ -543,6 +543,10 @@ void mgp_path_destroy(struct mgp_path *path);
 /// Return mgp_error::MGP_ERROR_UNABLE_TO_ALLOCATE if unable to allocate memory for path extension.
 enum mgp_error mgp_path_expand(struct mgp_path *path, struct mgp_edge *edge);
 
+/// Remove the last node and the last relationship from the path.
+/// Return mgp_error::MGP_ERROR_OUT_OF_RANGE if the path contains no relationships.
+enum mgp_error mgp_path_pop(struct mgp_path *path);
+
 /// Get the number of edges in a mgp_path.
 /// Current implementation always returns without errors.
 enum mgp_error mgp_path_size(struct mgp_path *path, size_t *result);
@@ -647,6 +651,12 @@ struct mgp_vertex_id {
 /// Get the ID of given vertex.
 enum mgp_error mgp_vertex_get_id(struct mgp_vertex *v, struct mgp_vertex_id *result);
 
+/// Get the in degree of given vertex.
+enum mgp_error mgp_vertex_get_in_degree(struct mgp_vertex *v, size_t *result);
+
+/// Get the out degree of given vertex.
+enum mgp_error mgp_vertex_get_out_degree(struct mgp_vertex *v, size_t *result);
+
 /// Result is non-zero if the vertex can be modified.
 /// The mutability of the vertex is the same as the graph which it is part of. If a vertex is immutable, then edges
 /// cannot be created or deleted, properties and labels cannot be set or removed and all of the returned edges will be
@@ -664,6 +674,15 @@ enum mgp_error mgp_vertex_underlying_graph_is_mutable(struct mgp_vertex *v, int
 enum mgp_error mgp_vertex_set_property(struct mgp_vertex *v, const char *property_name,
                                        struct mgp_value *property_value);
 
+/// Set the value of properties on a vertex.
+/// When the value is `null`, then the property is removed from the vertex.
+/// Return mgp_error::MGP_ERROR_UNABLE_TO_ALLOCATE if unable to allocate memory for storing the property.
+/// Return mgp_error::MGP_ERROR_IMMUTABLE_OBJECT if `v` is immutable.
+/// Return mgp_error::MGP_ERROR_DELETED_OBJECT if `v` has been deleted.
+/// Return mgp_error::MGP_ERROR_SERIALIZATION_ERROR if `v` has been modified by another transaction.
+/// Return mgp_error::MGP_ERROR_VALUE_CONVERSION if `property_value` is vertex, edge or path.
+enum mgp_error mgp_vertex_set_properties(struct mgp_vertex *v, struct mgp_map *properties);
+
 /// Add the label to the vertex.
 /// If the vertex already has the label, this function does nothing.
 /// Return mgp_error::MGP_ERROR_UNABLE_TO_ALLOCATE if unable to allocate memory for storing the label.
@@ -814,6 +833,15 @@ enum mgp_error mgp_edge_get_property(struct mgp_edge *e, const char *property_na
 /// Return mgp_error::MGP_ERROR_VALUE_CONVERSION if `property_value` is vertex, edge or path.
 enum mgp_error mgp_edge_set_property(struct mgp_edge *e, const char *property_name, struct mgp_value *property_value);
 
+/// Set the value of properties on a vertex.
+/// When the value is `null`, then the property is removed from the vertex.
+/// Return mgp_error::MGP_ERROR_UNABLE_TO_ALLOCATE if unable to allocate memory for storing the property.
+/// Return mgp_error::MGP_ERROR_IMMUTABLE_OBJECT if `v` is immutable.
+/// Return mgp_error::MGP_ERROR_DELETED_OBJECT if `v` has been deleted.
+/// Return mgp_error::MGP_ERROR_SERIALIZATION_ERROR if `v` has been modified by another transaction.
+/// Return mgp_error::MGP_ERROR_VALUE_CONVERSION if `property_value` is vertex, edge or path.
+enum mgp_error mgp_edge_set_properties(struct mgp_edge *e, struct mgp_map *properties);
+
 /// Start iterating over properties stored in the given edge.
 /// The properties of the edge are copied when the iterator is created, therefore later changes won't affect them.
 /// Resulting mgp_properties_iterator needs to be deallocated with
@@ -864,6 +892,22 @@ enum mgp_error mgp_graph_detach_delete_vertex(struct mgp_graph *graph, struct mg
 enum mgp_error mgp_graph_create_edge(struct mgp_graph *graph, struct mgp_vertex *from, struct mgp_vertex *to,
                                      struct mgp_edge_type type, struct mgp_memory *memory, struct mgp_edge **result);
 
+/// Change edge from vertex
+/// Return mgp_error::MGP_ERROR_IMMUTABLE_OBJECT if `graph` is immutable.
+/// Return mgp_error::MGP_ERROR_UNABLE_TO_ALLOCATE if unable to allocate a mgp_edge.
+/// Return mgp_error::MGP_ERROR_DELETED_OBJECT if `from` or `to` has been deleted.
+/// Return mgp_error::MGP_ERROR_SERIALIZATION_ERROR if `from` or `to` has been modified by another transaction.
+enum mgp_error mgp_graph_edge_set_from(struct mgp_graph *graph, struct mgp_edge *e, struct mgp_vertex *new_from,
+                                       struct mgp_memory *memory, struct mgp_edge **result);
+
+/// Change edge to vertex
+/// Return mgp_error::MGP_ERROR_IMMUTABLE_OBJECT if `graph` is immutable.
+/// Return mgp_error::MGP_ERROR_UNABLE_TO_ALLOCATE if unable to allocate a mgp_edge.
+/// Return mgp_error::MGP_ERROR_DELETED_OBJECT if `from` or `to` has been deleted.
+/// Return mgp_error::MGP_ERROR_SERIALIZATION_ERROR if `from` or `to` has been modified by another transaction.
+enum mgp_error mgp_graph_edge_set_to(struct mgp_graph *graph, struct mgp_edge *e, struct mgp_vertex *new_to,
+                                     struct mgp_memory *memory, struct mgp_edge **result);
+
 /// Delete an edge from the graph.
 /// Return mgp_error::MGP_ERROR_IMMUTABLE_OBJECT if `graph` is immutable.
 /// Return mgp_error::MGP_ERROR_SERIALIZATION_ERROR if `edge`, its source or destination vertex has been modified by

include/mgp.hpp

@@ -126,6 +126,12 @@ class MemoryDispatcher final {
     map_.erase(this_id);
   }
 
+  bool IsThisThreadRegistered() noexcept {
+    const auto this_id = std::this_thread::get_id();
+    std::shared_lock lock(mut_);
+    return map_.contains(this_id);
+  }
+
  private:
   std::unordered_map<std::thread::id, mgp_memory *> map_;
   std::shared_mutex mut_;
@@ -136,7 +142,7 @@ class MemoryDispatcher final {
 // header. The use of the 'mgp_memory *memory' pointer is deprecated
 // and will be removed in upcoming releases.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-inline extern MemoryDispatcher mrd{};
+inline MemoryDispatcher mrd{};
 
 // TODO - Once we deprecate this we should remove this
 // and make sure nothing relies on it anymore. This alone
@@ -164,7 +170,7 @@ class MemoryDispatcherGuard final {
 // the mapping instead.
 template <typename Func, typename... Args>
 inline decltype(auto) MemHandlerCallback(Func &&func, Args &&...args) {
-  if (memory) {
+  if (!mrd.IsThisThreadRegistered()) {
     return std::forward<Func>(func)(std::forward<Args>(args)..., memory);
   }
   return std::forward<Func>(func)(std::forward<Args>(args)..., mrd.GetMemoryResource());
@@ -250,6 +256,10 @@ class Graph {
   void DetachDeleteNode(const Node &node);
   /// @brief Creates a relationship of type `type` between nodes `from` and `to` and adds it to the graph.
   Relationship CreateRelationship(const Node &from, const Node &to, const std::string_view type);
+  /// @brief Changes a relationship from node.
+  void SetFrom(Relationship &relationship, const Node &new_from);
+  /// @brief Changes a relationship to node.
+  void SetTo(Relationship &relationship, const Node &new_to);
   /// @brief Deletes a relationship from the graph.
   void DeleteRelationship(const Relationship &relationship);
 
@@ -429,6 +439,12 @@ class Labels {
     friend class Labels;
 
    public:
+    using value_type = Labels;
+    using difference_type = std::ptrdiff_t;
+    using pointer = const Labels *;
+    using reference = const Labels &;
+    using iterator_category = std::forward_iterator_tag;
+
     bool operator==(const Iterator &other) const;
 
     bool operator!=(const Iterator &other) const;
@@ -512,6 +528,12 @@ class List {
     friend class List;
 
    public:
+    using value_type = List;
+    using difference_type = std::ptrdiff_t;
+    using pointer = const List *;
+    using reference = const List &;
+    using iterator_category = std::forward_iterator_tag;
+
     bool operator==(const Iterator &other) const;
 
     bool operator!=(const Iterator &other) const;
@@ -554,6 +576,9 @@ class List {
   /// @exception std::runtime_error List contains value of unknown type.
   bool operator!=(const List &other) const;
 
+  /// @brief returns the string representation
+  const std::string ToString() const;
+
  private:
   mgp_list *ptr_;
 };
@@ -669,6 +694,9 @@ class Map {
   /// @exception std::runtime_error Map contains value of unknown type.
   bool operator!=(const Map &other) const;
 
+  /// @brief returns the string representation
+  const std::string ToString() const;
+
  private:
   mgp_map *ptr_;
 };
@@ -709,11 +737,14 @@ class Node {
   bool HasLabel(std::string_view label) const;
 
   /// @brief Returns an std::map of the node’s properties.
-  std::map<std::string, Value> Properties() const;
+  std::unordered_map<std::string, Value> Properties() const;
 
   /// @brief Sets the chosen property to the given value.
   void SetProperty(std::string property, Value value);
 
+  /// @brief Sets the chosen properties to the given values.
+  void SetProperties(std::unordered_map<std::string_view, Value> properties);
+
   /// @brief Removes the chosen property.
   void RemoveProperty(std::string property);
 
@@ -740,6 +771,15 @@ class Node {
   /// @exception std::runtime_error Node properties contain value(s) of unknown type.
   bool operator!=(const Node &other) const;
 
+  /// @brief returns the string representation
+  const std::string ToString() const;
+
+  /// @brief returns the in degree of a node
+  inline size_t InDegree() const;
+
+  /// @brief returns the out degree of a node
+  inline size_t OutDegree() const;
+
  private:
   mgp_vertex *ptr_;
 };
@@ -775,11 +815,17 @@ class Relationship {
   std::string_view Type() const;
 
   /// @brief Returns an std::map of the relationship’s properties.
-  std::map<std::string, Value> Properties() const;
+  std::unordered_map<std::string, Value> Properties() const;
 
   /// @brief Sets the chosen property to the given value.
   void SetProperty(std::string property, Value value);
 
+  /// @brief Sets the chosen properties to the given values.
+  void SetProperties(std::unordered_map<std::string_view, Value> properties);
+
+  /// @brief Removes the chosen property.
+  void RemoveProperty(std::string property);
+
   /// @brief Retrieves the value of the chosen property.
   Value GetProperty(const std::string &property) const;
 
@@ -795,6 +841,9 @@ class Relationship {
   /// @exception std::runtime_error Relationship properties contain value(s) of unknown type.
   bool operator!=(const Relationship &other) const;
 
+  /// @brief returns the string representation
+  const std::string ToString() const;
+
  private:
   mgp_edge *ptr_;
 };
@@ -837,12 +886,17 @@ class Path {
 
   /// @brief Adds a relationship continuing from the last node on the path.
   void Expand(const Relationship &relationship);
+  /// @brief Removes the last node and the last relationship from the path.
+  void Pop();
 
   /// @exception std::runtime_error Path contains element(s) with unknown value.
   bool operator==(const Path &other) const;
   /// @exception std::runtime_error Path contains element(s) with unknown value.
   bool operator!=(const Path &other) const;
 
+  /// @brief returns the string representation
+  const std::string ToString() const;
+
  private:
   mgp_path *ptr_;
 };
@@ -900,6 +954,9 @@ class Date {
 
   bool operator<(const Date &other) const;
 
+  /// @brief returns the string representation
+  const std::string ToString() const;
+
  private:
   mgp_date *ptr_;
 };
@@ -959,6 +1016,9 @@ class LocalTime {
 
   bool operator<(const LocalTime &other) const;
 
+  /// @brief returns the string representation
+  const std::string ToString() const;
+
  private:
   mgp_local_time *ptr_;
 };
@@ -1024,6 +1084,9 @@ class LocalDateTime {
 
   bool operator<(const LocalDateTime &other) const;
 
+  /// @brief returns the string representation
+  const std::string ToString() const;
+
  private:
   mgp_local_date_time *ptr_;
 };
@@ -1075,6 +1138,9 @@ class Duration {
 
   bool operator<(const Duration &other) const;
 
+  /// @brief returns the string representation
+  const std::string ToString() const;
+
  private:
   mgp_duration *ptr_;
 };
@@ -1285,6 +1351,9 @@ class Value {
 
   friend std::ostream &operator<<(std::ostream &os, const mgp::Value &value);
 
+  /// @brief returns the string representation
+  const std::string ToString() const;
+
  private:
   mgp_value *ptr_;
 };
@@ -1946,6 +2015,18 @@ inline Relationship Graph::CreateRelationship(const Node &from, const Node &to,
   return relationship;
 }
 
+inline void Graph::SetFrom(Relationship &relationship, const Node &new_from) {
+  mgp_edge *edge = mgp::MemHandlerCallback(mgp::graph_edge_set_from, graph_, relationship.ptr_, new_from.ptr_);
+  relationship = Relationship(edge);
+  mgp::edge_destroy(edge);
+}
+
+inline void Graph::SetTo(Relationship &relationship, const Node &new_to) {
+  mgp_edge *edge = mgp::MemHandlerCallback(mgp::graph_edge_set_to, graph_, relationship.ptr_, new_to.ptr_);
+  relationship = Relationship(edge);
+  mgp::edge_destroy(edge);
+}
+
 inline void Graph::DeleteRelationship(const Relationship &relationship) {
   mgp::graph_delete_edge(graph_, relationship.ptr_);
 }
@@ -2397,6 +2478,22 @@ inline bool List::operator==(const List &other) const { return util::ListsEqual(
 
 inline bool List::operator!=(const List &other) const { return !(*this == other); }
 
+inline const std::string List::ToString() const {
+  const size_t size = Size();
+  if (size == 0) {
+    return "[]";
+  }
+  std::string return_str{"["};
+  size_t i = 0;
+  const mgp::List &list = (*this);
+  while (i < size - 1) {
+    return_str.append(list[i].ToString() + ", ");
+    i++;
+  }
+  return_str.append(list[i].ToString() + "]");
+  return return_str;
+}
+
 // MapItem:
 
 inline bool MapItem::operator==(MapItem &other) const { return key == other.key && value == other.value; }
@@ -2566,6 +2663,24 @@ inline bool Map::operator==(const Map &other) const { return util::MapsEqual(ptr
 
 inline bool Map::operator!=(const Map &other) const { return !(*this == other); }
 
+inline const std::string Map::ToString() const {
+  const size_t map_size = Size();
+  if (map_size == 0) {
+    return "{}";
+  }
+  std::string return_string{"{"};
+  size_t i = 0;
+  for (const auto &[key, value] : *this) {
+    if (i == map_size - 1) {
+      return_string.append(std::string(key) + ": " + value.ToString() + "}");
+      break;
+    }
+    return_string.append(std::string(key) + ": " + value.ToString() + ", ");
+    ++i;
+  }
+  return return_string;
+}
+
 /* #endregion */
 
 /* #region Graph elements (Node, Relationship & Path) */
@@ -2643,9 +2758,9 @@ inline void Node::RemoveLabel(const std::string_view label) {
   mgp::vertex_remove_label(this->ptr_, mgp_label{.name = label.data()});
 }
 
-inline std::map<std::string, Value> Node::Properties() const {
+inline std::unordered_map<std::string, Value> Node::Properties() const {
   mgp_properties_iterator *properties_iterator = mgp::MemHandlerCallback(vertex_iter_properties, ptr_);
-  std::map<std::string, Value> property_map;
+  std::unordered_map<std::string, Value> property_map;
   for (auto *property = mgp::properties_iterator_get(properties_iterator); property;
        property = mgp::properties_iterator_next(properties_iterator)) {
     property_map.emplace(std::string(property->name), Value(property->value));
@@ -2658,6 +2773,17 @@ inline void Node::SetProperty(std::string property, Value value) {
   mgp::vertex_set_property(ptr_, property.data(), value.ptr());
 }
 
+inline void Node::SetProperties(std::unordered_map<std::string_view, Value> properties) {
+  mgp_map *map = mgp::MemHandlerCallback(map_make_empty);
+
+  for (auto const &[k, v] : properties) {
+    mgp::map_insert(map, k.data(), v.ptr());
+  }
+
+  mgp::vertex_set_properties(ptr_, map);
+  mgp::map_destroy(map);
+}
+
 inline void Node::RemoveProperty(std::string property) { SetProperty(property, Value()); }
 
 inline Value Node::GetProperty(const std::string &property) const {
@@ -2671,6 +2797,45 @@ inline bool Node::operator==(const Node &other) const { return util::NodesEqual(
 
 inline bool Node::operator!=(const Node &other) const { return !(*this == other); }
 
+// this functions is used both in relationship and node ToString
+inline std::string PropertiesToString(const std::map<std::string, Value> &property_map) {
+  std::string properties;
+  const auto map_size = property_map.size();
+  size_t i = 0;
+  for (const auto &[key, value] : property_map) {
+    if (i == map_size - 1) {
+      properties.append(std::string(key) + ": " + value.ToString());
+      break;
+    }
+    properties.append(std::string(key) + ": " + value.ToString() + ", ");
+    ++i;
+  }
+  return properties;
+}
+
+inline const std::string Node::ToString() const {
+  std::string labels{", "};
+  for (auto label : Labels()) {
+    labels.append(":" + std::string(label));
+  }
+  if (labels == ", ") {
+    labels = "";  // dont use labels if they dont exist
+  }
+  std::unordered_map<std::string, Value> properties_map{Properties()};
+  std::map<std::string, Value> properties_map_sorted{};
+
+  for (const auto &[k, v] : properties_map) {
+    properties_map_sorted.emplace(k, v);
+  }
+  std::string properties{PropertiesToString(properties_map_sorted)};
+
+  return "(id: " + std::to_string(Id().AsInt()) + labels + ", properties: {" + properties + "})";
+}
+
+inline size_t Node::InDegree() const { return mgp::vertex_get_in_degree(ptr_); }
+
+inline size_t Node::OutDegree() const { return mgp::vertex_get_out_degree(ptr_); }
+
 // Relationship:
 
 inline Relationship::Relationship(mgp_edge *ptr) : ptr_(mgp::MemHandlerCallback(edge_copy, ptr)) {}
@@ -2711,9 +2876,9 @@ inline mgp::Id Relationship::Id() const { return Id::FromInt(mgp::edge_get_id(pt
 
 inline std::string_view Relationship::Type() const { return mgp::edge_get_type(ptr_).name; }
 
-inline std::map<std::string, Value> Relationship::Properties() const {
+inline std::unordered_map<std::string, Value> Relationship::Properties() const {
   mgp_properties_iterator *properties_iterator = mgp::MemHandlerCallback(edge_iter_properties, ptr_);
-  std::map<std::string, Value> property_map;
+  std::unordered_map<std::string, Value> property_map;
   for (mgp_property *property = mgp::properties_iterator_get(properties_iterator); property;
        property = mgp::properties_iterator_next(properties_iterator)) {
     property_map.emplace(property->name, Value(property->value));
@@ -2726,6 +2891,19 @@ inline void Relationship::SetProperty(std::string property, Value value) {
   mgp::edge_set_property(ptr_, property.data(), value.ptr());
 }
 
+inline void Relationship::SetProperties(std::unordered_map<std::string_view, Value> properties) {
+  mgp_map *map = mgp::MemHandlerCallback(map_make_empty);
+
+  for (auto const &[k, v] : properties) {
+    mgp::map_insert(map, k.data(), v.ptr());
+  }
+
+  mgp::edge_set_properties(ptr_, map);
+  mgp::map_destroy(map);
+}
+
+inline void Relationship::RemoveProperty(std::string property) { SetProperty(property, Value()); }
+
 inline Value Relationship::GetProperty(const std::string &property) const {
   mgp_value *edge_prop = mgp::MemHandlerCallback(edge_get_property, ptr_, property.data());
   return Value(steal, edge_prop);
@@ -2743,6 +2921,24 @@ inline bool Relationship::operator==(const Relationship &other) const {
 
 inline bool Relationship::operator!=(const Relationship &other) const { return !(*this == other); }
 
+inline const std::string Relationship::ToString() const {
+  const auto from = From();
+  const auto to = To();
+
+  const std::string type{Type()};
+  std::unordered_map<std::string, Value> properties_map{Properties()};
+  std::map<std::string, Value> properties_map_sorted{};
+
+  for (const auto &[k, v] : properties_map) {
+    properties_map_sorted.emplace(k, v);
+  }
+  std::string properties{PropertiesToString(properties_map_sorted)};
+
+  const std::string relationship{"[type: " + type + ", id: " + std::to_string(Id().AsInt()) + ", properties: {" +
+                                 properties + "}]"};
+
+  return from.ToString() + "-" + relationship + "->" + to.ToString();
+}
 // Path:
 
 inline Path::Path(mgp_path *ptr) : ptr_(mgp::MemHandlerCallback(path_copy, ptr)) {}
@@ -2801,10 +2997,38 @@ inline Relationship Path::GetRelationshipAt(size_t index) const {
 
 inline void Path::Expand(const Relationship &relationship) { mgp::path_expand(ptr_, relationship.ptr_); }
 
+inline void Path::Pop() { mgp::path_pop(ptr_); }
+
 inline bool Path::operator==(const Path &other) const { return util::PathsEqual(ptr_, other.ptr_); }
 
 inline bool Path::operator!=(const Path &other) const { return !(*this == other); }
 
+inline const std::string Path::ToString() const {
+  const auto length = Length();
+  size_t i = 0;
+  std::string return_string{""};
+  for (i = 0; i < length; i++) {
+    const auto node = GetNodeAt(i);
+    return_string.append(node.ToString() + "-");
+
+    const Relationship rel = GetRelationshipAt(i);
+    std::unordered_map<std::string, Value> properties_map{rel.Properties()};
+    std::map<std::string, Value> properties_map_sorted{};
+
+    for (const auto &[k, v] : properties_map) {
+      properties_map_sorted.emplace(k, v);
+    }
+    std::string properties{PropertiesToString(properties_map_sorted)};
+
+    return_string.append("[type: " + std::string(rel.Type()) + ", id: " + std::to_string(rel.Id().AsInt()) +
+                         ", properties: {" + properties + "}]->");
+  }
+
+  const auto node = GetNodeAt(i);
+  return_string.append(node.ToString());
+  return return_string;
+}
+
 /* #endregion */
 
 /* #region Temporal types (Date, LocalTime, LocalDateTime, Duration) */
@@ -2902,6 +3126,10 @@ inline bool Date::operator<(const Date &other) const {
   return is_less;
 }
 
+inline const std::string Date::ToString() const {
+  return std::to_string(Year()) + "-" + std::to_string(Month()) + "-" + std::to_string(Day());
+}
+
 // LocalTime:
 
 inline LocalTime::LocalTime(mgp_local_time *ptr) : ptr_(mgp::MemHandlerCallback(local_time_copy, ptr)) {}
@@ -3001,6 +3229,11 @@ inline bool LocalTime::operator<(const LocalTime &other) const {
   return is_less;
 }
 
+inline const std::string LocalTime::ToString() const {
+  return std::to_string(Hour()) + ":" + std::to_string(Minute()) + ":" + std::to_string(Second()) + "," +
+         std::to_string(Millisecond()) + std::to_string(Microsecond());
+}
+
 // LocalDateTime:
 
 inline LocalDateTime::LocalDateTime(mgp_local_date_time *ptr)
@@ -3115,6 +3348,12 @@ inline bool LocalDateTime::operator<(const LocalDateTime &other) const {
   return is_less;
 }
 
+inline const std::string LocalDateTime::ToString() const {
+  return std::to_string(Year()) + "-" + std::to_string(Month()) + "-" + std::to_string(Day()) + "T" +
+         std::to_string(Hour()) + ":" + std::to_string(Minute()) + ":" + std::to_string(Second()) + "," +
+         std::to_string(Millisecond()) + std::to_string(Microsecond());
+}
+
 // Duration:
 
 inline Duration::Duration(mgp_duration *ptr) : ptr_(mgp::MemHandlerCallback(duration_copy, ptr)) {}
@@ -3204,6 +3443,8 @@ inline bool Duration::operator<(const Duration &other) const {
   return is_less;
 }
 
+inline const std::string Duration::ToString() const { return std::to_string(Microseconds()) + "ms"; }
+
 /* #endregion */
 
 /* #endregion */
@@ -3668,6 +3909,42 @@ inline std::ostream &operator<<(std::ostream &os, const mgp::Type &type) {
   }
 }
 
+inline const std::string Value::ToString() const {
+  const mgp::Type &type = Type();
+  switch (type) {
+    case Type::Null:
+      return "";
+    case Type::Bool:
+      return ValueBool() ? "true" : "false";
+    case Type::Int:
+      return std::to_string(ValueInt());
+    case Type::Double:
+      return std::to_string(ValueDouble());
+    case Type::String:
+      return std::string(ValueString());
+    case Type::Node:
+      return ValueNode().ToString();
+    case Type::Relationship:
+      return ValueRelationship().ToString();
+    case Type::Date:
+      return ValueDate().ToString();
+    case Type::LocalTime:
+      return ValueLocalTime().ToString();
+    case Type::LocalDateTime:
+      return ValueLocalDateTime().ToString();
+    case Type::Duration:
+      return ValueDuration().ToString();
+    case Type::List:
+      return ValueList().ToString();
+    case Type::Map:
+      return ValueMap().ToString();
+    case Type::Path:
+      return ValuePath().ToString();
+    default:
+      throw ValueException("Undefined behaviour");
+  }
+}
+
 /* #endregion */
 
 /* #region Record */

include/mgp.py

@@ -479,6 +479,12 @@ class Properties:
         except KeyError:
             return False
 
+    def set_properties(self, properties: dict) -> None:
+        if not self._vertex_or_edge.is_valid():
+            raise InvalidContextError()
+
+        self._vertex_or_edge.set_properties(properties)
+
 
 class EdgeType:
     """Type of an Edge."""
@@ -977,6 +983,24 @@ class Path:
         self._vertices = None
         self._edges = None
 
+    def pop(self):
+        """
+        Remove the last node and the last relationship from the path.
+
+        Raises:
+            InvalidContextError: If using an invalid `Path` instance
+            OutOfRangeError: If the path contains no relationships.
+
+        Examples:
+            ```path.pop()```
+        """
+        if not self.is_valid():
+            raise InvalidContextError()
+        self._path.pop()
+        # Invalidate our cached tuples
+        self._vertices = None
+        self._edges = None
+
     @property
     def vertices(self) -> typing.Tuple[Vertex, ...]:
         """
@@ -1017,6 +1041,10 @@ class Path:
             self._edges = tuple(Edge(self._path.edge_at(i)) for i in range(num_edges))
         return self._edges
 
+    @property
+    def length(self) -> int:
+        return self._path.size()
+
 
 class Record:
     """Represents a record of resulting field values."""

include/mgp_mock.py

@@ -929,6 +929,25 @@ class Path:
         self._vertices = None
         self._edges = None
 
+    def pop(self):
+        """
+        Remove the last node and the last relationship from the path.
+
+        Raises:
+            InvalidContextError: If using an invalid `Path` instance
+            OutOfRangeError: If the path contains no relationships.
+
+        Examples:
+            ```path.pop()```
+        """
+        if not self.is_valid():
+            raise InvalidContextError()
+        self._path.pop()
+
+        # Invalidate cached tuples
+        self._vertices = None
+        self._edges = None
+
     @property
     def vertices(self) -> typing.Tuple[Vertex, ...]:
         """

libs/setup.sh

@@ -141,7 +141,7 @@ declare -A secondary_urls=(
   ["rocksdb"]="https://github.com/facebook/rocksdb.git"
   ["mgclient"]="https://github.com/memgraph/mgclient.git"
   ["pymgclient"]="https://github.com/memgraph/pymgclient.git"
-  ["mgconsole"]="http://github.com/memgraph/mgconsole.git"
+  ["mgconsole"]="https://github.com/memgraph/mgconsole.git"
   ["spdlog"]="https://github.com/gabime/spdlog"
   ["nlohmann"]="https://raw.githubusercontent.com/nlohmann/json/4f8fba14066156b73f1189a2b8bd568bde5284c5/single_include/nlohmann/json.hpp"
   ["neo4j"]="https://dist.neo4j.org/neo4j-community-5.6.0-unix.tar.gz"
@@ -212,7 +212,7 @@ pymgclient_tag="4f85c179e56302d46a1e3e2cf43509db65f062b3" # (2021-01-15)
 repo_clone_try_double "${primary_urls[pymgclient]}" "${secondary_urls[pymgclient]}" "pymgclient" "$pymgclient_tag"
 
 # mgconsole
-mgconsole_tag="v1.3.0" # (2022-11-20)
+mgconsole_tag="v1.4.0" # (2023-05-21)
 repo_clone_try_double "${primary_urls[mgconsole]}" "${secondary_urls[mgconsole]}" "mgconsole" "$mgconsole_tag" true
 
 spdlog_tag="v1.9.2" # (2021-08-12)

licenses/BSL.txt

@@ -36,7 +36,7 @@ ADDITIONAL USE GRANT:   You may use the Licensed Work in accordance with the
                         3. using the Licensed Work to create a work or solution
                         which competes (or might reasonably be expected to
                         compete) with the Licensed Work.
-CHANGE DATE:            2027-22-08
+CHANGE DATE:            2027-13-09
 CHANGE LICENSE:         Apache License, Version 2.0
 
 For information about alternative licensing arrangements, please visit: https://memgraph.com/legal.

release/debian/conffiles

@@ -1,3 +1,4 @@
 /etc/memgraph/memgraph.conf
+/etc/memgraph/apoc_compatibility_mappings.json
 /etc/memgraph/auth_module/ldap.example.yaml
 /etc/logrotate.d/memgraph

release/rpm/memgraph.spec.in

@@ -132,6 +132,7 @@ echo "Don't forget to switch to the 'memgraph' user to use Memgraph" || exit 1
 # Override CPACK_RPM_ABSOLUTE_INSTALL_FILES with our %config(noreplace), cpack
 # uses plain %config.
 %config(noreplace) "/etc/memgraph/memgraph.conf"
+%config(noreplace) "/etc/memgraph/apoc_compatibility_mappings.json"
 %config(noreplace) "/etc/memgraph/auth_module/ldap.example.yaml"
 %config(noreplace) "/etc/logrotate.d/memgraph"
 

src/CMakeLists.txt

@@ -18,6 +18,8 @@ add_subdirectory(rpc)
 add_subdirectory(license)
 add_subdirectory(auth)
 add_subdirectory(audit)
+add_subdirectory(dbms)
+add_subdirectory(flags)
 
 string(TOLOWER ${CMAKE_BUILD_TYPE} lower_build_type)
 
@@ -33,13 +35,11 @@ set(mg_single_node_v2_sources
         memgraph.cpp
 )
 
-set(mg_single_node_v2_libs stdc++fs Threads::Threads
-        mg-telemetry mg-query mg-communication mg-memory mg-utils mg-auth mg-license mg-settings mg-glue mg-audit)
-
 # memgraph main executable
 add_executable(memgraph ${mg_single_node_v2_sources})
 target_include_directories(memgraph PUBLIC ${CMAKE_SOURCE_DIR}/include)
-target_link_libraries(memgraph ${mg_single_node_v2_libs})
+target_link_libraries(memgraph stdc++fs Threads::Threads
+        mg-telemetry mg-communication mg-memory mg-utils mg-license mg-settings mg-glue mg-flags)
 
 # NOTE: `include/mg_procedure.syms` describes a pattern match for symbols which
 # should be dynamically exported, so that `dlopen` can correctly link the
@@ -72,7 +72,7 @@ if(lower_build_type STREQUAL "release")
                 COMMENT "Stripping symbols and sections from memgraph")
 endif()
 
-# Generate the configuration file.
+# Generate the configuration file under the build directory.
 add_custom_command(TARGET memgraph POST_BUILD
         COMMAND ${CMAKE_SOURCE_DIR}/config/generate.py
         ${CMAKE_BINARY_DIR}/memgraph
@@ -81,6 +81,11 @@ add_custom_command(TARGET memgraph POST_BUILD
         ${CMAKE_SOURCE_DIR}/config/flags.yaml
         BYPRODUCTS ${CMAKE_BINARY_DIR}/config/memgraph.conf
         COMMENT "Generating memgraph configuration file")
+# Copy the mappings file to the build directory.
+add_custom_command(TARGET memgraph POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy
+        ${CMAKE_SOURCE_DIR}/config/mappings.json
+        ${CMAKE_BINARY_DIR}/config/apoc_compatibility_mappings.json)
 
 # Everything here is under "memgraph" install component.
 set(CMAKE_INSTALL_DEFAULT_COMPONENT_NAME "memgraph")
@@ -116,6 +121,9 @@ install(FILES ${CMAKE_SOURCE_DIR}/include/mgp.hpp
 # Install the config file (must use absolute path).
 install(FILES ${CMAKE_BINARY_DIR}/config/memgraph.conf
         DESTINATION /etc/memgraph RENAME memgraph.conf)
+# Install the mappings file (must use absolute path).
+install(FILES ${CMAKE_BINARY_DIR}/config/apoc_compatibility_mappings.json
+        DESTINATION /etc/memgraph RENAME apoc_compatibility_mappings.json)
 
 # Install logrotate configuration (must use absolute path).
 install(FILES ${CMAKE_SOURCE_DIR}/release/logrotate.conf

src/communication/CMakeLists.txt

@@ -22,3 +22,4 @@ target_link_libraries(mg-communication Boost::headers Threads::Threads mg-utils
 find_package(OpenSSL REQUIRED)
 target_link_libraries(mg-communication ${OPENSSL_LIBRARIES})
 target_include_directories(mg-communication SYSTEM PUBLIC ${OPENSSL_INCLUDE_DIR})
+target_precompile_headers(mg-communication INTERFACE http/server.hpp <boost/beast/websocket.hpp> bolt/v1/session.hpp)

src/communication/bolt/v1/session.hpp

@@ -54,7 +54,7 @@ class SessionException : public utils::BasicException {
  * @tparam TOutputStream type of output stream that will be used
  */
 template <typename TInputStream, typename TOutputStream>
-class Session : public dbms::SessionInterface {
+class Session {
  public:
   using TEncoder = Encoder<ChunkedEncoderBuffer<TOutputStream>>;
 
@@ -159,6 +159,7 @@ class Session : public dbms::SessionInterface {
           break;
         case State::Idle:
         case State::Result:
+          at_least_one_run_ = true;
           state_ = StateExecutingRun(*this, state_);
           break;
         case State::Error:
@@ -180,6 +181,12 @@ class Session : public dbms::SessionInterface {
     }
   }
 
+  void HandleError() {
+    if (!at_least_one_run_) {
+      spdlog::info("Sudden connection loss. Make sure the client supports Memgraph.");
+    }
+  }
+
   // TODO: Rethink if there is a way to hide some members. At the momement all of them are public.
   TInputStream &input_stream_;
   TOutputStream &output_stream_;
@@ -192,6 +199,7 @@ class Session : public dbms::SessionInterface {
 
   bool handshake_done_{false};
   State state_{State::Handshake};
+  bool at_least_one_run_{false};
 
   struct Version {
     uint8_t major;
@@ -200,8 +208,8 @@ class Session : public dbms::SessionInterface {
 
   Version version_;
 
-  std::string GetDatabaseName() const override = 0;
-  std::string UUID() const final { return session_uuid_; }
+  virtual std::string GetDatabaseName() const = 0;
+  std::string UUID() const { return session_uuid_; }
 
  private:
   void ClientFailureInvalidData() {

src/communication/bolt/v1/states/init.hpp

@@ -174,7 +174,7 @@ State SendSuccessMessage(TSession &session) {
   // we send a hardcoded value for now.
   std::map<std::string, Value> metadata{{"connection_id", "bolt-1"}};
   if (auto server_name = session.GetServerNameForInit(); server_name) {
-    metadata.insert({"server", *server_name});
+    metadata.insert({"server", std::move(*server_name)});
   }
   bool success_sent = session.encoder_.MessageSuccess(metadata);
   if (!success_sent) {

src/communication/buffer.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -43,6 +43,7 @@ class Buffer final {
   Buffer(Buffer &&) = delete;
   Buffer &operator=(const Buffer &) = delete;
   Buffer &operator=(Buffer &&) = delete;
+  ~Buffer() = default;
 
   /**
    * This class provides all functions from the buffer that are needed to allow
@@ -50,12 +51,13 @@ class Buffer final {
    */
   class ReadEnd {
    public:
-    ReadEnd(Buffer *buffer);
+    explicit ReadEnd(Buffer *buffer);
 
     ReadEnd(const ReadEnd &) = delete;
     ReadEnd(ReadEnd &&) = delete;
     ReadEnd &operator=(const ReadEnd &) = delete;
     ReadEnd &operator=(ReadEnd &&) = delete;
+    ~ReadEnd() = default;
 
     uint8_t *data();
 
@@ -77,12 +79,13 @@ class Buffer final {
    */
   class WriteEnd {
    public:
-    WriteEnd(Buffer *buffer);
+    explicit WriteEnd(Buffer *buffer);
 
     WriteEnd(const WriteEnd &) = delete;
     WriteEnd(WriteEnd &&) = delete;
     WriteEnd &operator=(const WriteEnd &) = delete;
     WriteEnd &operator=(WriteEnd &&) = delete;
+    ~WriteEnd() = default;
 
     io::network::StreamBuffer Allocate();
 

src/communication/client.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -15,6 +15,10 @@
 #include <openssl/err.h>
 #include <openssl/ssl.h>
 
+// Centos 7 OpenSSL includes libkrb5 which has brings in macros TRUE and FALSE. undef to prevent issues.
+#undef TRUE
+#undef FALSE
+
 #include "communication/buffer.hpp"
 #include "communication/context.hpp"
 #include "communication/init.hpp"

src/communication/context.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -17,6 +17,10 @@
 #include <openssl/ssl.h>
 #include <boost/asio/ssl/context.hpp>
 
+// Centos 7 OpenSSL includes libkrb5 which has brings in macros TRUE and FALSE. undef to prevent issues.
+#undef TRUE
+#undef FALSE
+
 namespace memgraph::communication {
 
 /**

src/communication/http/server.hpp

@@ -26,10 +26,7 @@ class Server final {
   using tcp = boost::asio::ip::tcp;
 
  public:
-  explicit Server(io::network::Endpoint endpoint, TSessionContext *session_context, ServerContext *context)
-      : listener_{Listener<TRequestHandler, TSessionContext>::Create(
-            ioc_, session_context, context,
-            tcp::endpoint{boost::asio::ip::make_address(endpoint.address), endpoint.port})} {}
+  explicit Server(io::network::Endpoint endpoint, TSessionContext *session_context, ServerContext *context);
 
   Server(const Server &) = delete;
   Server(Server &&) = delete;
@@ -41,11 +38,7 @@ class Server final {
               "Server wasn't shutdown properly");
   }
 
-  void Start() {
-    MG_ASSERT(!background_thread_, "The server was already started!");
-    listener_->Run();
-    background_thread_.emplace([this] { ioc_.run(); });
-  }
+  void Start();
 
   void Shutdown() { ioc_.stop(); }
 
@@ -55,7 +48,7 @@ class Server final {
     }
   }
   bool IsRunning() const { return background_thread_ && !ioc_.stopped(); }
-  tcp::endpoint GetEndpoint() const { return listener_->GetEndpoint(); }
+  tcp::endpoint GetEndpoint() const;
 
  private:
   boost::asio::io_context ioc_;
@@ -63,4 +56,22 @@ class Server final {
   std::shared_ptr<Listener<TRequestHandler, TSessionContext>> listener_;
   std::optional<std::thread> background_thread_;
 };
+template <class TRequestHandler, typename TSessionContext>
+Server<TRequestHandler, TSessionContext>::Server(io::network::Endpoint endpoint, TSessionContext *session_context,
+                                                 ServerContext *context)
+    : listener_{Listener<TRequestHandler, TSessionContext>::Create(
+          ioc_, session_context, context,
+          tcp::endpoint{boost::asio::ip::make_address(endpoint.address), endpoint.port})} {}
+
+template <class TRequestHandler, typename TSessionContext>
+void Server<TRequestHandler, TSessionContext>::Start() {
+  MG_ASSERT(!background_thread_, "The server was already started!");
+  listener_->Run();
+  background_thread_.emplace([this] { ioc_.run(); });
+}
+
+template <class TRequestHandler, typename TSessionContext>
+boost::asio::ip::tcp::endpoint Server<TRequestHandler, TSessionContext>::GetEndpoint() const {
+  return listener_->GetEndpoint();
+}
 }  // namespace memgraph::communication::http

src/communication/server.hpp

@@ -58,11 +58,11 @@ class Server final {
    * Constructs and binds server to endpoint, operates on session data and
    * invokes workers_count workers
    */
-  Server(const io::network::Endpoint &endpoint, TSessionContext *session_context, ServerContext *context,
+  Server(io::network::Endpoint endpoint, TSessionContext *session_context, ServerContext *context,
          int inactivity_timeout_sec, const std::string &service_name,
          size_t workers_count = std::thread::hardware_concurrency())
       : alive_(false),
-        endpoint_(endpoint),
+        endpoint_(std::move(endpoint)),
         listener_(session_context, context, inactivity_timeout_sec, service_name, workers_count),
         service_name_(service_name) {}
 

src/communication/session.hpp

@@ -22,6 +22,10 @@
 #include <openssl/err.h>
 #include <openssl/ssl.h>
 
+// Centos 7 OpenSSL includes libkrb5 which has brings in macros TRUE and FALSE. undef to prevent issues.
+#undef TRUE
+#undef FALSE
+
 #include "communication/buffer.hpp"
 #include "communication/context.hpp"
 #include "communication/exceptions.hpp"

src/communication/v2/server.hpp

@@ -73,40 +73,19 @@ class Server final {
    * invokes workers_count workers
    */
   Server(ServerEndpoint &endpoint, TSessionContext *session_context, ServerContext *server_context,
-         const int inactivity_timeout_sec, const std::string_view service_name,
-         size_t workers_count = std::thread::hardware_concurrency())
-      : endpoint_{endpoint},
-        service_name_{service_name},
-        context_thread_pool_{workers_count},
-        listener_{Listener<TSession, TSessionContext>::Create(context_thread_pool_.GetIOContext(), session_context,
-                                                              server_context, endpoint_, service_name_,
-                                                              inactivity_timeout_sec)} {}
+         int inactivity_timeout_sec, std::string_view service_name,
+         size_t workers_count = std::thread::hardware_concurrency());
 
-  ~Server() { MG_ASSERT(!IsRunning(), "Server wasn't shutdown properly"); }
+  ~Server();
 
   Server(const Server &) = delete;
   Server(Server &&) = delete;
   Server &operator=(const Server &) = delete;
   Server &operator=(Server &&) = delete;
 
-  const auto &Endpoint() const {
-    MG_ASSERT(IsRunning(), "You can't get the server endpoint when it's not running!");
-    return endpoint_;
-  }
+  const auto &Endpoint() const;
 
-  bool Start() {
-    if (IsRunning()) {
-      spdlog::error("The server is already running");
-      return false;
-    }
-    listener_->Start();
-
-    spdlog::info("{} server is fully armed and operational", service_name_);
-    spdlog::info("{} listening on {}", service_name_, endpoint_.address());
-    context_thread_pool_.Run();
-
-    return true;
-  }
+  bool Start();
 
   void Shutdown() {
     context_thread_pool_.Shutdown();
@@ -115,7 +94,7 @@ class Server final {
 
   void AwaitShutdown() { context_thread_pool_.AwaitShutdown(); }
 
-  bool IsRunning() const noexcept { return context_thread_pool_.IsRunning() && listener_->IsRunning(); }
+  bool IsRunning() const noexcept;
 
  private:
   ServerEndpoint endpoint_;
@@ -125,4 +104,46 @@ class Server final {
   std::shared_ptr<Listener<TSession, TSessionContext>> listener_;
 };
 
+template <typename TSession, typename TSessionContext>
+Server<TSession, TSessionContext>::~Server() {
+  MG_ASSERT(!IsRunning(), "Server wasn't shutdown properly");
+}
+
+template <typename TSession, typename TSessionContext>
+Server<TSession, TSessionContext>::Server(ServerEndpoint &endpoint, TSessionContext *session_context,
+                                          ServerContext *server_context, const int inactivity_timeout_sec,
+                                          const std::string_view service_name, size_t workers_count)
+    : endpoint_{endpoint},
+      service_name_{service_name},
+      context_thread_pool_{workers_count},
+      listener_{Listener<TSession, TSessionContext>::Create(context_thread_pool_.GetIOContext(), session_context,
+                                                            server_context, endpoint_, service_name_,
+                                                            inactivity_timeout_sec)} {}
+
+template <typename TSession, typename TSessionContext>
+bool Server<TSession, TSessionContext>::Start() {
+  if (IsRunning()) {
+    spdlog::error("The server is already running");
+    return false;
+  }
+  listener_->Start();
+
+  spdlog::info("{} server is fully armed and operational", service_name_);
+  spdlog::info("{} listening on {}", service_name_, endpoint_.address());
+  context_thread_pool_.Run();
+
+  return true;
+}
+
+template <typename TSession, typename TSessionContext>
+const auto &Server<TSession, TSessionContext>::Endpoint() const {
+  MG_ASSERT(IsRunning(), "You can't get the server endpoint when it's not running!");
+  return endpoint_;
+}
+
+template <typename TSession, typename TSessionContext>
+bool Server<TSession, TSessionContext>::IsRunning() const noexcept {
+  return context_thread_pool_.IsRunning() && listener_->IsRunning();
+}
+
 }  // namespace memgraph::communication::v2

src/communication/v2/session.hpp

@@ -110,11 +110,7 @@ class WebsocketSession : public std::enable_shared_from_this<WebsocketSession<TS
     return std::shared_ptr<WebsocketSession>(new WebsocketSession(std::forward<Args>(args)...));
   }
 
-#ifdef MG_ENTERPRISE
-  ~WebsocketSession() { session_context_->Delete(session_); }
-#else
   ~WebsocketSession() = default;
-#endif
 
   WebsocketSession(const WebsocketSession &) = delete;
   WebsocketSession &operator=(const WebsocketSession &) = delete;
@@ -171,14 +167,15 @@ class WebsocketSession : public std::enable_shared_from_this<WebsocketSession<TS
       : ws_(std::move(socket)),
         strand_{boost::asio::make_strand(ws_.get_executor())},
         output_stream_([this](const uint8_t *data, size_t len, bool /*have_more*/) { return Write(data, len); }),
-        session_{*session_context, endpoint, input_buffer_.read_end(), &output_stream_},
+        session_{session_context->ic,       endpoint, input_buffer_.read_end(), &output_stream_, session_context->auth,
+#ifdef MG_ENTERPRISE
+                 session_context->audit_log
+#endif
+        },
         session_context_{session_context},
         endpoint_{endpoint},
         remote_endpoint_{ws_.next_layer().socket().remote_endpoint()},
         service_name_{service_name} {
-#ifdef MG_ENTERPRISE
-    session_context_->Register(session_);
-#endif
   }
 
   void OnAccept(boost::beast::error_code ec) {
@@ -286,11 +283,7 @@ class Session final : public std::enable_shared_from_this<Session<TSession, TSes
     return std::shared_ptr<Session>(new Session(std::forward<Args>(args)...));
   }
 
-#ifdef MG_ENTERPRISE
-  ~Session() { session_context_->Delete(session_); }
-#else
   ~Session() = default;
-#endif
 
   Session(const Session &) = delete;
   Session(Session &&) = delete;
@@ -366,17 +359,17 @@ class Session final : public std::enable_shared_from_this<Session<TSession, TSes
       : socket_(CreateSocket(std::move(socket), server_context)),
         strand_{boost::asio::make_strand(GetExecutor())},
         output_stream_([this](const uint8_t *data, size_t len, bool have_more) { return Write(data, len, have_more); }),
-        session_{*session_context, endpoint, input_buffer_.read_end(), &output_stream_},
+        session_{session_context->ic,       endpoint, input_buffer_.read_end(), &output_stream_, session_context->auth,
+#ifdef MG_ENTERPRISE
+                 session_context->audit_log
+#endif
+        },
         session_context_{session_context},
         endpoint_{endpoint},
         remote_endpoint_{GetRemoteEndpoint()},
         service_name_{service_name},
         timeout_seconds_(inactivity_timeout_sec),
         timeout_timer_(GetExecutor()) {
-#ifdef MG_ENTERPRISE
-    // TODO Try to remove Register (see comment at SessionInterface declaration)
-    session_context_->Register(session_);
-#endif
     ExecuteForSocket([](auto &&socket) {
       socket.lowest_layer().set_option(tcp::no_delay(true));                         // enable PSH
       socket.lowest_layer().set_option(boost::asio::socket_base::keep_alive(true));  // enable SO_KEEPALIVE
@@ -413,6 +406,8 @@ class Session final : public std::enable_shared_from_this<Session<TSession, TSes
 
   void OnRead(const boost::system::error_code &ec, const size_t bytes_transferred) {
     if (ec) {
+      // TODO Check if client disconnected
+      session_.HandleError();
       return OnError(ec);
     }
     input_buffer_.write_end()->Written(bytes_transferred);

src/data_structures/ring_buffer.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -31,7 +31,7 @@
 template <typename TElement>
 class RingBuffer {
  public:
-  explicit RingBuffer(int capacity) : capacity_(capacity) { buffer_ = std::make_unique<TElement[]>(capacity_); }
+  explicit RingBuffer(int capacity) : capacity_(capacity), buffer_{std::make_unique<TElement[]>(capacity_)} {}
 
   RingBuffer(const RingBuffer &) = delete;
   RingBuffer(RingBuffer &&) = delete;

src/dbms/CMakeLists.txt

@@ -0,0 +1,3 @@
+
+add_library(mg-dbms STATIC database.cpp)
+target_link_libraries(mg-dbms mg-utils mg-storage-v2 mg-query)

src/dbms/database.cpp

@@ -0,0 +1,37 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include "dbms/database.hpp"
+#include "flags/storage_mode.hpp"
+#include "storage/v2/disk/storage.hpp"
+#include "storage/v2/inmemory/storage.hpp"
+#include "storage/v2/storage_mode.hpp"
+
+template struct memgraph::utils::Gatekeeper<memgraph::dbms::Database>;
+
+namespace memgraph::dbms {
+
+Database::Database(const storage::Config &config)
+    : trigger_store_(config.durability.storage_directory / "triggers"),
+      streams_{config.durability.storage_directory / "streams"} {
+  if (config.storage_mode == memgraph::storage::StorageMode::ON_DISK_TRANSACTIONAL || config.force_on_disk ||
+      utils::DirExists(config.disk.main_storage_directory)) {
+    storage_ = std::make_unique<storage::DiskStorage>(config);
+  } else {
+    storage_ = std::make_unique<storage::InMemoryStorage>(config, config.storage_mode);
+  }
+}
+
+void Database::SwitchToOnDisk() {
+  storage_ = std::make_unique<memgraph::storage::DiskStorage>(std::move(storage_->config_));
+}
+
+}  // namespace memgraph::dbms

src/dbms/database.hpp

@@ -0,0 +1,148 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#include <algorithm>
+#include <filesystem>
+#include <iterator>
+#include <memory>
+#include <optional>
+#include <string_view>
+#include <unordered_map>
+
+#include "query/cypher_query_interpreter.hpp"
+#include "query/stream/streams.hpp"
+#include "query/trigger.hpp"
+#include "storage/v2/storage.hpp"
+#include "utils/gatekeeper.hpp"
+
+namespace memgraph::dbms {
+
+/**
+ * @brief Class containing everything associated with a single Database
+ *
+ */
+class Database {
+ public:
+  /**
+   * @brief Construct a new Database object
+   *
+   * @param config storage configuration
+   */
+  explicit Database(const storage::Config &config);
+
+  /**
+   * @brief Returns the raw storage pointer.
+   * @note Ideally everybody would be using an accessor
+   * TODO: Remove
+   *
+   * @return storage::Storage*
+   */
+  storage::Storage *storage() { return storage_.get(); }
+
+  /**
+   * @brief Storage's Accessor
+   *
+   * @param override_isolation_level
+   * @return std::unique_ptr<storage::Storage::Accessor>
+   */
+  std::unique_ptr<storage::Storage::Accessor> Access(
+      std::optional<storage::IsolationLevel> override_isolation_level = {}) {
+    return storage_->Access(override_isolation_level);
+  }
+
+  /**
+   * @brief Unique storage identified (name)
+   *
+   * @return const std::string&
+   */
+  const std::string &id() const { return storage_->id(); }
+
+  /**
+   * @brief Returns the storage configuration
+   *
+   * @return const storage::Config&
+   */
+  const storage::Config &config() const { return storage_->config_; }
+
+  /**
+   * @brief Get the storage mode
+   *
+   * @return storage::StorageMode
+   */
+  storage::StorageMode GetStorageMode() const { return storage_->GetStorageMode(); }
+
+  /**
+   * @brief Get the storage info
+   *
+   * @return storage::StorageInfo
+   */
+  storage::StorageInfo GetInfo() const { return storage_->GetInfo(); }
+
+  /**
+   * @brief Switch storage to OnDisk
+   *
+   */
+  void SwitchToOnDisk();
+
+  /**
+   * @brief Returns the raw TriggerStore pointer
+   *
+   * @return query::TriggerStore*
+   */
+  query::TriggerStore *trigger_store() { return &trigger_store_; }
+
+  /**
+   * @brief Returns the raw Streams pointer
+   *
+   * @return query::stream::Streams*
+   */
+  query::stream::Streams *streams() { return &streams_; }
+
+  /**
+   * @brief Returns the raw ThreadPool pointer (used for after commit triggers)
+   *
+   * @return utils::ThreadPool*
+   */
+  utils::ThreadPool *thread_pool() { return &after_commit_trigger_pool_; }
+
+  /**
+   * @brief Add task to the after commit trigger thread pool
+   *
+   * @param new_task
+   */
+  void AddTask(std::function<void()> new_task) { after_commit_trigger_pool_.AddTask(std::move(new_task)); }
+
+  /**
+   * @brief Returns the PlanCache vector raw pointer
+   *
+   * @return utils::SkipList<query::PlanCacheEntry>*
+   */
+  utils::SkipList<query::PlanCacheEntry> *plan_cache() { return &plan_cache_; }
+
+ private:
+  std::unique_ptr<storage::Storage> storage_;       //!< Underlying storage
+  query::TriggerStore trigger_store_;               //!< Triggers associated with the storage
+  utils::ThreadPool after_commit_trigger_pool_{1};  //!< Thread pool for executing after commit triggers
+  query::stream::Streams streams_;                  //!< Streams associated with the storage
+
+  // TODO: Move to a better place
+  utils::SkipList<query::PlanCacheEntry> plan_cache_;  //!< Plan cache associated with the storage
+};
+
+}  // namespace memgraph::dbms
+
+extern template struct memgraph::utils::Gatekeeper<memgraph::dbms::Database>;
+
+namespace memgraph::dbms {
+using DatabaseAccess = memgraph::utils::Gatekeeper<memgraph::dbms::Database>::Accessor;
+}  // namespace memgraph::dbms

src/dbms/database_handler.hpp

@@ -0,0 +1,97 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#ifdef MG_ENTERPRISE
+
+#include <algorithm>
+#include <filesystem>
+#include <iterator>
+#include <memory>
+#include <optional>
+#include <string_view>
+#include <unordered_map>
+
+#include "dbms/database.hpp"
+
+#include "handler.hpp"
+
+namespace memgraph::dbms {
+
+/* NOTE
+ * The Database object is shared. All the higher-level function calls should be protected.
+ * Storage function calls should already be protected; add protection where needed.
+ *
+ * Current implementation uses a handler of Database objects. It owns them and gives
+ * Gatekeeper::Accessor to it. These guarantee that the object won't be
+ * destroyed unless no one is using it.
+ */
+
+/**Config
+ * @brief Multi-database storage handler
+ *
+ */
+class DatabaseHandler : public Handler<Database> {
+ public:
+  using HandlerT = Handler<Database>;
+
+  /**
+   * @brief Generate new storage associated with the passed name.
+   *
+   * @param name Name associating the new interpreter context
+   * @param config Storage configuration
+   * @return HandlerT::NewResult
+   */
+  HandlerT::NewResult New(std::string_view name, storage::Config config) {
+    // Control that no one is using the same data directory
+    if (std::any_of(begin(), end(), [&](auto &elem) {
+          auto db_acc = elem.second.access();
+          MG_ASSERT(db_acc.has_value(), "Gatekeeper in invalid state");
+          return db_acc->get()->config().durability.storage_directory == config.durability.storage_directory;
+        })) {
+      spdlog::info("Tried to generate new storage using a claimed directory.");
+      return NewError::EXISTS;
+    }
+    config.name = name;  // Set storage id via config
+    return HandlerT::New(std::piecewise_construct, name, config);
+  }
+
+  /**
+   * @brief All currently active storage.
+   *
+   * @return std::vector<std::string>
+   */
+  std::vector<std::string> All() const {
+    std::vector<std::string> res;
+    res.reserve(std::distance(cbegin(), cend()));
+    std::for_each(cbegin(), cend(), [&](const auto &elem) { res.push_back(elem.first); });
+    return res;
+  }
+
+  /**
+   * @brief Get the associated storage's configuration
+   *
+   * @param name
+   * @return std::optional<storage::Config>
+   */
+  std::optional<storage::Config> GetConfig(std::string_view name) {
+    auto db = Get(name);
+    if (db) {
+      return (*db)->config();
+    }
+    return std::nullopt;
+  }
+};
+
+}  // namespace memgraph::dbms
+
+#endif

src/dbms/dbms_handler.hpp

@@ -0,0 +1,390 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#include <algorithm>
+#include <concepts>
+#include <cstdint>
+#include <filesystem>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <ostream>
+#include <stdexcept>
+#include <system_error>
+#include <unordered_map>
+
+#include "auth/auth.hpp"
+#include "constants.hpp"
+#include "dbms/database_handler.hpp"
+#include "global.hpp"
+#include "query/config.hpp"
+#include "query/interpreter_context.hpp"
+#include "spdlog/spdlog.h"
+#include "storage/v2/durability/durability.hpp"
+#include "storage/v2/durability/paths.hpp"
+#include "utils/exceptions.hpp"
+#include "utils/file.hpp"
+#include "utils/logging.hpp"
+#include "utils/result.hpp"
+#include "utils/rw_lock.hpp"
+#include "utils/synchronized.hpp"
+#include "utils/uuid.hpp"
+
+namespace memgraph::dbms {
+
+#ifdef MG_ENTERPRISE
+
+using DeleteResult = utils::BasicResult<DeleteError>;
+
+/**
+ * @brief Multi-database session contexts handler.
+ */
+class DbmsHandler {
+ public:
+  using LockT = utils::RWLock;
+  using NewResultT = utils::BasicResult<NewError, DatabaseAccess>;
+
+  struct Statistics {
+    uint64_t num_vertex;     //!< Sum of vertexes in every database
+    uint64_t num_edges;      //!< Sum of edges in every database
+    uint64_t num_databases;  //! number of isolated databases
+  };
+
+  /**
+   * @brief Initialize the handler.
+   *
+   * @param configs storage and interpreter configurations
+   * @param auth pointer to the global authenticator
+   * @param recovery_on_startup restore databases (and its content) and authentication data
+   * @param delete_on_drop when dropping delete any associated directories on disk
+   */
+  DbmsHandler(storage::Config config, auto *auth, bool recovery_on_startup, bool delete_on_drop)
+      : lock_{utils::RWLock::Priority::READ}, default_config_{std::move(config)}, delete_on_drop_(delete_on_drop) {
+    // TODO: Decouple storage config from dbms config
+    // TODO: Save individual db configs inside the kvstore and restore from there
+    storage::UpdatePaths(*default_config_, default_config_->durability.storage_directory / "databases");
+    const auto &db_dir = default_config_->durability.storage_directory;
+    const auto durability_dir = db_dir / ".durability";
+    utils::EnsureDirOrDie(db_dir);
+    utils::EnsureDirOrDie(durability_dir);
+    durability_ = std::make_unique<kvstore::KVStore>(durability_dir);
+
+    // Generate the default database
+    MG_ASSERT(!NewDefault_().HasError(), "Failed while creating the default DB.");
+
+    // Recover previous databases
+    if (recovery_on_startup) {
+      for (const auto &[name, _] : *durability_) {
+        if (name == kDefaultDB) continue;  // Already set
+        spdlog::info("Restoring database {}.", name);
+        MG_ASSERT(!New_(name).HasError(), "Failed while creating database {}.", name);
+        spdlog::info("Database {} restored.", name);
+      }
+    } else {  // Clear databases from the durability list and auth
+      auto locked_auth = auth->Lock();
+      for (const auto &[name, _] : *durability_) {
+        if (name == kDefaultDB) continue;
+        locked_auth->DeleteDatabase(name);
+        durability_->Delete(name);
+      }
+    }
+  }
+
+  /**
+   * @brief Create a new Database associated with the "name" database
+   *
+   * @param name name of the database
+   * @return NewResultT context on success, error on failure
+   */
+  NewResultT New(const std::string &name) {
+    std::lock_guard<LockT> wr(lock_);
+    return New_(name, name);
+  }
+
+  /**
+   * @brief Get the context associated with the "name" database
+   *
+   * @param name
+   * @return DatabaseAccess
+   * @throw UnknownDatabaseException if database not found
+   */
+  DatabaseAccess Get(std::string_view name) {
+    std::shared_lock<LockT> rd(lock_);
+    return Get_(name);
+  }
+
+  /**
+   * @brief Delete database.
+   *
+   * @param db_name database name
+   * @return DeleteResult error on failure
+   */
+  DeleteResult Delete(const std::string &db_name) {
+    std::lock_guard<LockT> wr(lock_);
+    if (db_name == kDefaultDB) {
+      // MSG cannot delete the default db
+      return DeleteError::DEFAULT_DB;
+    }
+
+    const auto storage_path = StorageDir_(db_name);
+    if (!storage_path) return DeleteError::NON_EXISTENT;
+
+    // Check if db exists
+    try {
+      // Low level handlers
+      if (!db_handler_.Delete(db_name)) {
+        return DeleteError::USING;
+      }
+    } catch (utils::BasicException &) {
+      return DeleteError::NON_EXISTENT;
+    }
+
+    // Remove from durability list
+    if (durability_) durability_->Delete(db_name);
+
+    // Delete disk storage
+    if (delete_on_drop_) {
+      std::error_code ec;
+      (void)std::filesystem::remove_all(*storage_path, ec);
+      if (ec) {
+        spdlog::error("Failed to clean disk while deleting database \"{}\".", db_name);
+        defunct_dbs_.emplace(db_name);
+        return DeleteError::DISK_FAIL;
+      }
+    }
+
+    // Delete from defunct_dbs_ (in case a second delete call was successful)
+    defunct_dbs_.erase(db_name);
+
+    return {};  // Success
+  }
+
+  /**
+   * @brief Return all active databases.
+   *
+   * @return std::vector<std::string>
+   */
+  std::vector<std::string> All() const {
+    std::shared_lock<LockT> rd(lock_);
+    return db_handler_.All();
+  }
+
+  /**
+   * @brief Return the number of vertex across all databases.
+   *
+   * @return uint64_t
+   */
+  Statistics Info() {
+    // TODO: Handle overflow?
+    uint64_t nv = 0;
+    uint64_t ne = 0;
+    std::shared_lock<LockT> rd(lock_);
+    const uint64_t ndb = std::distance(db_handler_.cbegin(), db_handler_.cend());
+    for (auto &[_, db_gk] : db_handler_) {
+      auto db_acc_opt = db_gk.access();
+      if (!db_acc_opt) continue;
+      auto &db_acc = *db_acc_opt;
+      const auto &info = db_acc->GetInfo();
+      nv += info.vertex_count;
+      ne += info.edge_count;
+    }
+    return {nv, ne, ndb};
+  }
+
+  /**
+   * @brief Restore triggers for all currently defined databases.
+   * @note: Triggers can execute query procedures, so we need to reload the modules first and then the triggers
+   *
+   * @param ic global InterpreterContext
+   */
+  void RestoreTriggers(query::InterpreterContext *ic) {
+    std::lock_guard<LockT> wr(lock_);
+    for (auto &[_, db_gk] : db_handler_) {
+      auto db_acc_opt = db_gk.access();
+      if (!db_acc_opt) continue;
+      auto &db_acc = *db_acc_opt;
+      spdlog::debug("Restoring trigger for database \"{}\"", db_acc->id());
+      auto storage_accessor = db_acc->Access();
+      auto dba = memgraph::query::DbAccessor{storage_accessor.get()};
+      db_acc->trigger_store()->RestoreTriggers(&ic->ast_cache, &dba, ic->config.query, ic->auth_checker);
+    }
+  }
+
+  /**
+   * @brief Restore streams of all currently defined databases.
+   * @note: Stream transformations are using modules, they have to be restored after the query modules are loaded.
+   *
+   * @param ic global InterpreterContext
+   */
+  void RestoreStreams(query::InterpreterContext *ic) {
+    std::lock_guard<LockT> wr(lock_);
+    for (auto &[_, db_gk] : db_handler_) {
+      auto db_acc = db_gk.access();
+      if (!db_acc) continue;
+      auto *db = db_acc->get();
+      spdlog::debug("Restoring streams for database \"{}\"", db->id());
+      db->streams()->RestoreStreams(*db_acc, ic);
+    }
+  }
+
+ private:
+  /**
+   * @brief return the storage directory of the associated database
+   *
+   * @param name Database name
+   * @return std::optional<std::filesystem::path>
+   */
+  std::optional<std::filesystem::path> StorageDir_(const std::string &name) {
+    const auto conf = db_handler_.GetConfig(name);
+    if (conf) {
+      return conf->durability.storage_directory;
+    }
+    spdlog::debug("Failed to find storage dir for database \"{}\"", name);
+    return {};
+  }
+
+  /**
+   * @brief Create a new Database associated with the "name" database
+   *
+   * @param name name of the database
+   * @return NewResultT context on success, error on failure
+   */
+  NewResultT New_(const std::string &name) { return New_(name, name); }
+
+  /**
+   * @brief Create a new Database associated with the "name" database
+   *
+   * @param name name of the database
+   * @param storage_subdir undelying RocksDB directory
+   * @return NewResultT context on success, error on failure
+   */
+  NewResultT New_(const std::string &name, std::filesystem::path storage_subdir) {
+    if (default_config_) {
+      auto config_copy = *default_config_;
+      storage::UpdatePaths(config_copy, default_config_->durability.storage_directory / storage_subdir);
+      return New_(name, config_copy);
+    }
+    spdlog::info("Trying to generate session context without any configurations.");
+    return NewError::NO_CONFIGS;
+  }
+
+  /**
+   * @brief Create a new Database associated with the "name" database
+   *
+   * @param name name of the database
+   * @param storage_config storage configuration
+   * @return NewResultT context on success, error on failure
+   */
+  NewResultT New_(const std::string &name, storage::Config &storage_config) {
+    if (defunct_dbs_.contains(name)) {
+      spdlog::warn("Failed to generate database due to the unknown state of the previously defunct database \"{}\".",
+                   name);
+      return NewError::DEFUNCT;
+    }
+
+    auto new_db = db_handler_.New(name, storage_config);
+    if (new_db.HasValue()) {
+      // Success
+      if (durability_) durability_->Put(name, "ok");  // TODO: Serialize the configuration?
+      return new_db.GetValue();
+    }
+    return new_db.GetError();
+  }
+
+  /**
+   * @brief Create a new Database associated with the default database
+   *
+   * @return NewResultT context on success, error on failure
+   */
+  NewResultT NewDefault_() {
+    // Create the default DB in the root (this is how it was done pre multi-tenancy)
+    auto res = New_(kDefaultDB, "..");
+    if (res.HasValue()) {
+      // For back-compatibility...
+      // Recreate the dbms layout for the default db and symlink to the root
+      const auto dir = StorageDir_(kDefaultDB);
+      MG_ASSERT(dir, "Failed to find storage path.");
+      const auto main_dir = *dir / "databases" / kDefaultDB;
+
+      if (!std::filesystem::exists(main_dir)) {
+        std::filesystem::create_directory(main_dir);
+      }
+
+      // Force link on-disk directories
+      const auto conf = db_handler_.GetConfig(kDefaultDB);
+      MG_ASSERT(conf, "No configuration for the default database.");
+      const auto &tmp_conf = conf->disk;
+      std::vector<std::filesystem::path> to_link{
+          tmp_conf.main_storage_directory,         tmp_conf.label_index_directory,
+          tmp_conf.label_property_index_directory, tmp_conf.unique_constraints_directory,
+          tmp_conf.name_id_mapper_directory,       tmp_conf.id_name_mapper_directory,
+          tmp_conf.durability_directory,           tmp_conf.wal_directory,
+      };
+
+      // Add in-memory paths
+      // Some directories are redundant (skip those)
+      const std::vector<std::string> skip{".lock", "audit_log", "auth", "databases", "internal_modules", "settings"};
+      for (auto const &item : std::filesystem::directory_iterator{*dir}) {
+        const auto dir_name = std::filesystem::relative(item.path(), item.path().parent_path());
+        if (std::find(skip.begin(), skip.end(), dir_name) != skip.end()) continue;
+        to_link.push_back(item.path());
+      }
+
+      // Symlink to root dir
+      for (auto const &item : to_link) {
+        const auto dir_name = std::filesystem::relative(item, item.parent_path());
+        const auto link = main_dir / dir_name;
+        const auto to = std::filesystem::relative(item, main_dir);
+        if (!std::filesystem::is_symlink(link) && !std::filesystem::exists(link)) {
+          std::filesystem::create_directory_symlink(to, link);
+        } else {  // Check existing link
+          std::error_code ec;
+          const auto test_link = std::filesystem::read_symlink(link, ec);
+          if (ec || test_link != to) {
+            MG_ASSERT(false,
+                      "Memgraph storage directory incompatible with new version.\n"
+                      "Please use a clean directory or remove \"{}\" and try again.",
+                      link.string());
+          }
+        }
+      }
+    }
+    return res;
+  }
+
+  /**
+   * @brief Get the DatabaseAccess for the database associated with the "name"
+   *
+   * @param name
+   * @return DatabaseAccess
+   * @throw UnknownDatabaseException if trying to get unknown database
+   */
+  DatabaseAccess Get_(std::string_view name) {
+    auto db = db_handler_.Get(name);
+    if (db) {
+      return *db;
+    }
+    throw UnknownDatabaseException("Tried to retrieve an unknown database \"{}\".", name);
+  }
+
+  // Should storage objects ever be deleted?
+  mutable LockT lock_;                             //!< protective lock
+  DatabaseHandler db_handler_;                     //!< multi-tenancy storage handler
+  std::optional<storage::Config> default_config_;  //!< Storage configuration used when creating new databases
+  std::unique_ptr<kvstore::KVStore> durability_;   //!< list of active dbs (pointer so we can postpone its creation)
+  std::set<std::string> defunct_dbs_;              //!< Databases that are in an unknown state due to various failures
+  bool delete_on_drop_;                            //!< Flag defining if dropping storage also deletes its directory
+};
+#endif
+
+}  // namespace memgraph::dbms

src/dbms/global.hpp

@@ -60,51 +60,4 @@ class UnknownDatabaseException : public utils::BasicException {
   using utils::BasicException::BasicException;
 };
 
-/**
- * @brief Session interface used by the DBMS to handle the the active sessions.
- * @todo Try to remove this dependency from SessionContextHandler. OnDelete could be removed, as it only does an assert.
- * OnChange could be removed if SetFor returned the pointer and the called then handled the OnChange execution.
- * However, the interface is very useful to  decouple the interpreter's query execution and the sessions themselves.
- */
-class SessionInterface {
- public:
-  SessionInterface() = default;
-  virtual ~SessionInterface() = default;
-
-  SessionInterface(const SessionInterface &) = default;
-  SessionInterface &operator=(const SessionInterface &) = default;
-  SessionInterface(SessionInterface &&) noexcept = default;
-  SessionInterface &operator=(SessionInterface &&) noexcept = default;
-
-  /**
-   * @brief Return the unique string identifying the session.
-   *
-   * @return std::string
-   */
-  virtual std::string UUID() const = 0;
-
-  /**
-   * @brief Return the currently active database.
-   *
-   * @return std::string
-   */
-  virtual std::string GetDatabaseName() const = 0;
-
-#ifdef MG_ENTERPRISE
-  /**
-   * @brief Gets called on database change.
-   *
-   * @return SetForResult enum (SUCCESS, ALREADY_SET or FAIL)
-   */
-  virtual dbms::SetForResult OnChange(const std::string &) = 0;
-
-  /**
-   * @brief Callback that gets called on database delete (drop).
-   *
-   * @return true on success
-   */
-  virtual bool OnDelete(const std::string &) = 0;
-#endif
-};
-
 }  // namespace memgraph::dbms

src/dbms/handler.hpp

@@ -18,21 +18,21 @@
 #include <unordered_map>
 
 #include "global.hpp"
+#include "utils/exceptions.hpp"
+#include "utils/gatekeeper.hpp"
 #include "utils/result.hpp"
-#include "utils/sync_ptr.hpp"
 
 namespace memgraph::dbms {
 
 /**
  * @brief Generic multi-database content handler.
  *
- * @tparam TContext
- * @tparam TConfig
+ * @tparam T
  */
-template <typename TContext, typename TConfig>
+template <typename T>
 class Handler {
  public:
-  using NewResult = utils::BasicResult<NewError, std::shared_ptr<TContext>>;
+  using NewResult = utils::BasicResult<NewError, typename utils::Gatekeeper<T>::Accessor>;
 
   /**
    * @brief Empty Handler constructor.
@@ -43,67 +43,65 @@ class Handler {
   /**
    * @brief Generate a new context and corresponding configuration.
    *
-   * @tparam T1 Variadic template of context constructor arguments
-   * @tparam T2 Variadic template of config constructor arguments
-   * @param name Name associated with the new context/config pair
-   * @param args1 Arguments passed (as a tuple) to the context constructor
-   * @param args2 Arguments passed (as a tuple) to the config constructor
+   * @tparam Args Variadic template of constructor arguments of T
+   * @param name Name associated with the new T
+   * @param args Arguments passed to the constructor of T
    * @return NewResult
    */
-  template <typename... T1, typename... T2>
-  NewResult New(std::string name, std::tuple<T1...> args1, std::tuple<T2...> args2) {
-    return New_(name, args1, args2, std::make_index_sequence<sizeof...(T1)>{},
-                std::make_index_sequence<sizeof...(T2)>{});
+  template <typename... Args>
+  NewResult New(std::piecewise_construct_t /* marker */, std::string_view name, Args... args) {
+    // Make sure the emplace will succeed, since we don't want to create temporary objects that could break something
+    if (!Has(name)) {
+      auto [itr, _] = items_.emplace(std::piecewise_construct, std::forward_as_tuple(name),
+                                     std::forward_as_tuple(std::forward<Args>(args)...));
+      auto db_acc = itr->second.access();
+      if (db_acc) return std::move(*db_acc);
+      return NewError::DEFUNCT;
+    }
+    spdlog::info("Item with name \"{}\" already exists.", name);
+    return NewError::EXISTS;
   }
 
   /**
    * @brief Get pointer to context.
    *
    * @param name Name associated with the wanted context
-   * @return std::optional<std::shared_ptr<TContext>>
+   * @return std::optional<typename utils::Gatekeeper<T>::Accessor>
    */
-  std::optional<std::shared_ptr<TContext>> Get(const std::string &name) {
+  std::optional<typename utils::Gatekeeper<T>::Accessor> Get(std::string_view name) {
     if (auto search = items_.find(name); search != items_.end()) {
-      return search->second.get();
+      return search->second.access();
     }
-    return {};
+    return std::nullopt;
   }
 
   /**
-   * @brief Get the config.
+   * @brief Delete the context associated with the name.
    *
-   * @param name Name associated with the wanted config
-   * @return std::optional<TConfig>
-   */
-  std::optional<TConfig> GetConfig(const std::string &name) const {
-    if (auto search = items_.find(name); search != items_.end()) {
-      return search->second.config();
-    }
-    return {};
-  }
-
-  /**
-   * @brief Delete the context/config pair associated with the name.
-   *
-   * @param name Name associated with the context/config pair to delete
+   * @param name Name associated with the context to delete
    * @return true on success
+   * @throw BasicException
    */
   bool Delete(const std::string &name) {
     if (auto itr = items_.find(name); itr != items_.end()) {
-      itr->second.DestroyAndSync();
-      items_.erase(itr);
-      return true;
+      auto db_acc = itr->second.access();
+      if (db_acc && db_acc->try_delete()) {
+        db_acc->reset();
+        items_.erase(itr);
+        return true;
+      }
+      return false;
     }
-    return false;
+    throw utils::BasicException("Unknown item \"{}\".", name);
   }
 
   /**
    * @brief Check if a name is already used.
    *
    * @param name Name to check
-   * @return true if a context/config pair is already associated with the name
+   * @return true if a T is already associated with the name
    */
-  bool Has(const std::string &name) const { return items_.find(name) != items_.end(); }
+  bool Has(std::string_view name) const { return items_.find(name) != items_.end(); }
 
   auto begin() { return items_.begin(); }
   auto end() { return items_.end(); }
@@ -112,31 +110,16 @@ class Handler {
   auto cbegin() const { return items_.cbegin(); }
   auto cend() const { return items_.cend(); }
 
- private:
-  /**
-   * @brief Lower level handler that hides some ugly code.
-   *
-   * @tparam T1 Variadic template of context constructor arguments
-   * @tparam T2 Variadic template of config constructor arguments
-   * @tparam I1 List of indexes associated with the first tuple
-   * @tparam I2 List of indexes associated with the second tuple
-   */
-  template <typename... T1, typename... T2, std::size_t... I1, std::size_t... I2>
-  NewResult New_(std::string name, std::tuple<T1...> &args1, std::tuple<T2...> &args2,
-                 std::integer_sequence<std::size_t, I1...> /*not-used*/,
-                 std::integer_sequence<std::size_t, I2...> /*not-used*/) {
-    // Make sure the emplace will succeed, since we don't want to create temporary objects that could break something
-    if (!Has(name)) {
-      auto [itr, _] = items_.emplace(std::piecewise_construct, std::forward_as_tuple(name),
-                                     std::forward_as_tuple(TConfig{std::forward<T1>(std::get<I1>(args1))...},
-                                                           std::forward<T2>(std::get<I2>(args2))...));
-      return itr->second.get();
-    }
-    spdlog::info("Item with name \"{}\" already exists.", name);
-    return NewError::EXISTS;
-  }
+  struct string_hash {
+    using is_transparent = void;
+    [[nodiscard]] size_t operator()(const char *s) const { return std::hash<std::string_view>{}(s); }
+    [[nodiscard]] size_t operator()(std::string_view s) const { return std::hash<std::string_view>{}(s); }
+    [[nodiscard]] size_t operator()(const std::string &s) const { return std::hash<std::string>{}(s); }
+  };
 
-  std::unordered_map<std::string, utils::SyncPtr<TContext, TConfig>> items_;  //!< map to all active items
+ private:
+  std::unordered_map<std::string, utils::Gatekeeper<T>, string_hash, std::equal_to<>>
+      items_;  //!< map to all active items
 };
 
 }  // namespace memgraph::dbms

src/dbms/interp_handler.hpp

@@ -1,106 +0,0 @@
-// Copyright 2023 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include "global.hpp"
-#include "query/auth_checker.hpp"
-#include "query/config.hpp"
-#include "query/interpreter.hpp"
-#include "storage/v2/storage.hpp"
-
-#include "handler.hpp"
-
-namespace memgraph::dbms {
-
-/**
- * @brief Simple class that adds useful information to the query's InterpreterContext
- *
- * @tparam T Multi-database handler type
- */
-template <typename T>
-class ExpandedInterpContext : public query::InterpreterContext {
- public:
-  template <typename... TArgs>
-  explicit ExpandedInterpContext(T &ref, TArgs &&...args)
-      : query::InterpreterContext(std::forward<TArgs>(args)...), sc_handler_(ref) {}
-
-  T &sc_handler_;  //!< Multi-database/SessionContext handler (used in some queries)
-};
-
-/**
- * @brief Simple structure that expands on the query's InterpreterConfig
- *
- */
-struct ExpandedInterpConfig {
-  storage::Config storage_config;          //!< Storage configuration
-  query::InterpreterConfig interp_config;  //!< Interpreter configuration
-};
-
-/**
- * @brief Multi-database interpreter context handler
- *
- * @tparam TSCHandler High-level multi-database/SessionContext handler type
- */
-template <typename TSCHandler>
-class InterpContextHandler : public Handler<ExpandedInterpContext<TSCHandler>, ExpandedInterpConfig> {
- public:
-  using InterpContextT = ExpandedInterpContext<TSCHandler>;
-  using HandlerT = Handler<InterpContextT, ExpandedInterpConfig>;
-
-  /**
-   * @brief Generate a new interpreter context associated with the passed name.
-   *
-   * @param name Name associating the new interpreter context
-   * @param sc_handler Multi-database/SessionContext handler used (some queries might use it)
-   * @param db Storage associated with the interpreter context
-   * @param config Interpreter's configuration
-   * @param dir Directory used by the interpreter
-   * @param auth_handler AuthQueryHandler used
-   * @param auth_checker AuthChecker used
-   * @return HandlerT::NewResult
-   */
-  typename HandlerT::NewResult New(const std::string &name, TSCHandler &sc_handler, storage::Config storage_config,
-                                   const query::InterpreterConfig &interpreter_config,
-                                   query::AuthQueryHandler &auth_handler, query::AuthChecker &auth_checker) {
-    // Check if compatible with the existing interpreters
-    if (std::any_of(HandlerT::cbegin(), HandlerT::cend(), [&](const auto &elem) {
-          const auto &config = elem.second.config().storage_config;
-          return config.durability.storage_directory == storage_config.durability.storage_directory;
-        })) {
-      spdlog::info("Tried to generate a new context using claimed directory and/or storage.");
-      return NewError::EXISTS;
-    }
-    const auto dir = storage_config.durability.storage_directory;
-    storage_config.name = name;  // Set storage id via config
-    return HandlerT::New(
-        name, std::forward_as_tuple(storage_config, interpreter_config),
-        std::forward_as_tuple(sc_handler, storage_config, interpreter_config, dir, &auth_handler, &auth_checker));
-  }
-
-  /**
-   * @brief All currently active storage.
-   *
-   * @return std::vector<std::string>
-   */
-  std::vector<std::string> All() const {
-    std::vector<std::string> res;
-    res.reserve(std::distance(HandlerT::cbegin(), HandlerT::cend()));
-    std::for_each(HandlerT::cbegin(), HandlerT::cend(), [&](const auto &elem) { res.push_back(elem.first); });
-    return res;
-  }
-};
-
-}  // namespace memgraph::dbms
-
-#endif

src/dbms/session_context.hpp

@@ -1,61 +0,0 @@
-// Copyright 2023 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include "auth/auth.hpp"
-#include "query/interpreter.hpp"
-#include "storage/v2/storage.hpp"
-#include "utils/synchronized.hpp"
-
-#if MG_ENTERPRISE
-#include "audit/log.hpp"
-#endif
-namespace memgraph::dbms {
-
-/**
- * @brief Structure encapsulating storage and interpreter context.
- *
- * @note Each session contains a copy.
- */
-struct SessionContext {
-  // Explicit constructor here to ensure that pointers to all objects are
-  // supplied.
-
-  SessionContext(std::shared_ptr<memgraph::query::InterpreterContext> interpreter_context, std::string run,
-                 memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth
-#ifdef MG_ENTERPRISE
-                 ,
-                 memgraph::audit::Log *audit_log
-#endif
-                 )
-      : interpreter_context(interpreter_context),
-        run_id(run),
-        auth(auth)
-#ifdef MG_ENTERPRISE
-        ,
-        audit_log(audit_log)
-#endif
-  {
-  }
-
-  std::shared_ptr<memgraph::query::InterpreterContext> interpreter_context;
-  std::string run_id;
-
-  // std::shared_ptr<AuthContext> auth_context;
-  memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth;
-
-#ifdef MG_ENTERPRISE
-  memgraph::audit::Log *audit_log;
-#endif
-};
-
-}  // namespace memgraph::dbms

src/dbms/session_context_handler.hpp

@@ -1,603 +0,0 @@
-// Copyright 2023 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include <algorithm>
-#include <concepts>
-#include <cstdint>
-#include <filesystem>
-#include <memory>
-#include <mutex>
-#include <optional>
-#include <ostream>
-#include <stdexcept>
-#include <system_error>
-#include <unordered_map>
-
-#include "constants.hpp"
-#include "global.hpp"
-#include "interp_handler.hpp"
-#include "query/auth_checker.hpp"
-#include "query/config.hpp"
-#include "query/interpreter.hpp"
-#include "session_context.hpp"
-#include "spdlog/spdlog.h"
-#include "storage/v2/durability/durability.hpp"
-#include "storage/v2/durability/paths.hpp"
-#include "utils/exceptions.hpp"
-#include "utils/file.hpp"
-#include "utils/logging.hpp"
-#include "utils/result.hpp"
-#include "utils/rw_lock.hpp"
-#include "utils/synchronized.hpp"
-#include "utils/uuid.hpp"
-
-#include "handler.hpp"
-
-namespace memgraph::dbms {
-
-#ifdef MG_ENTERPRISE
-
-using DeleteResult = utils::BasicResult<DeleteError>;
-
-/**
- * @brief Multi-database session contexts handler.
- */
-class SessionContextHandler {
- public:
-  using StorageT = storage::Storage;
-  using StorageConfigT = storage::Config;
-  using LockT = utils::RWLock;
-  using NewResultT = utils::BasicResult<NewError, SessionContext>;
-
-  struct Config {
-    StorageConfigT storage_config;           //!< Storage configuration
-    query::InterpreterConfig interp_config;  //!< Interpreter context configuration
-    std::function<void(utils::Synchronized<auth::Auth, utils::WritePrioritizedRWLock> *,
-                       std::unique_ptr<query::AuthQueryHandler> &, std::unique_ptr<query::AuthChecker> &)>
-        glue_auth;
-  };
-
-  struct Statistics {
-    uint64_t num_vertex;     //!< Sum of vertexes in every database
-    uint64_t num_edges;      //!< Sum of edges in every database
-    uint64_t num_databases;  //! number of isolated databases
-  };
-
-  /**
-   * @brief Initialize the handler.
-   *
-   * @param audit_log pointer to the audit logger (ENTERPRISE only)
-   * @param configs storage and interpreter configurations
-   * @param recovery_on_startup restore databases (and its content) and authentication data
-   */
-  SessionContextHandler(memgraph::audit::Log &audit_log, Config configs, bool recovery_on_startup, bool delete_on_drop)
-      : lock_{utils::RWLock::Priority::READ},
-        default_configs_(configs),
-        run_id_{utils::GenerateUUID()},
-        audit_log_(&audit_log),
-        delete_on_drop_(delete_on_drop) {
-    const auto &root = configs.storage_config.durability.storage_directory;
-    utils::EnsureDirOrDie(root);
-    // Verify that the user that started the process is the same user that is
-    // the owner of the storage directory.
-    storage::durability::VerifyStorageDirectoryOwnerAndProcessUserOrDie(root);
-
-    // Create the lock file and open a handle to it. This will crash the
-    // database if it can't open the file for writing or if any other process is
-    // holding the file opened.
-    lock_file_path_ = root / ".lock";
-    lock_file_handle_.Open(lock_file_path_, utils::OutputFile::Mode::OVERWRITE_EXISTING);
-    MG_ASSERT(lock_file_handle_.AcquireLock(),
-              "Couldn't acquire lock on the storage directory {}"
-              "!\nAnother Memgraph process is currently running with the same "
-              "storage directory, please stop it first before starting this "
-              "process!",
-              root);
-
-    // TODO: Figure out if this is needed/wanted
-    // Clear auth database since we are not recovering
-    // if (!recovery_on_startup) {
-    //   const auto &auth_dir = root / "auth";
-    //   // Backup if auth present
-    //   if (utils::DirExists(auth_dir)) {
-    //     auto backup_dir = root / storage::durability::kBackupDirectory;
-    //     std::error_code error_code;
-    //     utils::EnsureDirOrDie(backup_dir);
-    //     std::error_code ec;
-    //     const auto now = std::chrono::system_clock::now();
-    //     std::ostringstream os;
-    //     os << now.time_since_epoch().count();
-    //     std::filesystem::rename(auth_dir, backup_dir / ("auth-" + os.str()), ec);
-    //     MG_ASSERT(!ec, "Couldn't backup auth directory because of: {}", ec.message());
-    //     spdlog::warn(
-    //         "Since Memgraph was not supposed to recover on startup the authentication files will be "
-    //         "overwritten. To prevent important data loss, Memgraph has stored those files into .backup directory "
-    //         "inside the storage directory.");
-    //   }
-
-    //   // Clear
-    //   if (std::filesystem::exists(auth_dir)) {
-    //     std::filesystem::remove_all(auth_dir);
-    //   }
-    // }
-
-    // Lazy initialization of auth_
-    auth_ = std::make_unique<utils::Synchronized<auth::Auth, utils::WritePrioritizedRWLock>>(root / "auth");
-    configs.glue_auth(auth_.get(), auth_handler_, auth_checker_);
-
-    // TODO: Decouple storage config from dbms config
-    // TODO: Save individual db configs inside the kvstore and restore from there
-    storage::UpdatePaths(default_configs_->storage_config,
-                         default_configs_->storage_config.durability.storage_directory / "databases");
-    const auto &db_dir = default_configs_->storage_config.durability.storage_directory;
-    const auto durability_dir = db_dir / ".durability";
-    utils::EnsureDirOrDie(db_dir);
-    utils::EnsureDirOrDie(durability_dir);
-    durability_ = std::make_unique<kvstore::KVStore>(durability_dir);
-
-    // Generate the default database
-    MG_ASSERT(!NewDefault_().HasError(), "Failed while creating the default DB.");
-
-    // Recover previous databases
-    if (recovery_on_startup) {
-      for (const auto &[name, _] : *durability_) {
-        if (name == kDefaultDB) continue;  // Already set
-        spdlog::info("Restoring database {}.", name);
-        MG_ASSERT(!New_(name).HasError(), "Failed while creating database {}.", name);
-        spdlog::info("Database {} restored.", name);
-      }
-    } else {  // Clear databases from the durability list and auth
-      auto locked_auth = auth_->Lock();
-      for (const auto &[name, _] : *durability_) {
-        if (name == kDefaultDB) continue;
-        locked_auth->DeleteDatabase(name);
-        durability_->Delete(name);
-      }
-    }
-  }
-
-  void Shutdown() {
-    for (auto &ic : interp_handler_) memgraph::query::Shutdown(ic.second.get().get());
-  }
-
-  /**
-   * @brief Create a new SessionContext associated with the "name" database
-   *
-   * @param name name of the database
-   * @return NewResultT context on success, error on failure
-   */
-  NewResultT New(const std::string &name) {
-    std::lock_guard<LockT> wr(lock_);
-    return New_(name, name);
-  }
-
-  /**
-   * @brief Get the context associated with the "name" database
-   *
-   * @param name
-   * @return SessionContext
-   * @throw UnknownDatabaseException if getting unknown database
-   */
-  SessionContext Get(const std::string &name) {
-    std::shared_lock<LockT> rd(lock_);
-    return Get_(name);
-  }
-
-  /**
-   * @brief Set the undelying database for a particular session.
-   *
-   * @param uuid unique session identifier
-   * @param db_name unique database name
-   * @return SetForResult enum
-   * @throws UnknownDatabaseException, UnknownSessionException or anything OnChange throws
-   */
-  SetForResult SetFor(const std::string &uuid, const std::string &db_name) {
-    std::shared_lock<LockT> rd(lock_);
-    (void)Get_(
-        db_name);  // throws if db doesn't exist (TODO: Better to pass it via OnChange - but injecting dependency)
-    try {
-      auto &s = sessions_.at(uuid);
-      return s.OnChange(db_name);
-    } catch (std::out_of_range &) {
-      throw UnknownSessionException("Unknown session \"{}\"", uuid);
-    }
-  }
-
-  /**
-   * @brief Set the undelying database from a session itself. SessionContext handler.
-   *
-   * @param db_name unique database name
-   * @param handler function that gets called in place with the appropriate SessionContext
-   * @return SetForResult enum
-   */
-  template <typename THandler>
-  requires std::invocable<THandler, SessionContext> SetForResult SetInPlace(const std::string &db_name,
-                                                                            THandler handler) {
-    std::shared_lock<LockT> rd(lock_);
-    return handler(Get_(db_name));
-  }
-
-  /**
-   * @brief Call void handler under a shared lock.
-   *
-   * @param handler function that gets called in place
-   */
-  template <typename THandler>
-  requires std::invocable<THandler>
-  void CallInPlace(THandler handler) {
-    std::shared_lock<LockT> rd(lock_);
-    handler();
-  }
-
-  /**
-   * @brief Register an active session (used to handle callbacks).
-   *
-   * @param session
-   * @return true on success
-   */
-  bool Register(SessionInterface &session) {
-    std::lock_guard<LockT> wr(lock_);
-    auto [_, success] = sessions_.emplace(session.UUID(), session);
-    return success;
-  }
-
-  /**
-   * @brief Delete a session.
-   *
-   * @param session
-   */
-  bool Delete(const SessionInterface &session) {
-    std::lock_guard<LockT> wr(lock_);
-    return sessions_.erase(session.UUID()) > 0;
-  }
-
-  /**
-   * @brief Delete database.
-   *
-   * @param db_name database name
-   * @return DeleteResult error on failure
-   */
-  DeleteResult Delete(const std::string &db_name) {
-    std::lock_guard<LockT> wr(lock_);
-    if (db_name == kDefaultDB) {
-      // MSG cannot delete the default db
-      return DeleteError::DEFAULT_DB;
-    }
-    // Check if db exists
-    try {
-      auto sc = Get_(db_name);
-      // Check if a session is using the db
-      if (!sc.interpreter_context->interpreters->empty()) {
-        return DeleteError::USING;
-      }
-    } catch (UnknownDatabaseException &) {
-      return DeleteError::NON_EXISTENT;
-    }
-
-    // High level handlers
-    for (auto &[_, s] : sessions_) {
-      if (!s.OnDelete(db_name)) {
-        spdlog::error("Partial failure while deleting database \"{}\".", db_name);
-        defunct_dbs_.emplace(db_name);
-        return DeleteError::FAIL;
-      }
-    }
-
-    // Low level handlers
-    const auto storage_path = StorageDir_(db_name);
-    MG_ASSERT(storage_path, "Missing storage for {}", db_name);
-    if (!interp_handler_.Delete(db_name)) {
-      spdlog::error("Partial failure while deleting database \"{}\".", db_name);
-      defunct_dbs_.emplace(db_name);
-      return DeleteError::FAIL;
-    }
-
-    // Remove from auth
-    auth_->Lock()->DeleteDatabase(db_name);
-    // Remove from durability list
-    if (durability_) durability_->Delete(db_name);
-
-    // Delete disk storage
-    if (delete_on_drop_) {
-      std::error_code ec;
-      (void)std::filesystem::remove_all(*storage_path, ec);
-      if (ec) {
-        spdlog::error("Failed to clean disk while deleting database \"{}\".", db_name);
-        defunct_dbs_.emplace(db_name);
-        return DeleteError::DISK_FAIL;
-      }
-    }
-
-    // Delete from defunct_dbs_ (in case a second delete call was successful)
-    defunct_dbs_.erase(db_name);
-
-    return {};  // Success
-  }
-
-  /**
-   * @brief Set the default configurations.
-   *
-   * @param configs storage, interpreter and authorization configurations
-   */
-  void SetDefaultConfigs(Config configs) {
-    std::lock_guard<LockT> wr(lock_);
-    default_configs_ = configs;
-  }
-
-  /**
-   * @brief Get the default configurations.
-   *
-   * @return std::optional<Config>
-   */
-  std::optional<Config> GetDefaultConfigs() const {
-    std::shared_lock<LockT> rd(lock_);
-    return default_configs_;
-  }
-
-  /**
-   * @brief Return all active databases.
-   *
-   * @return std::vector<std::string>
-   */
-  std::vector<std::string> All() const {
-    std::shared_lock<LockT> rd(lock_);
-    return interp_handler_.All();
-  }
-
-  /**
-   * @brief Return the number of vertex across all databases.
-   *
-   * @return uint64_t
-   */
-  Statistics Info() const {
-    // TODO: Handle overflow
-    uint64_t nv = 0;
-    uint64_t ne = 0;
-    std::shared_lock<LockT> rd(lock_);
-    const uint64_t ndb = std::distance(interp_handler_.cbegin(), interp_handler_.cend());
-    for (const auto &ic : interp_handler_) {
-      const auto &info = ic.second.get()->db->GetInfo();
-      nv += info.vertex_count;
-      ne += info.edge_count;
-    }
-    return {nv, ne, ndb};
-  }
-
-  /**
-   * @brief Return the currently active database for a particular session.
-   *
-   * @param uuid session's unique identifier
-   * @return std::string name of the database
-   * @throw
-   */
-  std::string Current(const std::string &uuid) const {
-    std::shared_lock<LockT> rd(lock_);
-    return sessions_.at(uuid).GetDatabaseName();
-  }
-
-  /**
-   * @brief Restore triggers for all currently defined databases.
-   * @note: Triggers can execute query procedures, so we need to reload the modules first and then the triggers
-   */
-  void RestoreTriggers() {
-    std::lock_guard<LockT> wr(lock_);
-    for (auto &ic_itr : interp_handler_) {
-      auto ic = ic_itr.second.get();
-      spdlog::debug("Restoring trigger for database \"{}\"", ic->db->id());
-      auto storage_accessor = ic->db->Access();
-      auto dba = memgraph::query::DbAccessor{storage_accessor.get()};
-      ic->trigger_store.RestoreTriggers(&ic->ast_cache, &dba, ic->config.query, ic->auth_checker);
-    }
-  }
-
-  /**
-   * @brief Restore streams of all currently defined databases.
-   * @note: Stream transformations are using modules, they have to be restored after the query modules are loaded.
-   */
-  void RestoreStreams() {
-    std::lock_guard<LockT> wr(lock_);
-    for (auto &ic_itr : interp_handler_) {
-      auto ic = ic_itr.second.get();
-      spdlog::debug("Restoring streams for database \"{}\"", ic->db->id());
-      ic->streams.RestoreStreams();
-    }
-  }
-
- private:
-  std::optional<std::filesystem::path> StorageDir_(const std::string &name) const {
-    const auto conf = interp_handler_.GetConfig(name);
-    if (conf) {
-      return conf->storage_config.durability.storage_directory;
-    }
-    spdlog::debug("Failed to find storage dir for database \"{}\"", name);
-    return {};
-  }
-
-  /**
-   * @brief Create a new SessionContext associated with the "name" database
-   *
-   * @param name name of the database
-   * @return NewResultT context on success, error on failure
-   */
-  NewResultT New_(const std::string &name) { return New_(name, name); }
-
-  /**
-   * @brief Create a new SessionContext associated with the "name" database
-   *
-   * @param name name of the database
-   * @param storage_subdir undelying RocksDB directory
-   * @return NewResultT context on success, error on failure
-   */
-  NewResultT New_(const std::string &name, std::filesystem::path storage_subdir) {
-    if (default_configs_) {
-      auto storage = default_configs_->storage_config;
-      storage::UpdatePaths(storage, storage.durability.storage_directory / storage_subdir);
-      return New_(name, storage, default_configs_->interp_config);
-    }
-    spdlog::info("Trying to generate session context without any configurations.");
-    return NewError::NO_CONFIGS;
-  }
-
-  /**
-   * @brief Create a new SessionContext associated with the "name" database
-   *
-   * @param name name of the database
-   * @param storage_config storage configuration
-   * @param inter_config interpreter configuration
-   * @return NewResultT context on success, error on failure
-   */
-  NewResultT New_(const std::string &name, StorageConfigT &storage_config, query::InterpreterConfig &inter_config/*,
-                  const std::string &ah_flags*/) {
-    MG_ASSERT(auth_handler_, "No high level AuthQueryHandler has been supplied.");
-    MG_ASSERT(auth_checker_, "No high level AuthChecker has been supplied.");
-
-    if (defunct_dbs_.contains(name)) {
-      spdlog::warn("Failed to generate database due to the unknown state of the previously defunct database \"{}\".",
-                   name);
-      return NewError::DEFUNCT;
-    }
-
-    auto new_interp = interp_handler_.New(name, *this, storage_config, inter_config, *auth_handler_, *auth_checker_);
-
-    if (new_interp.HasValue()) {
-      // Success
-      if (durability_) durability_->Put(name, "ok");
-      return SessionContext{new_interp.GetValue(), run_id_, auth_.get(), audit_log_};
-    }
-    return new_interp.GetError();
-  }
-
-  /**
-   * @brief Create a new SessionContext associated with the default database
-   *
-   * @return NewResultT context on success, error on failure
-   */
-  NewResultT NewDefault_() {
-    // Create the default DB in the root (this is how it was done pre multi-tenancy)
-    auto res = New_(kDefaultDB, "..");
-    if (res.HasValue()) {
-      // For back-compatibility...
-      // Recreate the dbms layout for the default db and symlink to the root
-      const auto dir = StorageDir_(kDefaultDB);
-      MG_ASSERT(dir, "Failed to find storage path.");
-      const auto main_dir = *dir / "databases" / kDefaultDB;
-
-      if (!std::filesystem::exists(main_dir)) {
-        std::filesystem::create_directory(main_dir);
-      }
-
-      // Force link on-disk directories
-      const auto conf = interp_handler_.GetConfig(kDefaultDB);
-      MG_ASSERT(conf, "No configuration for the default database.");
-      const auto &tmp_conf = conf->storage_config.disk;
-      std::vector<std::filesystem::path> to_link{
-          tmp_conf.main_storage_directory,         tmp_conf.label_index_directory,
-          tmp_conf.label_property_index_directory, tmp_conf.unique_constraints_directory,
-          tmp_conf.name_id_mapper_directory,       tmp_conf.id_name_mapper_directory,
-          tmp_conf.durability_directory,           tmp_conf.wal_directory,
-      };
-
-      // Add in-memory paths
-      // Some directories are redundant (skip those)
-      const std::vector<std::string> skip{".lock", "audit_log", "auth", "databases", "internal_modules", "settings"};
-      for (auto const &item : std::filesystem::directory_iterator{*dir}) {
-        const auto dir_name = std::filesystem::relative(item.path(), item.path().parent_path());
-        if (std::find(skip.begin(), skip.end(), dir_name) != skip.end()) continue;
-        to_link.push_back(item.path());
-      }
-
-      // Symlink to root dir
-      for (auto const &item : to_link) {
-        const auto dir_name = std::filesystem::relative(item, item.parent_path());
-        const auto link = main_dir / dir_name;
-        const auto to = std::filesystem::relative(item, main_dir);
-        if (!std::filesystem::is_symlink(link) && !std::filesystem::exists(link)) {
-          std::filesystem::create_directory_symlink(to, link);
-        } else {  // Check existing link
-          std::error_code ec;
-          const auto test_link = std::filesystem::read_symlink(link, ec);
-          if (ec || test_link != to) {
-            MG_ASSERT(false,
-                      "Memgraph storage directory incompatible with new version.\n"
-                      "Please use a clean directory or remove \"{}\" and try again.",
-                      link.string());
-          }
-        }
-      }
-    }
-    return res;
-  }
-
-  /**
-   * @brief Get the context associated with the "name" database
-   *
-   * @param name
-   * @return SessionContext
-   * @throw UnknownDatabaseException if trying to get unknown database
-   */
-  SessionContext Get_(const std::string &name) {
-    auto interp = interp_handler_.Get(name);
-    if (interp) {
-      return SessionContext{*interp, run_id_, auth_.get(), audit_log_};
-    }
-    throw UnknownDatabaseException("Tried to retrieve an unknown database \"{}\".", name);
-  }
-
-  // Should storage objects ever be deleted?
-  mutable LockT lock_;                                          //!< protective lock
-  std::filesystem::path lock_file_path_;                        //!< Lock file protecting the main storage
-  utils::OutputFile lock_file_handle_;                          //!< Handler the lock (crash if already open)
-  InterpContextHandler<SessionContextHandler> interp_handler_;  //!< multi-tenancy interpreter handler
-  // AuthContextHandler auth_handler_; //!< multi-tenancy authorization handler (currently we use a single global
-  // auth)
-  std::unique_ptr<utils::Synchronized<auth::Auth, utils::WritePrioritizedRWLock>> auth_;
-  std::unique_ptr<query::AuthQueryHandler> auth_handler_;
-  std::unique_ptr<query::AuthChecker> auth_checker_;
-  std::optional<Config> default_configs_;                         //!< default storage and interpreter configurations
-  const std::string run_id_;                                      //!< run's unique identifier (auto generated)
-  memgraph::audit::Log *audit_log_;                               //!< pointer to the audit logger
-  std::unordered_map<std::string, SessionInterface &> sessions_;  //!< map of active/registered sessions
-  std::unique_ptr<kvstore::KVStore> durability_;  //!< list of active dbs (pointer so we can postpone its creation)
-
-  std::set<std::string> defunct_dbs_;  //!< Databases that are in an unknown state due to various failures
-  bool delete_on_drop_;                //!< Flag defining if dropping storage also deletes its directory
- public:
-  static SessionContextHandler &ExtractSCH(query::InterpreterContext *interpreter_context) {
-    return static_cast<typename decltype(interp_handler_)::InterpContextT *>(interpreter_context)->sc_handler_;
-  }
-};
-
-#else
-/**
- * @brief Initialize the handler.
- *
- * @param auth pointer to the authenticator
- * @param configs storage and interpreter configurations
- */
-static inline SessionContext Init(storage::Config &storage_config, query::InterpreterConfig &interp_config,
-                                  utils::Synchronized<auth::Auth, utils::WritePrioritizedRWLock> *auth,
-                                  query::AuthQueryHandler *auth_handler, query::AuthChecker *auth_checker) {
-  MG_ASSERT(auth, "Passed a nullptr auth");
-  MG_ASSERT(auth_handler, "Passed a nullptr auth_handler");
-  MG_ASSERT(auth_checker, "Passed a nullptr auth_checker");
-
-  storage_config.name = kDefaultDB;
-  auto interp_context = std::make_shared<query::InterpreterContext>(
-      storage_config, interp_config, storage_config.durability.storage_directory, auth_handler, auth_checker);
-  MG_ASSERT(interp_context, "Failed to construct main interpret context.");
-
-  return SessionContext{interp_context, utils::GenerateUUID(), auth};
-}
-#endif
-
-}  // namespace memgraph::dbms

src/flags/CMakeLists.txt

@@ -0,0 +1,10 @@
+add_library(mg-flags STATIC audit.cpp
+                            bolt.cpp
+                            general.cpp
+                            isolation_level.cpp
+                            log_level.cpp
+                            memory_limit.cpp
+                            run_time_configurable.cpp
+                            storage_mode.cpp)
+target_include_directories(mg-flags PUBLIC ${CMAKE_SOURCE_DIR}/include)
+target_link_libraries(mg-flags PUBLIC spdlog::spdlog mg-settings mg-utils)

src/flags/all.hpp

@@ -0,0 +1,20 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#pragma once
+
+#include "flags/audit.hpp"
+#include "flags/bolt.hpp"
+#include "flags/general.hpp"
+#include "flags/isolation_level.hpp"
+#include "flags/log_level.hpp"
+#include "flags/memory_limit.hpp"
+#include "flags/run_time_configurable.hpp"
+#include "flags/storage_mode.hpp"

src/flags/audit.cpp

@@ -0,0 +1,28 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#include "flags/audit.hpp"
+
+#include "audit/log.hpp"
+
+#include "utils/flag_validation.hpp"
+
+// Audit logging flags.
+#ifdef MG_ENTERPRISE
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_bool(audit_enabled, false, "Set to true to enable audit logging.");
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_VALIDATED_int32(audit_buffer_size, memgraph::audit::kBufferSizeDefault,
+                       "Maximum number of items in the audit log buffer.", FLAG_IN_RANGE(1, INT32_MAX));
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_VALIDATED_int32(audit_buffer_flush_interval_ms, memgraph::audit::kBufferFlushIntervalMillisDefault,
+                       "Interval (in milliseconds) used for flushing the audit log buffer.",
+                       FLAG_IN_RANGE(10, INT32_MAX));
+#endif

src/flags/audit.hpp

@@ -0,0 +1,23 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#pragma once
+
+#include "gflags/gflags.h"
+
+// Audit logging flags.
+#ifdef MG_ENTERPRISE
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_bool(audit_enabled);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_int32(audit_buffer_size);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_int32(audit_buffer_flush_interval_ms);
+#endif

src/flags/bolt.cpp

@@ -0,0 +1,42 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#include "flags/bolt.hpp"
+
+#include "utils/flag_validation.hpp"
+
+#include <limits>
+#include <thread>
+
+// Bolt server flags.
+DEFINE_string(bolt_address, "0.0.0.0", "IP address on which the Bolt server should listen.");
+
+DEFINE_VALIDATED_int32(bolt_port, 7687, "Port on which the Bolt server should listen.",
+                       FLAG_IN_RANGE(0, std::numeric_limits<uint16_t>::max()));
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_VALIDATED_int32(bolt_num_workers, std::max(std::thread::hardware_concurrency(), 1U),
+                       "Number of workers used by the Bolt server. By default, this will be the "
+                       "number of processing units available on the machine.",
+                       FLAG_IN_RANGE(1, INT32_MAX));
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_VALIDATED_int32(bolt_session_inactivity_timeout, 1800,
+                       "Time in seconds after which inactive Bolt sessions will be "
+                       "closed.",
+                       FLAG_IN_RANGE(1, INT32_MAX));
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_string(bolt_cert_file, "", "Certificate file which should be used for the Bolt server.");
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_string(bolt_key_file, "", "Key file which should be used for the Bolt server.");
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_string(bolt_server_name_for_init, "",
+              "Server name which the database should send to the client in the "
+              "Bolt INIT message.");

src/flags/bolt.hpp

@@ -0,0 +1,29 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#pragma once
+
+#include "gflags/gflags.h"
+
+// Bolt server flags.
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_string(bolt_address);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_int32(bolt_port);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_int32(bolt_num_workers);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_int32(bolt_session_inactivity_timeout);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_string(bolt_cert_file);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_string(bolt_key_file);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_string(bolt_server_name_for_init);

src/flags/general.cpp

@@ -0,0 +1,198 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include "general.hpp"
+
+#include "glue/auth_global.hpp"
+#include "storage/v2/config.hpp"
+#include "utils/file.hpp"
+#include "utils/flag_validation.hpp"
+#include "utils/string.hpp"
+
+#include <thread>
+
+// Short help flag.
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_HIDDEN_bool(h, false, "Print usage and exit.");
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_string(monitoring_address, "0.0.0.0",
+              "IP address on which the websocket server for Memgraph monitoring should listen.");
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_string(metrics_address, "0.0.0.0",
+              "IP address on which the Memgraph server for exposing metrics should listen.");
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_VALIDATED_int32(monitoring_port, 7444,
+                       "Port on which the websocket server for Memgraph monitoring should listen.",
+                       FLAG_IN_RANGE(0, std::numeric_limits<uint16_t>::max()));
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_VALIDATED_int32(metrics_port, 9091, "Port on which the Memgraph server for exposing metrics should listen.",
+                       FLAG_IN_RANGE(0, std::numeric_limits<uint16_t>::max()));
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_string(init_file, "",
+              "Path to cypherl file that is used for configuring users and database schema before server starts.");
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_string(init_data_file, "", "Path to cypherl file that is used for creating data after server starts.");
+
+// General purpose flags.
+// NOTE: The `data_directory` flag must be the same here and in
+// `mg_import_csv`. If you change it, make sure to change it there as well.
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_string(data_directory, "mg_data", "Path to directory in which to save all permanent data.");
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_bool(data_recovery_on_startup, false, "Controls whether the database recovers persisted data on startup.");
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_uint64(memory_warning_threshold, 1024,
+              "Memory warning threshold, in MB. If Memgraph detects there is "
+              "less available RAM it will log a warning. Set to 0 to "
+              "disable.");
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_bool(allow_load_csv, true, "Controls whether LOAD CSV clause is allowed in queries.");
+
+// Storage flags.
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_VALIDATED_uint64(storage_gc_cycle_sec, 30, "Storage garbage collector interval (in seconds).",
+                        FLAG_IN_RANGE(1, 24 * 3600));
+// NOTE: The `storage_properties_on_edges` flag must be the same here and in
+// `mg_import_csv`. If you change it, make sure to change it there as well.
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_bool(storage_properties_on_edges, false, "Controls whether edges have properties.");
+
+// storage_recover_on_startup deprecated; use data_recovery_on_startup instead
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_HIDDEN_bool(storage_recover_on_startup, false,
+                   "Controls whether the storage recovers persisted data on startup.");
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_VALIDATED_uint64(storage_snapshot_interval_sec, 0,
+                        "Storage snapshot creation interval (in seconds). Set "
+                        "to 0 to disable periodic snapshot creation.",
+                        FLAG_IN_RANGE(0, 7 * 24 * 3600));
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_bool(storage_wal_enabled, false,
+            "Controls whether the storage uses write-ahead-logging. To enable "
+            "WAL periodic snapshots must be enabled.");
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_VALIDATED_uint64(storage_snapshot_retention_count, 3, "The number of snapshots that should always be kept.",
+                        FLAG_IN_RANGE(1, 1000000));
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_VALIDATED_uint64(storage_wal_file_size_kib, memgraph::storage::Config::Durability().wal_file_size_kibibytes,
+                        "Minimum file size of each WAL file.",
+                        FLAG_IN_RANGE(1, static_cast<unsigned long>(1000) * 1024));
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_VALIDATED_uint64(storage_wal_file_flush_every_n_tx,
+                        memgraph::storage::Config::Durability().wal_file_flush_every_n_tx,
+                        "Issue a 'fsync' call after this amount of transactions are written to the "
+                        "WAL file. Set to 1 for fully synchronous operation.",
+                        FLAG_IN_RANGE(1, 1000000));
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_bool(storage_snapshot_on_exit, false, "Controls whether the storage creates another snapshot on exit.");
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_uint64(storage_items_per_batch, memgraph::storage::Config::Durability().items_per_batch,
+              "The number of edges and vertices stored in a batch in a snapshot file.");
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_bool(storage_parallel_index_recovery, false,
+            "Controls whether the index creation can be done in a multithreaded fashion.");
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_uint64(storage_recovery_thread_count,
+              std::max(static_cast<uint64_t>(std::thread::hardware_concurrency()),
+                       memgraph::storage::Config::Durability().recovery_thread_count),
+              "The number of threads used to recover persisted data from disk.");
+
+#ifdef MG_ENTERPRISE
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_bool(storage_delete_on_drop, true,
+            "If set to true the query 'DROP DATABASE x' will delete the underlying storage as well.");
+#endif
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_bool(telemetry_enabled, false,
+            "Set to true to enable telemetry. We collect information about the "
+            "running system (CPU and memory information) and information about "
+            "the database runtime (vertex and edge counts and resource usage) "
+            "to allow for easier improvement of the product.");
+
+// Streams flags
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_uint32(
+    stream_transaction_conflict_retries, 30,
+    "Number of times to retry when a stream transformation fails to commit because of conflicting transactions");
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_uint32(
+    stream_transaction_retry_interval, 500,
+    "Retry interval in milliseconds when a stream transformation fails to commit because of conflicting transactions");
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_string(kafka_bootstrap_servers, "",
+              "List of default Kafka brokers as a comma separated list of broker host or host:port.");
+
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_string(pulsar_service_url, "", "Default URL used while connecting to Pulsar brokers.");
+
+// Query flags.
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_double(query_execution_timeout_sec, -1,
+              "Maximum allowed query execution time. Queries exceeding this "
+              "limit will be aborted. Value of 0 means no limit.");
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_uint64(replication_replica_check_frequency_sec, 1,
+              "The time duration between two replica checks/pings. If < 1, replicas will NOT be checked at all. NOTE: "
+              "The MAIN instance allocates a new thread for each REPLICA.");
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_bool(replication_restore_state_on_startup, false, "Restore replication state on startup, e.g. recover replica");
+
+DEFINE_VALIDATED_string(query_modules_directory, "",
+                        "Directory where modules with custom query procedures are stored. "
+                        "NOTE: Multiple comma-separated directories can be defined.",
+                        {
+                          if (value.empty()) return true;
+                          const auto directories = memgraph::utils::Split(value, ",");
+                          for (const auto &dir : directories) {
+                            if (!memgraph::utils::DirExists(dir)) {
+                              std::cout << "Expected --" << flagname << " to point to directories." << std::endl;
+                              std::cout << dir << " is not a directory." << std::endl;
+                              return false;
+                            }
+                          }
+                          return true;
+                        });
+
+auto memgraph::flags::ParseQueryModulesDirectory() -> std::vector<std::filesystem::path> {
+  const auto directories = memgraph::utils::Split(FLAGS_query_modules_directory, ",");
+  std::vector<std::filesystem::path> query_modules_directories;
+  query_modules_directories.reserve(directories.size());
+  std::transform(directories.begin(), directories.end(), std::back_inserter(query_modules_directories),
+                 [](const auto &dir) { return dir; });
+
+  return query_modules_directories;
+}
+
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_string(query_callable_mappings_path, "",
+              "The path to mappings that describes aliases to callables in cypher queries in the form of key-value "
+              "pairs in a json file. With this option query module procedures that do not exist in memgraph can be "
+              "mapped to ones that exist.");
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_HIDDEN_string(license_key, "", "License key for Memgraph Enterprise.");
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_HIDDEN_string(organization_name, "", "Organization name.");
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_string(auth_user_or_role_name_regex, memgraph::glue::kDefaultUserRoleRegex.data(),
+              "Set to the regular expression that each user or role name must fulfill.");

src/flags/general.hpp

@@ -0,0 +1,122 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#include "gflags/gflags.h"
+
+#include <filesystem>
+
+// Short help flag.
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_bool(h);
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_string(monitoring_address);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_int32(monitoring_port);
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_string(metrics_address);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_int32(metrics_port);
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_string(init_file);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_string(init_data_file);
+
+// General purpose flags.
+// NOTE: The `data_directory` flag must be the same here and in
+// `mg_import_csv`. If you change it, make sure to change it there as well.
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_string(data_directory);
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_bool(data_recovery_on_startup);
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_uint64(memory_warning_threshold);
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_bool(allow_load_csv);
+
+// Storage flags.
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_uint64(storage_gc_cycle_sec);
+// NOTE: The `storage_properties_on_edges` flag must be the same here and in
+// `mg_import_csv`. If you change it, make sure to change it there as well.
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_bool(storage_properties_on_edges);
+// storage_recover_on_startup deprecated; use data_recovery_on_startup instead
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_bool(storage_recover_on_startup);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_uint64(storage_snapshot_interval_sec);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_bool(storage_wal_enabled);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_uint64(storage_snapshot_retention_count);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_uint64(storage_wal_file_size_kib);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_uint64(storage_wal_file_flush_every_n_tx);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_bool(storage_snapshot_on_exit);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_uint64(storage_items_per_batch);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_bool(storage_parallel_index_recovery);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_uint64(storage_recovery_thread_count);
+#ifdef MG_ENTERPRISE
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_bool(storage_delete_on_drop);
+#endif
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_bool(telemetry_enabled);
+
+// Streams flags
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_uint32(stream_transaction_conflict_retries);
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_uint32(stream_transaction_retry_interval);
+
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_string(kafka_bootstrap_servers);
+
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_string(pulsar_service_url);
+
+// Query flags.
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_double(query_execution_timeout_sec);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_string(query_modules_directory);
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_string(query_callable_mappings_path);
+namespace memgraph::flags {
+auto ParseQueryModulesDirectory() -> std::vector<std::filesystem::path>;
+}  // namespace memgraph::flags
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_uint64(replication_replica_check_frequency_sec);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_bool(replication_restore_state_on_startup);
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_string(license_key);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_string(organization_name);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_string(auth_user_or_role_name_regex);

src/flags/isolation_level.cpp

@@ -0,0 +1,54 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#include "flags/isolation_level.hpp"
+
+#include "utils/enum.hpp"
+#include "utils/flag_validation.hpp"
+
+#include "gflags/gflags.h"
+
+#include <array>
+#include <string_view>
+
+inline constexpr std::array isolation_level_mappings{
+    std::pair{std::string_view{"SNAPSHOT_ISOLATION"}, memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION},
+    std::pair{std::string_view{"READ_COMMITTED"}, memgraph::storage::IsolationLevel::READ_COMMITTED},
+    std::pair{std::string_view{"READ_UNCOMMITTED"}, memgraph::storage::IsolationLevel::READ_UNCOMMITTED}};
+
+const std::string isolation_level_help_string =
+    fmt::format("Default isolation level used for the transactions. Allowed values: {}",
+                memgraph::utils::GetAllowedEnumValuesString(isolation_level_mappings));
+
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_VALIDATED_string(isolation_level, "SNAPSHOT_ISOLATION", isolation_level_help_string.c_str(), {
+  if (const auto result = memgraph::utils::IsValidEnumValueString(value, isolation_level_mappings); result.HasError()) {
+    switch (result.GetError()) {
+      case memgraph::utils::ValidationError::EmptyValue: {
+        std::cout << "Isolation level cannot be empty." << std::endl;
+        break;
+      }
+      case memgraph::utils::ValidationError::InvalidValue: {
+        std::cout << "Invalid value for isolation level. Allowed values: "
+                  << memgraph::utils::GetAllowedEnumValuesString(isolation_level_mappings) << std::endl;
+        break;
+      }
+    }
+    return false;
+  }
+  return true;
+});
+
+memgraph::storage::IsolationLevel memgraph::flags::ParseIsolationLevel() {
+  const auto isolation_level =
+      memgraph::utils::StringToEnum<memgraph::storage::IsolationLevel>(FLAGS_isolation_level, isolation_level_mappings);
+  MG_ASSERT(isolation_level, "Invalid isolation level");
+  return *isolation_level;
+}

src/flags/isolation_level.hpp

@@ -0,0 +1,19 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#pragma once
+
+#include "storage/v2/isolation_level.hpp"
+
+namespace memgraph::flags {
+
+memgraph::storage::IsolationLevel ParseIsolationLevel();
+
+}  // namespace memgraph::flags

src/flags/log_level.cpp

@@ -0,0 +1,122 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#include "flags/log_level.hpp"
+
+#include "utils/enum.hpp"
+#include "utils/flag_validation.hpp"
+#include "utils/logging.hpp"
+
+#include "gflags/gflags.h"
+#include "spdlog/common.h"
+#include "spdlog/sinks/daily_file_sink.h"
+
+#include <array>
+#include <string_view>
+#include <utility>
+
+using namespace std::string_view_literals;
+
+// Logging flags
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_HIDDEN_bool(also_log_to_stderr, false, "Log messages go to stderr in addition to logfiles");
+DEFINE_string(log_file, "", "Path to where the log should be stored.");
+
+inline constexpr std::array log_level_mappings{
+    std::pair{"TRACE"sv, spdlog::level::trace}, std::pair{"DEBUG"sv, spdlog::level::debug},
+    std::pair{"INFO"sv, spdlog::level::info},   std::pair{"WARNING"sv, spdlog::level::warn},
+    std::pair{"ERROR"sv, spdlog::level::err},   std::pair{"CRITICAL"sv, spdlog::level::critical}};
+
+const std::string log_level_help_string = fmt::format("Minimum log level. Allowed values: {}",
+                                                      memgraph::utils::GetAllowedEnumValuesString(log_level_mappings));
+
+DEFINE_VALIDATED_string(log_level, "WARNING", log_level_help_string.c_str(),
+                        { return memgraph::flags::ValidLogLevel(value); });
+
+bool memgraph::flags::ValidLogLevel(std::string_view value) {
+  if (const auto result = memgraph::utils::IsValidEnumValueString(value, log_level_mappings); result.HasError()) {
+    const auto error = result.GetError();
+    switch (error) {
+      case memgraph::utils::ValidationError::EmptyValue: {
+        std::cout << "Log level cannot be empty." << std::endl;
+        break;
+      }
+      case memgraph::utils::ValidationError::InvalidValue: {
+        std::cout << "Invalid value for log level. Allowed values: "
+                  << memgraph::utils::GetAllowedEnumValuesString(log_level_mappings) << std::endl;
+        break;
+      }
+    }
+    return false;
+  }
+
+  return true;
+}
+
+std::optional<spdlog::level::level_enum> memgraph::flags::LogLevelToEnum(std::string_view value) {
+  return memgraph::utils::StringToEnum<spdlog::level::level_enum>(value, log_level_mappings);
+}
+
+spdlog::level::level_enum ParseLogLevel() {
+  const auto log_level = memgraph::flags::LogLevelToEnum(FLAGS_log_level);
+  MG_ASSERT(log_level, "Invalid log level");
+  return *log_level;
+}
+
+// 5 weeks * 7 days
+inline constexpr auto log_retention_count = 35;
+void CreateLoggerFromSink(const auto &sinks, const auto log_level) {
+  auto logger = std::make_shared<spdlog::logger>("memgraph_log", sinks.begin(), sinks.end());
+  logger->set_level(log_level);
+  logger->flush_on(spdlog::level::trace);
+  spdlog::set_default_logger(std::move(logger));
+  // Enable stderr sink
+  if (FLAGS_also_log_to_stderr) {
+    memgraph::flags::LogToStderr(log_level);
+  }
+}
+
+void memgraph::flags::InitializeLogger() {
+  std::vector<spdlog::sink_ptr> sinks;
+
+  // Force the stderr logger to be at the front of the sinks vector
+  // Will be used to disable/enable it at run-time by settings its log level
+  sinks.emplace_back(std::make_shared<spdlog::sinks::stderr_color_sink_mt>());
+  sinks.back()->set_level(spdlog::level::off);
+
+  if (!FLAGS_log_file.empty()) {
+    // get local time
+    time_t current_time{0};
+    struct tm *local_time{nullptr};
+
+    time(&current_time);
+    local_time = localtime(&current_time);
+
+    sinks.emplace_back(std::make_shared<spdlog::sinks::daily_file_sink_mt>(
+        FLAGS_log_file, local_time->tm_hour, local_time->tm_min, false, log_retention_count));
+  }
+  CreateLoggerFromSink(sinks, ParseLogLevel());
+}
+
+// TODO: Make sure this is used in a safe way
+void memgraph::flags::AddLoggerSink(spdlog::sink_ptr new_sink) {
+  auto default_logger = spdlog::default_logger();
+  auto sinks = default_logger->sinks();
+  sinks.push_back(new_sink);
+  CreateLoggerFromSink(sinks, default_logger->level());
+}
+
+// Thread-safe because the level enum is an atomic
+// NOTE: default_logger is not thread-safe and shouldn't be changed during application lifetime
+void memgraph::flags::LogToStderr(spdlog::level::level_enum log_level) {
+  auto default_logger = spdlog::default_logger();
+  auto sink = default_logger->sinks().front();
+  sink->set_level(log_level);
+}

src/flags/log_level.hpp

@@ -0,0 +1,29 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#pragma once
+
+#include <spdlog/sinks/sink.h>
+#include <optional>
+#include "gflags/gflags.h"
+
+DECLARE_string(log_level);
+DECLARE_bool(also_log_to_stderr);
+
+namespace memgraph::flags {
+
+bool ValidLogLevel(std::string_view value);
+std::optional<spdlog::level::level_enum> LogLevelToEnum(std::string_view value);
+
+void InitializeLogger();
+void AddLoggerSink(spdlog::sink_ptr new_sink);
+void LogToStderr(spdlog::level::level_enum log_level);
+
+}  // namespace memgraph::flags

src/flags/memory_limit.cpp

@@ -0,0 +1,41 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#include "flags/memory_limit.hpp"
+
+#include "utils/logging.hpp"
+#include "utils/sysinfo/memory.hpp"
+
+#include "gflags/gflags.h"
+
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_uint64(
+    memory_limit, 0,
+    "Total memory limit in MiB. Set to 0 to use the default values which are 100\% of the phyisical memory if the swap "
+    "is enabled and 90\% of the physical memory otherwise.");
+
+int64_t memgraph::flags::GetMemoryLimit() {
+  if (FLAGS_memory_limit == 0) {
+    auto maybe_total_memory = memgraph::utils::sysinfo::TotalMemory();
+    MG_ASSERT(maybe_total_memory, "Failed to fetch the total physical memory");
+    const auto maybe_swap_memory = memgraph::utils::sysinfo::SwapTotalMemory();
+    MG_ASSERT(maybe_swap_memory, "Failed to fetch the total swap memory");
+
+    if (*maybe_swap_memory == 0) {
+      // take only 90% of the total memory
+      *maybe_total_memory *= 9;
+      *maybe_total_memory /= 10;
+    }
+    return *maybe_total_memory * 1024;
+  }
+
+  // We parse the memory as MiB every time
+  return FLAGS_memory_limit * 1024 * 1024;
+}

src/flags/memory_limit.hpp

@@ -0,0 +1,17 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#pragma once
+
+#include <cstdint>
+
+namespace memgraph::flags {
+int64_t GetMemoryLimit();
+}  // namespace memgraph::flags

src/flags/run_time_configurable.cpp

@@ -0,0 +1,111 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include "flags/run_time_configurable.hpp"
+#include <string>
+#include "flags/bolt.hpp"
+#include "flags/general.hpp"
+#include "flags/log_level.hpp"
+#include "spdlog/cfg/helpers-inl.h"
+#include "spdlog/spdlog.h"
+#include "utils/exceptions.hpp"
+#include "utils/settings.hpp"
+#include "utils/string.hpp"
+
+namespace {
+// Bolt server name
+constexpr auto kServerNameSettingKey = "server.name";
+constexpr auto kDefaultServerName = "Neo4j/v5.11.0 compatible graph database server - Memgraph";
+// Query timeout
+constexpr auto kQueryTxSettingKey = "query.timeout";
+constexpr auto kDefaultQueryTx = "600";  // seconds
+// Log level
+// No default value because it is not persistent
+constexpr auto kLogLevelSettingKey = "log.level";
+// Log to stderr
+// No default value because it is not persistent
+constexpr auto kLogToStderrSettingKey = "log.to_stderr";
+}  // namespace
+
+namespace memgraph::flags::run_time {
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+memgraph::utils::Synchronized<std::string, memgraph::utils::SpinLock> bolt_server_name_;
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+std::atomic<double> execution_timeout_sec_;
+
+void Initialize() {
+  // Register bolt server name settings
+  memgraph::utils::global_settings.RegisterSetting(kServerNameSettingKey, kDefaultServerName, [&] {
+    const auto server_name = memgraph::utils::global_settings.GetValue(kServerNameSettingKey);
+    MG_ASSERT(server_name, "Bolt server name is missing from the settings");
+    *(bolt_server_name_.Lock()) = *server_name;
+  });
+  // Update value from read settings
+  const auto &name = memgraph::utils::global_settings.GetValue(kServerNameSettingKey);
+  MG_ASSERT(name, "Failed to read server name from settings.");
+  *(bolt_server_name_.Lock()) = *name;
+  // Override server name if passed via command line argument
+  if (!FLAGS_bolt_server_name_for_init.empty()) {
+    memgraph::utils::global_settings.SetValue(kServerNameSettingKey, FLAGS_bolt_server_name_for_init);
+  }
+
+  // Register query timeout
+  memgraph::utils::global_settings.RegisterSetting(kQueryTxSettingKey, kDefaultQueryTx, [&] {
+    const auto query_tx = memgraph::utils::global_settings.GetValue(kQueryTxSettingKey);
+    MG_ASSERT(query_tx, "Query timeout is missing from the settings");
+    execution_timeout_sec_ = std::stod(*query_tx);
+  });
+  // Update value from read settings
+  const auto &tx = memgraph::utils::global_settings.GetValue(kQueryTxSettingKey);
+  MG_ASSERT(tx, "Failed to read query timeout from settings.");
+  execution_timeout_sec_ = std::stod(*tx);
+  // Override query timeout if passed via command line argument
+  if (FLAGS_query_execution_timeout_sec != -1) {
+    memgraph::utils::global_settings.SetValue(kQueryTxSettingKey, std::to_string(FLAGS_query_execution_timeout_sec));
+  }
+
+  // Register log level
+  auto get_global_log_level = []() {
+    const auto log_level = memgraph::utils::global_settings.GetValue(kLogLevelSettingKey);
+    MG_ASSERT(log_level, "Log level is missing from the settings");
+    const auto ll_enum = memgraph::flags::LogLevelToEnum(*log_level);
+    if (!ll_enum) {
+      throw utils::BasicException("Unsupported log level {}", *log_level);
+    }
+    return *ll_enum;
+  };
+  memgraph::utils::global_settings.RegisterSetting(
+      kLogLevelSettingKey, FLAGS_log_level, [&] { spdlog::set_level(get_global_log_level()); },
+      memgraph::flags::ValidLogLevel);
+  // Always override log level with command line argument
+  memgraph::utils::global_settings.SetValue(kLogLevelSettingKey, FLAGS_log_level);
+
+  // Register logging to stderr
+  auto bool_to_str = [](bool in) { return in ? "true" : "false"; };
+  const std::string log_to_stderr_s = bool_to_str(FLAGS_also_log_to_stderr);
+  memgraph::utils::global_settings.RegisterSetting(
+      kLogToStderrSettingKey, log_to_stderr_s,
+      [&] {
+        const auto enable = memgraph::utils::global_settings.GetValue(kLogToStderrSettingKey);
+        if (enable == "true") {
+          LogToStderr(get_global_log_level());
+        } else {
+          LogToStderr(spdlog::level::off);
+        }
+      },
+      [](std::string_view in) {
+        const auto lc = memgraph::utils::ToLowerCase(in);
+        return lc == "false" || lc == "true";
+      });
+  // Always override log to stderr with command line argument
+  memgraph::utils::global_settings.SetValue(kLogToStderrSettingKey, log_to_stderr_s);
+}
+}  // namespace memgraph::flags::run_time

src/flags/run_time_configurable.hpp

@@ -0,0 +1,26 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#pragma once
+
+#include "utils/spin_lock.hpp"
+#include "utils/synchronized.hpp"
+
+namespace memgraph::flags::run_time {
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+extern utils::Synchronized<std::string, utils::SpinLock> bolt_server_name_;
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+extern std::atomic<double> execution_timeout_sec_;
+
+void Initialize();
+
+}  // namespace memgraph::flags::run_time

src/flags/storage_mode.cpp

@@ -0,0 +1,55 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include "flags/storage_mode.hpp"
+
+#include "storage/v2/storage_mode.hpp"
+#include "utils/enum.hpp"
+#include "utils/flag_validation.hpp"
+
+#include "gflags/gflags.h"
+
+#include <array>
+
+inline constexpr std::array storage_mode_mappings{
+    std::pair{std::string_view{"IN_MEMORY_TRANSACTIONAL"}, memgraph::storage::StorageMode::IN_MEMORY_TRANSACTIONAL},
+    std::pair{std::string_view{"IN_MEMORY_ANALYTICAL"}, memgraph::storage::StorageMode::IN_MEMORY_ANALYTICAL},
+    std::pair{std::string_view{"ON_DISK_TRANSACTIONAL"}, memgraph::storage::StorageMode::ON_DISK_TRANSACTIONAL}};
+
+const std::string storage_mode_help_string =
+    fmt::format("Default storage mode Memgraph uses. Allowed values: {}",
+                memgraph::utils::GetAllowedEnumValuesString(storage_mode_mappings));
+
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_VALIDATED_string(storage_mode, "IN_MEMORY_TRANSACTIONAL", storage_mode_help_string.c_str(), {
+  if (const auto result = memgraph::utils::IsValidEnumValueString(value, storage_mode_mappings); result.HasError()) {
+    switch (result.GetError()) {
+      case memgraph::utils::ValidationError::EmptyValue: {
+        std::cout << "Storage mode cannot be empty." << std::endl;
+        break;
+      }
+      case memgraph::utils::ValidationError::InvalidValue: {
+        std::cout << "Invalid value for storage mode. Allowed values: "
+                  << memgraph::utils::GetAllowedEnumValuesString(storage_mode_mappings) << std::endl;
+        break;
+      }
+    }
+    return false;
+  }
+  return true;
+});
+
+memgraph::storage::StorageMode memgraph::flags::ParseStorageMode() {
+  const auto storage_mode =
+      memgraph::utils::StringToEnum<memgraph::storage::StorageMode>(FLAGS_storage_mode, storage_mode_mappings);
+  MG_ASSERT(storage_mode, "Invalid storage mode");
+  return *storage_mode;
+}

src/flags/storage_mode.hpp

@@ -0,0 +1,19 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#pragma once
+
+#include "storage/v2/storage_mode.hpp"
+
+namespace memgraph::flags {
+
+memgraph::storage::StorageMode ParseStorageMode();
+
+}  // namespace memgraph::flags

src/glue/CMakeLists.txt

@@ -1,4 +1,11 @@
-set(mg_glue_sources auth.cpp auth_checker.cpp auth_handler.cpp communication.cpp)
-
-add_library(mg-glue STATIC ${mg_glue_sources})
-target_link_libraries(mg-glue mg-query mg-auth)
+add_library(mg-glue STATIC )
+target_sources(mg-glue PRIVATE auth.cpp
+                               auth_checker.cpp
+                               auth_handler.cpp
+                               communication.cpp
+                               SessionHL.cpp
+                               ServerT.cpp
+                               MonitoringServerT.cpp
+                               run_id.cpp)
+target_link_libraries(mg-glue mg-query mg-auth mg-audit)
+target_precompile_headers(mg-glue INTERFACE auth_checker.hpp auth_handler.hpp)

src/glue/MonitoringServerT.cpp

@@ -0,0 +1,13 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#include "glue/MonitoringServerT.hpp"
+
+template class memgraph::communication::http::Server<memgraph::http::MetricsRequestHandler, memgraph::storage::Storage>;

src/glue/MonitoringServerT.hpp

@@ -0,0 +1,24 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#pragma once
+
+#include "communication/http/server.hpp"
+#include "http_handlers/metrics.hpp"
+#include "storage/v2/storage.hpp"
+
+extern template class memgraph::communication::http::Server<memgraph::http::MetricsRequestHandler,
+                                                            memgraph::storage::Storage>;
+
+namespace memgraph::glue {
+
+using MonitoringServerT =
+    memgraph::communication::http::Server<memgraph::http::MetricsRequestHandler, memgraph::storage::Storage>;
+}  // namespace memgraph::glue

src/glue/ServerT.cpp

@@ -0,0 +1,13 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#include "glue/ServerT.hpp"
+
+template class memgraph::communication::v2::Server<memgraph::glue::SessionHL, Context>;

src/glue/ServerT.hpp

@@ -0,0 +1,46 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#pragma once
+
+#include "communication/v2/server.hpp"
+#include "glue/SessionHL.hpp"
+#include "utils/synchronized.hpp"
+
+namespace memgraph::query {
+struct InterpreterContext;
+}
+
+#if MG_ENTERPRISE
+namespace memgraph::audit {
+class Log;
+}
+#endif
+
+namespace memgraph::auth {
+class Auth;
+}
+namespace memgraph::utils {
+class WritePrioritizedRWLock;
+}
+
+struct Context {
+  memgraph::query::InterpreterContext *ic;
+  memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth;
+#if MG_ENTERPRISE
+  memgraph::audit::Log *audit_log;
+#endif
+};
+
+extern template class memgraph::communication::v2::Server<memgraph::glue::SessionHL, Context>;
+
+namespace memgraph::glue {
+using ServerT = memgraph::communication::v2::Server<memgraph::glue::SessionHL, Context>;
+}  // namespace memgraph::glue

src/glue/SessionHL.cpp

@@ -0,0 +1,315 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include <optional>
+#include "gflags/gflags.h"
+
+#include "audit/log.hpp"
+#include "dbms/constants.hpp"
+#include "flags/run_time_configurable.hpp"
+#include "glue/SessionHL.hpp"
+#include "glue/auth_checker.hpp"
+#include "glue/communication.hpp"
+#include "glue/run_id.hpp"
+#include "license/license.hpp"
+#include "query/discard_value_stream.hpp"
+#include "query/interpreter_context.hpp"
+#include "utils/spin_lock.hpp"
+
+namespace memgraph::metrics {
+extern const Event ActiveBoltSessions;
+}  // namespace memgraph::metrics
+
+auto ToQueryExtras(const memgraph::communication::bolt::Value &extra) -> memgraph::query::QueryExtras {
+  auto const &as_map = extra.ValueMap();
+
+  auto metadata_pv = std::map<std::string, memgraph::storage::PropertyValue>{};
+
+  if (auto const it = as_map.find("tx_metadata"); it != as_map.cend() && it->second.IsMap()) {
+    for (const auto &[key, bolt_md] : it->second.ValueMap()) {
+      metadata_pv.emplace(key, memgraph::glue::ToPropertyValue(bolt_md));
+    }
+  }
+
+  auto tx_timeout = std::optional<int64_t>{};
+  if (auto const it = as_map.find("tx_timeout"); it != as_map.cend() && it->second.IsInt()) {
+    tx_timeout = it->second.ValueInt();
+  }
+
+  return memgraph::query::QueryExtras{std::move(metadata_pv), tx_timeout};
+}
+
+class TypedValueResultStreamBase {
+ public:
+  explicit TypedValueResultStreamBase(memgraph::storage::Storage *storage);
+
+  std::vector<memgraph::communication::bolt::Value> DecodeValues(
+      const std::vector<memgraph::query::TypedValue> &values) const;
+
+ protected:
+  // NOTE: Needed only for ToBoltValue conversions
+  memgraph::storage::Storage *storage_;
+};
+
+/// Wrapper around TEncoder which converts TypedValue to Value
+/// before forwarding the calls to original TEncoder.
+template <typename TEncoder>
+class TypedValueResultStream : public TypedValueResultStreamBase {
+ public:
+  TypedValueResultStream(TEncoder *encoder, memgraph::storage::Storage *storage)
+      : TypedValueResultStreamBase{storage}, encoder_(encoder) {}
+
+  void Result(const std::vector<memgraph::query::TypedValue> &values) { encoder_->MessageRecord(DecodeValues(values)); }
+
+ private:
+  TEncoder *encoder_;
+};
+
+std::vector<memgraph::communication::bolt::Value> TypedValueResultStreamBase::DecodeValues(
+    const std::vector<memgraph::query::TypedValue> &values) const {
+  std::vector<memgraph::communication::bolt::Value> decoded_values;
+  decoded_values.reserve(values.size());
+  for (const auto &v : values) {
+    auto maybe_value = memgraph::glue::ToBoltValue(v, *storage_, memgraph::storage::View::NEW);
+    if (maybe_value.HasError()) {
+      switch (maybe_value.GetError()) {
+        case memgraph::storage::Error::DELETED_OBJECT:
+          throw memgraph::communication::bolt::ClientError("Returning a deleted object as a result.");
+        case memgraph::storage::Error::NONEXISTENT_OBJECT:
+          throw memgraph::communication::bolt::ClientError("Returning a nonexistent object as a result.");
+        case memgraph::storage::Error::VERTEX_HAS_EDGES:
+        case memgraph::storage::Error::SERIALIZATION_ERROR:
+        case memgraph::storage::Error::PROPERTIES_DISABLED:
+          throw memgraph::communication::bolt::ClientError("Unexpected storage error when streaming results.");
+      }
+    }
+    decoded_values.emplace_back(std::move(*maybe_value));
+  }
+  return decoded_values;
+}
+TypedValueResultStreamBase::TypedValueResultStreamBase(memgraph::storage::Storage *storage) : storage_(storage) {}
+
+namespace memgraph::glue {
+
+#ifdef MG_ENTERPRISE
+inline static void MultiDatabaseAuth(const std::optional<auth::User> &user, std::string_view db) {
+  if (user && !AuthChecker::IsUserAuthorized(*user, {}, std::string(db))) {
+    throw memgraph::communication::bolt::ClientError(
+        "You are not authorized on the database \"{}\"! Please contact your database administrator.", db);
+  }
+}
+std::string SessionHL::GetDefaultDB() {
+  if (user_.has_value()) {
+    return user_->db_access().GetDefault();
+  }
+  return memgraph::dbms::kDefaultDB;
+}
+#endif
+
+std::string SessionHL::GetDatabaseName() const {
+  if (!interpreter_.db_acc_) return "";
+  const auto *db = interpreter_.db_acc_->get();
+  return db->id();
+}
+
+std::optional<std::string> SessionHL::GetServerNameForInit() {
+  auto locked_name = flags::run_time::bolt_server_name_.Lock();
+  return locked_name->empty() ? std::nullopt : std::make_optional(*locked_name);
+}
+
+bool SessionHL::Authenticate(const std::string &username, const std::string &password) {
+  bool res = true;
+  {
+    auto locked_auth = auth_->Lock();
+    if (locked_auth->HasUsers()) {
+      user_ = locked_auth->Authenticate(username, password);
+      res = user_.has_value();
+    }
+  }
+#ifdef MG_ENTERPRISE
+  // Start off with the default database
+  interpreter_.SetCurrentDB(GetDefaultDB());
+#endif
+  implicit_db_.emplace(GetDatabaseName());
+  return res;
+}
+
+void SessionHL::Abort() { interpreter_.Abort(); }
+
+std::map<std::string, memgraph::communication::bolt::Value> SessionHL::Discard(std::optional<int> n,
+                                                                               std::optional<int> qid) {
+  try {
+    memgraph::query::DiscardValueResultStream stream;
+    return DecodeSummary(interpreter_.Pull(&stream, n, qid));
+  } catch (const memgraph::query::QueryException &e) {
+    // Wrap QueryException into ClientError, because we want to allow the
+    // client to fix their query.
+    throw memgraph::communication::bolt::ClientError(e.what());
+  }
+}
+std::map<std::string, memgraph::communication::bolt::Value> SessionHL::Pull(SessionHL::TEncoder *encoder,
+                                                                            std::optional<int> n,
+                                                                            std::optional<int> qid) {
+  // TODO: Update once interpreter can handle non-database queries (db_acc will be nullopt)
+  auto *db = interpreter_.db_acc_->get();
+  try {
+    TypedValueResultStream<TEncoder> stream(encoder, db->storage());
+    return DecodeSummary(interpreter_.Pull(&stream, n, qid));
+  } catch (const memgraph::query::QueryException &e) {
+    // Wrap QueryException into ClientError, because we want to allow the
+    // client to fix their query.
+    throw memgraph::communication::bolt::ClientError(e.what());
+  }
+}
+
+std::pair<std::vector<std::string>, std::optional<int>> SessionHL::Interpret(
+    const std::string &query, const std::map<std::string, memgraph::communication::bolt::Value> &params,
+    const std::map<std::string, memgraph::communication::bolt::Value> &extra) {
+  std::map<std::string, memgraph::storage::PropertyValue> params_pv;
+  for (const auto &[key, bolt_param] : params) {
+    params_pv.emplace(key, ToPropertyValue(bolt_param));
+  }
+  const std::string *username{nullptr};
+  if (user_) {
+    username = &user_->username();
+  }
+
+#ifdef MG_ENTERPRISE
+  // TODO: Update once interpreter can handle non-database queries (db_acc will be nullopt)
+  auto *db = interpreter_.db_acc_->get();
+  if (memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
+    audit_log_->Record(endpoint_.address().to_string(), user_ ? *username : "", query,
+                       memgraph::storage::PropertyValue(params_pv), db->id());
+  }
+#endif
+  try {
+    auto result = interpreter_.Prepare(query, params_pv, username, ToQueryExtras(extra), UUID());
+    const std::string db_name = result.db ? *result.db : "";
+    if (user_ && !AuthChecker::IsUserAuthorized(*user_, result.privileges, db_name)) {
+      interpreter_.Abort();
+      if (db_name.empty()) {
+        throw memgraph::communication::bolt::ClientError(
+            "You are not authorized to execute this query! Please contact your database administrator.");
+      }
+      throw memgraph::communication::bolt::ClientError(
+          "You are not authorized to execute this query on database \"{}\"! Please contact your database "
+          "administrator.",
+          db_name);
+    }
+    return {std::move(result.headers), result.qid};
+
+  } catch (const memgraph::query::QueryException &e) {
+    // Wrap QueryException into ClientError, because we want to allow the
+    // client to fix their query.
+    throw memgraph::communication::bolt::ClientError(e.what());
+  } catch (const memgraph::query::ReplicationException &e) {
+    throw memgraph::communication::bolt::ClientError(e.what());
+  }
+}
+void SessionHL::RollbackTransaction() { interpreter_.RollbackTransaction(); }
+void SessionHL::CommitTransaction() { interpreter_.CommitTransaction(); }
+void SessionHL::BeginTransaction(const std::map<std::string, memgraph::communication::bolt::Value> &extra) {
+  interpreter_.BeginTransaction(ToQueryExtras(extra));
+}
+void SessionHL::Configure(const std::map<std::string, memgraph::communication::bolt::Value> &run_time_info) {
+#ifdef MG_ENTERPRISE
+  std::string db;
+  bool update = false;
+  // Check if user explicitly defined the database to use
+  if (run_time_info.contains("db")) {
+    const auto &db_info = run_time_info.at("db");
+    if (!db_info.IsString()) {
+      throw memgraph::communication::bolt::ClientError("Malformed database name.");
+    }
+    db = db_info.ValueString();
+    const auto &current = GetDatabaseName();
+    update = db != current;
+    if (!in_explicit_db_) implicit_db_.emplace(current);  // Still not in an explicit database, save for recovery
+    in_explicit_db_ = true;
+    // NOTE: Once in a transaction, the drivers stop explicitly sending the db and count on using it until commit
+  } else if (in_explicit_db_ && !interpreter_.in_explicit_transaction_) {  // Just on a switch
+    if (implicit_db_) {
+      db = *implicit_db_;
+    } else {
+      db = GetDefaultDB();
+    }
+    update = db != GetDatabaseName();
+    in_explicit_db_ = false;
+  }
+
+  // Check if the underlying database needs to be updated
+  if (update) {
+    MultiDatabaseAuth(user_, db);
+    interpreter_.SetCurrentDB(db);
+  }
+#endif
+}
+SessionHL::SessionHL(memgraph::query::InterpreterContext *interpreter_context,
+                     const memgraph::communication::v2::ServerEndpoint &endpoint,
+                     memgraph::communication::v2::InputStream *input_stream,
+                     memgraph::communication::v2::OutputStream *output_stream,
+                     memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth
+#ifdef MG_ENTERPRISE
+                     ,
+                     memgraph::audit::Log *audit_log
+#endif
+                     )
+    : Session<memgraph::communication::v2::InputStream, memgraph::communication::v2::OutputStream>(input_stream,
+                                                                                                   output_stream),
+      interpreter_context_(interpreter_context),
+      interpreter_(interpreter_context_),
+#ifdef MG_ENTERPRISE
+      audit_log_(audit_log),
+#endif
+      auth_(auth),
+      endpoint_(endpoint),
+      implicit_db_(dbms::kDefaultDB) {
+  // Metrics update
+  memgraph::metrics::IncrementCounter(memgraph::metrics::ActiveBoltSessions);
+#ifdef MG_ENTERPRISE
+  interpreter_.OnChangeCB([&](std::string_view db_name) { MultiDatabaseAuth(user_, db_name); });
+#endif
+  interpreter_context_->interpreters.WithLock([this](auto &interpreters) { interpreters.insert(&interpreter_); });
+}
+
+SessionHL::~SessionHL() {
+  memgraph::metrics::DecrementCounter(memgraph::metrics::ActiveBoltSessions);
+  interpreter_context_->interpreters.WithLock([this](auto &interpreters) { interpreters.erase(&interpreter_); });
+}
+
+std::map<std::string, memgraph::communication::bolt::Value> SessionHL::DecodeSummary(
+    const std::map<std::string, memgraph::query::TypedValue> &summary) {
+  // TODO: Update once interpreter can handle non-database queries (db_acc will be nullopt)
+  auto *db = interpreter_.db_acc_->get();
+  std::map<std::string, memgraph::communication::bolt::Value> decoded_summary;
+  for (const auto &kv : summary) {
+    auto maybe_value = ToBoltValue(kv.second, *db->storage(), memgraph::storage::View::NEW);
+    if (maybe_value.HasError()) {
+      switch (maybe_value.GetError()) {
+        case memgraph::storage::Error::DELETED_OBJECT:
+        case memgraph::storage::Error::SERIALIZATION_ERROR:
+        case memgraph::storage::Error::VERTEX_HAS_EDGES:
+        case memgraph::storage::Error::PROPERTIES_DISABLED:
+        case memgraph::storage::Error::NONEXISTENT_OBJECT:
+          throw memgraph::communication::bolt::ClientError("Unexpected storage error when streaming summary.");
+      }
+    }
+    decoded_summary.emplace(kv.first, std::move(*maybe_value));
+  }
+  // Add this memgraph instance run_id, received from telemetry
+  // This is sent with every query, instead of only on bolt init inside
+  // communication/bolt/v1/states/init.hpp because neo4jdriver does not
+  // read the init message.
+  decoded_summary.emplace("run_id", memgraph::glue::run_id_);
+
+  return decoded_summary;
+}
+}  // namespace memgraph::glue

src/glue/SessionHL.hpp

@@ -0,0 +1,96 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+#pragma once
+
+#include "audit/log.hpp"
+#include "auth/auth.hpp"
+#include "communication/v2/server.hpp"
+#include "communication/v2/session.hpp"
+#include "dbms/database.hpp"
+#include "query/interpreter.hpp"
+
+namespace memgraph::glue {
+
+class SessionHL final : public memgraph::communication::bolt::Session<memgraph::communication::v2::InputStream,
+                                                                      memgraph::communication::v2::OutputStream> {
+ public:
+  SessionHL(memgraph::query::InterpreterContext *interpreter_context,
+            const memgraph::communication::v2::ServerEndpoint &endpoint,
+            memgraph::communication::v2::InputStream *input_stream,
+            memgraph::communication::v2::OutputStream *output_stream,
+            memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth
+#ifdef MG_ENTERPRISE
+            ,
+            memgraph::audit::Log *audit_log
+#endif
+  );
+
+  ~SessionHL() override;
+
+  SessionHL(const SessionHL &) = delete;
+  SessionHL &operator=(const SessionHL &) = delete;
+  SessionHL(SessionHL &&) = delete;
+  SessionHL &operator=(SessionHL &&) = delete;
+
+  void Configure(const std::map<std::string, memgraph::communication::bolt::Value> &run_time_info) override;
+
+  using TEncoder = memgraph::communication::bolt::Encoder<
+      memgraph::communication::bolt::ChunkedEncoderBuffer<memgraph::communication::v2::OutputStream>>;
+
+  void BeginTransaction(const std::map<std::string, memgraph::communication::bolt::Value> &extra) override;
+
+  void CommitTransaction() override;
+
+  void RollbackTransaction() override;
+
+  std::pair<std::vector<std::string>, std::optional<int>> Interpret(
+      const std::string &query, const std::map<std::string, memgraph::communication::bolt::Value> &params,
+      const std::map<std::string, memgraph::communication::bolt::Value> &extra) override;
+
+  std::map<std::string, memgraph::communication::bolt::Value> Pull(TEncoder *encoder, std::optional<int> n,
+                                                                   std::optional<int> qid) override;
+
+  std::map<std::string, memgraph::communication::bolt::Value> Discard(std::optional<int> n,
+                                                                      std::optional<int> qid) override;
+
+  void Abort() override;
+
+  // Called during Init
+  bool Authenticate(const std::string &username, const std::string &password) override;
+
+  std::optional<std::string> GetServerNameForInit() override;
+
+  std::string GetDatabaseName() const override;
+
+ private:
+  std::map<std::string, memgraph::communication::bolt::Value> DecodeSummary(
+      const std::map<std::string, memgraph::query::TypedValue> &summary);
+
+  /**
+   * @brief Get the user's default database
+   *
+   * @return std::string
+   */
+  std::string GetDefaultDB();
+
+  memgraph::query::InterpreterContext *interpreter_context_;
+  memgraph::query::Interpreter interpreter_;
+  std::optional<memgraph::auth::User> user_;
+#ifdef MG_ENTERPRISE
+  memgraph::audit::Log *audit_log_;
+  bool in_explicit_db_{false};  //!< If true, the user has defined the database to use via metadata
+#endif
+  memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth_;
+  memgraph::communication::v2::ServerEndpoint endpoint_;
+  std::optional<std::string> implicit_db_;
+};
+
+}  // namespace memgraph::glue

src/glue/auth_checker.cpp

@@ -94,20 +94,24 @@ std::unique_ptr<memgraph::query::FineGrainedAuthChecker> AuthChecker::GetFineGra
     return {};
   }
   try {
-    auto locked_auth = auth_->Lock();
-    if (username != user_.username()) {
-      auto maybe_user = locked_auth->GetUser(username);
+    auto user = user_.Lock();
+    if (username != user->username()) {
+      auto maybe_user = auth_->ReadLock()->GetUser(username);
       if (!maybe_user) {
         throw memgraph::query::QueryRuntimeException("User '{}' doesn't exist .", username);
       }
-      user_ = std::move(*maybe_user);
+      *user = std::move(*maybe_user);
     }
-    return std::make_unique<memgraph::glue::FineGrainedAuthChecker>(user_, dba);
+    return std::make_unique<memgraph::glue::FineGrainedAuthChecker>(*user, dba);
 
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
 }
+
+void AuthChecker::ClearCache() const {
+  user_.WithLock([](auto &user) mutable { user = {}; });
+}
 #endif
 
 bool AuthChecker::IsUserAuthorized(const memgraph::auth::User &user,

src/glue/auth_checker.hpp

@@ -16,6 +16,7 @@
 #include "query/auth_checker.hpp"
 #include "query/db_accessor.hpp"
 #include "query/frontend/ast/ast.hpp"
+#include "utils/spin_lock.hpp"
 
 namespace memgraph::glue {
 
@@ -32,6 +33,8 @@ class AuthChecker : public query::AuthChecker {
   std::unique_ptr<memgraph::query::FineGrainedAuthChecker> GetFineGrainedAuthChecker(
       const std::string &username, const memgraph::query::DbAccessor *dba) const override;
 
+  void ClearCache() const override;
+
 #endif
   [[nodiscard]] static bool IsUserAuthorized(const memgraph::auth::User &user,
                                              const std::vector<memgraph::query::AuthQuery::Privilege> &privileges,
@@ -39,7 +42,7 @@ class AuthChecker : public query::AuthChecker {
 
  private:
   memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth_;
-  mutable auth::User user_;
+  mutable memgraph::utils::Synchronized<auth::User, memgraph::utils::SpinLock> user_;  // cached user
 };
 #ifdef MG_ENTERPRISE
 class FineGrainedAuthChecker : public query::FineGrainedAuthChecker {

src/glue/auth_global.hpp

@@ -0,0 +1,16 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+namespace memgraph::glue {
+inline constexpr std::string_view kDefaultUserRoleRegex = "[a-zA-Z0-9_.+-@]+";
+}  // namespace memgraph::glue

src/glue/auth_handler.cpp

@@ -406,6 +406,14 @@ bool AuthQueryHandler::SetMainDatabase(const std::string &db, const std::string
     throw memgraph::query::QueryRuntimeException(e.what());
   }
 }
+
+void AuthQueryHandler::DeleteDatabase(std::string_view db) {
+  try {
+    auth_->Lock()->DeleteDatabase(std::string(db));
+  } catch (const memgraph::auth::AuthException &e) {
+    throw memgraph::query::QueryRuntimeException(e.what());
+  }
+}
 #endif
 
 bool AuthQueryHandler::DropRole(const std::string &rolename) {

src/glue/auth_handler.hpp

@@ -14,15 +14,14 @@
 #include <regex>
 
 #include "auth/auth.hpp"
+#include "auth_global.hpp"
 #include "glue/auth.hpp"
 #include "license/license.hpp"
-#include "query/interpreter.hpp"
+#include "query/auth_query_handler.hpp"
 #include "utils/string.hpp"
 
 namespace memgraph::glue {
 
-inline constexpr std::string_view kDefaultUserRoleRegex = "[a-zA-Z0-9_.+-@]+";
-
 class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
   memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth_;
   std::string name_regex_string_;
@@ -46,6 +45,8 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
   std::vector<std::vector<memgraph::query::TypedValue>> GetDatabasePrivileges(const std::string &username) override;
 
   bool SetMainDatabase(const std::string &db, const std::string &username) override;
+
+  void DeleteDatabase(std::string_view db) override;
 #endif
 
   bool CreateRole(const std::string &rolename) override;

src/glue/communication.cpp

@@ -151,8 +151,8 @@ storage::Result<communication::bolt::Vertex> ToBoltVertex(const storage::VertexA
     properties[db.PropertyToName(prop.first)] = ToBoltValue(prop.second);
   }
   // Introduced in Bolt v5 (for now just send the ID)
-  const auto element_id = std::to_string(id.AsInt());
-  return communication::bolt::Vertex{id, labels, properties, element_id};
+  auto element_id = std::to_string(id.AsInt());
+  return communication::bolt::Vertex{id, std::move(labels), std::move(properties), std::move(element_id)};
 }
 
 storage::Result<communication::bolt::Edge> ToBoltEdge(const storage::EdgeAccessor &edge, const storage::Storage &db,
@@ -171,7 +171,8 @@ storage::Result<communication::bolt::Edge> ToBoltEdge(const storage::EdgeAccesso
   const auto element_id = std::to_string(id.AsInt());
   const auto from_element_id = std::to_string(from.AsInt());
   const auto to_element_id = std::to_string(to.AsInt());
-  return communication::bolt::Edge{id, from, to, type, properties, element_id, from_element_id, to_element_id};
+  return communication::bolt::Edge{
+      id, from, to, std::move(type), std::move(properties), element_id, from_element_id, to_element_id};
 }
 
 storage::Result<communication::bolt::Path> ToBoltPath(const query::Path &path, const storage::Storage &db,

src/glue/run_id.cpp

@@ -0,0 +1,15 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include "glue/run_id.hpp"
+#include "utils/uuid.hpp"
+
+const std::string memgraph::glue::run_id_ = memgraph::utils::GenerateUUID();

src/glue/run_id.hpp

@@ -0,0 +1,16 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+namespace memgraph::glue {
+extern const std::string run_id_;
+}  // namespace memgraph::glue

src/helpers.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -63,7 +63,7 @@ inline void LoadConfig(const std::string &product_name) {
   delete[] custom_argv;
 }
 
-std::pair<std::string, std::string> LoadUsernameAndPassword(const std::string &pass_file) {
+inline std::pair<std::string, std::string> LoadUsernameAndPassword(const std::string &pass_file) {
   std::ifstream file(pass_file);
   if (file.fail()) {
     spdlog::warn("Problem with opening MG_PASSFILE, memgraph server will start without user");

src/http_handlers/metrics.hpp

@@ -47,10 +47,9 @@ struct MetricsResponse {
   std::vector<std::tuple<std::string, std::string, uint64_t>> event_histograms{};
 };
 
-template <typename TSessionContext>
 class MetricsService {
  public:
-  explicit MetricsService(TSessionContext *session_context) : db_(session_context->interpreter_context->db.get()) {}
+  explicit MetricsService(storage::Storage *storage) : db_(storage) {}
 
   nlohmann::json GetMetricsJSON() {
     auto response = GetMetrics();
@@ -98,9 +97,10 @@ class MetricsService {
     return metrics_response;
   }
 
-  auto GetEventCounters() {
+  inline static std::vector<std::tuple<std::string, std::string, uint64_t>> GetEventCounters() {
     // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
     std::vector<std::tuple<std::string, std::string, uint64_t>> event_counters{};
+    event_counters.reserve(memgraph::metrics::CounterEnd());
 
     for (auto i = 0; i < memgraph::metrics::CounterEnd(); i++) {
       event_counters.emplace_back(memgraph::metrics::GetCounterName(i), memgraph::metrics::GetCounterType(i),
@@ -110,9 +110,10 @@ class MetricsService {
     return event_counters;
   }
 
-  auto GetEventGauges() {
+  inline static std::vector<std::tuple<std::string, std::string, uint64_t>> GetEventGauges() {
     // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
     std::vector<std::tuple<std::string, std::string, uint64_t>> event_gauges{};
+    event_gauges.reserve(memgraph::metrics::GaugeEnd());
 
     for (auto i = 0; i < memgraph::metrics::GaugeEnd(); i++) {
       event_gauges.emplace_back(memgraph::metrics::GetGaugeName(i), memgraph::metrics::GetGaugeType(i),
@@ -122,7 +123,7 @@ class MetricsService {
     return event_gauges;
   }
 
-  auto GetEventHistograms() {
+  inline static std::vector<std::tuple<std::string, std::string, uint64_t>> GetEventHistograms() {
     // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
     std::vector<std::tuple<std::string, std::string, uint64_t>> event_histograms{};
 
@@ -141,10 +142,11 @@ class MetricsService {
   }
 };
 
-template <typename TSessionContext>
+// TODO: Should this be inside Database?
+// Raw pointer could be dangerous
 class MetricsRequestHandler final {
  public:
-  explicit MetricsRequestHandler(TSessionContext *session_context) : service_(session_context) {
+  explicit MetricsRequestHandler(storage::Storage *storage) : service_(storage) {
     spdlog::info("Basic request handler started!");
   }
 
@@ -206,6 +208,6 @@ class MetricsRequestHandler final {
   }
 
  private:
-  MetricsService<TSessionContext> service_;
+  MetricsService service_;
 };
 }  // namespace memgraph::http

src/io/network/endpoint.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -91,7 +91,6 @@ std::string Endpoint::SocketAddress() const {
   return ip_address + ":" + std::to_string(port);
 }
 
-Endpoint::Endpoint() {}
 Endpoint::Endpoint(std::string ip_address, uint16_t port) : address(std::move(ip_address)), port(port) {
   IpFamily ip_family = GetIpFamily(address);
   if (ip_family == IpFamily::NONE) {

src/io/network/endpoint.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -25,8 +25,13 @@ namespace memgraph::io::network {
  * connection address.
  */
 struct Endpoint {
-  Endpoint();
+  Endpoint() = default;
   Endpoint(std::string ip_address, uint16_t port);
+  Endpoint(Endpoint const &) = default;
+  Endpoint(Endpoint &&) noexcept = default;
+  Endpoint &operator=(Endpoint const &) = default;
+  Endpoint &operator=(Endpoint &&) noexcept = default;
+  ~Endpoint() = default;
 
   enum class IpFamily : std::uint8_t { NONE, IP4, IP6 };
 

src/kvstore/kvstore.cpp

@@ -72,7 +72,7 @@ std::optional<std::string> KVStore::Get(const std::string &key) const noexcept {
   return value;
 }
 
-bool KVStore::Delete(const std::string &key) {
+bool KVStore::Delete(std::string_view key) {
   auto s = pimpl_->db->Delete(rocksdb::WriteOptions(), key);
   return s.ok();
 }

src/kvstore/kvstore.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -91,7 +91,7 @@ class KVStore final {
    *         true if the key doesn't exist and underlying storage
    *         didn't encounter any error.
    */
-  bool Delete(const std::string &key);
+  bool Delete(std::string_view key);
 
   /**
    * Deletes the keys and corresponding values from storage.

src/mg_import_csv.cpp

@@ -20,6 +20,7 @@
 #include <unordered_map>
 
 #include "helpers.hpp"
+#include "storage/v2/config.hpp"
 #include "storage/v2/edge_accessor.hpp"
 #include "storage/v2/inmemory/storage.hpp"
 #include "utils/exceptions.hpp"
@@ -700,13 +701,14 @@ int main(int argc, char *argv[]) {
   }
 
   std::unordered_map<NodeId, memgraph::storage::Gid> node_id_map;
-  std::unique_ptr<memgraph::storage::Storage> store{new memgraph::storage::InMemoryStorage{{
+  auto store = std::make_unique<memgraph::storage::InMemoryStorage>(memgraph::storage::Config{
+
       .items = {.properties_on_edges = FLAGS_storage_properties_on_edges},
       .durability = {.storage_directory = FLAGS_data_directory,
                      .recover_on_startup = false,
                      .snapshot_wal_mode = memgraph::storage::Config::Durability::SnapshotWalMode::DISABLED,
                      .snapshot_on_exit = true},
-  }}};
+  });
 
   memgraph::utils::Timer load_timer;
 

src/query/CMakeLists.txt

@@ -36,11 +36,25 @@ set(mg_query_sources
     trigger_context.cpp
     typed_value.cpp
     graph.cpp
-    db_accessor.cpp)
+    db_accessor.cpp
+    auth_query_handler.cpp
+        interpreter_context.cpp)
 
 add_library(mg-query STATIC ${mg_query_sources})
 target_include_directories(mg-query PUBLIC ${CMAKE_SOURCE_DIR}/include)
-target_link_libraries(mg-query PUBLIC dl cppitertools Python3::Python mg-integrations-pulsar mg-integrations-kafka mg-storage-v2 mg-license mg-utils mg-kvstore mg-memory mg::csv)
+target_link_libraries(mg-query PUBLIC dl
+                                      cppitertools
+                                      Python3::Python
+                                      mg-integrations-pulsar
+                                      mg-integrations-kafka
+                                      mg-storage-v2
+                                      mg-license
+                                      mg-utils
+                                      mg-kvstore
+                                      mg-memory
+                                      mg::csv
+                                      mg-flags
+                                      mg-dbms)
 if(NOT "${MG_PYTHON_PATH}" STREQUAL "")
     set(Python3_ROOT_DIR "${MG_PYTHON_PATH}")
 endif()

src/query/auth_checker.hpp

@@ -11,7 +11,11 @@
 
 #pragma once
 
-#include "query/db_accessor.hpp"
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
 #include "query/frontend/ast/ast.hpp"
 #include "storage/v2/id_types.hpp"
 
@@ -19,17 +23,21 @@ namespace memgraph::query {
 
 class FineGrainedAuthChecker;
 
+class DbAccessor;
+
 class AuthChecker {
  public:
   virtual ~AuthChecker() = default;
 
   [[nodiscard]] virtual bool IsUserAuthorized(const std::optional<std::string> &username,
-                                              const std::vector<query::AuthQuery::Privilege> &privileges,
+                                              const std::vector<AuthQuery::Privilege> &privileges,
                                               const std::string &db_name) const = 0;
 
 #ifdef MG_ENTERPRISE
   [[nodiscard]] virtual std::unique_ptr<FineGrainedAuthChecker> GetFineGrainedAuthChecker(
-      const std::string &username, const memgraph::query::DbAccessor *db_accessor) const = 0;
+      const std::string &username, const DbAccessor *db_accessor) const = 0;
+
+  virtual void ClearCache() const = 0;
 #endif
 };
 #ifdef MG_ENTERPRISE
@@ -37,73 +45,73 @@ class FineGrainedAuthChecker {
  public:
   virtual ~FineGrainedAuthChecker() = default;
 
-  [[nodiscard]] virtual bool Has(const query::VertexAccessor &vertex, memgraph::storage::View view,
-                                 query::AuthQuery::FineGrainedPrivilege fine_grained_privilege) const = 0;
+  [[nodiscard]] virtual bool Has(const VertexAccessor &vertex, memgraph::storage::View view,
+                                 AuthQuery::FineGrainedPrivilege fine_grained_privilege) const = 0;
 
-  [[nodiscard]] virtual bool Has(const query::EdgeAccessor &edge,
-                                 query::AuthQuery::FineGrainedPrivilege fine_grained_privilege) const = 0;
+  [[nodiscard]] virtual bool Has(const EdgeAccessor &edge,
+                                 AuthQuery::FineGrainedPrivilege fine_grained_privilege) const = 0;
 
   [[nodiscard]] virtual bool Has(const std::vector<memgraph::storage::LabelId> &labels,
-                                 query::AuthQuery::FineGrainedPrivilege fine_grained_privilege) const = 0;
+                                 AuthQuery::FineGrainedPrivilege fine_grained_privilege) const = 0;
 
   [[nodiscard]] virtual bool Has(const memgraph::storage::EdgeTypeId &edge_type,
-                                 query::AuthQuery::FineGrainedPrivilege fine_grained_privilege) const = 0;
+                                 AuthQuery::FineGrainedPrivilege fine_grained_privilege) const = 0;
 
   [[nodiscard]] virtual bool HasGlobalPrivilegeOnVertices(
-      memgraph::query::AuthQuery::FineGrainedPrivilege fine_grained_privilege) const = 0;
+      AuthQuery::FineGrainedPrivilege fine_grained_privilege) const = 0;
 
   [[nodiscard]] virtual bool HasGlobalPrivilegeOnEdges(
-      memgraph::query::AuthQuery::FineGrainedPrivilege fine_grained_privilege) const = 0;
+      AuthQuery::FineGrainedPrivilege fine_grained_privilege) const = 0;
 };
 
-class AllowEverythingFineGrainedAuthChecker final : public query::FineGrainedAuthChecker {
+class AllowEverythingFineGrainedAuthChecker final : public FineGrainedAuthChecker {
  public:
   bool Has(const VertexAccessor & /*vertex*/, const memgraph::storage::View /*view*/,
-           const query::AuthQuery::FineGrainedPrivilege /*fine_grained_privilege*/) const override {
+           const AuthQuery::FineGrainedPrivilege /*fine_grained_privilege*/) const override {
     return true;
   }
 
-  bool Has(const memgraph::query::EdgeAccessor & /*edge*/,
-           const query::AuthQuery::FineGrainedPrivilege /*fine_grained_privilege*/) const override {
+  bool Has(const EdgeAccessor & /*edge*/,
+           const AuthQuery::FineGrainedPrivilege /*fine_grained_privilege*/) const override {
     return true;
   }
 
   bool Has(const std::vector<memgraph::storage::LabelId> & /*labels*/,
-           const query::AuthQuery::FineGrainedPrivilege /*fine_grained_privilege*/) const override {
+           const AuthQuery::FineGrainedPrivilege /*fine_grained_privilege*/) const override {
     return true;
   }
 
   bool Has(const memgraph::storage::EdgeTypeId & /*edge_type*/,
-           const query::AuthQuery::FineGrainedPrivilege /*fine_grained_privilege*/) const override {
+           const AuthQuery::FineGrainedPrivilege /*fine_grained_privilege*/) const override {
     return true;
   }
 
-  bool HasGlobalPrivilegeOnVertices(
-      const memgraph::query::AuthQuery::FineGrainedPrivilege /*fine_grained_privilege*/) const override {
+  bool HasGlobalPrivilegeOnVertices(const AuthQuery::FineGrainedPrivilege /*fine_grained_privilege*/) const override {
     return true;
   }
 
-  bool HasGlobalPrivilegeOnEdges(
-      const memgraph::query::AuthQuery::FineGrainedPrivilege /*fine_grained_privilege*/) const override {
+  bool HasGlobalPrivilegeOnEdges(const AuthQuery::FineGrainedPrivilege /*fine_grained_privilege*/) const override {
     return true;
   }
-};  // namespace memgraph::query
+};
 #endif
 
-class AllowEverythingAuthChecker final : public query::AuthChecker {
+class AllowEverythingAuthChecker final : public AuthChecker {
  public:
   bool IsUserAuthorized(const std::optional<std::string> & /*username*/,
-                        const std::vector<query::AuthQuery::Privilege> & /*privileges*/,
+                        const std::vector<AuthQuery::Privilege> & /*privileges*/,
                         const std::string & /*db*/) const override {
     return true;
   }
 
 #ifdef MG_ENTERPRISE
   std::unique_ptr<FineGrainedAuthChecker> GetFineGrainedAuthChecker(const std::string & /*username*/,
-                                                                    const query::DbAccessor * /*dba*/) const override {
+                                                                    const DbAccessor * /*dba*/) const override {
     return std::make_unique<AllowEverythingFineGrainedAuthChecker>();
   }
+
+  void ClearCache() const override {}
 #endif
-};  // namespace memgraph::query
+};
 
 }  // namespace memgraph::query

src/query/auth_query_handler.cpp

@@ -0,0 +1,12 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include "query/auth_query_handler.hpp"

src/query/auth_query_handler.hpp

@@ -0,0 +1,126 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "query/frontend/ast/ast.hpp"  // overkill
+#include "query/typed_value.hpp"
+
+namespace memgraph::query {
+
+class AuthQueryHandler {
+ public:
+  AuthQueryHandler() = default;
+  virtual ~AuthQueryHandler() = default;
+
+  AuthQueryHandler(const AuthQueryHandler &) = delete;
+  AuthQueryHandler(AuthQueryHandler &&) = delete;
+  AuthQueryHandler &operator=(const AuthQueryHandler &) = delete;
+  AuthQueryHandler &operator=(AuthQueryHandler &&) = delete;
+
+  /// Return false if the user already exists.
+  /// @throw QueryRuntimeException if an error ocurred.
+  virtual bool CreateUser(const std::string &username, const std::optional<std::string> &password) = 0;
+
+  /// Return false if the user does not exist.
+  /// @throw QueryRuntimeException if an error ocurred.
+  virtual bool DropUser(const std::string &username) = 0;
+
+  /// @throw QueryRuntimeException if an error ocurred.
+  virtual void SetPassword(const std::string &username, const std::optional<std::string> &password) = 0;
+
+#ifdef MG_ENTERPRISE
+  /// Return true if access revoked successfully
+  /// @throw QueryRuntimeException if an error ocurred.
+  virtual bool RevokeDatabaseFromUser(const std::string &db, const std::string &username) = 0;
+
+  /// Return true if access granted successfully
+  /// @throw QueryRuntimeException if an error ocurred.
+  virtual bool GrantDatabaseToUser(const std::string &db, const std::string &username) = 0;
+
+  /// Returns database access rights for the user
+  /// @throw QueryRuntimeException if an error ocurred.
+  virtual std::vector<std::vector<memgraph::query::TypedValue>> GetDatabasePrivileges(const std::string &username) = 0;
+
+  /// Return true if main database set successfully
+  /// @throw QueryRuntimeException if an error ocurred.
+  virtual bool SetMainDatabase(const std::string &db, const std::string &username) = 0;
+
+  /// Delete database from all users
+  /// @throw QueryRuntimeException if an error ocurred.
+  virtual void DeleteDatabase(std::string_view db) = 0;
+#endif
+
+  /// Return false if the role already exists.
+  /// @throw QueryRuntimeException if an error ocurred.
+  virtual bool CreateRole(const std::string &rolename) = 0;
+
+  /// Return false if the role does not exist.
+  /// @throw QueryRuntimeException if an error ocurred.
+  virtual bool DropRole(const std::string &rolename) = 0;
+
+  /// @throw QueryRuntimeException if an error ocurred.
+  virtual std::vector<memgraph::query::TypedValue> GetUsernames() = 0;
+
+  /// @throw QueryRuntimeException if an error ocurred.
+  virtual std::vector<memgraph::query::TypedValue> GetRolenames() = 0;
+
+  /// @throw QueryRuntimeException if an error ocurred.
+  virtual std::optional<std::string> GetRolenameForUser(const std::string &username) = 0;
+
+  /// @throw QueryRuntimeException if an error ocurred.
+  virtual std::vector<memgraph::query::TypedValue> GetUsernamesForRole(const std::string &rolename) = 0;
+
+  /// @throw QueryRuntimeException if an error ocurred.
+  virtual void SetRole(const std::string &username, const std::string &rolename) = 0;
+
+  /// @throw QueryRuntimeException if an error ocurred.
+  virtual void ClearRole(const std::string &username) = 0;
+
+  virtual std::vector<std::vector<memgraph::query::TypedValue>> GetPrivileges(const std::string &user_or_role) = 0;
+
+  /// @throw QueryRuntimeException if an error ocurred.
+  virtual void GrantPrivilege(
+      const std::string &user_or_role, const std::vector<memgraph::query::AuthQuery::Privilege> &privileges
+#ifdef MG_ENTERPRISE
+      ,
+      const std::vector<std::unordered_map<memgraph::query::AuthQuery::FineGrainedPrivilege, std::vector<std::string>>>
+          &label_privileges,
+
+      const std::vector<std::unordered_map<memgraph::query::AuthQuery::FineGrainedPrivilege, std::vector<std::string>>>
+          &edge_type_privileges
+#endif
+      ) = 0;
+
+  /// @throw QueryRuntimeException if an error ocurred.
+  virtual void DenyPrivilege(const std::string &user_or_role,
+                             const std::vector<memgraph::query::AuthQuery::Privilege> &privileges) = 0;
+
+  /// @throw QueryRuntimeException if an error ocurred.
+  virtual void RevokePrivilege(
+      const std::string &user_or_role, const std::vector<memgraph::query::AuthQuery::Privilege> &privileges
+#ifdef MG_ENTERPRISE
+      ,
+      const std::vector<std::unordered_map<memgraph::query::AuthQuery::FineGrainedPrivilege, std::vector<std::string>>>
+          &label_privileges,
+
+      const std::vector<std::unordered_map<memgraph::query::AuthQuery::FineGrainedPrivilege, std::vector<std::string>>>
+          &edge_type_privileges
+#endif
+      ) = 0;
+};
+
+}  // namespace memgraph::query

src/query/config.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -19,8 +19,6 @@ struct InterpreterConfig {
     bool allow_load_csv{true};
   } query;
 
-  // The default execution timeout is 10 minutes.
-  double execution_timeout_sec{600.0};
   // The same as \ref memgraph::storage::replication::ReplicationClientConfig
   std::chrono::seconds replication_replica_check_frequency{1};
 

src/query/context.hpp

@@ -51,6 +51,8 @@ struct EvaluationContext {
   /// All counters generated by `counter` function, mutable because the function
   /// modifies the values
   mutable std::unordered_map<std::string, int64_t> counters{};
+  /// Property lookup cache ({symbol: {property_id: property_value, ...}, ...})
+  mutable std::unordered_map<int32_t, std::map<storage::PropertyId, storage::PropertyValue>> property_lookups_cache{};
 };
 
 inline std::vector<storage::PropertyId> NamesToProperties(const std::vector<std::string> &property_names,

src/query/cypher_query_interpreter.cpp

@@ -10,6 +10,8 @@
 // licenses/APL.txt.
 
 #include "query/cypher_query_interpreter.hpp"
+#include "query/frontend/ast/cypher_main_visitor.hpp"
+#include "query/frontend/opencypher/parser.hpp"
 
 // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_bool(query_cost_planner, true, "Use the cost-estimating query planner.");
@@ -76,7 +78,7 @@ ParsedQuery ParseQuery(const std::string &query_string, const std::map<std::stri
 
     // Convert the ANTLR4 parse tree into an AST.
     AstStorage ast_storage;
-    frontend::ParsingContext context{true};
+    frontend::ParsingContext context{.is_query_cached = true};
     frontend::CypherMainVisitor visitor(context, &ast_storage);
 
     visitor.visit(parser->tree());

src/query/cypher_query_interpreter.hpp

@@ -12,8 +12,6 @@
 #pragma once
 
 #include "query/config.hpp"
-#include "query/frontend/ast/cypher_main_visitor.hpp"
-#include "query/frontend/opencypher/parser.hpp"
 #include "query/frontend/semantic/required_privileges.hpp"
 #include "query/frontend/semantic/symbol_generator.hpp"
 #include "query/frontend/stripped.hpp"

src/query/db_accessor.cpp

@@ -76,6 +76,24 @@ SubgraphDbAccessor::DetachRemoveVertex(  // NOLINT(readability-convert-member-fu
       "Vertex holds only partial information about edges. Cannot detach delete safely while using projected graph."};
 }
 
+storage::Result<EdgeAccessor> SubgraphDbAccessor::EdgeSetFrom(EdgeAccessor *edge, SubgraphVertexAccessor *new_from) {
+  VertexAccessor *new_from_impl = &new_from->impl_;
+  if (!this->graph_->ContainsVertex(*new_from_impl)) {
+    throw std::logic_error{"Projected graph must contain the new `from` vertex!"};
+  }
+  auto result = db_accessor_.EdgeSetFrom(edge, new_from_impl);
+  return result;
+}
+
+storage::Result<EdgeAccessor> SubgraphDbAccessor::EdgeSetTo(EdgeAccessor *edge, SubgraphVertexAccessor *new_to) {
+  VertexAccessor *new_to_impl = &new_to->impl_;
+  if (!this->graph_->ContainsVertex(*new_to_impl)) {
+    throw std::logic_error{"Projected graph must contain the new `to` vertex!"};
+  }
+  auto result = db_accessor_.EdgeSetTo(edge, new_to_impl);
+  return result;
+}
+
 storage::Result<std::optional<VertexAccessor>> SubgraphDbAccessor::RemoveVertex(
     SubgraphVertexAccessor *subgraphvertex_accessor) {
   VertexAccessor *vertex_accessor = &subgraphvertex_accessor->impl_;
@@ -111,10 +129,10 @@ query::Graph *SubgraphDbAccessor::getGraph() { return graph_; }
 
 VertexAccessor SubgraphVertexAccessor::GetVertexAccessor() const { return impl_; }
 
-auto SubgraphVertexAccessor::OutEdges(storage::View view) const -> decltype(impl_.OutEdges(view)) {
+storage::Result<EdgeVertexAccessorResult> SubgraphVertexAccessor::OutEdges(storage::View view) const {
   auto maybe_edges = impl_.impl_.OutEdges(view, {});
   if (maybe_edges.HasError()) return maybe_edges.GetError();
-  auto edges = std::move(*maybe_edges);
+  auto edges = std::move(maybe_edges->edges);
   const auto &graph_edges = graph_->edges();
 
   std::vector<storage::EdgeAccessor> filteredOutEdges;
@@ -125,13 +143,18 @@ auto SubgraphVertexAccessor::OutEdges(storage::View view) const -> decltype(impl
     }
   }
 
-  return iter::imap(VertexAccessor::MakeEdgeAccessor, std::move(filteredOutEdges));
+  std::vector<EdgeAccessor> resulting_edges;
+  resulting_edges.reserve(filteredOutEdges.size());
+  std::ranges::transform(filteredOutEdges, std::back_inserter(resulting_edges),
+                         [](auto const &edge) { return VertexAccessor::MakeEdgeAccessor(edge); });
+
+  return EdgeVertexAccessorResult{.edges = std::move(resulting_edges), .expanded_count = maybe_edges->expanded_count};
 }
 
-auto SubgraphVertexAccessor::InEdges(storage::View view) const -> decltype(impl_.InEdges(view)) {
+storage::Result<EdgeVertexAccessorResult> SubgraphVertexAccessor::InEdges(storage::View view) const {
   auto maybe_edges = impl_.impl_.InEdges(view, {});
   if (maybe_edges.HasError()) return maybe_edges.GetError();
-  auto edges = std::move(*maybe_edges);
+  auto edges = std::move(maybe_edges->edges);
   const auto &graph_edges = graph_->edges();
 
   std::vector<storage::EdgeAccessor> filteredOutEdges;
@@ -142,7 +165,12 @@ auto SubgraphVertexAccessor::InEdges(storage::View view) const -> decltype(impl_
     }
   }
 
-  return iter::imap(VertexAccessor::MakeEdgeAccessor, std::move(filteredOutEdges));
+  std::vector<EdgeAccessor> resulting_edges;
+  resulting_edges.reserve(filteredOutEdges.size());
+  std::ranges::transform(filteredOutEdges, std::back_inserter(resulting_edges),
+                         [](auto const &edge) { return VertexAccessor::MakeEdgeAccessor(edge); });
+
+  return EdgeVertexAccessorResult{.edges = std::move(resulting_edges), .expanded_count = maybe_edges->expanded_count};
 }
 
 }  // namespace memgraph::query

src/query/db_accessor.hpp

@@ -12,6 +12,7 @@
 #pragma once
 
 #include <optional>
+#include <ranges>
 
 #include <cppitertools/filter.hpp>
 #include <cppitertools/imap.hpp>
@@ -21,31 +22,13 @@
 #include "storage/v2/id_types.hpp"
 #include "storage/v2/property_value.hpp"
 #include "storage/v2/result.hpp"
-#include "storage/v2/storage_mode.hpp"
-#include "utils/pmr/unordered_set.hpp"
-#include "utils/variant_helpers.hpp"
-
-///////////////////////////////////////////////////////////
-// Our communication layer and query engine don't mix
-// very well on Centos because OpenSSL version available
-// on Centos 7 include  libkrb5 which has brilliant macros
-// called TRUE and FALSE. For more detailed explanation go
-// to memgraph.cpp.
-//
-// Because of the replication storage now uses some form of
-// communication so we have some unwanted macros.
-// This cannot be avoided by simple include orderings so we
-// simply undefine those macros as we're sure that libkrb5
-// won't and can't be used anywhere in the query engine.
 #include "storage/v2/storage.hpp"
-
-#undef FALSE
-#undef TRUE
-///////////////////////////////////////////////////////////
-
+#include "storage/v2/storage_mode.hpp"
 #include "storage/v2/view.hpp"
 #include "utils/bound.hpp"
 #include "utils/exceptions.hpp"
+#include "utils/pmr/unordered_set.hpp"
+#include "utils/variant_helpers.hpp"
 
 namespace memgraph::query {
 
@@ -94,6 +77,14 @@ class EdgeAccessor final {
 
   VertexAccessor From() const;
 
+  /// When edge is deleted and you are accessing To vertex
+  /// for_deleted_ flag will in this case be updated properly
+  VertexAccessor DeletedEdgeToVertex() const;
+
+  /// When edge is deleted and you are accessing From vertex
+  /// for_deleted_ flag will in this case be updated properly
+  VertexAccessor DeletedEdgeFromVertex() const;
+
   bool IsCycle() const;
 
   int64_t CypherId() const { return impl_.Gid().AsInt(); }
@@ -105,6 +96,11 @@ class EdgeAccessor final {
   bool operator!=(const EdgeAccessor &e) const noexcept { return !(*this == e); }
 };
 
+struct EdgeVertexAccessorResult {
+  std::vector<EdgeAccessor> edges;
+  int64_t expanded_count;
+};
+
 class VertexAccessor final {
  public:
   storage::VertexAccessor impl_;
@@ -153,37 +149,62 @@ class VertexAccessor final {
     return impl_.ClearProperties();
   }
 
-  auto InEdges(storage::View view, const std::vector<storage::EdgeTypeId> &edge_types) const
-      -> storage::Result<decltype(iter::imap(MakeEdgeAccessor, *impl_.InEdges(view)))> {
-    auto maybe_edges = impl_.InEdges(view, edge_types);
-    if (maybe_edges.HasError()) return maybe_edges.GetError();
-    return iter::imap(MakeEdgeAccessor, std::move(*maybe_edges));
+  storage::Result<EdgeVertexAccessorResult> InEdges(storage::View view,
+                                                    const std::vector<storage::EdgeTypeId> &edge_types) const {
+    auto maybe_result = impl_.InEdges(view, edge_types);
+    if (maybe_result.HasError()) return maybe_result.GetError();
+
+    std::vector<EdgeAccessor> edges;
+    edges.reserve((*maybe_result).edges.size());
+    std::ranges::transform((*maybe_result).edges, std::back_inserter(edges),
+                           [](auto const &edge) { return EdgeAccessor(edge); });
+
+    return EdgeVertexAccessorResult{.edges = edges, .expanded_count = (*maybe_result).expanded_count};
   }
 
-  auto InEdges(storage::View view) const { return InEdges(view, {}); }
+  storage::Result<EdgeVertexAccessorResult> InEdges(storage::View view) const { return InEdges(view, {}); }
 
-  auto InEdges(storage::View view, const std::vector<storage::EdgeTypeId> &edge_types, const VertexAccessor &dest) const
-      -> storage::Result<decltype(iter::imap(MakeEdgeAccessor, *impl_.InEdges(view)))> {
-    auto maybe_edges = impl_.InEdges(view, edge_types, &dest.impl_);
-    if (maybe_edges.HasError()) return maybe_edges.GetError();
-    return iter::imap(MakeEdgeAccessor, std::move(*maybe_edges));
+  storage::Result<EdgeVertexAccessorResult> InEdges(storage::View view,
+                                                    const std::vector<storage::EdgeTypeId> &edge_types,
+                                                    const VertexAccessor &dest) const {
+    auto maybe_result = impl_.InEdges(view, edge_types, &dest.impl_);
+    if (maybe_result.HasError()) return maybe_result.GetError();
+
+    std::vector<EdgeAccessor> edges;
+    edges.reserve((*maybe_result).edges.size());
+    std::ranges::transform((*maybe_result).edges, std::back_inserter(edges),
+                           [](auto const &edge) { return EdgeAccessor(edge); });
+
+    return EdgeVertexAccessorResult{.edges = edges, .expanded_count = (*maybe_result).expanded_count};
   }
 
-  auto OutEdges(storage::View view, const std::vector<storage::EdgeTypeId> &edge_types) const
-      -> storage::Result<decltype(iter::imap(MakeEdgeAccessor, *impl_.OutEdges(view)))> {
-    auto maybe_edges = impl_.OutEdges(view, edge_types);
-    if (maybe_edges.HasError()) return maybe_edges.GetError();
-    return iter::imap(MakeEdgeAccessor, std::move(*maybe_edges));
+  storage::Result<EdgeVertexAccessorResult> OutEdges(storage::View view,
+                                                     const std::vector<storage::EdgeTypeId> &edge_types) const {
+    auto maybe_result = impl_.OutEdges(view, edge_types);
+    if (maybe_result.HasError()) return maybe_result.GetError();
+
+    std::vector<EdgeAccessor> edges;
+    edges.reserve((*maybe_result).edges.size());
+    std::ranges::transform((*maybe_result).edges, std::back_inserter(edges),
+                           [](auto const &edge) { return EdgeAccessor(edge); });
+
+    return EdgeVertexAccessorResult{.edges = edges, .expanded_count = (*maybe_result).expanded_count};
   }
 
-  auto OutEdges(storage::View view) const { return OutEdges(view, {}); }
+  storage::Result<EdgeVertexAccessorResult> OutEdges(storage::View view) const { return OutEdges(view, {}); }
 
-  auto OutEdges(storage::View view, const std::vector<storage::EdgeTypeId> &edge_types,
-                const VertexAccessor &dest) const
-      -> storage::Result<decltype(iter::imap(MakeEdgeAccessor, *impl_.OutEdges(view)))> {
-    auto maybe_edges = impl_.OutEdges(view, edge_types, &dest.impl_);
-    if (maybe_edges.HasError()) return maybe_edges.GetError();
-    return iter::imap(MakeEdgeAccessor, std::move(*maybe_edges));
+  storage::Result<EdgeVertexAccessorResult> OutEdges(storage::View view,
+                                                     const std::vector<storage::EdgeTypeId> &edge_types,
+                                                     const VertexAccessor &dest) const {
+    auto maybe_result = impl_.OutEdges(view, edge_types, &dest.impl_);
+    if (maybe_result.HasError()) return maybe_result.GetError();
+
+    std::vector<EdgeAccessor> edges;
+    edges.reserve((*maybe_result).edges.size());
+    std::ranges::transform((*maybe_result).edges, std::back_inserter(edges),
+                           [](auto const &edge) { return EdgeAccessor(edge); });
+
+    return EdgeVertexAccessorResult{.edges = edges, .expanded_count = (*maybe_result).expanded_count};
   }
 
   storage::Result<size_t> InDegree(storage::View view) const { return impl_.InDegree(view); }
@@ -206,6 +227,12 @@ inline VertexAccessor EdgeAccessor::To() const { return VertexAccessor(impl_.ToV
 
 inline VertexAccessor EdgeAccessor::From() const { return VertexAccessor(impl_.FromVertex()); }
 
+inline VertexAccessor EdgeAccessor::DeletedEdgeToVertex() const { return VertexAccessor(impl_.DeletedEdgeToVertex()); }
+
+inline VertexAccessor EdgeAccessor::DeletedEdgeFromVertex() const {
+  return VertexAccessor(impl_.DeletedEdgeFromVertex());
+}
+
 inline bool EdgeAccessor::IsCycle() const { return To() == From(); }
 
 class SubgraphVertexAccessor final {
@@ -242,15 +269,24 @@ class SubgraphVertexAccessor final {
 
   storage::Gid Gid() const noexcept { return impl_.Gid(); }
 
+  storage::Result<size_t> InDegree(storage::View view) const { return impl_.InDegree(view); }
+
+  storage::Result<size_t> OutDegree(storage::View view) const { return impl_.OutDegree(view); }
+
   storage::Result<storage::PropertyValue> SetProperty(storage::PropertyId key, const storage::PropertyValue &value) {
     return impl_.SetProperty(key, value);
   }
+
+  storage::Result<std::vector<std::tuple<storage::PropertyId, storage::PropertyValue, storage::PropertyValue>>>
+  UpdateProperties(std::map<storage::PropertyId, storage::PropertyValue> &properties) const {
+    return impl_.UpdateProperties(properties);
+  }
+
   VertexAccessor GetVertexAccessor() const;
 };
 }  // namespace memgraph::query
 
 namespace std {
-
 template <>
 struct hash<memgraph::query::VertexAccessor> {
   size_t operator()(const memgraph::query::VertexAccessor &v) const { return std::hash<decltype(v.impl_)>{}(v.impl_); }
@@ -278,17 +314,17 @@ class VerticesIterable final {
         it_;
 
    public:
-    explicit Iterator(storage::VerticesIterable::Iterator it) : it_(it) {}
+    explicit Iterator(storage::VerticesIterable::Iterator it) : it_(std::move(it)) {}
     explicit Iterator(std::unordered_set<VertexAccessor, std::hash<VertexAccessor>, std::equal_to<void>,
                                          utils::Allocator<VertexAccessor>>::iterator it)
         : it_(it) {}
 
     VertexAccessor operator*() const {
-      return std::visit([](auto it_) { return VertexAccessor(*it_); }, it_);
+      return std::visit([](auto &it_) { return VertexAccessor(*it_); }, it_);
     }
 
     Iterator &operator++() {
-      std::visit([this](auto it_) { this->it_ = ++it_; }, it_);
+      std::visit([](auto &it_) { ++it_; }, it_);
       return *this;
     }
 
@@ -370,6 +406,18 @@ class DbAccessor final {
     return EdgeAccessor(*maybe_edge);
   }
 
+  storage::Result<EdgeAccessor> EdgeSetFrom(EdgeAccessor *edge, VertexAccessor *new_from) {
+    auto changed_edge = accessor_->EdgeSetFrom(&edge->impl_, &new_from->impl_);
+    if (changed_edge.HasError()) return storage::Result<EdgeAccessor>(changed_edge.GetError());
+    return EdgeAccessor(*changed_edge);
+  }
+
+  storage::Result<EdgeAccessor> EdgeSetTo(EdgeAccessor *edge, VertexAccessor *new_to) {
+    auto changed_edge = accessor_->EdgeSetTo(&edge->impl_, &new_to->impl_);
+    if (changed_edge.HasError()) return storage::Result<EdgeAccessor>(changed_edge.GetError());
+    return EdgeAccessor(*changed_edge);
+  }
+
   storage::Result<std::optional<EdgeAccessor>> RemoveEdge(EdgeAccessor *edge) {
     auto res = accessor_->DeleteEdge(&edge->impl_);
     if (res.HasError()) {
@@ -404,8 +452,8 @@ class DbAccessor final {
 
     std::vector<EdgeAccessor> deleted_edges;
     deleted_edges.reserve(edges.size());
-    std::transform(edges.begin(), edges.end(), std::back_inserter(deleted_edges),
-                   [](const auto &deleted_edge) { return EdgeAccessor{deleted_edge}; });
+    std::ranges::transform(edges, std::back_inserter(deleted_edges),
+                           [](const auto &deleted_edge) { return EdgeAccessor{deleted_edge}; });
 
     return std::make_optional<ReturnType>(vertex, std::move(deleted_edges));
   }
@@ -424,6 +472,53 @@ class DbAccessor final {
     return std::make_optional<VertexAccessor>(*value);
   }
 
+  storage::Result<std::optional<std::pair<std::vector<VertexAccessor>, std::vector<EdgeAccessor>>>> DetachDelete(
+      std::vector<VertexAccessor> nodes, std::vector<EdgeAccessor> edges, bool detach) {
+    using ReturnType = std::pair<std::vector<VertexAccessor>, std::vector<EdgeAccessor>>;
+
+    std::vector<storage::VertexAccessor *> nodes_impl;
+    std::vector<storage::EdgeAccessor *> edges_impl;
+
+    nodes_impl.reserve(nodes.size());
+    edges_impl.reserve(edges.size());
+
+    for (auto &vertex_accessor : nodes) {
+      accessor_->PrefetchOutEdges(vertex_accessor.impl_);
+      accessor_->PrefetchInEdges(vertex_accessor.impl_);
+
+      nodes_impl.push_back(&vertex_accessor.impl_);
+    }
+
+    for (auto &edge_accessor : edges) {
+      edges_impl.push_back(&edge_accessor.impl_);
+    }
+
+    auto res = accessor_->DetachDelete(std::move(nodes_impl), std::move(edges_impl), detach);
+    if (res.HasError()) {
+      return res.GetError();
+    }
+
+    const auto &value = res.GetValue();
+    if (!value) {
+      return std::optional<ReturnType>{};
+    }
+
+    const auto &[val_vertices, val_edges] = *value;
+
+    std::vector<VertexAccessor> deleted_vertices;
+    std::vector<EdgeAccessor> deleted_edges;
+
+    deleted_vertices.reserve(val_vertices.size());
+    deleted_edges.reserve(val_edges.size());
+
+    std::ranges::transform(val_vertices, std::back_inserter(deleted_vertices),
+                           [](const auto &deleted_vertex) { return VertexAccessor{deleted_vertex}; });
+    std::ranges::transform(val_edges, std::back_inserter(deleted_edges),
+                           [](const auto &deleted_edge) { return EdgeAccessor{deleted_edge}; });
+
+    return std::make_optional<ReturnType>(std::move(deleted_vertices), std::move(deleted_edges));
+  }
+
   storage::PropertyId NameToProperty(const std::string_view name) { return accessor_->NameToProperty(name); }
 
   storage::LabelId NameToLabel(const std::string_view name) { return accessor_->NameToLabel(name); }
@@ -539,6 +634,10 @@ class SubgraphDbAccessor final {
   storage::Result<EdgeAccessor> InsertEdge(SubgraphVertexAccessor *from, SubgraphVertexAccessor *to,
                                            const storage::EdgeTypeId &edge_type);
 
+  storage::Result<EdgeAccessor> EdgeSetFrom(EdgeAccessor *edge, SubgraphVertexAccessor *new_from);
+
+  storage::Result<EdgeAccessor> EdgeSetTo(EdgeAccessor *edge, SubgraphVertexAccessor *new_to);
+
   storage::Result<std::optional<std::pair<VertexAccessor, std::vector<EdgeAccessor>>>> DetachRemoveVertex(
       SubgraphVertexAccessor *vertex_accessor);
 

src/query/dump.cpp

@@ -487,8 +487,8 @@ PullPlanDump::PullChunk PullPlanDump::CreateEdgePullChunk() {
       }
       auto &maybe_edges = *maybe_edge_iterable;
       MG_ASSERT(maybe_edges.HasValue(), "Invalid database state!");
-      auto current_edge_iter = maybe_current_edge_iter ? *maybe_current_edge_iter : maybe_edges->begin();
-      for (; current_edge_iter != maybe_edges->end() && (!n || local_counter < *n); ++current_edge_iter) {
+      auto current_edge_iter = maybe_current_edge_iter ? *maybe_current_edge_iter : maybe_edges->edges.begin();
+      for (; current_edge_iter != maybe_edges->edges.end() && (!n || local_counter < *n); ++current_edge_iter) {
         std::ostringstream os;
         DumpEdge(&os, dba_, *current_edge_iter);
         stream->Result({TypedValue(os.str())});
@@ -496,7 +496,7 @@ PullPlanDump::PullChunk PullPlanDump::CreateEdgePullChunk() {
         ++local_counter;
       }
 
-      if (current_edge_iter != maybe_edges->end()) {
+      if (current_edge_iter != maybe_edges->edges.end()) {
         maybe_current_edge_iter.emplace(current_edge_iter);
         return std::nullopt;
       }

src/query/dump.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -38,7 +38,7 @@ struct PullPlanDump {
   using VertexAccessorIterableIterator = decltype(std::declval<VertexAccessorIterable>().begin());
 
   using EdgeAccessorIterable = decltype(std::declval<VertexAccessor>().OutEdges(storage::View::OLD));
-  using EdgeAccessorIterableIterator = decltype(std::declval<EdgeAccessorIterable>().GetValue().begin());
+  using EdgeAccessorIterableIterator = decltype(std::declval<EdgeAccessorIterable>().GetValue().edges.begin());
 
   VertexAccessorIterable vertices_iterable_;
   bool internal_index_created_ = false;

src/query/exceptions.hpp

@@ -158,9 +158,17 @@ class ExplicitTransactionUsageException : public QueryRuntimeException {
   using QueryRuntimeException::QueryRuntimeException;
 };
 
-/**
- * An exception for serialization error
- */
+class DatabaseContextRequiredException : public QueryRuntimeException {
+ public:
+  using QueryRuntimeException::QueryRuntimeException;
+};
+
+class WriteVertexOperationInEdgeImportModeException : public QueryException {
+ public:
+  WriteVertexOperationInEdgeImportModeException()
+      : QueryException("Write operations on vertices are forbidden while the edge import mode is active.") {}
+};
+
 class TransactionSerializationException : public QueryException {
  public:
   using QueryException::QueryException;
@@ -271,6 +279,12 @@ class StorageModeModificationInMulticommandTxException : public QueryException {
       : QueryException("Storage mode cannot be modified in multicommand transactions.") {}
 };
 
+class EdgeImportModeModificationInMulticommandTxException : public QueryException {
+ public:
+  EdgeImportModeModificationInMulticommandTxException()
+      : QueryException("Edge import mode cannot be modified in multicommand transactions.") {}
+};
+
 class CreateSnapshotInMulticommandTxException final : public QueryException {
  public:
   CreateSnapshotInMulticommandTxException()
@@ -282,6 +296,12 @@ class CreateSnapshotDisabledOnDiskStorage final : public QueryException {
   CreateSnapshotDisabledOnDiskStorage() : QueryException("In the on-disk storage mode data is already persistent.") {}
 };
 
+class EdgeImportModeQueryDisabledOnDiskStorage final : public QueryException {
+ public:
+  EdgeImportModeQueryDisabledOnDiskStorage()
+      : QueryException("Edge import mode is only allowed for on-disk storage mode.") {}
+};
+
 class SettingConfigInMulticommandTxException final : public QueryException {
  public:
   SettingConfigInMulticommandTxException()

src/query/frontend/ast/ast.cpp

@@ -285,4 +285,8 @@ constexpr utils::TypeInfo query::MultiDatabaseQuery::kType{utils::TypeId::AST_MU
 
 constexpr utils::TypeInfo query::ShowDatabasesQuery::kType{utils::TypeId::AST_SHOW_DATABASES, "ShowDatabasesQuery",
                                                            &query::Query::kType};
+
+constexpr utils::TypeInfo query::EdgeImportModeQuery::kType{utils::TypeId::AST_EDGE_IMPORT_MODE_QUERY,
+                                                            "EdgeImportModeQuery", &query::Query::kType};
+
 }  // namespace memgraph

src/query/frontend/ast/ast.hpp

@@ -1105,6 +1105,8 @@ class MapProjectionLiteral : public memgraph::query::BaseLiteral {
   DEFVISITABLE(ExpressionVisitor<void>);
   bool Accept(HierarchicalTreeVisitor &visitor) override {
     if (visitor.PreVisit(*this)) {
+      map_variable_->Accept(visitor);
+
       for (auto pair : elements_) {
         if (!pair.second) continue;
 
@@ -1184,6 +1186,8 @@ class PropertyLookup : public memgraph::query::Expression {
   static const utils::TypeInfo kType;
   const utils::TypeInfo &GetTypeInfo() const override { return kType; }
 
+  enum class EvaluationMode { GET_OWN_PROPERTY, GET_ALL_PROPERTIES };
+
   PropertyLookup() = default;
 
   DEFVISITABLE(ExpressionVisitor<TypedValue>);
@@ -1198,11 +1202,13 @@ class PropertyLookup : public memgraph::query::Expression {
 
   memgraph::query::Expression *expression_{nullptr};
   memgraph::query::PropertyIx property_;
+  memgraph::query::PropertyLookup::EvaluationMode evaluation_mode_{EvaluationMode::GET_OWN_PROPERTY};
 
   PropertyLookup *Clone(AstStorage *storage) const override {
     PropertyLookup *object = storage->Create<PropertyLookup>();
     object->expression_ = expression_ ? expression_->Clone(storage) : nullptr;
     object->property_ = storage->GetPropertyIx(property_.name);
+    object->evaluation_mode_ = evaluation_mode_;
     return object;
   }
 
@@ -3003,6 +3009,29 @@ class ReplicationQuery : public memgraph::query::Query {
   friend class AstStorage;
 };
 
+class EdgeImportModeQuery : public memgraph::query::Query {
+ public:
+  static const utils::TypeInfo kType;
+  const utils::TypeInfo &GetTypeInfo() const override { return kType; }
+
+  enum class Status { ACTIVE, INACTIVE };
+
+  EdgeImportModeQuery() = default;
+
+  DEFVISITABLE(QueryVisitor<void>);
+
+  memgraph::query::EdgeImportModeQuery::Status status_;
+
+  EdgeImportModeQuery *Clone(AstStorage *storage) const override {
+    auto *object = storage->Create<EdgeImportModeQuery>();
+    object->status_ = status_;
+    return object;
+  }
+
+ private:
+  friend class AstStorage;
+};
+
 class LockPathQuery : public memgraph::query::Query {
  public:
   static const utils::TypeInfo kType;

src/query/frontend/ast/ast_visitor.hpp

@@ -105,6 +105,7 @@ class TransactionQueueQuery;
 class Exists;
 class MultiDatabaseQuery;
 class ShowDatabasesQuery;
+class EdgeImportModeQuery;
 
 using TreeCompositeVisitor = utils::CompositeVisitor<
     SingleQuery, CypherUnion, NamedExpression, OrOperator, XorOperator, AndOperator, NotOperator, AdditionOperator,
@@ -143,6 +144,6 @@ class QueryVisitor
                             ConstraintQuery, DumpQuery, ReplicationQuery, LockPathQuery, FreeMemoryQuery, TriggerQuery,
                             IsolationLevelQuery, CreateSnapshotQuery, StreamQuery, SettingQuery, VersionQuery,
                             ShowConfigQuery, TransactionQueueQuery, StorageModeQuery, AnalyzeGraphQuery,
-                            MultiDatabaseQuery, ShowDatabasesQuery> {};
+                            MultiDatabaseQuery, ShowDatabasesQuery, EdgeImportModeQuery> {};
 
 }  // namespace memgraph::query

src/query/frontend/ast/cypher_main_visitor.cpp

@@ -269,6 +269,17 @@ antlrcpp::Any CypherMainVisitor::visitReplicationQuery(MemgraphCypher::Replicati
   return replication_query;
 }
 
+antlrcpp::Any CypherMainVisitor::visitEdgeImportModeQuery(MemgraphCypher::EdgeImportModeQueryContext *ctx) {
+  auto *edge_import_mode_query = storage_->Create<EdgeImportModeQuery>();
+  if (ctx->ACTIVE()) {
+    edge_import_mode_query->status_ = EdgeImportModeQuery::Status::ACTIVE;
+  } else {
+    edge_import_mode_query->status_ = EdgeImportModeQuery::Status::INACTIVE;
+  }
+  query_ = edge_import_mode_query;
+  return edge_import_mode_query;
+}
+
 antlrcpp::Any CypherMainVisitor::visitSetReplicationRole(MemgraphCypher::SetReplicationRoleContext *ctx) {
   auto *replication_query = storage_->Create<ReplicationQuery>();
   replication_query->action_ = ReplicationQuery::Action::SET_REPLICATION_ROLE;