Add initial toolchain build script

.github/workflows/daily_benchmark.yaml

@@ -67,7 +67,7 @@ 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 --num-workers-for-benchmark 12 --export-results benchmark_result.json pokec/medium/*/*
 
       - name: Upload mgbench results
         run: |

CMakeLists.txt

@@ -231,8 +231,6 @@ endif()
 message(STATUS "CMake build type: ${CMAKE_BUILD_TYPE}")
 # -----------------------------------------------------------------------------
 
-add_definitions( -DCMAKE_BUILD_TYPE_NAME="${CMAKE_BUILD_TYPE}")
-
 if (NOT MG_ARCH)
     set(MG_ARCH_DESCR "Host architecture to build Memgraph on. Supported values are x86_64, ARM64.")
     if (${CMAKE_HOST_SYSTEM_PROCESSOR} MATCHES "aarch64")

config/flags.yaml

@@ -103,10 +103,6 @@ modifications:
     value: "true"
     override: false
 
-  - name: "storage_parallel_index_recovery"
-    value: "false"
-    override: true
-
 undocumented:
   - "flag_file"
   - "also_log_to_stderr"

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-18-05
+CHANGE DATE:            2027-05-04
 CHANGE LICENSE:         Apache License, Version 2.0
 
 For information about alternative licensing arrangements, please visit: https://memgraph.com/legal.

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

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 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
@@ -22,15 +22,10 @@
 #include "communication/bolt/v1/state.hpp"
 #include "communication/bolt/v1/states/handlers.hpp"
 #include "communication/bolt/v1/value.hpp"
-#include "utils/event_counter.hpp"
 #include "utils/likely.hpp"
 #include "utils/logging.hpp"
 #include "utils/message.hpp"
 
-namespace memgraph::metrics {
-extern const Event BoltMessages;
-}  // namespace memgraph::metrics
-
 namespace memgraph::communication::bolt {
 
 template <typename TSession>
@@ -108,10 +103,8 @@ State StateExecutingRun(TSession &session, State state) {
 
   switch (session.version_.major) {
     case 1:
-      memgraph::metrics::IncrementCounter(memgraph::metrics::BoltMessages);
       return RunHandlerV1(signature, session, state, marker);
     case 4: {
-      memgraph::metrics::IncrementCounter(memgraph::metrics::BoltMessages);
       if (session.version_.minor >= 3) {
         return RunHandlerV4<TSession, 3>(signature, session, state, marker);
       }

src/communication/http/listener.hpp

@@ -1,108 +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 <list>
-#include <memory>
-
-#include <spdlog/spdlog.h>
-#include <boost/asio/io_context.hpp>
-#include <boost/asio/ip/tcp.hpp>
-#include <boost/asio/strand.hpp>
-#include <boost/beast/core.hpp>
-
-#include "communication/context.hpp"
-#include "communication/http/session.hpp"
-#include "utils/spin_lock.hpp"
-#include "utils/synchronized.hpp"
-
-namespace memgraph::communication::http {
-
-template <class TRequestHandler, typename TSessionData>
-class Listener final : public std::enable_shared_from_this<Listener<TRequestHandler, TSessionData>> {
-  using tcp = boost::asio::ip::tcp;
-  using SessionHandler = Session<TRequestHandler, TSessionData>;
-  using std::enable_shared_from_this<Listener<TRequestHandler, TSessionData>>::shared_from_this;
-
- public:
-  Listener(const Listener &) = delete;
-  Listener(Listener &&) = delete;
-  Listener &operator=(const Listener &) = delete;
-  Listener &operator=(Listener &&) = delete;
-  ~Listener() {}
-
-  template <typename... Args>
-  static std::shared_ptr<Listener> Create(Args &&...args) {
-    return std::shared_ptr<Listener>{new Listener(std::forward<Args>(args)...)};
-  }
-
-  // Start accepting incoming connections
-  void Run() { DoAccept(); }
-  tcp::endpoint GetEndpoint() const { return acceptor_.local_endpoint(); }
-
- private:
-  Listener(boost::asio::io_context &ioc, TSessionData *data, ServerContext *context, tcp::endpoint endpoint)
-      : ioc_(ioc), data_(data), context_(context), acceptor_(ioc) {
-    boost::beast::error_code ec;
-
-    // Open the acceptor
-    acceptor_.open(endpoint.protocol(), ec);
-    if (ec) {
-      LogError(ec, "open");
-      return;
-    }
-
-    // Allow address reuse
-    acceptor_.set_option(boost::asio::socket_base::reuse_address(true), ec);
-    if (ec) {
-      LogError(ec, "set_option");
-      return;
-    }
-
-    // Bind to the server address
-    acceptor_.bind(endpoint, ec);
-    if (ec) {
-      LogError(ec, "bind");
-      return;
-    }
-
-    acceptor_.listen(boost::asio::socket_base::max_listen_connections, ec);
-    if (ec) {
-      LogError(ec, "listen");
-      return;
-    }
-
-    spdlog::info("HTTP server is listening on {}:{}", endpoint.address(), endpoint.port());
-  }
-
-  void DoAccept() {
-    acceptor_.async_accept(ioc_, [shared_this = shared_from_this()](auto ec, auto socket) {
-      shared_this->OnAccept(ec, std::move(socket));
-    });
-  }
-
-  void OnAccept(boost::beast::error_code ec, tcp::socket socket) {
-    if (ec) {
-      return LogError(ec, "accept");
-    }
-
-    SessionHandler::Create(std::move(socket), data_, *context_)->Run();
-
-    DoAccept();
-  }
-
-  boost::asio::io_context &ioc_;
-  TSessionData *data_;
-  ServerContext *context_;
-  tcp::acceptor acceptor_;
-};
-}  // namespace memgraph::communication::http

src/communication/http/server.hpp

@@ -1,65 +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 <thread>
-
-#include <boost/asio/io_context.hpp>
-#include <boost/asio/ip/tcp.hpp>
-
-#include "communication/http/listener.hpp"
-#include "io/network/endpoint.hpp"
-
-namespace memgraph::communication::http {
-
-template <class TRequestHandler, typename TSessionData>
-class Server final {
-  using tcp = boost::asio::ip::tcp;
-
- public:
-  explicit Server(io::network::Endpoint endpoint, TSessionData *data, ServerContext *context)
-      : listener_{Listener<TRequestHandler, TSessionData>::Create(
-            ioc_, data, context, tcp::endpoint{boost::asio::ip::make_address(endpoint.address), endpoint.port})} {}
-
-  Server(const Server &) = delete;
-  Server(Server &&) = delete;
-  Server &operator=(const Server &) = delete;
-  Server &operator=(Server &&) = delete;
-
-  ~Server() {
-    MG_ASSERT(!background_thread_ || (ioc_.stopped() && !background_thread_->joinable()),
-              "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 Shutdown() { ioc_.stop(); }
-
-  void AwaitShutdown() {
-    if (background_thread_ && background_thread_->joinable()) {
-      background_thread_->join();
-    }
-  }
-  bool IsRunning() const { return background_thread_ && !ioc_.stopped(); }
-  tcp::endpoint GetEndpoint() const { return listener_->GetEndpoint(); }
-
- private:
-  boost::asio::io_context ioc_;
-
-  std::shared_ptr<Listener<TRequestHandler, TSessionData>> listener_;
-  std::optional<std::thread> background_thread_;
-};
-}  // namespace memgraph::communication::http

src/communication/http/session.hpp

@@ -1,193 +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 <deque>
-#include <functional>
-#include <memory>
-#include <optional>
-#include <string>
-#include <variant>
-
-#include <spdlog/spdlog.h>
-#include <boost/asio/bind_executor.hpp>
-#include <boost/asio/dispatch.hpp>
-#include <boost/asio/ip/tcp.hpp>
-#include <boost/asio/strand.hpp>
-#include <boost/beast/core/buffers_to_string.hpp>
-#include <boost/beast/core/stream_traits.hpp>
-#include <boost/beast/core/tcp_stream.hpp>
-#include <boost/beast/http.hpp>
-#include <boost/beast/ssl.hpp>
-#include <boost/beast/version.hpp>
-#include <json/json.hpp>
-
-#include "communication/context.hpp"
-#include "utils/logging.hpp"
-#include "utils/variant_helpers.hpp"
-
-namespace memgraph::communication::http {
-
-inline constexpr uint16_t kSSLExpirySeconds = 30;
-inline void LogError(boost::beast::error_code ec, const std::string_view what) {
-  spdlog::warn("HTTP session failed on {}: {}", what, ec.message());
-}
-
-template <class TRequestHandler, typename TSessionData>
-class Session : public std::enable_shared_from_this<Session<TRequestHandler, TSessionData>> {
-  using tcp = boost::asio::ip::tcp;
-  using std::enable_shared_from_this<Session<TRequestHandler, TSessionData>>::shared_from_this;
-
- public:
-  template <typename... Args>
-  static std::shared_ptr<Session> Create(Args &&...args) {
-    return std::shared_ptr<Session>{new Session{std::forward<Args>(args)...}};
-  }
-
-  void Run() {
-    if (auto *ssl = std::get_if<SSLSocket>(&stream_); ssl != nullptr) {
-      try {
-        boost::beast::get_lowest_layer(*ssl).expires_after(std::chrono::seconds(kSSLExpirySeconds));
-        ssl->handshake(boost::asio::ssl::stream_base::server);
-      } catch (const boost::system::system_error &e) {
-        spdlog::warn("Failed on SSL handshake: {}", e.what());
-        return;
-      }
-    }
-
-    // run on the strand
-    boost::asio::dispatch(strand_, [shared_this = shared_from_this()] { shared_this->DoRead(); });
-  }
-
- private:
-  using PlainSocket = boost::beast::tcp_stream;
-  using SSLSocket = boost::beast::ssl_stream<boost::beast::tcp_stream>;
-
-  explicit Session(tcp::socket &&socket, TSessionData *data, ServerContext &context)
-      : stream_(CreateSocket(std::move(socket), context)),
-        handler_(data),
-        strand_{boost::asio::make_strand(GetExecutor())} {}
-
-  std::variant<PlainSocket, SSLSocket> CreateSocket(tcp::socket &&socket, ServerContext &context) {
-    if (context.use_ssl()) {
-      ssl_context_.emplace(context.context_clone());
-      return Session::SSLSocket{std::move(socket), *ssl_context_};
-    }
-
-    return Session::PlainSocket{std::move(socket)};
-  }
-
-  void OnWrite(boost::beast::error_code ec, size_t bytes_transferred) {
-    boost::ignore_unused(bytes_transferred);
-
-    if (ec) {
-      close_ = true;
-      return LogError(ec, "write");
-    }
-
-    if (close_) {
-      DoClose();
-      return;
-    }
-
-    res_ = nullptr;
-
-    DoRead();
-  }
-
-  void DoRead() {
-    req_ = {};
-
-    ExecuteForStream([this](auto &&stream) {
-      boost::beast::get_lowest_layer(stream).expires_after(std::chrono::seconds(kSSLExpirySeconds));
-
-      boost::beast::http::async_read(
-          stream, buffer_, req_,
-          boost::asio::bind_executor(strand_, std::bind_front(&Session::OnRead, shared_from_this())));
-    });
-  }
-
-  void OnRead(boost::beast::error_code ec, size_t bytes_transferred) {
-    boost::ignore_unused(bytes_transferred);
-
-    if (ec == boost::beast::http::error::end_of_stream) {
-      DoClose();
-      return;
-    }
-
-    if (ec) {
-      return LogError(ec, "read");
-    }
-
-    auto async_write = [this](boost::beast::http::response<boost::beast::http::string_body> msg) {
-      ExecuteForStream([this, &msg](auto &&stream) {
-        // The lifetime of the message has to extend
-        // for the duration of the async operation so
-        // we use a shared_ptr to manage it.
-        auto sp = std::make_shared<boost::beast::http::response<boost::beast::http::string_body>>(std::move(msg));
-
-        // Store a type-erased version of the shared
-        // pointer in the class to keep it alive.
-        res_ = sp;
-        // Write the response
-        boost::beast::http::async_write(
-            stream, *sp, boost::asio::bind_executor(strand_, std::bind_front(&Session::OnWrite, shared_from_this())));
-      });
-    };
-
-    // handle request
-    handler_.HandleRequest(std::move(req_), async_write);
-  }
-
-  void DoClose() {
-    std::visit(utils::Overloaded{[this](SSLSocket &stream) {
-                                   boost::beast::get_lowest_layer(stream).expires_after(std::chrono::seconds(30));
-
-                                   // Perform the SSL shutdown
-                                   stream.async_shutdown(
-                                       boost::beast::bind_front_handler(&Session::OnClose, shared_from_this()));
-                                 },
-                                 [](PlainSocket &stream) {
-                                   boost::beast::error_code ec;
-                                   stream.socket().shutdown(tcp::socket::shutdown_send, ec);
-                                 }},
-               stream_);
-  }
-  void OnClose(boost::beast::error_code ec) {
-    if (ec) {
-      LogError(ec, "close");
-    }
-
-    // At this point the connection is closed gracefully
-  }
-
-  auto GetExecutor() {
-    return std::visit(utils::Overloaded{[](auto &&stream) { return stream.get_executor(); }}, stream_);
-  }
-
-  template <typename F>
-  decltype(auto) ExecuteForStream(F &&fn) {
-    return std::visit(utils::Overloaded{std::forward<F>(fn)}, stream_);
-  }
-
-  std::optional<std::reference_wrapper<boost::asio::ssl::context>> ssl_context_;
-  std::variant<PlainSocket, SSLSocket> stream_;
-  boost::beast::flat_buffer buffer_;
-
-  TRequestHandler handler_;
-  boost::beast::http::request<boost::beast::http::string_body> req_;
-  std::shared_ptr<void> res_;
-
-  boost::asio::strand<boost::beast::tcp_stream::executor_type> strand_;
-  bool close_{false};
-};
-}  // namespace memgraph::communication::http

src/communication/v2/listener.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 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
@@ -30,7 +30,6 @@
 #include "communication/context.hpp"
 #include "communication/v2/pool.hpp"
 #include "communication/v2/session.hpp"
-#include "utils/message.hpp"
 #include "utils/spin_lock.hpp"
 #include "utils/synchronized.hpp"
 

src/communication/v2/session.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 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
@@ -41,21 +41,11 @@
 #include <boost/beast/websocket/rfc6455.hpp>
 #include <boost/system/detail/error_code.hpp>
 
-#include "communication/buffer.hpp"
 #include "communication/context.hpp"
 #include "communication/exceptions.hpp"
-#include "utils/event_counter.hpp"
 #include "utils/logging.hpp"
-#include "utils/on_scope_exit.hpp"
 #include "utils/variant_helpers.hpp"
 
-namespace memgraph::metrics {
-extern const Event ActiveSessions;
-extern const Event ActiveTCPSessions;
-extern const Event ActiveSSLSessions;
-extern const Event ActiveWebSocketSessions;
-}  // namespace memgraph::metrics
-
 namespace memgraph::communication::v2 {
 
 /**
@@ -109,8 +99,6 @@ class WebsocketSession : public std::enable_shared_from_this<WebsocketSession<TS
   // Start the asynchronous accept operation
   template <class Body, class Allocator>
   void DoAccept(boost::beast::http::request<Body, boost::beast::http::basic_fields<Allocator>> req) {
-    memgraph::metrics::IncrementCounter(memgraph::metrics::ActiveWebSocketSessions);
-
     execution_active_ = true;
     // Set suggested timeout settings for the websocket
     ws_.set_option(boost::beast::websocket::stream_base::timeout::suggested(boost::beast::role_type::server));
@@ -225,10 +213,6 @@ class WebsocketSession : public std::enable_shared_from_this<WebsocketSession<TS
     if (!IsConnected()) {
       return;
     }
-
-    memgraph::metrics::DecrementCounter(memgraph::metrics::ActiveSessions);
-    memgraph::metrics::DecrementCounter(memgraph::metrics::ActiveWebSocketSessions);
-
     if (ec) {
       return OnError(ec, "close");
     }
@@ -275,19 +259,12 @@ class Session final : public std::enable_shared_from_this<Session<TSession, TSes
     if (execution_active_) {
       return false;
     }
-
-    memgraph::metrics::IncrementCounter(memgraph::metrics::ActiveSessions);
-
     execution_active_ = true;
     timeout_timer_.async_wait(boost::asio::bind_executor(strand_, std::bind(&Session::OnTimeout, shared_from_this())));
 
     if (std::holds_alternative<SSLSocket>(socket_)) {
-      utils::OnScopeExit increment_counter(
-          [] { memgraph::metrics::IncrementCounter(memgraph::metrics::ActiveSSLSessions); });
       boost::asio::dispatch(strand_, [shared_this = shared_from_this()] { shared_this->DoHandshake(); });
     } else {
-      utils::OnScopeExit increment_counter(
-          [] { memgraph::metrics::IncrementCounter(memgraph::metrics::ActiveTCPSessions); });
       boost::asio::dispatch(strand_, [shared_this = shared_from_this()] { shared_this->DoRead(); });
     }
     return true;
@@ -473,14 +450,6 @@ class Session final : public std::enable_shared_from_this<Session<TSession, TSes
   }
 
   void OnClose(const boost::system::error_code &ec) {
-    if (ssl_context_.has_value()) {
-      memgraph::metrics::DecrementCounter(memgraph::metrics::ActiveSSLSessions);
-    } else {
-      memgraph::metrics::DecrementCounter(memgraph::metrics::ActiveTCPSessions);
-    }
-
-    memgraph::metrics::DecrementCounter(memgraph::metrics::ActiveSessions);
-
     if (ec) {
       return OnError(ec);
     }
@@ -496,7 +465,7 @@ class Session final : public std::enable_shared_from_this<Session<TSession, TSes
     if (timeout_timer_.expiry() <= boost::asio::steady_timer::clock_type::now()) {
       // The deadline has passed. Stop the session. The other actors will
       // terminate as soon as possible.
-      spdlog::info("Shutting down session after {} seconds of inactivity", timeout_seconds_.count());
+      spdlog::info("Shutting down session after {} of inactivity", timeout_seconds_);
       DoShutdown();
     } else {
       // Put the actor back to sleep.

src/http_handlers/CMakeLists.txt

@@ -1,4 +0,0 @@
-set(mg_http_handlers_sources)
-
-add_library(mg-http-handlers STATIC ${mg_http_handlers_sources})
-target_link_libraries(mg-http-handlers mg-query mg-storage-v2)

src/http_handlers/metrics.hpp

@@ -1,211 +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 <atomic>
-#include <tuple>
-#include <vector>
-
-#include <spdlog/spdlog.h>
-#include <boost/beast/http.hpp>
-#include <boost/beast/version.hpp>
-#include <json/json.hpp>
-
-#include <utils/event_counter.hpp>
-#include <utils/event_gauge.hpp>
-#include "storage/v2/storage.hpp"
-#include "utils/event_gauge.hpp"
-#include "utils/event_histogram.hpp"
-
-namespace memgraph::http {
-
-struct MetricsResponse {
-  uint64_t vertex_count;
-  uint64_t edge_count;
-  double average_degree;
-  uint64_t memory_usage;
-  uint64_t disk_usage;
-
-  // Storage of all the counter values throughout the system
-  // e.g. number of active transactions
-  std::vector<std::tuple<std::string, std::string, uint64_t>> event_counters{};
-
-  // Storage of all the current values throughout the system
-  std::vector<std::tuple<std::string, std::string, uint64_t>> event_gauges{};
-
-  // Storage of all the percentile values across the histograms in the system
-  // e.g. query latency percentiles, snapshot recovery duration percentiles, etc.
-  std::vector<std::tuple<std::string, std::string, uint64_t>> event_histograms{};
-};
-
-template <typename TSessionData>
-class MetricsService {
- public:
-  explicit MetricsService(TSessionData *data) : db_(data->db) {}
-
-  nlohmann::json GetMetricsJSON() {
-    auto response = GetMetrics();
-    return AsJson(response);
-  }
-
- private:
-  const storage::Storage *db_;
-
-  MetricsResponse GetMetrics() {
-    auto info = db_->GetInfo();
-
-    return MetricsResponse{.vertex_count = info.vertex_count,
-                           .edge_count = info.edge_count,
-                           .average_degree = info.average_degree,
-                           .memory_usage = info.memory_usage,
-                           .disk_usage = info.disk_usage,
-                           .event_counters = GetEventCounters(),
-                           .event_gauges = GetEventGauges(),
-                           .event_histograms = GetEventHistograms()};
-  }
-
-  nlohmann::json AsJson(MetricsResponse response) {
-    auto metrics_response = nlohmann::json();
-    const auto *general_type = "General";
-
-    metrics_response[general_type]["vertex_count"] = response.vertex_count;
-    metrics_response[general_type]["edge_count"] = response.edge_count;
-    metrics_response[general_type]["average_degree"] = response.average_degree;
-    metrics_response[general_type]["memory_usage"] = response.memory_usage;
-    metrics_response[general_type]["disk_usage"] = response.disk_usage;
-
-    for (const auto &[name, type, value] : response.event_counters) {
-      metrics_response[type][name] = value;
-    }
-
-    for (const auto &[name, type, value] : response.event_gauges) {
-      metrics_response[type][name] = value;
-    }
-
-    for (const auto &[name, type, value] : response.event_histograms) {
-      metrics_response[type][name] = value;
-    }
-
-    return metrics_response;
-  }
-
-  auto GetEventCounters() {
-    // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-    std::vector<std::tuple<std::string, std::string, uint64_t>> event_counters{};
-
-    for (auto i = 0; i < memgraph::metrics::CounterEnd(); i++) {
-      event_counters.emplace_back(memgraph::metrics::GetCounterName(i), memgraph::metrics::GetCounterType(i),
-                                  memgraph::metrics::global_counters[i].load(std::memory_order_acquire));
-    }
-
-    return event_counters;
-  }
-
-  auto GetEventGauges() {
-    // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-    std::vector<std::tuple<std::string, std::string, uint64_t>> event_gauges{};
-
-    for (auto i = 0; i < memgraph::metrics::GaugeEnd(); i++) {
-      event_gauges.emplace_back(memgraph::metrics::GetGaugeName(i), memgraph::metrics::GetGaugeType(i),
-                                memgraph::metrics::global_gauges[i].load(std::memory_order_acquire));
-    }
-
-    return event_gauges;
-  }
-
-  auto GetEventHistograms() {
-    // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-    std::vector<std::tuple<std::string, std::string, uint64_t>> event_histograms{};
-
-    for (auto i = 0; i < memgraph::metrics::HistogramEnd(); i++) {
-      const auto *name = memgraph::metrics::GetHistogramName(i);
-      auto &histogram = memgraph::metrics::global_histograms[i];
-
-      for (auto &[percentile, value] : histogram.YieldPercentiles()) {
-        auto metric_name = std::string(name) + "_" + std::to_string(percentile) + "p";
-
-        event_histograms.emplace_back(metric_name, memgraph::metrics::GetHistogramType(i), value);
-      }
-    }
-
-    return event_histograms;
-  }
-};
-
-template <typename TSessionData>
-class MetricsRequestHandler final {
- public:
-  explicit MetricsRequestHandler(TSessionData *data) : service_(data) {
-    spdlog::info("Basic request handler started!");
-  }
-
-  MetricsRequestHandler(const MetricsRequestHandler &) = delete;
-  MetricsRequestHandler(MetricsRequestHandler &&) = delete;
-  MetricsRequestHandler &operator=(const MetricsRequestHandler &) = delete;
-  MetricsRequestHandler &operator=(MetricsRequestHandler &&) = delete;
-  ~MetricsRequestHandler() = default;
-
-  template <class Body, class Allocator>
-  // NOLINTNEXTLINE(misc-unused-parameters)
-  void HandleRequest(boost::beast::http::request<Body, boost::beast::http::basic_fields<Allocator>> &&req,
-                     std::function<void(boost::beast::http::response<boost::beast::http::string_body>)> &&send) {
-    auto response_json = nlohmann::json();
-    // Returns a bad request response
-    auto const bad_request = [&req, &response_json](const auto why) {
-      response_json["error"] = std::string(why);
-
-      // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-      boost::beast::http::response<boost::beast::http::string_body> res{boost::beast::http::status::bad_request,
-                                                                        req.version()};
-      res.set(boost::beast::http::field::server, BOOST_BEAST_VERSION_STRING);
-      res.set(boost::beast::http::field::content_type, "application/json");
-      res.keep_alive(req.keep_alive());
-      res.body() = response_json.dump();
-      res.prepare_payload();
-      return res;
-    };
-
-    // Make sure we can handle the method
-    if (req.method() != boost::beast::http::verb::get) {
-      return send(bad_request("Unknown HTTP-method"));
-    }
-
-    // Request path must be absolute and not contain "..".
-    if (req.target().empty() || req.target()[0] != '/' || req.target().find("..") != boost::beast::string_view::npos) {
-      return send(bad_request("Illegal request-target"));
-    }
-
-    // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-    boost::beast::http::string_body::value_type body;
-
-    auto service_response = service_.GetMetricsJSON();
-    body.append(service_response.dump());
-
-    // Cache the size since we need it after the move
-    const auto size = body.size();
-
-    // Respond to GET request
-    // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-    boost::beast::http::response<boost::beast::http::string_body> res{
-        std::piecewise_construct, std::make_tuple(std::move(body)),
-        std::make_tuple(boost::beast::http::status::ok, req.version())};
-    res.set(boost::beast::http::field::server, BOOST_BEAST_VERSION_STRING);
-    res.set(boost::beast::http::field::content_type, "application/json");
-    res.content_length(size);
-    res.keep_alive(req.keep_alive());
-    return send(std::move(res));
-  }
-
- private:
-  MetricsService<TSessionData> service_;
-};
-}  // namespace memgraph::http

src/memgraph.cpp

@@ -36,13 +36,11 @@
 
 #include "auth/models.hpp"
 #include "communication/bolt/v1/constants.hpp"
-#include "communication/http/server.hpp"
 #include "communication/websocket/auth.hpp"
 #include "communication/websocket/server.hpp"
 #include "glue/auth_checker.hpp"
 #include "glue/auth_handler.hpp"
 #include "helpers.hpp"
-#include "http_handlers/metrics.hpp"
 #include "license/license.hpp"
 #include "license/license_sender.hpp"
 #include "py/py.hpp"
@@ -115,9 +113,6 @@ DEFINE_string(bolt_address, "0.0.0.0", "IP address on which the Bolt server shou
 // 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.");
 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)
@@ -125,9 +120,6 @@ 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_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.",
@@ -200,20 +192,6 @@ DEFINE_VALIDATED_uint64(storage_wal_file_flush_every_n_tx,
 // 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.");
-
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_bool(telemetry_enabled, false,
             "Set to true to enable telemetry. We collect information about the "
@@ -500,10 +478,6 @@ void InitFromCypherlFile(memgraph::query::InterpreterContext &ctx, std::string c
   }
 }
 
-namespace memgraph::metrics {
-extern const Event ActiveBoltSessions;
-}  // namespace memgraph::metrics
-
 class BoltSession final : public memgraph::communication::bolt::Session<memgraph::communication::v2::InputStream,
                                                                         memgraph::communication::v2::OutputStream> {
  public:
@@ -521,12 +495,10 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
 #endif
         endpoint_(endpoint),
         run_id_(data->run_id) {
-    memgraph::metrics::IncrementCounter(memgraph::metrics::ActiveBoltSessions);
     interpreter_context_->interpreters.WithLock([this](auto &interpreters) { interpreters.insert(&interpreter_); });
   }
 
   ~BoltSession() override {
-    memgraph::metrics::DecrementCounter(memgraph::metrics::ActiveBoltSessions);
     interpreter_context_->interpreters.WithLock([this](auto &interpreters) { interpreters.erase(&interpreter_); });
   }
 
@@ -686,8 +658,6 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
 };
 
 using ServerT = memgraph::communication::v2::Server<BoltSession, SessionData>;
-using MonitoringServerT =
-    memgraph::communication::http::Server<memgraph::http::MetricsRequestHandler<SessionData>, SessionData>;
 using memgraph::communication::ServerContext;
 
 // Needed to correctly handle memgraph destruction from a signal handler.
@@ -882,10 +852,7 @@ int main(int argc, char **argv) {
                      .wal_file_size_kibibytes = FLAGS_storage_wal_file_size_kib,
                      .wal_file_flush_every_n_tx = FLAGS_storage_wal_file_flush_every_n_tx,
                      .snapshot_on_exit = FLAGS_storage_snapshot_on_exit,
-                     .restore_replicas_on_startup = true,
-                     .items_per_batch = FLAGS_storage_items_per_batch,
-                     .recovery_thread_count = FLAGS_storage_recovery_thread_count,
-                     .allow_parallel_index_creation = FLAGS_storage_parallel_index_recovery},
+                     .restore_replicas_on_startup = true},
       .transaction = {.isolation_level = ParseIsolationLevel()}};
   if (FLAGS_storage_snapshot_interval_sec == 0) {
     if (FLAGS_storage_wal_enabled) {
@@ -997,9 +964,8 @@ int main(int argc, char **argv) {
     });
     telemetry->AddCollector("event_counters", []() -> nlohmann::json {
       nlohmann::json ret;
-      for (size_t i = 0; i < memgraph::metrics::CounterEnd(); ++i) {
-        ret[memgraph::metrics::GetCounterName(i)] =
-            memgraph::metrics::global_counters[i].load(std::memory_order_relaxed);
+      for (size_t i = 0; i < EventCounter::End(); ++i) {
+        ret[EventCounter::GetName(i)] = EventCounter::global_counters[i].load(std::memory_order_relaxed);
       }
       return ret;
     });
@@ -1015,43 +981,6 @@ int main(int argc, char **argv) {
       {FLAGS_monitoring_address, static_cast<uint16_t>(FLAGS_monitoring_port)}, &context, websocket_auth};
   AddLoggerSink(websocket_server.GetLoggingSink());
 
-  MonitoringServerT metrics_server{
-      {FLAGS_metrics_address, static_cast<uint16_t>(FLAGS_metrics_port)}, &session_data, &context};
-
-#ifdef MG_ENTERPRISE
-  if (memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
-    // Handler for regular termination signals
-    auto shutdown = [&metrics_server, &websocket_server, &server, &interpreter_context] {
-      // Server needs to be shutdown first and then the database. This prevents
-      // a race condition when a transaction is accepted during server shutdown.
-      server.Shutdown();
-      // After the server is notified to stop accepting and processing
-      // connections we tell the execution engine to stop processing all pending
-      // queries.
-      memgraph::query::Shutdown(&interpreter_context);
-
-      websocket_server.Shutdown();
-      metrics_server.Shutdown();
-    };
-
-    InitSignalHandlers(shutdown);
-  } else {
-    // Handler for regular termination signals
-    auto shutdown = [&websocket_server, &server, &interpreter_context] {
-      // Server needs to be shutdown first and then the database. This prevents
-      // a race condition when a transaction is accepted during server shutdown.
-      server.Shutdown();
-      // After the server is notified to stop accepting and processing
-      // connections we tell the execution engine to stop processing all pending
-      // queries.
-      memgraph::query::Shutdown(&interpreter_context);
-
-      websocket_server.Shutdown();
-    };
-
-    InitSignalHandlers(shutdown);
-  }
-#else
   // Handler for regular termination signals
   auto shutdown = [&websocket_server, &server, &interpreter_context] {
     // Server needs to be shutdown first and then the database. This prevents
@@ -1061,22 +990,14 @@ int main(int argc, char **argv) {
     // connections we tell the execution engine to stop processing all pending
     // queries.
     memgraph::query::Shutdown(&interpreter_context);
-
     websocket_server.Shutdown();
   };
 
   InitSignalHandlers(shutdown);
-#endif
 
   MG_ASSERT(server.Start(), "Couldn't start the Bolt server!");
   websocket_server.Start();
 
-#ifdef MG_ENTERPRISE
-  if (memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
-    metrics_server.Start();
-  }
-#endif
-
   if (!FLAGS_init_data_file.empty()) {
     spdlog::info("Running init data file.");
 #ifdef MG_ENTERPRISE
@@ -1090,11 +1011,6 @@ int main(int argc, char **argv) {
 
   server.AwaitShutdown();
   websocket_server.AwaitShutdown();
-#ifdef MG_ENTERPRISE
-  if (memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
-    metrics_server.AwaitShutdown();
-  }
-#endif
 
   memgraph::query::procedure::gModuleRegistry.UnloadAllModules();
 

src/query/frontend/ast/ast.cpp

@@ -114,18 +114,12 @@ constexpr utils::TypeInfo query::ListLiteral::kType{utils::TypeId::AST_LIST_LITE
 constexpr utils::TypeInfo query::MapLiteral::kType{utils::TypeId::AST_MAP_LITERAL, "MapLiteral",
                                                    &query::BaseLiteral::kType};
 
-constexpr utils::TypeInfo query::MapProjectionLiteral::kType{utils::TypeId::AST_MAP_PROJECTION_LITERAL,
-                                                             "MapProjectionLiteral", &query::BaseLiteral::kType};
-
 constexpr utils::TypeInfo query::Identifier::kType{utils::TypeId::AST_IDENTIFIER, "Identifier",
                                                    &query::Expression::kType};
 
 constexpr utils::TypeInfo query::PropertyLookup::kType{utils::TypeId::AST_PROPERTY_LOOKUP, "PropertyLookup",
                                                        &query::Expression::kType};
 
-constexpr utils::TypeInfo query::AllPropertiesLookup::kType{utils::TypeId::AST_ALL_PROPERTIES_LOOKUP,
-                                                            "AllPropertiesLookup", &query::Expression::kType};
-
 constexpr utils::TypeInfo query::LabelsTest::kType{utils::TypeId::AST_LABELS_TEST, "LabelsTest",
                                                    &query::Expression::kType};
 

src/query/frontend/ast/ast.hpp

@@ -1063,9 +1063,8 @@ class MapLiteral : public memgraph::query::BaseLiteral {
   DEFVISITABLE(ExpressionVisitor<void>);
   bool Accept(HierarchicalTreeVisitor &visitor) override {
     if (visitor.PreVisit(*this)) {
-      for (auto pair : elements_) {
+      for (auto pair : elements_)
         if (!pair.second->Accept(visitor)) break;
-      }
     }
     return visitor.PostVisit(*this);
   }
@@ -1088,60 +1087,6 @@ class MapLiteral : public memgraph::query::BaseLiteral {
   friend class AstStorage;
 };
 
-struct MapProjectionData {
-  Expression *map_variable;
-  std::unordered_map<PropertyIx, Expression *> elements;
-};
-
-class MapProjectionLiteral : public memgraph::query::BaseLiteral {
- public:
-  static const utils::TypeInfo kType;
-  const utils::TypeInfo &GetTypeInfo() const override { return kType; }
-
-  MapProjectionLiteral() = default;
-
-  DEFVISITABLE(ExpressionVisitor<TypedValue>);
-  DEFVISITABLE(ExpressionVisitor<TypedValue *>);
-  DEFVISITABLE(ExpressionVisitor<void>);
-  bool Accept(HierarchicalTreeVisitor &visitor) override {
-    if (visitor.PreVisit(*this)) {
-      for (auto pair : elements_) {
-        if (!pair.second) continue;
-
-        if (!pair.second->Accept(visitor)) break;
-      }
-    }
-    return visitor.PostVisit(*this);
-  }
-
-  Expression *map_variable_;
-  std::unordered_map<PropertyIx, Expression *> elements_;
-
-  MapProjectionLiteral *Clone(AstStorage *storage) const override {
-    MapProjectionLiteral *object = storage->Create<MapProjectionLiteral>();
-    object->map_variable_ = map_variable_;
-
-    for (const auto &entry : elements_) {
-      auto key = storage->GetPropertyIx(entry.first.name);
-
-      if (!entry.second) {
-        object->elements_[key] = nullptr;
-        continue;
-      }
-
-      object->elements_[key] = entry.second->Clone(storage);
-    }
-    return object;
-  }
-
- protected:
-  explicit MapProjectionLiteral(Expression *map_variable, std::unordered_map<PropertyIx, Expression *> &&elements)
-      : map_variable_(map_variable), elements_(std::move(elements)) {}
-
- private:
-  friend class AstStorage;
-};
-
 class Identifier : public memgraph::query::Expression {
  public:
   static const utils::TypeInfo kType;
@@ -1213,38 +1158,6 @@ class PropertyLookup : public memgraph::query::Expression {
   friend class AstStorage;
 };
 
-class AllPropertiesLookup : public memgraph::query::Expression {
- public:
-  static const utils::TypeInfo kType;
-  const utils::TypeInfo &GetTypeInfo() const override { return kType; }
-
-  AllPropertiesLookup() = default;
-
-  DEFVISITABLE(ExpressionVisitor<TypedValue>);
-  DEFVISITABLE(ExpressionVisitor<TypedValue *>);
-  DEFVISITABLE(ExpressionVisitor<void>);
-  bool Accept(HierarchicalTreeVisitor &visitor) override {
-    if (visitor.PreVisit(*this)) {
-      expression_->Accept(visitor);
-    }
-    return visitor.PostVisit(*this);
-  }
-
-  memgraph::query::Expression *expression_{nullptr};
-
-  AllPropertiesLookup *Clone(AstStorage *storage) const override {
-    AllPropertiesLookup *object = storage->Create<AllPropertiesLookup>();
-    object->expression_ = expression_ ? expression_->Clone(storage) : nullptr;
-    return object;
-  }
-
- protected:
-  explicit AllPropertiesLookup(Expression *expression) : expression_(expression) {}
-
- private:
-  friend class AstStorage;
-};
-
 class LabelsTest : public memgraph::query::Expression {
  public:
   static const utils::TypeInfo kType;
@@ -2873,7 +2786,7 @@ class InfoQuery : public memgraph::query::Query {
   static const utils::TypeInfo kType;
   const utils::TypeInfo &GetTypeInfo() const override { return kType; }
 
-  enum class InfoType { STORAGE, INDEX, CONSTRAINT, BUILD };
+  enum class InfoType { STORAGE, INDEX, CONSTRAINT };
 
   DEFVISITABLE(QueryVisitor<void>);
 
@@ -2985,7 +2898,7 @@ class LockPathQuery : public memgraph::query::Query {
   static const utils::TypeInfo kType;
   const utils::TypeInfo &GetTypeInfo() const override { return kType; }
 
-  enum class Action { LOCK_PATH, UNLOCK_PATH, STATUS };
+  enum class Action { LOCK_PATH, UNLOCK_PATH };
 
   LockPathQuery() = default;
 

src/query/frontend/ast/ast_visitor.hpp

@@ -22,7 +22,6 @@ class CypherUnion;
 class NamedExpression;
 class Identifier;
 class PropertyLookup;
-class AllPropertiesLookup;
 class LabelsTest;
 class Aggregation;
 class Function;
@@ -45,7 +44,6 @@ class EdgeAtom;
 class PrimitiveLiteral;
 class ListLiteral;
 class MapLiteral;
-class MapProjectionLiteral;
 class OrOperator;
 class XorOperator;
 class AndOperator;
@@ -108,10 +106,9 @@ using TreeCompositeVisitor = utils::CompositeVisitor<
     SubtractionOperator, MultiplicationOperator, DivisionOperator, ModOperator, NotEqualOperator, EqualOperator,
     LessOperator, GreaterOperator, LessEqualOperator, GreaterEqualOperator, InListOperator, SubscriptOperator,
     ListSlicingOperator, IfOperator, UnaryPlusOperator, UnaryMinusOperator, IsNullOperator, ListLiteral, MapLiteral,
-    MapProjectionLiteral, PropertyLookup, AllPropertiesLookup, LabelsTest, Aggregation, Function, Reduce, Coalesce,
-    Extract, All, Single, Any, None, CallProcedure, Create, Match, Return, With, Pattern, NodeAtom, EdgeAtom, Delete,
-    Where, SetProperty, SetProperties, SetLabels, RemoveProperty, RemoveLabels, Merge, Unwind, RegexMatch, LoadCsv,
-    Foreach, Exists, CallSubquery, CypherQuery>;
+    PropertyLookup, LabelsTest, Aggregation, Function, Reduce, Coalesce, Extract, All, Single, Any, None, CallProcedure,
+    Create, Match, Return, With, Pattern, NodeAtom, EdgeAtom, Delete, Where, SetProperty, SetProperties, SetLabels,
+    RemoveProperty, RemoveLabels, Merge, Unwind, RegexMatch, LoadCsv, Foreach, Exists, CallSubquery, CypherQuery>;
 
 using TreeLeafVisitor = utils::LeafVisitor<Identifier, PrimitiveLiteral, ParameterLookup>;
 
@@ -125,14 +122,13 @@ class HierarchicalTreeVisitor : public TreeCompositeVisitor, public TreeLeafVisi
 
 template <class TResult>
 class ExpressionVisitor
-    : public utils::Visitor<TResult, NamedExpression, OrOperator, XorOperator, AndOperator, NotOperator,
-                            AdditionOperator, SubtractionOperator, MultiplicationOperator, DivisionOperator,
-                            ModOperator, NotEqualOperator, EqualOperator, LessOperator, GreaterOperator,
-                            LessEqualOperator, GreaterEqualOperator, InListOperator, SubscriptOperator,
-                            ListSlicingOperator, IfOperator, UnaryPlusOperator, UnaryMinusOperator, IsNullOperator,
-                            ListLiteral, MapLiteral, MapProjectionLiteral, PropertyLookup, AllPropertiesLookup,
-                            LabelsTest, Aggregation, Function, Reduce, Coalesce, Extract, All, Single, Any, None,
-                            ParameterLookup, Identifier, PrimitiveLiteral, RegexMatch, Exists> {};
+    : public utils::Visitor<
+          TResult, NamedExpression, OrOperator, XorOperator, AndOperator, NotOperator, AdditionOperator,
+          SubtractionOperator, MultiplicationOperator, DivisionOperator, ModOperator, NotEqualOperator, EqualOperator,
+          LessOperator, GreaterOperator, LessEqualOperator, GreaterEqualOperator, InListOperator, SubscriptOperator,
+          ListSlicingOperator, IfOperator, UnaryPlusOperator, UnaryMinusOperator, IsNullOperator, ListLiteral,
+          MapLiteral, PropertyLookup, LabelsTest, Aggregation, Function, Reduce, Coalesce, Extract, All, Single, Any,
+          None, ParameterLookup, Identifier, PrimitiveLiteral, RegexMatch, Exists> {};
 
 template <class TResult>
 class QueryVisitor

src/query/frontend/ast/cypher_main_visitor.cpp

@@ -124,9 +124,6 @@ antlrcpp::Any CypherMainVisitor::visitInfoQuery(MemgraphCypher::InfoQueryContext
   } else if (ctx->constraintInfo()) {
     info_query->info_type_ = InfoQuery::InfoType::CONSTRAINT;
     return info_query;
-  } else if (ctx->buildInfo()) {
-    info_query->info_type_ = InfoQuery::InfoType::BUILD;
-    return info_query;
   } else {
     throw utils::NotYetImplemented("Info query: '{}'", ctx->getText());
   }
@@ -328,9 +325,7 @@ antlrcpp::Any CypherMainVisitor::visitShowReplicas(MemgraphCypher::ShowReplicasC
 
 antlrcpp::Any CypherMainVisitor::visitLockPathQuery(MemgraphCypher::LockPathQueryContext *ctx) {
   auto *lock_query = storage_->Create<LockPathQuery>();
-  if (ctx->STATUS()) {
-    lock_query->action_ = LockPathQuery::Action::STATUS;
-  } else if (ctx->LOCK()) {
+  if (ctx->LOCK()) {
     lock_query->action_ = LockPathQuery::Action::LOCK_PATH;
   } else if (ctx->UNLOCK()) {
     lock_query->action_ = LockPathQuery::Action::UNLOCK_PATH;
@@ -1701,38 +1696,6 @@ antlrcpp::Any CypherMainVisitor::visitMapLiteral(MemgraphCypher::MapLiteralConte
   return map;
 }
 
-antlrcpp::Any CypherMainVisitor::visitMapProjectionLiteral(MemgraphCypher::MapProjectionLiteralContext *ctx) {
-  MapProjectionData map_projection_data;
-
-  map_projection_data.map_variable =
-      storage_->Create<Identifier>(std::any_cast<std::string>(ctx->variable()->accept(this)));
-  for (auto *map_el : ctx->mapElement()) {
-    if (map_el->propertyLookup()) {
-      auto key = std::any_cast<PropertyIx>(map_el->propertyLookup()->propertyKeyName()->accept(this));
-      auto property = std::any_cast<PropertyIx>(map_el->propertyLookup()->accept(this));
-      auto *property_lookup = storage_->Create<PropertyLookup>(map_projection_data.map_variable, property);
-      map_projection_data.elements.insert_or_assign(key, property_lookup);
-    }
-    if (map_el->allPropertiesLookup()) {
-      auto key = AddProperty("*");
-      auto *all_properties_lookup = storage_->Create<AllPropertiesLookup>(map_projection_data.map_variable);
-      map_projection_data.elements.insert_or_assign(key, all_properties_lookup);
-    }
-    if (map_el->variable()) {
-      auto key = AddProperty(std::any_cast<std::string>(map_el->variable()->accept(this)));
-      auto *variable = storage_->Create<Identifier>(std::any_cast<std::string>(map_el->variable()->accept(this)));
-      map_projection_data.elements.insert_or_assign(key, variable);
-    }
-    if (map_el->propertyKeyValuePair()) {
-      auto key = std::any_cast<PropertyIx>(map_el->propertyKeyValuePair()->propertyKeyName()->accept(this));
-      auto *value = std::any_cast<Expression *>(map_el->propertyKeyValuePair()->expression()->accept(this));
-      map_projection_data.elements.insert_or_assign(key, value);
-    }
-  }
-
-  return map_projection_data;
-}
-
 antlrcpp::Any CypherMainVisitor::visitListLiteral(MemgraphCypher::ListLiteralContext *ctx) {
   std::vector<Expression *> expressions;
   for (auto *expr_ctx : ctx->expression()) {
@@ -2313,10 +2276,6 @@ antlrcpp::Any CypherMainVisitor::visitLiteral(MemgraphCypher::LiteralContext *ct
   } else if (ctx->listLiteral()) {
     return static_cast<Expression *>(
         storage_->Create<ListLiteral>(std::any_cast<std::vector<Expression *>>(ctx->listLiteral()->accept(this))));
-  } else if (ctx->mapProjectionLiteral()) {
-    auto map_projection_data = std::any_cast<MapProjectionData>(ctx->mapProjectionLiteral()->accept(this));
-    return static_cast<Expression *>(storage_->Create<MapProjectionLiteral>(map_projection_data.map_variable,
-                                                                            std::move(map_projection_data.elements)));
   } else {
     return static_cast<Expression *>(storage_->Create<MapLiteral>(
         std::any_cast<std::unordered_map<PropertyIx, Expression *>>(ctx->mapLiteral()->accept(this))));

src/query/frontend/ast/cypher_main_visitor.hpp

@@ -15,6 +15,8 @@
 #include <unordered_set>
 #include <utility>
 
+#include <antlr4-runtime.h>
+
 #include "query/frontend/ast/ast.hpp"
 #include "query/frontend/opencypher/generated/MemgraphCypherBaseVisitor.h"
 #include "utils/exceptions.hpp"
@@ -606,11 +608,6 @@ class CypherMainVisitor : public antlropencypher::MemgraphCypherBaseVisitor {
    */
   antlrcpp::Any visitMapLiteral(MemgraphCypher::MapLiteralContext *ctx) override;
 
-  /**
-   * @return MapProjectionData
-   */
-  antlrcpp::Any visitMapProjectionLiteral(MemgraphCypher::MapProjectionLiteralContext *ctx) override;
-
   /**
    * @return vector<Expression*>
    */

src/query/frontend/ast/pretty_print.cpp

@@ -54,7 +54,6 @@ class ExpressionPrettyPrinter : public ExpressionVisitor<void> {
   void Visit(IfOperator &op) override;
   void Visit(ListLiteral &op) override;
   void Visit(MapLiteral &op) override;
-  void Visit(MapProjectionLiteral &op) override;
   void Visit(LabelsTest &op) override;
   void Visit(Aggregation &op) override;
   void Visit(Function &op) override;
@@ -69,7 +68,6 @@ class ExpressionPrettyPrinter : public ExpressionVisitor<void> {
   void Visit(Identifier &op) override;
   void Visit(PrimitiveLiteral &op) override;
   void Visit(PropertyLookup &op) override;
-  void Visit(AllPropertiesLookup &op) override;
   void Visit(ParameterLookup &op) override;
   void Visit(NamedExpression &op) override;
   void Visit(RegexMatch &op) override;
@@ -91,8 +89,6 @@ void PrintObject(std::ostream *out, Aggregation::Op op);
 
 void PrintObject(std::ostream *out, Expression *expr);
 
-void PrintObject(std::ostream *out, AllPropertiesLookup *apl);
-
 void PrintObject(std::ostream *out, Identifier *expr);
 
 void PrintObject(std::ostream *out, const storage::PropertyValue &value);
@@ -126,15 +122,6 @@ void PrintObject(std::ostream *out, Expression *expr) {
   }
 }
 
-void PrintObject(std::ostream *out, AllPropertiesLookup *apl) {
-  if (apl) {
-    ExpressionPrettyPrinter printer{out};
-    *out << ".*";
-  } else {
-    *out << "<null>";
-  }
-}
-
 void PrintObject(std::ostream *out, Identifier *expr) { PrintObject(out, static_cast<Expression *>(expr)); }
 
 void PrintObject(std::ostream *out, const storage::PropertyValue &value) {
@@ -262,17 +249,6 @@ void ExpressionPrettyPrinter::Visit(MapLiteral &op) {
   PrintObject(out_, map);
 }
 
-void ExpressionPrettyPrinter::Visit(MapProjectionLiteral &op) {
-  std::map<std::string, Expression *> map_projection_elements;
-  for (const auto &kv : op.elements_) {
-    map_projection_elements[kv.first.name] = kv.second;
-  }
-  PrintObject(out_, op.map_variable_);
-  PrintObject(out_, map_projection_elements);
-}
-
-void ExpressionPrettyPrinter::Visit(AllPropertiesLookup &op) { PrintObject(out_, &op); }
-
 void ExpressionPrettyPrinter::Visit(LabelsTest &op) { PrintOperator(out_, "LabelsTest", op.expression_); }
 
 void ExpressionPrettyPrinter::Visit(Aggregation &op) { PrintOperator(out_, "Aggregation", op.op_); }

src/query/frontend/opencypher/grammar/Cypher.g4

@@ -46,9 +46,7 @@ indexInfo : INDEX INFO ;
 
 constraintInfo : CONSTRAINT INFO ;
 
-buildInfo : BUILD INFO ;
-
-infoQuery : SHOW ( storageInfo | indexInfo | constraintInfo | buildInfo) ;
+infoQuery : SHOW ( storageInfo | indexInfo | constraintInfo ) ;
 
 explainQuery : EXPLAIN cypherQuery ;
 
@@ -250,7 +248,6 @@ literal : numberLiteral
         | booleanLiteral
         | CYPHERNULL
         | mapLiteral
-        | mapProjectionLiteral
         | listLiteral
         ;
 
@@ -293,8 +290,6 @@ patternComprehension : '[' ( variable '=' )? relationshipsPattern ( WHERE expres
 
 propertyLookup : '.' ( propertyKeyName ) ;
 
-allPropertiesLookup : '.' '*' ;
-
 caseExpression : ( ( CASE ( caseAlternatives )+ ) | ( CASE test=expression ( caseAlternatives )+ ) ) ( ELSE else_expression=expression )? END ;
 
 caseAlternatives : WHEN when_expression=expression THEN then_expression=expression ;
@@ -307,22 +302,12 @@ numberLiteral : doubleLiteral
 
 mapLiteral : '{' ( propertyKeyName ':' expression ( ',' propertyKeyName ':' expression )* )? '}' ;
 
-mapProjectionLiteral : variable '{' ( mapElement ( ',' mapElement )* )? '}' ;
-
-mapElement : propertyLookup
-           | allPropertiesLookup
-           | variable
-           | propertyKeyValuePair
-           ;
-
 parameter : '$' ( symbolicName | DecimalLiteral ) ;
 
 propertyExpression : atom ( propertyLookup )+ ;
 
 propertyKeyName : symbolicName ;
 
-propertyKeyValuePair : propertyKeyName ':' expression ;
-
 integerLiteral : DecimalLiteral
                | OctalLiteral
                | HexadecimalLiteral

src/query/frontend/opencypher/grammar/MemgraphCypher.g4

@@ -31,7 +31,6 @@ memgraphCypherKeyword : cypherKeyword
                       | BATCH_SIZE
                       | BEFORE
                       | BOOTSTRAP_SERVERS
-                      | BUILD
                       | CHECK
                       | CLEAR
                       | COMMIT
@@ -91,7 +90,6 @@ memgraphCypherKeyword : cypherKeyword
                       | SNAPSHOT
                       | START
                       | STATS
-                      | STATUS
                       | STORAGE
                       | STREAM
                       | STREAMS
@@ -336,7 +334,7 @@ dropReplica : DROP REPLICA replicaName ;
 
 showReplicas  : SHOW REPLICAS ;
 
-lockPathQuery : ( LOCK | UNLOCK ) DATA DIRECTORY | DATA DIRECTORY LOCK STATUS;
+lockPathQuery : ( LOCK | UNLOCK ) DATA DIRECTORY ;
 
 freeMemoryQuery : FREE MEMORY ;
 

src/query/frontend/opencypher/grammar/MemgraphCypherLexer.g4

@@ -35,7 +35,6 @@ BATCH_INTERVAL          : B A T C H UNDERSCORE I N T E R V A L ;
 BATCH_LIMIT             : B A T C H UNDERSCORE L I M I T ;
 BATCH_SIZE              : B A T C H UNDERSCORE S I Z E ;
 BEFORE                  : B E F O R E ;
-BUILD                   : B U I L D ;
 BOOTSTRAP_SERVERS       : B O O T S T R A P UNDERSCORE S E R V E R S ;
 CALL                    : C A L L ;
 CHECK                   : C H E C K ;
@@ -107,7 +106,6 @@ SNAPSHOT                : S N A P S H O T ;
 START                   : S T A R T ;
 STATISTICS              : S T A T I S T I C S ;
 STATS                   : S T A T S ;
-STATUS                  : S T A T U S ;
 STOP                    : S T O P ;
 STORAGE                 : S T O R A G E;
 STORAGE_MODE            : S T O R A G E UNDERSCORE MODE;

src/query/frontend/semantic/required_privileges.cpp

@@ -43,7 +43,6 @@ class PrivilegeExtractor : public QueryVisitor<void>, public HierarchicalTreeVis
         AddPrivilege(AuthQuery::Privilege::INDEX);
         break;
       case InfoQuery::InfoType::STORAGE:
-      case InfoQuery::InfoType::BUILD:
         AddPrivilege(AuthQuery::Privilege::STATS);
         break;
       case InfoQuery::InfoType::CONSTRAINT:

src/query/frontend/stripped_lexer_constants.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 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
@@ -145,7 +145,6 @@ const trie::Trie kKeywords = {"union",
                               "drop",
                               "show",
                               "stats",
-                              "status",
                               "unique",
                               "explain",
                               "profile",
@@ -212,12 +211,7 @@ const trie::Trie kKeywords = {"union",
                               "edge_types",
                               "off",
                               "in_memory_transactional",
-                              "in_memory_analytical",
-                              "data",
-                              "directory",
-                              "lock",
-                              "unlock"
-                              "build"};
+                              "in_memory_analytical"};
 
 // Unicode codepoints that are allowed at the start of the unescaped name.
 const std::bitset<kBitsetSize> kUnescapedNameAllowedStarts(

src/query/interpret/eval.hpp

@@ -17,7 +17,6 @@
 #include <map>
 #include <optional>
 #include <regex>
-#include <string>
 #include <vector>
 
 #include "query/common.hpp"
@@ -74,13 +73,11 @@ class ReferenceExpressionEvaluator : public ExpressionVisitor<TypedValue *> {
   UNSUCCESSFUL_VISIT(ListSlicingOperator);
   UNSUCCESSFUL_VISIT(IsNullOperator);
   UNSUCCESSFUL_VISIT(PropertyLookup);
-  UNSUCCESSFUL_VISIT(AllPropertiesLookup);
   UNSUCCESSFUL_VISIT(LabelsTest);
 
   UNSUCCESSFUL_VISIT(PrimitiveLiteral);
   UNSUCCESSFUL_VISIT(ListLiteral);
   UNSUCCESSFUL_VISIT(MapLiteral);
-  UNSUCCESSFUL_VISIT(MapProjectionLiteral);
   UNSUCCESSFUL_VISIT(Aggregation);
   UNSUCCESSFUL_VISIT(Coalesce);
   UNSUCCESSFUL_VISIT(Function);
@@ -469,101 +466,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
         throw QueryRuntimeException("Invalid property name {} for Graph", prop_name);
       }
       default:
-        throw QueryRuntimeException(
-            "Only nodes, edges, maps, temporal types and graphs have properties to be looked up.");
-    }
-  }
-
-  TypedValue Visit(AllPropertiesLookup &all_properties_lookup) override {
-    TypedValue::TMap result(ctx_->memory);
-
-    auto expression_result = all_properties_lookup.expression_->Accept(*this);
-    switch (expression_result.type()) {
-      case TypedValue::Type::Null:
-        return TypedValue(ctx_->memory);
-      case TypedValue::Type::Vertex: {
-        for (const auto properties = *expression_result.ValueVertex().Properties(view_);
-             const auto &[property_id, value] : properties) {
-          result.emplace(dba_->PropertyToName(property_id), value);
-        }
-        return TypedValue(result, ctx_->memory);
-      }
-      case TypedValue::Type::Edge: {
-        for (const auto properties = *expression_result.ValueEdge().Properties(view_);
-             const auto &[property_id, value] : properties) {
-          result.emplace(dba_->PropertyToName(property_id), value);
-        }
-        return TypedValue(result, ctx_->memory);
-      }
-      case TypedValue::Type::Map: {
-        for (auto &[name, value] : expression_result.ValueMap()) {
-          result.emplace(name, value);
-        }
-        return TypedValue(result, ctx_->memory);
-      }
-      case TypedValue::Type::Duration: {
-        const auto &dur = expression_result.ValueDuration();
-        result.emplace("day", TypedValue(dur.Days(), ctx_->memory));
-        result.emplace("hour", TypedValue(dur.SubDaysAsHours(), ctx_->memory));
-        result.emplace("minute", TypedValue(dur.SubDaysAsMinutes(), ctx_->memory));
-        result.emplace("second", TypedValue(dur.SubDaysAsSeconds(), ctx_->memory));
-        result.emplace("millisecond", TypedValue(dur.SubDaysAsMilliseconds(), ctx_->memory));
-        result.emplace("microseconds", TypedValue(dur.SubDaysAsMicroseconds(), ctx_->memory));
-        result.emplace("nanoseconds", TypedValue(dur.SubDaysAsNanoseconds(), ctx_->memory));
-        return TypedValue(result, ctx_->memory);
-      }
-      case TypedValue::Type::Date: {
-        const auto &date = expression_result.ValueDate();
-        result.emplace("year", TypedValue(date.year, ctx_->memory));
-        result.emplace("month", TypedValue(date.month, ctx_->memory));
-        result.emplace("day", TypedValue(date.day, ctx_->memory));
-        return TypedValue(result, ctx_->memory);
-      }
-      case TypedValue::Type::LocalTime: {
-        const auto &lt = expression_result.ValueLocalTime();
-        result.emplace("hour", TypedValue(lt.hour, ctx_->memory));
-        result.emplace("minute", TypedValue(lt.minute, ctx_->memory));
-        result.emplace("second", TypedValue(lt.second, ctx_->memory));
-        result.emplace("millisecond", TypedValue(lt.millisecond, ctx_->memory));
-        result.emplace("microsecond", TypedValue(lt.microsecond, ctx_->memory));
-        return TypedValue(result, ctx_->memory);
-      }
-      case TypedValue::Type::LocalDateTime: {
-        const auto &ldt = expression_result.ValueLocalDateTime();
-        const auto &date = ldt.date;
-        const auto &lt = ldt.local_time;
-        result.emplace("year", TypedValue(date.year, ctx_->memory));
-        result.emplace("month", TypedValue(date.month, ctx_->memory));
-        result.emplace("day", TypedValue(date.day, ctx_->memory));
-        result.emplace("hour", TypedValue(lt.hour, ctx_->memory));
-        result.emplace("minute", TypedValue(lt.minute, ctx_->memory));
-        result.emplace("second", TypedValue(lt.second, ctx_->memory));
-        result.emplace("millisecond", TypedValue(lt.millisecond, ctx_->memory));
-        result.emplace("microsecond", TypedValue(lt.microsecond, ctx_->memory));
-        return TypedValue(result, ctx_->memory);
-      }
-      case TypedValue::Type::Graph: {
-        const auto &graph = expression_result.ValueGraph();
-
-        utils::pmr::vector<TypedValue> vertices(ctx_->memory);
-        vertices.reserve(graph.vertices().size());
-        for (const auto &v : graph.vertices()) {
-          vertices.emplace_back(TypedValue(v, ctx_->memory));
-        }
-        result.emplace("nodes", TypedValue(std::move(vertices), ctx_->memory));
-
-        utils::pmr::vector<TypedValue> edges(ctx_->memory);
-        edges.reserve(graph.edges().size());
-        for (const auto &e : graph.edges()) {
-          edges.emplace_back(TypedValue(e, ctx_->memory));
-        }
-        result.emplace("edges", TypedValue(std::move(edges), ctx_->memory));
-
-        return TypedValue(result, ctx_->memory);
-      }
-      default:
-        throw QueryRuntimeException(
-            "Only nodes, edges, maps, temporal types and graphs have properties to be looked up.");
+        throw QueryRuntimeException("Only nodes, edges, maps and temporal types have properties to be looked-up.");
     }
   }
 
@@ -628,30 +531,6 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     return TypedValue(result, ctx_->memory);
   }
 
-  TypedValue Visit(MapProjectionLiteral &literal) override {
-    constexpr std::string_view kAllPropertiesSelector{"*"};
-
-    TypedValue::TMap result(ctx_->memory);
-    TypedValue::TMap all_properties_lookup(ctx_->memory);
-    for (const auto &[property_key, property_value] : literal.elements_) {
-      if (property_key.name == kAllPropertiesSelector.data()) {
-        auto maybe_all_properties_lookup = property_value->Accept(*this);
-
-        if (maybe_all_properties_lookup.type() != TypedValue::Type::Map) {
-          throw QueryRuntimeException("Expected a map from AllPropertiesLookup, got {}.",
-                                      maybe_all_properties_lookup.type());
-        }
-        all_properties_lookup = std::move(maybe_all_properties_lookup.ValueMap());
-        continue;
-      }
-
-      result.emplace(property_key.name, property_value->Accept(*this));
-    }
-    if (!all_properties_lookup.empty()) result.merge(all_properties_lookup);
-
-    return TypedValue(result, ctx_->memory);
-  }
-
   TypedValue Visit(Aggregation &aggregation) override {
     return TypedValue(frame_->at(symbol_table_->at(aggregation)), ctx_->memory);
   }
@@ -973,7 +852,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
   DbAccessor *dba_;
   // which switching approach should be used when evaluating
   storage::View view_;
-};  // namespace memgraph::query
+};
 
 /// A helper function for evaluating an expression that's an int.
 ///

src/query/interpreter.cpp

@@ -53,14 +53,10 @@
 #include "query/typed_value.hpp"
 #include "storage/v2/edge.hpp"
 #include "storage/v2/id_types.hpp"
-#include "storage/v2/isolation_level.hpp"
 #include "storage/v2/property_value.hpp"
-#include "storage/v2/storage_mode.hpp"
 #include "utils/algorithm.hpp"
-#include "utils/build_info.hpp"
 #include "utils/csv_parsing.hpp"
 #include "utils/event_counter.hpp"
-#include "utils/event_histogram.hpp"
 #include "utils/exceptions.hpp"
 #include "utils/flag_validation.hpp"
 #include "utils/likely.hpp"
@@ -75,20 +71,17 @@
 #include "utils/typeinfo.hpp"
 #include "utils/variant_helpers.hpp"
 
-namespace memgraph::metrics {
+namespace EventCounter {
 extern Event ReadQuery;
 extern Event WriteQuery;
 extern Event ReadWriteQuery;
 
+extern const Event LabelIndexCreated;
+extern const Event LabelPropertyIndexCreated;
+
 extern const Event StreamsCreated;
 extern const Event TriggersCreated;
-
-extern const Event QueryExecutionLatency_us;
-
-extern const Event CommitedTransactions;
-extern const Event RollbackedTransactions;
-extern const Event ActiveTransactions;
-}  // namespace memgraph::metrics
+}  // namespace EventCounter
 
 namespace memgraph::query {
 
@@ -99,13 +92,13 @@ namespace {
 void UpdateTypeCount(const plan::ReadWriteTypeChecker::RWType type) {
   switch (type) {
     case plan::ReadWriteTypeChecker::RWType::R:
-      memgraph::metrics::IncrementCounter(memgraph::metrics::ReadQuery);
+      EventCounter::IncrementCounter(EventCounter::ReadQuery);
       break;
     case plan::ReadWriteTypeChecker::RWType::W:
-      memgraph::metrics::IncrementCounter(memgraph::metrics::WriteQuery);
+      EventCounter::IncrementCounter(EventCounter::WriteQuery);
       break;
     case plan::ReadWriteTypeChecker::RWType::RW:
-      memgraph::metrics::IncrementCounter(memgraph::metrics::ReadWriteQuery);
+      EventCounter::IncrementCounter(EventCounter::ReadWriteQuery);
       break;
     default:
       break;
@@ -670,8 +663,6 @@ Callback::CallbackFunction GetKafkaCreateCallback(StreamQuery *stream_query, Exp
     return config_map;
   };
 
-  memgraph::metrics::IncrementCounter(memgraph::metrics::StreamsCreated);
-
   return [interpreter_context, stream_name = stream_query->stream_name_,
           topic_names = EvaluateTopicNames(evaluator, stream_query->topic_names_),
           consumer_group = std::move(consumer_group), common_stream_info = std::move(common_stream_info),
@@ -702,8 +693,6 @@ Callback::CallbackFunction GetPulsarCreateCallback(StreamQuery *stream_query, Ex
     throw SemanticException("Service URL must not be an empty string!");
   }
   auto common_stream_info = GetCommonStreamInfo(stream_query, evaluator);
-  memgraph::metrics::IncrementCounter(memgraph::metrics::StreamsCreated);
-
   return [interpreter_context, stream_name = stream_query->stream_name_,
           topic_names = EvaluateTopicNames(evaluator, stream_query->topic_names_),
           common_stream_info = std::move(common_stream_info), service_url = std::move(service_url),
@@ -734,6 +723,7 @@ Callback HandleStreamQuery(StreamQuery *stream_query, const Parameters &paramete
   Callback callback;
   switch (stream_query->action_) {
     case StreamQuery::Action::CREATE_STREAM: {
+      EventCounter::IncrementCounter(EventCounter::StreamsCreated);
       switch (stream_query->type_) {
         case StreamQuery::Type::KAFKA:
           callback.fn = GetKafkaCreateCallback(stream_query, evaluator, interpreter_context, username);
@@ -1076,18 +1066,16 @@ std::optional<plan::ProfilingStatsWithTotalTime> PullPlan::Pull(AnyStream *strea
   utils::ResourceWithOutOfMemoryException resource_with_exception;
   utils::MonotonicBufferResource monotonic_memory{&stack_data[0], stack_size, &resource_with_exception};
   std::optional<utils::PoolResource> pool_memory;
-  static constexpr auto kMaxBlockPerChunks = 128;
 
   if (!use_monotonic_memory_) {
-    pool_memory.emplace(kMaxBlockPerChunks, kExecutionPoolMaxBlockSize, &resource_with_exception,
-                        &resource_with_exception);
+    pool_memory.emplace(8, kExecutionPoolMaxBlockSize, utils::NewDeleteResource(), utils::NewDeleteResource());
   } else {
     // We can throw on every query because a simple queries for deleting will use only
     // the stack allocated buffer.
     // Also, we want to throw only when the query engine requests more memory and not the storage
     // so we add the exception to the allocator.
     // TODO (mferencevic): Tune the parameters accordingly.
-    pool_memory.emplace(kMaxBlockPerChunks, 1024, &monotonic_memory, &resource_with_exception);
+    pool_memory.emplace(128, 1024, &monotonic_memory, utils::NewDeleteResource());
   }
 
   std::optional<utils::LimitedMemoryResource> maybe_limited_resource;
@@ -1144,11 +1132,7 @@ std::optional<plan::ProfilingStatsWithTotalTime> PullPlan::Pull(AnyStream *strea
   if (has_unsent_results_) {
     return std::nullopt;
   }
-
   summary->insert_or_assign("plan_execution_time", execution_time_.count());
-  memgraph::metrics::Measure(memgraph::metrics::QueryExecutionLatency_us,
-                             std::chrono::duration_cast<std::chrono::microseconds>(execution_time_).count());
-
   // We are finished with pulling all the data, therefore we can send any
   // metadata about the results i.e. notifications and statistics
   const bool is_any_counter_set =
@@ -1185,9 +1169,6 @@ PreparedQuery Interpreter::PrepareTransactionQuery(std::string_view query_upper)
       if (in_explicit_transaction_) {
         throw ExplicitTransactionUsageException("Nested transactions are not supported.");
       }
-
-      memgraph::metrics::IncrementCounter(memgraph::metrics::ActiveTransactions);
-
       in_explicit_transaction_ = true;
       expect_rollback_ = false;
 
@@ -1226,9 +1207,6 @@ PreparedQuery Interpreter::PrepareTransactionQuery(std::string_view query_upper)
       if (!in_explicit_transaction_) {
         throw ExplicitTransactionUsageException("No current transaction to rollback.");
       }
-
-      memgraph::metrics::IncrementCounter(memgraph::metrics::RollbackedTransactions);
-
       Abort();
       expect_rollback_ = false;
       in_explicit_transaction_ = false;
@@ -1397,16 +1375,6 @@ PreparedQuery PrepareProfileQuery(ParsedQuery parsed_query, bool in_explicit_tra
                  &interpreter_context->ast_cache, interpreter_context->config.query);
 
   auto *cypher_query = utils::Downcast<CypherQuery>(parsed_inner_query.query);
-
-  bool contains_csv = false;
-  auto clauses = cypher_query->single_query_->clauses_;
-  if (std::any_of(clauses.begin(), clauses.end(),
-                  [](const auto *clause) { return clause->GetTypeInfo() == LoadCsv::kType; })) {
-    contains_csv = true;
-  }
-  // If this is LOAD CSV query, use PoolResource without MonotonicMemoryResource as we want to reuse allocated memory
-  auto use_monotonic_memory = !contains_csv;
-
   MG_ASSERT(cypher_query, "Cypher grammar should not allow other queries in PROFILE");
   Frame frame(0);
   SymbolTable symbol_table;
@@ -1431,14 +1399,14 @@ PreparedQuery PrepareProfileQuery(ParsedQuery parsed_query, bool in_explicit_tra
                         // We want to execute the query we are profiling lazily, so we delay
                         // the construction of the corresponding context.
                         stats_and_total_time = std::optional<plan::ProfilingStatsWithTotalTime>{},
-                        pull_plan = std::shared_ptr<PullPlanVector>(nullptr), transaction_status, use_monotonic_memory](
+                        pull_plan = std::shared_ptr<PullPlanVector>(nullptr), transaction_status](
                            AnyStream *stream, std::optional<int> n) mutable -> std::optional<QueryHandlerResult> {
                          // No output symbols are given so that nothing is streamed.
                          if (!stats_and_total_time) {
-                           stats_and_total_time = PullPlan(plan, parameters, true, dba, interpreter_context,
-                                                           execution_memory, optional_username, transaction_status,
-                                                           nullptr, memory_limit, use_monotonic_memory)
-                                                      .Pull(stream, {}, {}, summary);
+                           stats_and_total_time =
+                               PullPlan(plan, parameters, true, dba, interpreter_context, execution_memory,
+                                        optional_username, transaction_status, nullptr, memory_limit)
+                                   .Pull(stream, {}, {}, summary);
                            pull_plan = std::make_shared<PullPlanVector>(ProfilingStatsToTable(*stats_and_total_time));
                          }
 
@@ -1655,6 +1623,7 @@ PreparedQuery PrepareIndexQuery(ParsedQuery parsed_query, bool in_explicit_trans
               [&index_notification, &label_name, &properties_stringified]<typename T>(T &&) {
                 using ErrorType = std::remove_cvref_t<T>;
                 if constexpr (std::is_same_v<ErrorType, storage::ReplicationError>) {
+                  EventCounter::IncrementCounter(EventCounter::LabelIndexCreated);
                   throw ReplicationException(
                       fmt::format("At least one SYNC replica has not confirmed the creation of the index on label {} "
                                   "on properties {}.",
@@ -1668,6 +1637,8 @@ PreparedQuery PrepareIndexQuery(ParsedQuery parsed_query, bool in_explicit_trans
                 }
               },
               error);
+        } else {
+          EventCounter::IncrementCounter(EventCounter::LabelIndexCreated);
         }
       };
       break;
@@ -1794,49 +1765,25 @@ PreparedQuery PrepareLockPathQuery(ParsedQuery parsed_query, bool in_explicit_tr
 
   auto *lock_path_query = utils::Downcast<LockPathQuery>(parsed_query.query);
 
-  return PreparedQuery{
-      {"STATUS"},
-      std::move(parsed_query.required_privileges),
-      [interpreter_context, action = lock_path_query->action_](
-          AnyStream *stream, std::optional<int> n) -> std::optional<QueryHandlerResult> {
-        std::vector<std::vector<TypedValue>> status;
-        std::string res;
-
-        switch (action) {
-          case LockPathQuery::Action::LOCK_PATH: {
-            const auto lock_success = interpreter_context->db->LockPath();
-            if (lock_success.HasError()) [[unlikely]] {
-              throw QueryRuntimeException("Failed to lock the data directory");
-            }
-            res = lock_success.GetValue() ? "Data directory is now locked." : "Data directory is already locked.";
-            break;
-          }
-          case LockPathQuery::Action::UNLOCK_PATH: {
-            const auto unlock_success = interpreter_context->db->UnlockPath();
-            if (unlock_success.HasError()) [[unlikely]] {
-              throw QueryRuntimeException("Failed to unlock the data directory");
-            }
-            res = unlock_success.GetValue() ? "Data directory is now unlocked." : "Data directory is already unlocked.";
-            break;
-          }
-          case LockPathQuery::Action::STATUS: {
-            const auto locked_status = interpreter_context->db->IsPathLocked();
-            if (locked_status.HasError()) [[unlikely]] {
-              throw QueryRuntimeException("Failed to access the data directory");
-            }
-            res = locked_status.GetValue() ? "Data directory is locked." : "Data directory is unlocked.";
-            break;
-          }
-        }
-
-        status.emplace_back(std::vector<TypedValue>{TypedValue(res)});
-        auto pull_plan = std::make_shared<PullPlanVector>(std::move(status));
-        if (pull_plan->Pull(stream, n)) {
-          return QueryHandlerResult::COMMIT;
-        }
-        return std::nullopt;
-      },
-      RWType::NONE};
+  return PreparedQuery{{},
+                       std::move(parsed_query.required_privileges),
+                       [interpreter_context, action = lock_path_query->action_](
+                           AnyStream *stream, std::optional<int> n) -> std::optional<QueryHandlerResult> {
+                         switch (action) {
+                           case LockPathQuery::Action::LOCK_PATH:
+                             if (!interpreter_context->db->LockPath()) {
+                               throw QueryRuntimeException("Failed to lock the data directory");
+                             }
+                             break;
+                           case LockPathQuery::Action::UNLOCK_PATH:
+                             if (!interpreter_context->db->UnlockPath()) {
+                               throw QueryRuntimeException("Failed to unlock the data directory");
+                             }
+                             break;
+                         }
+                         return QueryHandlerResult::COMMIT;
+                       },
+                       RWType::NONE};
 }
 
 PreparedQuery PrepareFreeMemoryQuery(ParsedQuery parsed_query, bool in_explicit_transaction,
@@ -1924,7 +1871,6 @@ Callback CreateTrigger(TriggerQuery *trigger_query,
             std::move(trigger_name), trigger_statement, user_parameters, ToTriggerEventType(event_type),
             before_commit ? TriggerPhase::BEFORE_COMMIT : TriggerPhase::AFTER_COMMIT, &interpreter_context->ast_cache,
             dba, interpreter_context->config.query, std::move(owner), interpreter_context->auth_checker);
-        memgraph::metrics::IncrementCounter(memgraph::metrics::TriggersCreated);
         return {};
       }};
 }
@@ -1979,6 +1925,7 @@ PreparedQuery PrepareTriggerQuery(ParsedQuery parsed_query, bool in_explicit_tra
       case TriggerQuery::Action::CREATE_TRIGGER:
         trigger_notification.emplace(SeverityLevel::INFO, NotificationCode::CREATE_TRIGGER,
                                      fmt::format("Created trigger {}.", trigger_query->trigger_name_));
+        EventCounter::IncrementCounter(EventCounter::TriggersCreated);
         return CreateTrigger(trigger_query, user_parameters, interpreter_context, dba, std::move(owner));
       case TriggerQuery::Action::DROP_TRIGGER:
         trigger_notification.emplace(SeverityLevel::INFO, NotificationCode::DROP_TRIGGER,
@@ -2359,10 +2306,8 @@ PreparedQuery PrepareVersionQuery(ParsedQuery parsed_query, bool in_explicit_tra
 }
 
 PreparedQuery PrepareInfoQuery(ParsedQuery parsed_query, bool in_explicit_transaction,
-                               std::map<std::string, TypedValue> * /*summary*/, InterpreterContext *interpreter_context,
-                               storage::Storage *db, utils::MemoryResource * /*execution_memory*/,
-                               std::optional<storage::IsolationLevel> interpreter_isolation_level,
-                               std::optional<storage::IsolationLevel> next_transaction_isolation_level) {
+                               std::map<std::string, TypedValue> *summary, InterpreterContext *interpreter_context,
+                               storage::Storage *db, utils::MemoryResource *execution_memory) {
   if (in_explicit_transaction) {
     throw InfoInMulticommandTxException();
   }
@@ -2374,8 +2319,7 @@ PreparedQuery PrepareInfoQuery(ParsedQuery parsed_query, bool in_explicit_transa
   switch (info_query->info_type_) {
     case InfoQuery::InfoType::STORAGE:
       header = {"storage info", "value"};
-
-      handler = [db, interpreter_isolation_level, next_transaction_isolation_level] {
+      handler = [db] {
         auto info = db->GetInfo();
         std::vector<std::vector<TypedValue>> results{
             {TypedValue("vertex_count"), TypedValue(static_cast<int64_t>(info.vertex_count))},
@@ -2384,12 +2328,8 @@ PreparedQuery PrepareInfoQuery(ParsedQuery parsed_query, bool in_explicit_transa
             {TypedValue("memory_usage"), TypedValue(static_cast<int64_t>(info.memory_usage))},
             {TypedValue("disk_usage"), TypedValue(static_cast<int64_t>(info.disk_usage))},
             {TypedValue("memory_allocated"), TypedValue(static_cast<int64_t>(utils::total_memory_tracker.Amount()))},
-            {TypedValue("allocation_limit"), TypedValue(static_cast<int64_t>(utils::total_memory_tracker.HardLimit()))},
-            {TypedValue("global_isolation_level"), TypedValue(IsolationLevelToString(db->GetIsolationLevel()))},
-            {TypedValue("session_isolation_level"), TypedValue(IsolationLevelToString(interpreter_isolation_level))},
-            {TypedValue("next_session_isolation_level"),
-             TypedValue(IsolationLevelToString(next_transaction_isolation_level))},
-            {TypedValue("storage_mode"), TypedValue(StorageModeToString(db->GetStorageMode()))}};
+            {TypedValue("allocation_limit"),
+             TypedValue(static_cast<int64_t>(utils::total_memory_tracker.HardLimit()))}};
         return std::pair{results, QueryHandlerResult::COMMIT};
       };
       break;
@@ -2433,15 +2373,6 @@ PreparedQuery PrepareInfoQuery(ParsedQuery parsed_query, bool in_explicit_transa
         return std::pair{results, QueryHandlerResult::NOTHING};
       };
       break;
-
-    case InfoQuery::InfoType::BUILD:
-      header = {"build info", "value"};
-      handler = [] {
-        std::vector<std::vector<TypedValue>> results{
-            {TypedValue("build_type"), TypedValue(utils::GetBuildInfo().build_name)}};
-        return std::pair{results, QueryHandlerResult::NOTHING};
-      };
-      break;
   }
 
   return PreparedQuery{std::move(header), std::move(parsed_query.required_privileges),
@@ -2772,14 +2703,14 @@ Interpreter::PrepareResult Interpreter::Prepare(const std::string &query_string,
   // an explicit transaction block.
   if (in_explicit_transaction_) {
     AdvanceCommand();
-  } else if (db_accessor_) {
-    // If we're not in an explicit transaction block and we have an open
-    // transaction, abort it since we're about to prepare a new query.
+  }
+  // If we're not in an explicit transaction block and we have an open
+  // transaction, abort it since we're about to prepare a new query.
+  else if (db_accessor_) {
     query_executions_.emplace_back(
         std::make_unique<QueryExecution>(utils::MonotonicBufferResource(kExecutionMemoryBlockSize)));
     AbortCommand(&query_executions_.back());
   }
-
   std::unique_ptr<QueryExecution> *query_execution_ptr = nullptr;
   try {
     query_executions_.emplace_back(
@@ -2790,15 +2721,8 @@ Interpreter::PrepareResult Interpreter::Prepare(const std::string &query_string,
         ParseQuery(query_string, params, &interpreter_context_->ast_cache, interpreter_context_->config.query);
     TypedValue parsing_time{parsing_timer.Elapsed().count()};
 
-    if ((utils::Downcast<CypherQuery>(parsed_query.query) || utils::Downcast<ProfileQuery>(parsed_query.query))) {
-      CypherQuery *cypher_query = nullptr;
-      if (utils::Downcast<CypherQuery>(parsed_query.query)) {
-        cypher_query = utils::Downcast<CypherQuery>(parsed_query.query);
-      } else {
-        auto *profile_query = utils::Downcast<ProfileQuery>(parsed_query.query);
-        cypher_query = profile_query->cypher_query_;
-      }
-
+    if (utils::Downcast<CypherQuery>(parsed_query.query)) {
+      auto *cypher_query = utils::Downcast<CypherQuery>(parsed_query.query);
       if (const auto &clauses = cypher_query->single_query_->clauses_;
           std::any_of(clauses.begin(), clauses.end(),
                       [](const auto *clause) { return clause->GetTypeInfo() == LoadCsv::kType; })) {
@@ -2827,7 +2751,6 @@ Interpreter::PrepareResult Interpreter::Prepare(const std::string &query_string,
          utils::Downcast<ProfileQuery>(parsed_query.query) || utils::Downcast<DumpQuery>(parsed_query.query) ||
          utils::Downcast<TriggerQuery>(parsed_query.query) || utils::Downcast<AnalyzeGraphQuery>(parsed_query.query) ||
          utils::Downcast<TransactionQueueQuery>(parsed_query.query))) {
-      memgraph::metrics::IncrementCounter(memgraph::metrics::ActiveTransactions);
       db_accessor_ =
           std::make_unique<storage::Storage::Accessor>(interpreter_context_->db->Access(GetIsolationLevelOverride()));
       execution_db_accessor_.emplace(db_accessor_.get());
@@ -2871,8 +2794,7 @@ Interpreter::PrepareResult Interpreter::Prepare(const std::string &query_string,
     } else if (utils::Downcast<InfoQuery>(parsed_query.query)) {
       prepared_query = PrepareInfoQuery(std::move(parsed_query), in_explicit_transaction_, &query_execution->summary,
                                         interpreter_context_, interpreter_context_->db,
-                                        &query_execution->execution_memory_with_exception, interpreter_isolation_level,
-                                        next_transaction_isolation_level);
+                                        &query_execution->execution_memory_with_exception);
     } else if (utils::Downcast<ConstraintQuery>(parsed_query.query)) {
       prepared_query = PrepareConstraintQuery(std::move(parsed_query), in_explicit_transaction_,
                                               &query_execution->notifications, interpreter_context_);
@@ -2931,7 +2853,7 @@ Interpreter::PrepareResult Interpreter::Prepare(const std::string &query_string,
 
     return {query_execution->prepared_query->header, query_execution->prepared_query->privileges, qid};
   } catch (const utils::BasicException &) {
-    memgraph::metrics::IncrementCounter(memgraph::metrics::FailedQuery);
+    EventCounter::IncrementCounter(EventCounter::FailedQuery);
     AbortCommand(query_execution_ptr);
     throw;
   }
@@ -2962,11 +2884,7 @@ void Interpreter::Abort() {
 
   expect_rollback_ = false;
   in_explicit_transaction_ = false;
-
-  memgraph::metrics::DecrementCounter(memgraph::metrics::ActiveTransactions);
-
   if (!db_accessor_) return;
-
   db_accessor_->Abort();
   execution_db_accessor_.reset();
   db_accessor_.reset();
@@ -3062,11 +2980,6 @@ void Interpreter::Commit() {
   utils::OnScopeExit clean_status(
       [this]() { transaction_status_.store(TransactionStatus::IDLE, std::memory_order_release); });
 
-  utils::OnScopeExit update_metrics([]() {
-    memgraph::metrics::IncrementCounter(memgraph::metrics::CommitedTransactions);
-    memgraph::metrics::DecrementCounter(memgraph::metrics::ActiveTransactions);
-  });
-
   std::optional<TriggerContext> trigger_context = std::nullopt;
   if (trigger_context_collector_) {
     trigger_context.emplace(std::move(*trigger_context_collector_).TransformToTriggerContext());

src/query/interpreter.hpp

@@ -44,14 +44,14 @@
 #include "utils/timer.hpp"
 #include "utils/tsc.hpp"
 
-namespace memgraph::metrics {
+namespace EventCounter {
 extern const Event FailedQuery;
-}  // namespace memgraph::metrics
+}  // namespace EventCounter
 
 namespace memgraph::query {
 
 inline constexpr size_t kExecutionMemoryBlockSize = 1UL * 1024UL * 1024UL;
-inline constexpr size_t kExecutionPoolMaxBlockSize = 1024UL;  // 2 ^ 10
+inline constexpr size_t kExecutionPoolMaxBlockSize = 2048UL;  // 2 ^ 11
 
 class AuthQueryHandler {
  public:
@@ -515,7 +515,7 @@ std::map<std::string, TypedValue> Interpreter::Pull(TStream *result_stream, std:
     query_execution.reset(nullptr);
     throw;
   } catch (const utils::BasicException &) {
-    memgraph::metrics::IncrementCounter(memgraph::metrics::FailedQuery);
+    EventCounter::IncrementCounter(EventCounter::FailedQuery);
     AbortCommand(&query_execution);
     throw;
   }

src/query/plan/operator.cpp

@@ -53,7 +53,6 @@
 #include "utils/likely.hpp"
 #include "utils/logging.hpp"
 #include "utils/memory.hpp"
-#include "utils/pmr/deque.hpp"
 #include "utils/pmr/list.hpp"
 #include "utils/pmr/unordered_map.hpp"
 #include "utils/pmr/unordered_set.hpp"
@@ -81,7 +80,7 @@
     LOG_FATAL("Operator " #class_name " has no single input!");  \
   }
 
-namespace memgraph::metrics {
+namespace EventCounter {
 extern const Event OnceOperator;
 extern const Event CreateNodeOperator;
 extern const Event CreateExpandOperator;
@@ -119,7 +118,7 @@ extern const Event ForeachOperator;
 extern const Event EmptyResultOperator;
 extern const Event EvaluatePatternFilterOperator;
 extern const Event ApplyOperator;
-}  // namespace memgraph::metrics
+}  // namespace EventCounter
 
 namespace memgraph::query::plan {
 
@@ -170,7 +169,7 @@ bool Once::OnceCursor::Pull(Frame &, ExecutionContext &context) {
 }
 
 UniqueCursorPtr Once::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::OnceOperator);
+  EventCounter::IncrementCounter(EventCounter::OnceOperator);
 
   return MakeUniqueCursorPtr<OnceCursor>(mem);
 }
@@ -232,7 +231,7 @@ VertexAccessor &CreateLocalVertex(const NodeCreationInfo &node_info, Frame *fram
 ACCEPT_WITH_INPUT(CreateNode)
 
 UniqueCursorPtr CreateNode::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::CreateNodeOperator);
+  EventCounter::IncrementCounter(EventCounter::CreateNodeOperator);
 
   return MakeUniqueCursorPtr<CreateNodeCursor>(mem, *this, mem);
 }
@@ -282,7 +281,7 @@ CreateExpand::CreateExpand(const NodeCreationInfo &node_info, const EdgeCreation
 ACCEPT_WITH_INPUT(CreateExpand)
 
 UniqueCursorPtr CreateExpand::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::CreateNodeOperator);
+  EventCounter::IncrementCounter(EventCounter::CreateNodeOperator);
 
   return MakeUniqueCursorPtr<CreateExpandCursor>(mem, *this, mem);
 }
@@ -489,7 +488,7 @@ ScanAll::ScanAll(const std::shared_ptr<LogicalOperator> &input, Symbol output_sy
 ACCEPT_WITH_INPUT(ScanAll)
 
 UniqueCursorPtr ScanAll::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::ScanAllOperator);
+  EventCounter::IncrementCounter(EventCounter::ScanAllOperator);
 
   auto vertices = [this](Frame &, ExecutionContext &context) {
     auto *db = context.db_accessor;
@@ -512,7 +511,7 @@ ScanAllByLabel::ScanAllByLabel(const std::shared_ptr<LogicalOperator> &input, Sy
 ACCEPT_WITH_INPUT(ScanAllByLabel)
 
 UniqueCursorPtr ScanAllByLabel::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::ScanAllByLabelOperator);
+  EventCounter::IncrementCounter(EventCounter::ScanAllByLabelOperator);
 
   auto vertices = [this](Frame &, ExecutionContext &context) {
     auto *db = context.db_accessor;
@@ -542,7 +541,7 @@ ScanAllByLabelPropertyRange::ScanAllByLabelPropertyRange(const std::shared_ptr<L
 ACCEPT_WITH_INPUT(ScanAllByLabelPropertyRange)
 
 UniqueCursorPtr ScanAllByLabelPropertyRange::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::ScanAllByLabelPropertyRangeOperator);
+  EventCounter::IncrementCounter(EventCounter::ScanAllByLabelPropertyRangeOperator);
 
   auto vertices = [this](Frame &frame, ExecutionContext &context)
       -> std::optional<decltype(context.db_accessor->Vertices(view_, label_, property_, std::nullopt, std::nullopt))> {
@@ -602,7 +601,7 @@ ScanAllByLabelPropertyValue::ScanAllByLabelPropertyValue(const std::shared_ptr<L
 ACCEPT_WITH_INPUT(ScanAllByLabelPropertyValue)
 
 UniqueCursorPtr ScanAllByLabelPropertyValue::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::ScanAllByLabelPropertyValueOperator);
+  EventCounter::IncrementCounter(EventCounter::ScanAllByLabelPropertyValueOperator);
 
   auto vertices = [this](Frame &frame, ExecutionContext &context)
       -> std::optional<decltype(context.db_accessor->Vertices(view_, label_, property_, storage::PropertyValue()))> {
@@ -627,7 +626,7 @@ ScanAllByLabelProperty::ScanAllByLabelProperty(const std::shared_ptr<LogicalOper
 ACCEPT_WITH_INPUT(ScanAllByLabelProperty)
 
 UniqueCursorPtr ScanAllByLabelProperty::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::ScanAllByLabelPropertyOperator);
+  EventCounter::IncrementCounter(EventCounter::ScanAllByLabelPropertyOperator);
 
   auto vertices = [this](Frame &frame, ExecutionContext &context) {
     auto *db = context.db_accessor;
@@ -646,7 +645,7 @@ ScanAllById::ScanAllById(const std::shared_ptr<LogicalOperator> &input, Symbol o
 ACCEPT_WITH_INPUT(ScanAllById)
 
 UniqueCursorPtr ScanAllById::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::ScanAllByIdOperator);
+  EventCounter::IncrementCounter(EventCounter::ScanAllByIdOperator);
 
   auto vertices = [this](Frame &frame, ExecutionContext &context) -> std::optional<std::vector<VertexAccessor>> {
     auto *db = context.db_accessor;
@@ -701,7 +700,7 @@ Expand::Expand(const std::shared_ptr<LogicalOperator> &input, Symbol input_symbo
 ACCEPT_WITH_INPUT(Expand)
 
 UniqueCursorPtr Expand::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::ExpandOperator);
+  EventCounter::IncrementCounter(EventCounter::ExpandOperator);
 
   return MakeUniqueCursorPtr<ExpandCursor>(mem, *this, mem);
 }
@@ -2171,7 +2170,7 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
 };
 
 UniqueCursorPtr ExpandVariable::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::ExpandVariableOperator);
+  EventCounter::IncrementCounter(EventCounter::ExpandVariableOperator);
 
   switch (type_) {
     case EdgeAtom::Type::BREADTH_FIRST:
@@ -2274,7 +2273,7 @@ class ConstructNamedPathCursor : public Cursor {
 ACCEPT_WITH_INPUT(ConstructNamedPath)
 
 UniqueCursorPtr ConstructNamedPath::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::ConstructNamedPathOperator);
+  EventCounter::IncrementCounter(EventCounter::ConstructNamedPathOperator);
 
   return MakeUniqueCursorPtr<ConstructNamedPathCursor>(mem, *this, mem);
 }
@@ -2300,7 +2299,7 @@ bool Filter::Accept(HierarchicalLogicalOperatorVisitor &visitor) {
 }
 
 UniqueCursorPtr Filter::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::FilterOperator);
+  EventCounter::IncrementCounter(EventCounter::FilterOperator);
 
   return MakeUniqueCursorPtr<FilterCursor>(mem, *this, mem);
 }
@@ -2353,7 +2352,7 @@ EvaluatePatternFilter::EvaluatePatternFilter(const std::shared_ptr<LogicalOperat
 ACCEPT_WITH_INPUT(EvaluatePatternFilter);
 
 UniqueCursorPtr EvaluatePatternFilter::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::EvaluatePatternFilterOperator);
+  EventCounter::IncrementCounter(EventCounter::EvaluatePatternFilterOperator);
 
   return MakeUniqueCursorPtr<EvaluatePatternFilterCursor>(mem, *this, mem);
 }
@@ -2386,7 +2385,7 @@ Produce::Produce(const std::shared_ptr<LogicalOperator> &input, const std::vecto
 ACCEPT_WITH_INPUT(Produce)
 
 UniqueCursorPtr Produce::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::ProduceOperator);
+  EventCounter::IncrementCounter(EventCounter::ProduceOperator);
 
   return MakeUniqueCursorPtr<ProduceCursor>(mem, *this, mem);
 }
@@ -2429,7 +2428,7 @@ Delete::Delete(const std::shared_ptr<LogicalOperator> &input_, const std::vector
 ACCEPT_WITH_INPUT(Delete)
 
 UniqueCursorPtr Delete::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::DeleteOperator);
+  EventCounter::IncrementCounter(EventCounter::DeleteOperator);
 
   return MakeUniqueCursorPtr<DeleteCursor>(mem, *this, mem);
 }
@@ -2581,7 +2580,7 @@ SetProperty::SetProperty(const std::shared_ptr<LogicalOperator> &input, storage:
 ACCEPT_WITH_INPUT(SetProperty)
 
 UniqueCursorPtr SetProperty::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::SetPropertyOperator);
+  EventCounter::IncrementCounter(EventCounter::SetPropertyOperator);
 
   return MakeUniqueCursorPtr<SetPropertyCursor>(mem, *this, mem);
 }
@@ -2664,7 +2663,7 @@ SetProperties::SetProperties(const std::shared_ptr<LogicalOperator> &input, Symb
 ACCEPT_WITH_INPUT(SetProperties)
 
 UniqueCursorPtr SetProperties::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::SetPropertiesOperator);
+  EventCounter::IncrementCounter(EventCounter::SetPropertiesOperator);
 
   return MakeUniqueCursorPtr<SetPropertiesCursor>(mem, *this, mem);
 }
@@ -2861,7 +2860,7 @@ SetLabels::SetLabels(const std::shared_ptr<LogicalOperator> &input, Symbol input
 ACCEPT_WITH_INPUT(SetLabels)
 
 UniqueCursorPtr SetLabels::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::SetLabelsOperator);
+  EventCounter::IncrementCounter(EventCounter::SetLabelsOperator);
 
   return MakeUniqueCursorPtr<SetLabelsCursor>(mem, *this, mem);
 }
@@ -2933,7 +2932,7 @@ RemoveProperty::RemoveProperty(const std::shared_ptr<LogicalOperator> &input, st
 ACCEPT_WITH_INPUT(RemoveProperty)
 
 UniqueCursorPtr RemoveProperty::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::RemovePropertyOperator);
+  EventCounter::IncrementCounter(EventCounter::RemovePropertyOperator);
 
   return MakeUniqueCursorPtr<RemovePropertyCursor>(mem, *this, mem);
 }
@@ -3019,7 +3018,7 @@ RemoveLabels::RemoveLabels(const std::shared_ptr<LogicalOperator> &input, Symbol
 ACCEPT_WITH_INPUT(RemoveLabels)
 
 UniqueCursorPtr RemoveLabels::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::RemoveLabelsOperator);
+  EventCounter::IncrementCounter(EventCounter::RemoveLabelsOperator);
 
   return MakeUniqueCursorPtr<RemoveLabelsCursor>(mem, *this, mem);
 }
@@ -3092,7 +3091,7 @@ EdgeUniquenessFilter::EdgeUniquenessFilter(const std::shared_ptr<LogicalOperator
 ACCEPT_WITH_INPUT(EdgeUniquenessFilter)
 
 UniqueCursorPtr EdgeUniquenessFilter::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::EdgeUniquenessFilterOperator);
+  EventCounter::IncrementCounter(EventCounter::EdgeUniquenessFilterOperator);
 
   return MakeUniqueCursorPtr<EdgeUniquenessFilterCursor>(mem, *this, mem);
 }
@@ -3194,7 +3193,7 @@ class EmptyResultCursor : public Cursor {
 };
 
 UniqueCursorPtr EmptyResult::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::EmptyResultOperator);
+  EventCounter::IncrementCounter(EventCounter::EmptyResultOperator);
 
   return MakeUniqueCursorPtr<EmptyResultCursor>(mem, *this, mem);
 }
@@ -3249,13 +3248,13 @@ class AccumulateCursor : public Cursor {
  private:
   const Accumulate &self_;
   const UniqueCursorPtr input_cursor_;
-  utils::pmr::deque<utils::pmr::vector<TypedValue>> cache_;
+  utils::pmr::vector<utils::pmr::vector<TypedValue>> cache_;
   decltype(cache_.begin()) cache_it_ = cache_.begin();
   bool pulled_all_input_{false};
 };
 
 UniqueCursorPtr Accumulate::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::AccumulateOperator);
+  EventCounter::IncrementCounter(EventCounter::AccumulateOperator);
 
   return MakeUniqueCursorPtr<AccumulateCursor>(mem, *this, mem);
 }
@@ -3617,7 +3616,7 @@ class AggregateCursor : public Cursor {
 };
 
 UniqueCursorPtr Aggregate::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::AggregateOperator);
+  EventCounter::IncrementCounter(EventCounter::AggregateOperator);
 
   return MakeUniqueCursorPtr<AggregateCursor>(mem, *this, mem);
 }
@@ -3628,7 +3627,7 @@ Skip::Skip(const std::shared_ptr<LogicalOperator> &input, Expression *expression
 ACCEPT_WITH_INPUT(Skip)
 
 UniqueCursorPtr Skip::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::SkipOperator);
+  EventCounter::IncrementCounter(EventCounter::SkipOperator);
 
   return MakeUniqueCursorPtr<SkipCursor>(mem, *this, mem);
 }
@@ -3681,7 +3680,7 @@ Limit::Limit(const std::shared_ptr<LogicalOperator> &input, Expression *expressi
 ACCEPT_WITH_INPUT(Limit)
 
 UniqueCursorPtr Limit::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::LimitOperator);
+  EventCounter::IncrementCounter(EventCounter::LimitOperator);
 
   return MakeUniqueCursorPtr<LimitCursor>(mem, *this, mem);
 }
@@ -3829,7 +3828,7 @@ class OrderByCursor : public Cursor {
 };
 
 UniqueCursorPtr OrderBy::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::OrderByOperator);
+  EventCounter::IncrementCounter(EventCounter::OrderByOperator);
 
   return MakeUniqueCursorPtr<OrderByCursor>(mem, *this, mem);
 }
@@ -3846,7 +3845,7 @@ bool Merge::Accept(HierarchicalLogicalOperatorVisitor &visitor) {
 }
 
 UniqueCursorPtr Merge::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::MergeOperator);
+  EventCounter::IncrementCounter(EventCounter::MergeOperator);
 
   return MakeUniqueCursorPtr<MergeCursor>(mem, *this, mem);
 }
@@ -3926,7 +3925,7 @@ bool Optional::Accept(HierarchicalLogicalOperatorVisitor &visitor) {
 }
 
 UniqueCursorPtr Optional::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::OptionalOperator);
+  EventCounter::IncrementCounter(EventCounter::OptionalOperator);
 
   return MakeUniqueCursorPtr<OptionalCursor>(mem, *this, mem);
 }
@@ -4054,7 +4053,7 @@ class UnwindCursor : public Cursor {
 };
 
 UniqueCursorPtr Unwind::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::UnwindOperator);
+  EventCounter::IncrementCounter(EventCounter::UnwindOperator);
 
   return MakeUniqueCursorPtr<UnwindCursor>(mem, *this, mem);
 }
@@ -4108,7 +4107,7 @@ Distinct::Distinct(const std::shared_ptr<LogicalOperator> &input, const std::vec
 ACCEPT_WITH_INPUT(Distinct)
 
 UniqueCursorPtr Distinct::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::DistinctOperator);
+  EventCounter::IncrementCounter(EventCounter::DistinctOperator);
 
   return MakeUniqueCursorPtr<DistinctCursor>(mem, *this, mem);
 }
@@ -4130,7 +4129,7 @@ Union::Union(const std::shared_ptr<LogicalOperator> &left_op, const std::shared_
       right_symbols_(right_symbols) {}
 
 UniqueCursorPtr Union::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::UnionOperator);
+  EventCounter::IncrementCounter(EventCounter::UnionOperator);
 
   return MakeUniqueCursorPtr<Union::UnionCursor>(mem, *this, mem);
 }
@@ -4289,7 +4288,7 @@ class CartesianCursor : public Cursor {
 }  // namespace
 
 UniqueCursorPtr Cartesian::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::CartesianOperator);
+  EventCounter::IncrementCounter(EventCounter::CartesianOperator);
 
   return MakeUniqueCursorPtr<CartesianCursor>(mem, *this, mem);
 }
@@ -4545,7 +4544,7 @@ class CallProcedureCursor : public Cursor {
       result_row_it_ = result_.rows.begin();
     }
 
-    auto &values = result_row_it_->values;
+    const auto &values = result_row_it_->values;
     // Check that the row has all fields as required by the result signature.
     // C API guarantees that it's impossible to set fields which are not part of
     // the result record, but it does not gurantee that some may be missing. See
@@ -4563,7 +4562,7 @@ class CallProcedureCursor : public Cursor {
         throw QueryRuntimeException("Procedure '{}' did not yield a record with '{}' field.", self_->procedure_name_,
                                     field_name);
       }
-      frame[self_->result_symbols_[i]] = std::move(result_it->second);
+      frame[self_->result_symbols_[i]] = result_it->second;
     }
     ++result_row_it_;
 
@@ -4580,7 +4579,7 @@ class CallProcedureCursor : public Cursor {
 };
 
 UniqueCursorPtr CallProcedure::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::CallProcedureOperator);
+  EventCounter::IncrementCounter(EventCounter::CallProcedureOperator);
   CallProcedure::IncrementCounter(procedure_name_);
 
   return MakeUniqueCursorPtr<CallProcedureCursor>(mem, this, mem);
@@ -4786,7 +4785,7 @@ Foreach::Foreach(std::shared_ptr<LogicalOperator> input, std::shared_ptr<Logical
       loop_variable_symbol_(loop_variable_symbol) {}
 
 UniqueCursorPtr Foreach::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::ForeachOperator);
+  EventCounter::IncrementCounter(EventCounter::ForeachOperator);
   return MakeUniqueCursorPtr<ForeachCursor>(mem, *this, mem);
 }
 
@@ -4818,7 +4817,7 @@ bool Apply::Accept(HierarchicalLogicalOperatorVisitor &visitor) {
 }
 
 UniqueCursorPtr Apply::MakeCursor(utils::MemoryResource *mem) const {
-  memgraph::metrics::IncrementCounter(memgraph::metrics::ApplyOperator);
+  EventCounter::IncrementCounter(EventCounter::ApplyOperator);
 
   return MakeUniqueCursorPtr<ApplyCursor>(mem, *this, mem);
 }

src/query/plan/preprocess.hpp

@@ -180,7 +180,6 @@ class PatternFilterVisitor : public ExpressionVisitor<void> {
   void Visit(IfOperator &op) override{};
   void Visit(ListLiteral &op) override{};
   void Visit(MapLiteral &op) override{};
-  void Visit(MapProjectionLiteral &op) override{};
   void Visit(LabelsTest &op) override{};
   void Visit(Aggregation &op) override{};
   void Visit(Function &op) override{};
@@ -195,7 +194,6 @@ class PatternFilterVisitor : public ExpressionVisitor<void> {
   void Visit(Identifier &op) override{};
   void Visit(PrimitiveLiteral &op) override{};
   void Visit(PropertyLookup &op) override{};
-  void Visit(AllPropertiesLookup &op) override{};
   void Visit(ParameterLookup &op) override{};
   void Visit(NamedExpression &op) override{};
   void Visit(RegexMatch &op) override{};

src/query/plan/rule_based_planner.cpp

@@ -124,18 +124,11 @@ class ReturnBodyContext : public HierarchicalTreeVisitor {
 
   bool PostVisit(MapLiteral &map_literal) override {
     MG_ASSERT(map_literal.elements_.size() <= has_aggregation_.size(),
-              "Expected as many has_aggregation_ flags as there are map elements.");
+              "Expected has_aggregation_ flags as much as there are map elements.");
     PostVisitCollectionLiteral(map_literal, [](auto it) { return it->second; });
     return true;
   }
 
-  bool PostVisit(MapProjectionLiteral &map_projection_literal) override {
-    MG_ASSERT(map_projection_literal.elements_.size() <= has_aggregation_.size(),
-              "Expected as many has_aggregation_ flags as there are map elements.");
-    PostVisitCollectionLiteral(map_projection_literal, [](auto it) { return it->second; });
-    return true;
-  }
-
   bool PostVisit(All &all) override {
     // Remove the symbol which is bound by all, because we are only interested
     // in free (unbound) symbols.

src/query/procedure/py_module.cpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 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
@@ -14,7 +14,6 @@
 #include <datetime.h>
 #include <pyerrors.h>
 #include <array>
-#include <optional>
 #include <sstream>
 #include <stdexcept>
 #include <string>
@@ -861,7 +860,7 @@ py::Object MgpListToPyTuple(mgp_list *list, PyObject *py_graph) {
 }
 
 namespace {
-std::optional<py::ExceptionInfo> AddRecordFromPython(mgp_result *result, py::Object py_record, mgp_memory *memory) {
+std::optional<py::ExceptionInfo> AddRecordFromPython(mgp_result *result, py::Object py_record) {
   py::Object py_mgp(PyImport_ImportModule("mgp"));
   if (!py_mgp) return py::FetchError();
   auto record_cls = py_mgp.GetAttr("Record");
@@ -903,8 +902,8 @@ std::optional<py::ExceptionInfo> AddRecordFromPython(mgp_result *result, py::Obj
     if (!field_name) return py::FetchError();
     auto *val = PyTuple_GetItem(item, 1);
     if (!val) return py::FetchError();
-    // This memory is one dedicated for mg_procedure.
-    mgp_value *field_val = PyObjectToMgpValueWithPythonExceptions(val, memory);
+    mgp_memory memory{result->rows.get_allocator().GetMemoryResource()};
+    mgp_value *field_val = PyObjectToMgpValueWithPythonExceptions(val, &memory);
     if (field_val == nullptr) {
       return py::FetchError();
     }
@@ -922,26 +921,15 @@ std::optional<py::ExceptionInfo> AddRecordFromPython(mgp_result *result, py::Obj
   return std::nullopt;
 }
 
-std::optional<py::ExceptionInfo> AddMultipleRecordsFromPython(mgp_result *result, py::Object py_seq,
-                                                              mgp_memory *memory) {
+std::optional<py::ExceptionInfo> AddMultipleRecordsFromPython(mgp_result *result, py::Object py_seq) {
   Py_ssize_t len = PySequence_Size(py_seq.Ptr());
   if (len == -1) return py::FetchError();
-  result->rows.reserve(len);
-  // This proved to be good enough constant not to lose performance on transformation
-  static constexpr auto del_cnt{100000};
-  for (Py_ssize_t i = 0, curr_item = 0; i < len; ++i, ++curr_item) {
-    py::Object py_record(PySequence_GetItem(py_seq.Ptr(), curr_item));
+  for (Py_ssize_t i = 0; i < len; ++i) {
+    py::Object py_record(PySequence_GetItem(py_seq.Ptr(), i));
     if (!py_record) return py::FetchError();
-    auto maybe_exc = AddRecordFromPython(result, py_record, memory);
+    auto maybe_exc = AddRecordFromPython(result, py_record);
     if (maybe_exc) return maybe_exc;
-    // Once PySequence_DelSlice deletes "transformed" objects, starting index is 0 again.
-    if (i && i % del_cnt == 0) {
-      PySequence_DelSlice(py_seq.Ptr(), 0, del_cnt);
-      curr_item = -1;
-    }
   }
-  // Clear at the end what left
-  PySequence_DelSlice(py_seq.Ptr(), 0, PySequence_Size(py_seq.Ptr()));
   return std::nullopt;
 }
 
@@ -974,7 +962,6 @@ std::function<void()> PyObjectCleanup(py::Object &py_object) {
 
 void CallPythonProcedure(const py::Object &py_cb, mgp_list *args, mgp_graph *graph, mgp_result *result,
                          mgp_memory *memory) {
-  // *memory here is memory from `EvalContext`
   auto gil = py::EnsureGIL();
 
   auto error_to_msg = [](const std::optional<py::ExceptionInfo> &exc_info) -> std::optional<std::string> {
@@ -992,9 +979,9 @@ void CallPythonProcedure(const py::Object &py_cb, mgp_list *args, mgp_graph *gra
     auto py_res = py_cb.Call(py_graph, py_args);
     if (!py_res) return py::FetchError();
     if (PySequence_Check(py_res.Ptr())) {
-      return AddMultipleRecordsFromPython(result, py_res, memory);
+      return AddMultipleRecordsFromPython(result, py_res);
     } else {
-      return AddRecordFromPython(result, py_res, memory);
+      return AddRecordFromPython(result, py_res);
     }
   };
 
@@ -1040,9 +1027,9 @@ void CallPythonTransformation(const py::Object &py_cb, mgp_messages *msgs, mgp_g
     auto py_res = py_cb.Call(py_graph, py_messages);
     if (!py_res) return py::FetchError();
     if (PySequence_Check(py_res.Ptr())) {
-      return AddMultipleRecordsFromPython(result, py_res, memory);
+      return AddMultipleRecordsFromPython(result, py_res);
     }
-    return AddRecordFromPython(result, py_res, memory);
+    return AddRecordFromPython(result, py_res);
   };
 
   // It is *VERY IMPORTANT* to note that this code takes great care not to keep

src/query/stream/streams.cpp

@@ -36,9 +36,9 @@
 #include "utils/pmr/string.hpp"
 #include "utils/variant_helpers.hpp"
 
-namespace memgraph::metrics {
+namespace EventCounter {
 extern const Event MessagesConsumed;
-}  // namespace memgraph::metrics
+}  // namespace EventCounter
 
 namespace memgraph::query::stream {
 namespace {
@@ -495,7 +495,7 @@ Streams::StreamsMap::iterator Streams::CreateConsumer(StreamsMap &map, const std
     utils::OnScopeExit interpreter_cleanup{
         [interpreter_context, interpreter]() { interpreter_context->interpreters->erase(interpreter.get()); }};
 
-    memgraph::metrics::IncrementCounter(memgraph::metrics::MessagesConsumed, messages.size());
+    EventCounter::IncrementCounter(EventCounter::MessagesConsumed, messages.size());
     CallCustomTransformation(transformation_name, messages, result, accessor, *memory_resource, stream_name);
 
     DiscardValueResultStream stream;

src/query/trigger.cpp

@@ -25,9 +25,9 @@
 #include "utils/event_counter.hpp"
 #include "utils/memory.hpp"
 
-namespace memgraph::metrics {
+namespace EventCounter {
 extern const Event TriggersExecuted;
-}  // namespace memgraph::metrics
+}  // namespace EventCounter
 
 namespace memgraph::query {
 namespace {
@@ -248,7 +248,7 @@ void Trigger::Execute(DbAccessor *dba, utils::MonotonicBufferResource *execution
     ;
 
   cursor->Shutdown();
-  memgraph::metrics::IncrementCounter(memgraph::metrics::TriggersExecuted);
+  EventCounter::IncrementCounter(EventCounter::TriggersExecuted);
 }
 
 namespace {

src/storage/v2/CMakeLists.txt

@@ -10,9 +10,7 @@ set(storage_v2_src_files
     indices.cpp
     property_store.cpp
     vertex_accessor.cpp
-    storage.cpp
-    storage_mode.cpp
-    isolation_level.cpp)
+    storage.cpp)
 
 
 set(storage_v2_src_files

src/storage/v2/config.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 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
@@ -50,11 +50,6 @@ struct Config {
 
     bool snapshot_on_exit{false};
     bool restore_replicas_on_startup{false};
-
-    uint64_t items_per_batch{1'000'000};
-    uint64_t recovery_thread_count{8};
-
-    bool allow_parallel_index_creation{false};
   } durability;
 
   struct Transaction {

src/storage/v2/durability/durability.cpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 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
@@ -27,15 +27,9 @@
 #include "storage/v2/durability/paths.hpp"
 #include "storage/v2/durability/snapshot.hpp"
 #include "storage/v2/durability/wal.hpp"
-#include "utils/event_histogram.hpp"
 #include "utils/logging.hpp"
 #include "utils/memory_tracker.hpp"
 #include "utils/message.hpp"
-#include "utils/timer.hpp"
-
-namespace memgraph::metrics {
-extern const Event SnapshotRecoveryLatency_us;
-}  // namespace memgraph::metrics
 
 namespace memgraph::storage::durability {
 
@@ -119,15 +113,13 @@ std::optional<std::vector<WalDurabilityInfo>> GetWalFiles(const std::filesystem:
 // to ensure that the indices and constraints are consistent at the end of the
 // recovery process.
 void RecoverIndicesAndConstraints(const RecoveredIndicesAndConstraints &indices_constraints, Indices *indices,
-                                  Constraints *constraints, utils::SkipList<Vertex> *vertices,
-                                  const std::optional<ParalellizedIndexCreationInfo> &paralell_exec_info) {
+                                  Constraints *constraints, utils::SkipList<Vertex> *vertices) {
   spdlog::info("Recreating indices from metadata.");
   // Recover label indices.
   spdlog::info("Recreating {} label indices from metadata.", indices_constraints.indices.label.size());
   for (const auto &item : indices_constraints.indices.label) {
-    if (!indices->label_index.CreateIndex(item, vertices->access(), paralell_exec_info))
+    if (!indices->label_index.CreateIndex(item, vertices->access()))
       throw RecoveryFailure("The label index must be created here!");
-
     spdlog::info("A label index is recreated from metadata.");
   }
   spdlog::info("Label indices are recreated.");
@@ -171,7 +163,7 @@ std::optional<RecoveryInfo> RecoverData(const std::filesystem::path &snapshot_di
                                         std::deque<std::pair<std::string, uint64_t>> *epoch_history,
                                         utils::SkipList<Vertex> *vertices, utils::SkipList<Edge> *edges,
                                         std::atomic<uint64_t> *edge_count, NameIdMapper *name_id_mapper,
-                                        Indices *indices, Constraints *constraints, const Config &config,
+                                        Indices *indices, Constraints *constraints, Config::Items items,
                                         uint64_t *wal_seq_num) {
   utils::MemoryTracker::OutOfMemoryExceptionEnabler oom_exception;
   spdlog::info("Recovering persisted data using snapshot ({}) and WAL directory ({}).", snapshot_directory,
@@ -182,8 +174,6 @@ std::optional<RecoveryInfo> RecoverData(const std::filesystem::path &snapshot_di
     return std::nullopt;
   }
 
-  utils::Timer timer;
-
   auto snapshot_files = GetSnapshotFiles(snapshot_directory);
 
   RecoveryInfo recovery_info;
@@ -205,7 +195,7 @@ std::optional<RecoveryInfo> RecoverData(const std::filesystem::path &snapshot_di
       }
       spdlog::info("Starting snapshot recovery from {}.", path);
       try {
-        recovered_snapshot = LoadSnapshot(path, vertices, edges, epoch_history, name_id_mapper, edge_count, config);
+        recovered_snapshot = LoadSnapshot(path, vertices, edges, epoch_history, name_id_mapper, edge_count, items);
         spdlog::info("Snapshot recovery successful!");
         break;
       } catch (const RecoveryFailure &e) {
@@ -223,11 +213,7 @@ std::optional<RecoveryInfo> RecoverData(const std::filesystem::path &snapshot_di
     *epoch_id = std::move(recovered_snapshot->snapshot_info.epoch_id);
 
     if (!utils::DirExists(wal_directory)) {
-      const auto par_exec_info = config.durability.allow_parallel_index_creation
-                                     ? std::make_optional(std::make_pair(recovery_info.vertex_batches,
-                                                                         config.durability.recovery_thread_count))
-                                     : std::nullopt;
-      RecoverIndicesAndConstraints(indices_constraints, indices, constraints, vertices, par_exec_info);
+      RecoverIndicesAndConstraints(indices_constraints, indices, constraints, vertices);
       return recovered_snapshot->recovery_info;
     }
   } else {
@@ -333,7 +319,7 @@ std::optional<RecoveryInfo> RecoverData(const std::filesystem::path &snapshot_di
       }
       try {
         auto info = LoadWal(wal_file.path, &indices_constraints, last_loaded_timestamp, vertices, edges, name_id_mapper,
-                            edge_count, config.items);
+                            edge_count, items);
         recovery_info.next_vertex_id = std::max(recovery_info.next_vertex_id, info.next_vertex_id);
         recovery_info.next_edge_id = std::max(recovery_info.next_edge_id, info.next_edge_id);
         recovery_info.next_timestamp = std::max(recovery_info.next_timestamp, info.next_timestamp);
@@ -355,10 +341,6 @@ std::optional<RecoveryInfo> RecoverData(const std::filesystem::path &snapshot_di
   }
 
   RecoverIndicesAndConstraints(indices_constraints, indices, constraints, vertices);
-
-  memgraph::metrics::Measure(memgraph::metrics::SnapshotRecoveryLatency_us,
-                             std::chrono::duration_cast<std::chrono::microseconds>(timer.Elapsed()).count());
-
   return recovery_info;
 }
 

src/storage/v2/durability/durability.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 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,18 +91,13 @@ std::optional<std::vector<WalDurabilityInfo>> GetWalFiles(const std::filesystem:
                                                           std::string_view uuid = "",
                                                           std::optional<size_t> current_seq_num = {});
 
-using ParalellizedIndexCreationInfo =
-    std::pair<std::vector<std::pair<Gid, uint64_t>> /*vertex_recovery_info*/, uint64_t /*thread_count*/>;
-
 // Helper function used to recover all discovered indices and constraints. The
 // indices and constraints must be recovered after the data recovery is done
 // to ensure that the indices and constraints are consistent at the end of the
 // recovery process.
 /// @throw RecoveryFailure
-void RecoverIndicesAndConstraints(
-    const RecoveredIndicesAndConstraints &indices_constraints, Indices *indices, Constraints *constraints,
-    utils::SkipList<Vertex> *vertices,
-    const std::optional<ParalellizedIndexCreationInfo> &paralell_exec_info = std::nullopt);
+void RecoverIndicesAndConstraints(const RecoveredIndicesAndConstraints &indices_constraints, Indices *indices,
+                                  Constraints *constraints, utils::SkipList<Vertex> *vertices);
 
 /// Recovers data either from a snapshot and/or WAL files.
 /// @throw RecoveryFailure
@@ -113,7 +108,7 @@ std::optional<RecoveryInfo> RecoverData(const std::filesystem::path &snapshot_di
                                         std::deque<std::pair<std::string, uint64_t>> *epoch_history,
                                         utils::SkipList<Vertex> *vertices, utils::SkipList<Edge> *edges,
                                         std::atomic<uint64_t> *edge_count, NameIdMapper *name_id_mapper,
-                                        Indices *indices, Constraints *constraints, const Config &config,
+                                        Indices *indices, Constraints *constraints, Config::Items items,
                                         uint64_t *wal_seq_num);
 
 }  // namespace memgraph::storage::durability

src/storage/v2/durability/metadata.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 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
@@ -12,7 +12,6 @@
 #pragma once
 
 #include <algorithm>
-#include <optional>
 #include <set>
 #include <utility>
 #include <vector>
@@ -30,8 +29,6 @@ struct RecoveryInfo {
 
   // last timestamp read from a WAL file
   std::optional<uint64_t> last_commit_timestamp;
-
-  std::vector<std::pair<Gid /*first vertex gid*/, uint64_t /*batch size*/>> vertex_batches;
 };
 
 /// Structure used to track indices and constraints during recovery.

src/storage/v2/durability/snapshot.cpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 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
@@ -11,26 +11,18 @@
 
 #include "storage/v2/durability/snapshot.hpp"
 
-#include <thread>
-
 #include "storage/v2/durability/exceptions.hpp"
 #include "storage/v2/durability/paths.hpp"
 #include "storage/v2/durability/serialization.hpp"
 #include "storage/v2/durability/version.hpp"
 #include "storage/v2/durability/wal.hpp"
-#include "storage/v2/edge.hpp"
 #include "storage/v2/edge_accessor.hpp"
 #include "storage/v2/edge_ref.hpp"
-#include "storage/v2/id_types.hpp"
 #include "storage/v2/mvcc.hpp"
-#include "storage/v2/vertex.hpp"
 #include "storage/v2/vertex_accessor.hpp"
-#include "utils/concepts.hpp"
 #include "utils/file_locker.hpp"
 #include "utils/logging.hpp"
 #include "utils/message.hpp"
-#include "utils/spin_lock.hpp"
-#include "utils/synchronized.hpp"
 
 namespace memgraph::storage::durability {
 
@@ -48,8 +40,6 @@ namespace memgraph::storage::durability {
 //     * offset to the constraints section
 //     * offset to the mapper section
 //     * offset to the metadata section
-//     * offset to the offset-count pair of the first edge batch (`0` if properties on edges are disabled)
-//     * offset to the offset-count pair of the first vertex batch
 //
 // 4) Encoded edges (if properties on edges are enabled); each edge is written
 //    in the following format:
@@ -97,23 +87,9 @@ namespace memgraph::storage::durability {
 //     * number of edges
 //     * number of vertices
 //
-// 10) Batch infos
-//     * number of edge batch infos
-//     * edge batch infos
-//        * starting offset of the batch
-//        * number of edges in the batch
-//     * vertex batch infos
-//        * starting offset of the batch
-//        * number of vertices in the batch
-//
 // IMPORTANT: When changing snapshot encoding/decoding bump the snapshot/WAL
 // version in `version.hpp`.
 
-struct BatchInfo {
-  uint64_t offset;
-  uint64_t count;
-};
-
 // Function used to read information about the snapshot file.
 SnapshotInfo ReadSnapshotInfo(const std::filesystem::path &path) {
   // Check magic and version.
@@ -148,13 +124,6 @@ SnapshotInfo ReadSnapshotInfo(const std::filesystem::path &path) {
     info.offset_mapper = read_offset();
     info.offset_epoch_history = read_offset();
     info.offset_metadata = read_offset();
-    if (*version >= 15U) {
-      info.offset_edge_batches = read_offset();
-      info.offset_vertex_batches = read_offset();
-    } else {
-      info.offset_edge_batches = 0U;
-      info.offset_vertex_batches = 0U;
-    }
   }
 
   // Read metadata.
@@ -188,385 +157,17 @@ SnapshotInfo ReadSnapshotInfo(const std::filesystem::path &path) {
   return info;
 }
 
-std::vector<BatchInfo> ReadBatchInfos(Decoder &snapshot) {
-  std::vector<BatchInfo> infos;
-  const auto infos_size = snapshot.ReadUint();
-  if (!infos_size.has_value()) {
-    throw RecoveryFailure("Invalid snapshot data!");
-  }
-  infos.reserve(*infos_size);
-
-  for (auto i{0U}; i < *infos_size; ++i) {
-    const auto offset = snapshot.ReadUint();
-    if (!offset.has_value()) {
-      throw RecoveryFailure("Invalid snapshot data!");
-    }
-
-    const auto count = snapshot.ReadUint();
-    if (!count.has_value()) {
-      throw RecoveryFailure("Invalid snapshot data!");
-    }
-    infos.push_back(BatchInfo{*offset, *count});
-  }
-  return infos;
-}
-
-template <typename TFunc>
-void LoadPartialEdges(const std::filesystem::path &path, utils::SkipList<Edge> &edges, const uint64_t from_offset,
-                      const uint64_t edges_count, const Config::Items items, TFunc get_property_from_id) {
-  Decoder snapshot;
-  snapshot.Initialize(path, kSnapshotMagic);
-
-  // Recover edges.
-  auto edge_acc = edges.access();
-  uint64_t last_edge_gid = 0;
-  spdlog::info("Recovering {} edges.", edges_count);
-  if (!snapshot.SetPosition(from_offset)) throw RecoveryFailure("Couldn't read data from snapshot!");
-
-  std::vector<std::pair<PropertyId, PropertyValue>> read_properties;
-  for (uint64_t i = 0; i < edges_count; ++i) {
-    {
-      const auto marker = snapshot.ReadMarker();
-      if (!marker || *marker != Marker::SECTION_EDGE) throw RecoveryFailure("Invalid snapshot data!");
-    }
-
-    // Read edge GID.
-    auto gid = snapshot.ReadUint();
-    if (!gid) throw RecoveryFailure("Invalid snapshot data!");
-    if (i > 0 && *gid <= last_edge_gid) throw RecoveryFailure("Invalid snapshot data!");
-    last_edge_gid = *gid;
-
-    if (items.properties_on_edges) {
-      spdlog::debug("Recovering edge {} with properties.", *gid);
-      auto [it, inserted] = edge_acc.insert(Edge{Gid::FromUint(*gid), nullptr});
-      if (!inserted) throw RecoveryFailure("The edge must be inserted here!");
-
-      // Recover properties.
-      {
-        auto props_size = snapshot.ReadUint();
-        if (!props_size) throw RecoveryFailure("Invalid snapshot data!");
-        auto &props = it->properties;
-        read_properties.clear();
-        read_properties.reserve(*props_size);
-        for (uint64_t j = 0; j < *props_size; ++j) {
-          auto key = snapshot.ReadUint();
-          if (!key) throw RecoveryFailure("Invalid snapshot data!");
-          auto value = snapshot.ReadPropertyValue();
-          if (!value) throw RecoveryFailure("Invalid snapshot data!");
-          read_properties.emplace_back(get_property_from_id(*key), std::move(*value));
-        }
-        props.InitProperties(std::move(read_properties));
-      }
-    } else {
-      spdlog::debug("Ensuring edge {} doesn't have any properties.", *gid);
-      // Read properties.
-      {
-        auto props_size = snapshot.ReadUint();
-        if (!props_size) throw RecoveryFailure("Invalid snapshot data!");
-        if (*props_size != 0)
-          throw RecoveryFailure(
-              "The snapshot has properties on edges, but the storage is "
-              "configured without properties on edges!");
-      }
-    }
-  }
-  spdlog::info("Partial edges are recovered.");
-}
-
-// Returns the gid of the last recovered vertex
-template <typename TLabelFromIdFunc, typename TPropertyFromIdFunc>
-uint64_t LoadPartialVertices(const std::filesystem::path &path, utils::SkipList<Vertex> &vertices,
-                             const uint64_t from_offset, const uint64_t vertices_count,
-                             TLabelFromIdFunc get_label_from_id, TPropertyFromIdFunc get_property_from_id) {
-  Decoder snapshot;
-  snapshot.Initialize(path, kSnapshotMagic);
-  if (!snapshot.SetPosition(from_offset)) throw RecoveryFailure("Couldn't read data from snapshot!");
-
-  auto vertex_acc = vertices.access();
-  uint64_t last_vertex_gid = 0;
-  spdlog::info("Recovering {} vertices.", vertices_count);
-  std::vector<std::pair<PropertyId, PropertyValue>> read_properties;
-  for (uint64_t i = 0; i < vertices_count; ++i) {
-    {
-      auto marker = snapshot.ReadMarker();
-      if (!marker || *marker != Marker::SECTION_VERTEX) throw RecoveryFailure("Invalid snapshot data!");
-    }
-
-    // Insert vertex.
-    auto gid = snapshot.ReadUint();
-    if (!gid) throw RecoveryFailure("Invalid snapshot data!");
-    if (i > 0 && *gid <= last_vertex_gid) {
-      throw RecoveryFailure("Invalid snapshot data!");
-    }
-    last_vertex_gid = *gid;
-    spdlog::debug("Recovering vertex {}.", *gid);
-    auto [it, inserted] = vertex_acc.insert(Vertex{Gid::FromUint(*gid), nullptr});
-    if (!inserted) throw RecoveryFailure("The vertex must be inserted here!");
-
-    // Recover labels.
-    spdlog::trace("Recovering labels for vertex {}.", *gid);
-    {
-      auto labels_size = snapshot.ReadUint();
-      if (!labels_size) throw RecoveryFailure("Invalid snapshot data!");
-      auto &labels = it->labels;
-      labels.reserve(*labels_size);
-      for (uint64_t j = 0; j < *labels_size; ++j) {
-        auto label = snapshot.ReadUint();
-        if (!label) throw RecoveryFailure("Invalid snapshot data!");
-        labels.emplace_back(get_label_from_id(*label));
-      }
-    }
-
-    // Recover properties.
-    spdlog::trace("Recovering properties for vertex {}.", *gid);
-    {
-      auto props_size = snapshot.ReadUint();
-      if (!props_size) throw RecoveryFailure("Invalid snapshot data!");
-      auto &props = it->properties;
-      read_properties.clear();
-      read_properties.reserve(*props_size);
-      for (uint64_t j = 0; j < *props_size; ++j) {
-        auto key = snapshot.ReadUint();
-        if (!key) throw RecoveryFailure("Invalid snapshot data!");
-        auto value = snapshot.ReadPropertyValue();
-        if (!value) throw RecoveryFailure("Invalid snapshot data!");
-        read_properties.emplace_back(get_property_from_id(*key), std::move(*value));
-      }
-      props.InitProperties(std::move(read_properties));
-    }
-
-    // Skip in edges.
-    {
-      auto in_size = snapshot.ReadUint();
-      if (!in_size) throw RecoveryFailure("Invalid snapshot data!");
-      for (uint64_t j = 0; j < *in_size; ++j) {
-        auto edge_gid = snapshot.ReadUint();
-        if (!edge_gid) throw RecoveryFailure("Invalid snapshot data!");
-        auto from_gid = snapshot.ReadUint();
-        if (!from_gid) throw RecoveryFailure("Invalid snapshot data!");
-        auto edge_type = snapshot.ReadUint();
-        if (!edge_type) throw RecoveryFailure("Invalid snapshot data!");
-      }
-    }
-
-    // Skip out edges.
-    auto out_size = snapshot.ReadUint();
-    if (!out_size) throw RecoveryFailure("Invalid snapshot data!");
-    for (uint64_t j = 0; j < *out_size; ++j) {
-      auto edge_gid = snapshot.ReadUint();
-      if (!edge_gid) throw RecoveryFailure("Invalid snapshot data!");
-      auto to_gid = snapshot.ReadUint();
-      if (!to_gid) throw RecoveryFailure("Invalid snapshot data!");
-      auto edge_type = snapshot.ReadUint();
-      if (!edge_type) throw RecoveryFailure("Invalid snapshot data!");
-    }
-  }
-  spdlog::info("Partial vertices are recovered.");
-
-  return last_vertex_gid;
-}
-
-// Returns the number of edges recovered
-
-struct LoadPartialConnectivityResult {
-  uint64_t edge_count;
-  uint64_t highest_edge_id;
-  Gid first_vertex_gid;
-};
-
-template <typename TEdgeTypeFromIdFunc>
-LoadPartialConnectivityResult LoadPartialConnectivity(const std::filesystem::path &path,
-                                                      utils::SkipList<Vertex> &vertices, utils::SkipList<Edge> &edges,
-                                                      const uint64_t from_offset, const uint64_t vertices_count,
-                                                      const Config::Items items, const bool snapshot_has_edges,
-                                                      TEdgeTypeFromIdFunc get_edge_type_from_id) {
-  Decoder snapshot;
-  snapshot.Initialize(path, kSnapshotMagic);
-  if (!snapshot.SetPosition(from_offset)) throw RecoveryFailure("Couldn't read data from snapshot!");
-
-  auto vertex_acc = vertices.access();
-  auto edge_acc = edges.access();
-
-  // Read the first gid to find the necessary iterator in vertices
-  const auto first_vertex_gid = std::invoke([&]() mutable {
-    {
-      auto marker = snapshot.ReadMarker();
-      if (!marker || *marker != Marker::SECTION_VERTEX) throw RecoveryFailure("Invalid snapshot data!");
-    }
-
-    auto gid = snapshot.ReadUint();
-    if (!gid) throw RecoveryFailure("Invalid snapshot data!");
-    return Gid::FromUint(*gid);
-  });
-
-  uint64_t edge_count{0};
-  uint64_t highest_edge_gid{0};
-  auto vertex_it = vertex_acc.find(first_vertex_gid);
-  if (vertex_it == vertex_acc.end()) {
-    throw RecoveryFailure("Invalid snapshot data!");
-  }
-
-  spdlog::info("Recovering connectivity for {} vertices.", vertices_count);
-
-  if (!snapshot.SetPosition(from_offset)) throw RecoveryFailure("Couldn't read data from snapshot!");
-
-  for (uint64_t i = 0; i < vertices_count; ++i) {
-    auto &vertex = *vertex_it;
-    {
-      auto marker = snapshot.ReadMarker();
-      if (!marker || *marker != Marker::SECTION_VERTEX) throw RecoveryFailure("Invalid snapshot data!");
-    }
-
-    auto gid = snapshot.ReadUint();
-    if (!gid) throw RecoveryFailure("Invalid snapshot data!");
-    if (gid != vertex.gid.AsUint()) throw RecoveryFailure("Invalid snapshot data!");
-
-    // Skip labels.
-    {
-      auto labels_size = snapshot.ReadUint();
-      if (!labels_size) throw RecoveryFailure("Invalid snapshot data!");
-      for (uint64_t j = 0; j < *labels_size; ++j) {
-        auto label = snapshot.ReadUint();
-        if (!label) throw RecoveryFailure("Invalid snapshot data!");
-      }
-    }
-
-    // Skip properties.
-    {
-      auto props_size = snapshot.ReadUint();
-      if (!props_size) throw RecoveryFailure("Invalid snapshot data!");
-      for (uint64_t j = 0; j < *props_size; ++j) {
-        auto key = snapshot.ReadUint();
-        if (!key) throw RecoveryFailure("Invalid snapshot data!");
-        auto value = snapshot.SkipPropertyValue();
-        if (!value) throw RecoveryFailure("Invalid snapshot data!");
-      }
-    }
-
-    // Recover in edges.
-    {
-      spdlog::trace("Recovering inbound edges for vertex {}.", vertex.gid.AsUint());
-      auto in_size = snapshot.ReadUint();
-      if (!in_size) throw RecoveryFailure("Invalid snapshot data!");
-      vertex.in_edges.reserve(*in_size);
-      for (uint64_t j = 0; j < *in_size; ++j) {
-        auto edge_gid = snapshot.ReadUint();
-        if (!edge_gid) throw RecoveryFailure("Invalid snapshot data!");
-        highest_edge_gid = std::max(highest_edge_gid, *edge_gid);
-
-        auto from_gid = snapshot.ReadUint();
-        if (!from_gid) throw RecoveryFailure("Invalid snapshot data!");
-        auto edge_type = snapshot.ReadUint();
-        if (!edge_type) throw RecoveryFailure("Invalid snapshot data!");
-
-        auto from_vertex = vertex_acc.find(Gid::FromUint(*from_gid));
-        if (from_vertex == vertex_acc.end()) throw RecoveryFailure("Invalid from vertex!");
-
-        EdgeRef edge_ref(Gid::FromUint(*edge_gid));
-        if (items.properties_on_edges) {
-          // The snapshot contains the individiual edges only if it was created with a config where properties are
-          // allowed on edges. That means the snapshots that were created without edge properties will only contain the
-          // edges in the in/out edges list of vertices, therefore the edges has to be created here.
-          if (snapshot_has_edges) {
-            auto edge = edge_acc.find(Gid::FromUint(*edge_gid));
-            if (edge == edge_acc.end()) throw RecoveryFailure("Invalid edge!");
-            edge_ref = EdgeRef(&*edge);
-          } else {
-            auto [edge, inserted] = edge_acc.insert(Edge{Gid::FromUint(*edge_gid), nullptr});
-            edge_ref = EdgeRef(&*edge);
-          }
-        }
-        vertex.in_edges.emplace_back(get_edge_type_from_id(*edge_type), &*from_vertex, edge_ref);
-      }
-    }
-
-    // Recover out edges.
-    {
-      spdlog::trace("Recovering outbound edges for vertex {}.", vertex.gid.AsUint());
-      auto out_size = snapshot.ReadUint();
-      if (!out_size) throw RecoveryFailure("Invalid snapshot data!");
-      vertex.out_edges.reserve(*out_size);
-      for (uint64_t j = 0; j < *out_size; ++j) {
-        auto edge_gid = snapshot.ReadUint();
-        if (!edge_gid) throw RecoveryFailure("Invalid snapshot data!");
-
-        auto to_gid = snapshot.ReadUint();
-        if (!to_gid) throw RecoveryFailure("Invalid snapshot data!");
-        auto edge_type = snapshot.ReadUint();
-        if (!edge_type) throw RecoveryFailure("Invalid snapshot data!");
-
-        auto to_vertex = vertex_acc.find(Gid::FromUint(*to_gid));
-        if (to_vertex == vertex_acc.end()) throw RecoveryFailure("Invalid to vertex!");
-
-        EdgeRef edge_ref(Gid::FromUint(*edge_gid));
-        if (items.properties_on_edges) {
-          // The snapshot contains the individiual edges only if it was created with a config where properties are
-          // allowed on edges. That means the snapshots that were created without edge properties will only contain the
-          // edges in the in/out edges list of vertices, therefore the edges has to be created here.
-          if (snapshot_has_edges) {
-            auto edge = edge_acc.find(Gid::FromUint(*edge_gid));
-            if (edge == edge_acc.end()) throw RecoveryFailure("Invalid edge!");
-            edge_ref = EdgeRef(&*edge);
-          } else {
-            auto [edge, inserted] = edge_acc.insert(Edge{Gid::FromUint(*edge_gid), nullptr});
-            edge_ref = EdgeRef(&*edge);
-          }
-        }
-        vertex.out_edges.emplace_back(get_edge_type_from_id(*edge_type), &*to_vertex, edge_ref);
-        // Increment edge count. We only increment the count here because the
-        // information is duplicated in in_edges.
-        edge_count++;
-      }
-    }
-    ++vertex_it;
-  }
-  spdlog::info("Partial connectivities are recovered.");
-  return {edge_count, highest_edge_gid, first_vertex_gid};
-}
-
-template <typename TFunc>
-void RecoverOnMultipleThreads(size_t thread_count, const TFunc &func, const std::vector<BatchInfo> &batches) {
-  utils::Synchronized<std::optional<RecoveryFailure>, utils::SpinLock> maybe_error{};
-  {
-    std::atomic<uint64_t> batch_counter = 0;
-    thread_count = std::min(thread_count, batches.size());
-    std::vector<std::jthread> threads;
-    threads.reserve(thread_count);
-
-    for (auto i{0U}; i < thread_count; ++i) {
-      threads.emplace_back([&func, &batches, &maybe_error, &batch_counter]() {
-        while (!maybe_error.Lock()->has_value()) {
-          const auto batch_index = batch_counter++;
-          if (batch_index >= batches.size()) {
-            return;
-          }
-          const auto &batch = batches[batch_index];
-          try {
-            func(batch_index, batch);
-          } catch (RecoveryFailure &failure) {
-            *maybe_error.Lock() = std::move(failure);
-          }
-        }
-      });
-    }
-  }
-  if (maybe_error.Lock()->has_value()) {
-    throw RecoveryFailure((*maybe_error.Lock())->what());
-  }
-}
-
-RecoveredSnapshot LoadSnapshotVersion14(const std::filesystem::path &path, utils::SkipList<Vertex> *vertices,
-                                        utils::SkipList<Edge> *edges,
-                                        std::deque<std::pair<std::string, uint64_t>> *epoch_history,
-                                        NameIdMapper *name_id_mapper, std::atomic<uint64_t> *edge_count,
-                                        Config::Items items) {
+RecoveredSnapshot LoadSnapshot(const std::filesystem::path &path, utils::SkipList<Vertex> *vertices,
+                               utils::SkipList<Edge> *edges,
+                               std::deque<std::pair<std::string, uint64_t>> *epoch_history,
+                               NameIdMapper *name_id_mapper, std::atomic<uint64_t> *edge_count, Config::Items items) {
   RecoveryInfo ret;
   RecoveredIndicesAndConstraints indices_constraints;
 
   Decoder snapshot;
   auto version = snapshot.Initialize(path, kSnapshotMagic);
   if (!version) throw RecoveryFailure("Couldn't read snapshot magic and/or version!");
-  if (*version != 14U) throw RecoveryFailure(fmt::format("Expected snapshot version is 14, but got {}", *version));
+  if (!IsVersionSupported(*version)) throw RecoveryFailure(fmt::format("Invalid snapshot version {}", *version));
 
   // Cleanup of loaded data in case of failure.
   bool success = false;
@@ -1024,297 +625,10 @@ RecoveredSnapshot LoadSnapshotVersion14(const std::filesystem::path &path, utils
   return {info, ret, std::move(indices_constraints)};
 }
 
-RecoveredSnapshot LoadSnapshot(const std::filesystem::path &path, utils::SkipList<Vertex> *vertices,
-                               utils::SkipList<Edge> *edges,
-                               std::deque<std::pair<std::string, uint64_t>> *epoch_history,
-                               NameIdMapper *name_id_mapper, std::atomic<uint64_t> *edge_count, const Config &config) {
-  RecoveryInfo recovery_info;
-  RecoveredIndicesAndConstraints indices_constraints;
-
-  Decoder snapshot;
-  const auto version = snapshot.Initialize(path, kSnapshotMagic);
-  if (!version) throw RecoveryFailure("Couldn't read snapshot magic and/or version!");
-
-  if (!IsVersionSupported(*version)) throw RecoveryFailure(fmt::format("Invalid snapshot version {}", *version));
-  if (*version == 14U) {
-    return LoadSnapshotVersion14(path, vertices, edges, epoch_history, name_id_mapper, edge_count, config.items);
-  }
-
-  // Cleanup of loaded data in case of failure.
-  bool success = false;
-  utils::OnScopeExit cleanup([&] {
-    if (!success) {
-      edges->clear();
-      vertices->clear();
-      epoch_history->clear();
-    }
-  });
-
-  // Read snapshot info.
-  const auto info = ReadSnapshotInfo(path);
-  spdlog::info("Recovering {} vertices and {} edges.", info.vertices_count, info.edges_count);
-  // Check for edges.
-  bool snapshot_has_edges = info.offset_edges != 0;
-
-  // Recover mapper.
-  std::unordered_map<uint64_t, uint64_t> snapshot_id_map;
-  {
-    spdlog::info("Recovering mapper metadata.");
-    if (!snapshot.SetPosition(info.offset_mapper)) throw RecoveryFailure("Couldn't read data from snapshot!");
-
-    auto marker = snapshot.ReadMarker();
-    if (!marker || *marker != Marker::SECTION_MAPPER) throw RecoveryFailure("Invalid snapshot data!");
-
-    auto size = snapshot.ReadUint();
-    if (!size) throw RecoveryFailure("Invalid snapshot data!");
-
-    for (uint64_t i = 0; i < *size; ++i) {
-      auto id = snapshot.ReadUint();
-      if (!id) throw RecoveryFailure("Invalid snapshot data!");
-      auto name = snapshot.ReadString();
-      if (!name) throw RecoveryFailure("Invalid snapshot data!");
-      auto my_id = name_id_mapper->NameToId(*name);
-      snapshot_id_map.emplace(*id, my_id);
-      SPDLOG_TRACE("Mapping \"{}\"from snapshot id {} to actual id {}.", *name, *id, my_id);
-    }
-  }
-  auto get_label_from_id = [&snapshot_id_map](uint64_t snapshot_id) {
-    auto it = snapshot_id_map.find(snapshot_id);
-    if (it == snapshot_id_map.end()) throw RecoveryFailure("Invalid snapshot data!");
-    return LabelId::FromUint(it->second);
-  };
-  auto get_property_from_id = [&snapshot_id_map](uint64_t snapshot_id) {
-    auto it = snapshot_id_map.find(snapshot_id);
-    if (it == snapshot_id_map.end()) throw RecoveryFailure("Invalid snapshot data!");
-    return PropertyId::FromUint(it->second);
-  };
-  auto get_edge_type_from_id = [&snapshot_id_map](uint64_t snapshot_id) {
-    auto it = snapshot_id_map.find(snapshot_id);
-    if (it == snapshot_id_map.end()) throw RecoveryFailure("Invalid snapshot data!");
-    return EdgeTypeId::FromUint(it->second);
-  };
-
-  // Reset current edge count.
-  edge_count->store(0, std::memory_order_release);
-
-  {
-    spdlog::info("Recovering edges.");
-    // Recover edges.
-    if (snapshot_has_edges) {
-      // We don't need to check whether we store properties on edge or not, because `LoadPartialEdges` will always
-      // iterate over the edges in the snapshot (if they exist) and the current configuration of properties on edge only
-      // affect what it does:
-      // 1. If properties are allowed on edges, then it loads the edges.
-      // 2. If properties are not allowed on edges, then it checks that none of the edges have any properties.
-      if (!snapshot.SetPosition(info.offset_edge_batches)) {
-        throw RecoveryFailure("Couldn't read data from snapshot!");
-      }
-      const auto edge_batches = ReadBatchInfos(snapshot);
-
-      RecoverOnMultipleThreads(
-          config.durability.recovery_thread_count,
-          [path, edges, items = config.items, &get_property_from_id](const size_t /*batch_index*/,
-                                                                     const BatchInfo &batch) {
-            LoadPartialEdges(path, *edges, batch.offset, batch.count, items, get_property_from_id);
-          },
-          edge_batches);
-    }
-    spdlog::info("Edges are recovered.");
-
-    // Recover vertices (labels and properties).
-    spdlog::info("Recovering vertices.", info.vertices_count);
-    uint64_t last_vertex_gid{0};
-
-    if (!snapshot.SetPosition(info.offset_vertex_batches)) {
-      throw RecoveryFailure("Couldn't read data from snapshot!");
-    }
-
-    const auto vertex_batches = ReadBatchInfos(snapshot);
-    RecoverOnMultipleThreads(
-        config.durability.recovery_thread_count,
-        [path, vertices, &vertex_batches, &get_label_from_id, &get_property_from_id, &last_vertex_gid](
-            const size_t batch_index, const BatchInfo &batch) {
-          const auto last_vertex_gid_in_batch =
-              LoadPartialVertices(path, *vertices, batch.offset, batch.count, get_label_from_id, get_property_from_id);
-          if (batch_index == vertex_batches.size() - 1) {
-            last_vertex_gid = last_vertex_gid_in_batch;
-          }
-        },
-        vertex_batches);
-
-    spdlog::info("Vertices are recovered.");
-
-    // Recover vertices (in/out edges).
-    spdlog::info("Recover connectivity.");
-    recovery_info.vertex_batches.reserve(vertex_batches.size());
-    for (const auto batch : vertex_batches) {
-      recovery_info.vertex_batches.emplace_back(std::make_pair(Gid::FromUint(0), batch.count));
-    }
-    std::atomic<uint64_t> highest_edge_gid{0};
-
-    RecoverOnMultipleThreads(
-        config.durability.recovery_thread_count,
-        [path, vertices, edges, edge_count, items = config.items, snapshot_has_edges, &get_edge_type_from_id,
-         &highest_edge_gid, &recovery_info](const size_t batch_index, const BatchInfo &batch) {
-          const auto result = LoadPartialConnectivity(path, *vertices, *edges, batch.offset, batch.count, items,
-                                                      snapshot_has_edges, get_edge_type_from_id);
-          edge_count->fetch_add(result.edge_count);
-          auto known_highest_edge_gid = highest_edge_gid.load();
-          while (known_highest_edge_gid < result.highest_edge_id) {
-            highest_edge_gid.compare_exchange_weak(known_highest_edge_gid, result.highest_edge_id);
-          }
-          recovery_info.vertex_batches[batch_index].first = result.first_vertex_gid;
-        },
-        vertex_batches);
-
-    spdlog::info("Connectivity is recovered.");
-
-    // Set initial values for edge/vertex ID generators.
-    recovery_info.next_edge_id = highest_edge_gid + 1;
-    recovery_info.next_vertex_id = last_vertex_gid + 1;
-  }
-
-  // Recover indices.
-  {
-    spdlog::info("Recovering metadata of indices.");
-    if (!snapshot.SetPosition(info.offset_indices)) throw RecoveryFailure("Couldn't read data from snapshot!");
-
-    auto marker = snapshot.ReadMarker();
-    if (!marker || *marker != Marker::SECTION_INDICES) throw RecoveryFailure("Invalid snapshot data!");
-
-    // Recover label indices.
-    {
-      auto size = snapshot.ReadUint();
-      if (!size) throw RecoveryFailure("Invalid snapshot data!");
-      spdlog::info("Recovering metadata of {} label indices.", *size);
-      for (uint64_t i = 0; i < *size; ++i) {
-        auto label = snapshot.ReadUint();
-        if (!label) throw RecoveryFailure("Invalid snapshot data!");
-        AddRecoveredIndexConstraint(&indices_constraints.indices.label, get_label_from_id(*label),
-                                    "The label index already exists!");
-        SPDLOG_TRACE("Recovered metadata of label index for :{}", name_id_mapper->IdToName(snapshot_id_map.at(*label)));
-      }
-      spdlog::info("Metadata of label indices are recovered.");
-    }
-
-    // Recover label+property indices.
-    {
-      auto size = snapshot.ReadUint();
-      if (!size) throw RecoveryFailure("Invalid snapshot data!");
-      spdlog::info("Recovering metadata of {} label+property indices.", *size);
-      for (uint64_t i = 0; i < *size; ++i) {
-        auto label = snapshot.ReadUint();
-        if (!label) throw RecoveryFailure("Invalid snapshot data!");
-        auto property = snapshot.ReadUint();
-        if (!property) throw RecoveryFailure("Invalid snapshot data!");
-        AddRecoveredIndexConstraint(&indices_constraints.indices.label_property,
-                                    {get_label_from_id(*label), get_property_from_id(*property)},
-                                    "The label+property index already exists!");
-        SPDLOG_TRACE("Recovered metadata of label+property index for :{}({})",
-                     name_id_mapper->IdToName(snapshot_id_map.at(*label)),
-                     name_id_mapper->IdToName(snapshot_id_map.at(*property)));
-      }
-      spdlog::info("Metadata of label+property indices are recovered.");
-    }
-    spdlog::info("Metadata of indices are recovered.");
-  }
-
-  // Recover constraints.
-  {
-    spdlog::info("Recovering metadata of constraints.");
-    if (!snapshot.SetPosition(info.offset_constraints)) throw RecoveryFailure("Couldn't read data from snapshot!");
-
-    auto marker = snapshot.ReadMarker();
-    if (!marker || *marker != Marker::SECTION_CONSTRAINTS) throw RecoveryFailure("Invalid snapshot data!");
-
-    // Recover existence constraints.
-    {
-      auto size = snapshot.ReadUint();
-      if (!size) throw RecoveryFailure("Invalid snapshot data!");
-      spdlog::info("Recovering metadata of {} existence constraints.", *size);
-      for (uint64_t i = 0; i < *size; ++i) {
-        auto label = snapshot.ReadUint();
-        if (!label) throw RecoveryFailure("Invalid snapshot data!");
-        auto property = snapshot.ReadUint();
-        if (!property) throw RecoveryFailure("Invalid snapshot data!");
-        AddRecoveredIndexConstraint(&indices_constraints.constraints.existence,
-                                    {get_label_from_id(*label), get_property_from_id(*property)},
-                                    "The existence constraint already exists!");
-        SPDLOG_TRACE("Recovered metadata of existence constraint for :{}({})",
-                     name_id_mapper->IdToName(snapshot_id_map.at(*label)),
-                     name_id_mapper->IdToName(snapshot_id_map.at(*property)));
-      }
-      spdlog::info("Metadata of existence constraints are recovered.");
-    }
-
-    // Recover unique constraints.
-    // Snapshot version should be checked since unique constraints were
-    // implemented in later versions of snapshot.
-    if (*version >= kUniqueConstraintVersion) {
-      auto size = snapshot.ReadUint();
-      if (!size) throw RecoveryFailure("Invalid snapshot data!");
-      spdlog::info("Recovering metadata of {} unique constraints.", *size);
-      for (uint64_t i = 0; i < *size; ++i) {
-        auto label = snapshot.ReadUint();
-        if (!label) throw RecoveryFailure("Invalid snapshot data!");
-        auto properties_count = snapshot.ReadUint();
-        if (!properties_count) throw RecoveryFailure("Invalid snapshot data!");
-        std::set<PropertyId> properties;
-        for (uint64_t j = 0; j < *properties_count; ++j) {
-          auto property = snapshot.ReadUint();
-          if (!property) throw RecoveryFailure("Invalid snapshot data!");
-          properties.insert(get_property_from_id(*property));
-        }
-        AddRecoveredIndexConstraint(&indices_constraints.constraints.unique, {get_label_from_id(*label), properties},
-                                    "The unique constraint already exists!");
-        SPDLOG_TRACE("Recovered metadata of unique constraints for :{}",
-                     name_id_mapper->IdToName(snapshot_id_map.at(*label)));
-      }
-      spdlog::info("Metadata of unique constraints are recovered.");
-    }
-    spdlog::info("Metadata of constraints are recovered.");
-  }
-
-  spdlog::info("Recovering metadata.");
-  // Recover epoch history
-  {
-    if (!snapshot.SetPosition(info.offset_epoch_history)) throw RecoveryFailure("Couldn't read data from snapshot!");
-
-    const auto marker = snapshot.ReadMarker();
-    if (!marker || *marker != Marker::SECTION_EPOCH_HISTORY) throw RecoveryFailure("Invalid snapshot data!");
-
-    const auto history_size = snapshot.ReadUint();
-    if (!history_size) {
-      throw RecoveryFailure("Invalid snapshot data!");
-    }
-
-    for (int i = 0; i < *history_size; ++i) {
-      auto maybe_epoch_id = snapshot.ReadString();
-      if (!maybe_epoch_id) {
-        throw RecoveryFailure("Invalid snapshot data!");
-      }
-      const auto maybe_last_commit_timestamp = snapshot.ReadUint();
-      if (!maybe_last_commit_timestamp) {
-        throw RecoveryFailure("Invalid snapshot data!");
-      }
-      epoch_history->emplace_back(std::move(*maybe_epoch_id), *maybe_last_commit_timestamp);
-    }
-  }
-
-  spdlog::info("Metadata recovered.");
-  // Recover timestamp.
-  recovery_info.next_timestamp = info.start_timestamp + 1;
-
-  // Set success flag (to disable cleanup).
-  success = true;
-
-  return {info, recovery_info, std::move(indices_constraints)};
-}
-
 void CreateSnapshot(Transaction *transaction, const std::filesystem::path &snapshot_directory,
                     const std::filesystem::path &wal_directory, uint64_t snapshot_retention_count,
                     utils::SkipList<Vertex> *vertices, utils::SkipList<Edge> *edges, NameIdMapper *name_id_mapper,
-                    Indices *indices, Constraints *constraints, const Config &config, const std::string &uuid,
+                    Indices *indices, Constraints *constraints, Config::Items items, const std::string &uuid,
                     const std::string_view epoch_id, const std::deque<std::pair<std::string, uint64_t>> &epoch_history,
                     utils::FileRetainer *file_retainer) {
   // Ensure that the storage directory exists.
@@ -1335,8 +649,6 @@ void CreateSnapshot(Transaction *transaction, const std::filesystem::path &snaps
   uint64_t offset_mapper = 0;
   uint64_t offset_metadata = 0;
   uint64_t offset_epoch_history = 0;
-  uint64_t offset_edge_batches = 0;
-  uint64_t offset_vertex_batches = 0;
   {
     snapshot.WriteMarker(Marker::SECTION_OFFSETS);
     offset_offsets = snapshot.GetPosition();
@@ -1347,8 +659,6 @@ void CreateSnapshot(Transaction *transaction, const std::filesystem::path &snaps
     snapshot.WriteUint(offset_mapper);
     snapshot.WriteUint(offset_epoch_history);
     snapshot.WriteUint(offset_metadata);
-    snapshot.WriteUint(offset_edge_batches);
-    snapshot.WriteUint(offset_vertex_batches);
   }
 
   // Object counters.
@@ -1362,13 +672,9 @@ void CreateSnapshot(Transaction *transaction, const std::filesystem::path &snaps
     snapshot.WriteUint(mapping.AsUint());
   };
 
-  std::vector<BatchInfo> edge_batch_infos;
-  auto items_in_current_batch{0UL};
-  auto batch_start_offset{0UL};
   // Store all edges.
-  if (config.items.properties_on_edges) {
+  if (items.properties_on_edges) {
     offset_edges = snapshot.GetPosition();
-    batch_start_offset = offset_edges;
     auto acc = edges->access();
     for (auto &edge : acc) {
       // The edge visibility check must be done here manually because we don't
@@ -1407,8 +713,8 @@ void CreateSnapshot(Transaction *transaction, const std::filesystem::path &snaps
       // type and invalid from/to pointers because we don't know them here,
       // but that isn't an issue because we won't use that part of the API
       // here.
-      auto ea = EdgeAccessor{
-          edge_ref, EdgeTypeId::FromUint(0UL), nullptr, nullptr, transaction, indices, constraints, config.items};
+      auto ea =
+          EdgeAccessor{edge_ref, EdgeTypeId::FromUint(0UL), nullptr, nullptr, transaction, indices, constraints, items};
 
       // Get edge data.
       auto maybe_props = ea.Properties(View::OLD);
@@ -1427,29 +733,16 @@ void CreateSnapshot(Transaction *transaction, const std::filesystem::path &snaps
       }
 
       ++edges_count;
-      ++items_in_current_batch;
-      if (items_in_current_batch == config.durability.items_per_batch) {
-        edge_batch_infos.push_back(BatchInfo{batch_start_offset, items_in_current_batch});
-        batch_start_offset = snapshot.GetPosition();
-        items_in_current_batch = 0;
-      }
     }
   }
 
-  if (items_in_current_batch > 0) {
-    edge_batch_infos.push_back(BatchInfo{batch_start_offset, items_in_current_batch});
-  }
-
-  std::vector<BatchInfo> vertex_batch_infos;
   // Store all vertices.
   {
-    items_in_current_batch = 0;
     offset_vertices = snapshot.GetPosition();
-    batch_start_offset = offset_vertices;
     auto acc = vertices->access();
     for (auto &vertex : acc) {
       // The visibility check is implemented for vertices so we use it here.
-      auto va = VertexAccessor::Create(&vertex, transaction, indices, constraints, config.items, View::OLD);
+      auto va = VertexAccessor::Create(&vertex, transaction, indices, constraints, items, View::OLD);
       if (!va) continue;
 
       // Get vertex data.
@@ -1496,16 +789,6 @@ void CreateSnapshot(Transaction *transaction, const std::filesystem::path &snaps
       }
 
       ++vertices_count;
-      ++items_in_current_batch;
-      if (items_in_current_batch == config.durability.items_per_batch) {
-        vertex_batch_infos.push_back(BatchInfo{batch_start_offset, items_in_current_batch});
-        batch_start_offset = snapshot.GetPosition();
-        items_in_current_batch = 0;
-      }
-    }
-
-    if (items_in_current_batch > 0) {
-      vertex_batch_infos.push_back(BatchInfo{batch_start_offset, items_in_current_batch});
     }
   }
 
@@ -1596,26 +879,6 @@ void CreateSnapshot(Transaction *transaction, const std::filesystem::path &snaps
     snapshot.WriteUint(vertices_count);
   }
 
-  auto write_batch_infos = [&snapshot](const std::vector<BatchInfo> &batch_infos) {
-    snapshot.WriteUint(batch_infos.size());
-    for (const auto &batch_info : batch_infos) {
-      snapshot.WriteUint(batch_info.offset);
-      snapshot.WriteUint(batch_info.count);
-    }
-  };
-
-  // Write edge batches
-  {
-    offset_edge_batches = snapshot.GetPosition();
-    write_batch_infos(edge_batch_infos);
-  }
-
-  // Write vertex batches
-  {
-    offset_vertex_batches = snapshot.GetPosition();
-    write_batch_infos(vertex_batch_infos);
-  }
-
   // Write true offsets.
   {
     snapshot.SetPosition(offset_offsets);
@@ -1626,8 +889,6 @@ void CreateSnapshot(Transaction *transaction, const std::filesystem::path &snaps
     snapshot.WriteUint(offset_mapper);
     snapshot.WriteUint(offset_epoch_history);
     snapshot.WriteUint(offset_metadata);
-    snapshot.WriteUint(offset_edge_batches);
-    snapshot.WriteUint(offset_vertex_batches);
   }
 
   // Finalize snapshot file.

src/storage/v2/durability/snapshot.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 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
@@ -37,8 +37,6 @@ struct SnapshotInfo {
   uint64_t offset_mapper;
   uint64_t offset_epoch_history;
   uint64_t offset_metadata;
-  uint64_t offset_edge_batches;
-  uint64_t offset_vertex_batches;
 
   std::string uuid;
   std::string epoch_id;
@@ -64,13 +62,13 @@ SnapshotInfo ReadSnapshotInfo(const std::filesystem::path &path);
 RecoveredSnapshot LoadSnapshot(const std::filesystem::path &path, utils::SkipList<Vertex> *vertices,
                                utils::SkipList<Edge> *edges,
                                std::deque<std::pair<std::string, uint64_t>> *epoch_history,
-                               NameIdMapper *name_id_mapper, std::atomic<uint64_t> *edge_count, const Config &config);
+                               NameIdMapper *name_id_mapper, std::atomic<uint64_t> *edge_count, Config::Items items);
 
 /// Function used to create a snapshot using the given transaction.
 void CreateSnapshot(Transaction *transaction, const std::filesystem::path &snapshot_directory,
                     const std::filesystem::path &wal_directory, uint64_t snapshot_retention_count,
                     utils::SkipList<Vertex> *vertices, utils::SkipList<Edge> *edges, NameIdMapper *name_id_mapper,
-                    Indices *indices, Constraints *constraints, const Config &config, const std::string &uuid,
+                    Indices *indices, Constraints *constraints, Config::Items items, const std::string &uuid,
                     std::string_view epoch_id, const std::deque<std::pair<std::string, uint64_t>> &epoch_history,
                     utils::FileRetainer *file_retainer);
 

src/storage/v2/durability/version.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 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
@@ -20,7 +20,7 @@ namespace memgraph::storage::durability {
 // The current version of snapshot and WAL encoding / decoding.
 // IMPORTANT: Please bump this version for every snapshot and/or WAL format
 // change!!!
-const uint64_t kVersion{15};
+const uint64_t kVersion{14};
 
 const uint64_t kOldestSupportedVersion{14};
 const uint64_t kUniqueConstraintVersion{13};

src/storage/v2/indices.cpp

@@ -13,14 +13,12 @@
 #include <algorithm>
 #include <iterator>
 #include <limits>
-#include <thread>
 
 #include "storage/v2/mvcc.hpp"
 #include "storage/v2/property_value.hpp"
 #include "utils/bound.hpp"
 #include "utils/logging.hpp"
 #include "utils/memory_tracker.hpp"
-#include "utils/synchronized.hpp"
 
 namespace memgraph::storage {
 
@@ -265,95 +263,6 @@ bool CurrentVersionHasLabelProperty(const Vertex &vertex, LabelId label, Propert
   return !deleted && has_label && current_value_equal_to_value;
 }
 
-template <typename TIndexAccessor>
-void TryInsertLabelIndex(Vertex &vertex, LabelId label, TIndexAccessor &index_accessor) {
-  if (vertex.deleted || !utils::Contains(vertex.labels, label)) {
-    return;
-  }
-
-  index_accessor.insert({&vertex, 0});
-}
-
-template <typename TIndexAccessor>
-void TryInsertLabelPropertyIndex(Vertex &vertex, std::pair<LabelId, PropertyId> label_property_pair,
-                                 TIndexAccessor &index_accessor) {
-  if (vertex.deleted || !utils::Contains(vertex.labels, label_property_pair.first)) {
-    return;
-  }
-  auto value = vertex.properties.GetProperty(label_property_pair.second);
-  if (value.IsNull()) {
-    return;
-  }
-  index_accessor.insert({std::move(value), &vertex, 0});
-}
-
-template <typename TSkiplistIter, typename TIndex, typename TIndexKey, typename TFunc>
-void CreateIndexOnSingleThread(utils::SkipList<Vertex>::Accessor &vertices, TSkiplistIter it, TIndex &index,
-                               TIndexKey key, const TFunc &func) {
-  utils::MemoryTracker::OutOfMemoryExceptionEnabler oom_exception;
-  try {
-    auto acc = it->second.access();
-    for (Vertex &vertex : vertices) {
-      func(vertex, key, acc);
-    }
-  } catch (const utils::OutOfMemoryException &) {
-    utils::MemoryTracker::OutOfMemoryExceptionBlocker oom_exception_blocker;
-    index.erase(it);
-    throw;
-  }
-}
-
-template <typename TIndex, typename TIndexKey, typename TSKiplistIter, typename TFunc>
-void CreateIndexOnMultipleThreads(utils::SkipList<Vertex>::Accessor &vertices, TSKiplistIter skiplist_iter,
-                                  TIndex &index, TIndexKey key, const ParalellizedIndexCreationInfo &paralell_exec_info,
-                                  const TFunc &func) {
-  utils::MemoryTracker::OutOfMemoryExceptionEnabler oom_exception;
-
-  const auto &vertex_batches = paralell_exec_info.first;
-  const auto thread_count = std::min(paralell_exec_info.second, vertex_batches.size());
-
-  MG_ASSERT(!vertex_batches.empty(),
-            "The size of batches should always be greater than zero if you want to use the parallel version of index "
-            "creation!");
-
-  std::atomic<uint64_t> batch_counter = 0;
-
-  utils::Synchronized<std::optional<utils::OutOfMemoryException>, utils::SpinLock> maybe_error{};
-  {
-    std::vector<std::jthread> threads;
-    threads.reserve(thread_count);
-
-    for (auto i{0U}; i < thread_count; ++i) {
-      threads.emplace_back(
-          [&skiplist_iter, &func, &index, &vertex_batches, &maybe_error, &batch_counter, &key, &vertices]() {
-            while (!maybe_error.Lock()->has_value()) {
-              const auto batch_index = batch_counter++;
-              if (batch_index >= vertex_batches.size()) {
-                return;
-              }
-              const auto &batch = vertex_batches[batch_index];
-              auto index_accessor = index.at(key).access();
-              auto it = vertices.find(batch.first);
-
-              try {
-                for (auto i{0U}; i < batch.second; ++i, ++it) {
-                  func(*it, key, index_accessor);
-                }
-
-              } catch (utils::OutOfMemoryException &failure) {
-                utils::MemoryTracker::OutOfMemoryExceptionBlocker oom_exception_blocker;
-                index.erase(skiplist_iter);
-                *maybe_error.Lock() = std::move(failure);
-              }
-            }
-          });
-    }
-  }
-  if (maybe_error.Lock()->has_value()) {
-    throw utils::OutOfMemoryException((*maybe_error.Lock())->what());
-  }
-}
-
 }  // namespace
 
 void LabelIndex::UpdateOnAddLabel(LabelId label, Vertex *vertex, const Transaction &tx) {
@@ -363,43 +272,27 @@ void LabelIndex::UpdateOnAddLabel(LabelId label, Vertex *vertex, const Transacti
   acc.insert(Entry{vertex, tx.start_timestamp});
 }
 
-bool LabelIndex::CreateIndex(LabelId label, utils::SkipList<Vertex>::Accessor vertices,
-                             const std::optional<ParalellizedIndexCreationInfo> &paralell_exec_info) {
-  auto create_index_seq = [this](LabelId label, utils::SkipList<Vertex>::Accessor &vertices,
-                                 std::map<LabelId, utils::SkipList<Entry>>::iterator it) {
-    using IndexAccessor = decltype(it->second.access());
-
-    CreateIndexOnSingleThread(vertices, it, index_, label,
-                              [](Vertex &vertex, LabelId label, IndexAccessor &index_accessor) {
-                                TryInsertLabelIndex(vertex, label, index_accessor);
-                              });
-
-    return true;
-  };
-
-  auto create_index_par = [this](LabelId label, utils::SkipList<Vertex>::Accessor &vertices,
-                                 std::map<LabelId, utils::SkipList<Entry>>::iterator label_it,
-                                 const ParalellizedIndexCreationInfo &paralell_exec_info) {
-    using IndexAccessor = decltype(label_it->second.access());
-
-    CreateIndexOnMultipleThreads(vertices, label_it, index_, label, paralell_exec_info,
-                                 [](Vertex &vertex, LabelId label, IndexAccessor &index_accessor) {
-                                   TryInsertLabelIndex(vertex, label, index_accessor);
-                                 });
-
-    return true;
-  };
-
+bool LabelIndex::CreateIndex(LabelId label, utils::SkipList<Vertex>::Accessor vertices) {
+  utils::MemoryTracker::OutOfMemoryExceptionEnabler oom_exception;
   auto [it, emplaced] = index_.emplace(std::piecewise_construct, std::forward_as_tuple(label), std::forward_as_tuple());
   if (!emplaced) {
     // Index already exists.
     return false;
   }
-
-  if (paralell_exec_info) {
-    return create_index_par(label, vertices, it, *paralell_exec_info);
+  try {
+    auto acc = it->second.access();
+    for (Vertex &vertex : vertices) {
+      if (vertex.deleted || !utils::Contains(vertex.labels, label)) {
+        continue;
+      }
+      acc.insert(Entry{&vertex, 0});
+    }
+  } catch (const utils::OutOfMemoryException &) {
+    utils::MemoryTracker::OutOfMemoryExceptionBlocker oom_exception_blocker;
+    index_.erase(it);
+    throw;
   }
-  return create_index_seq(label, vertices, it);
+  return true;
 }
 
 std::vector<LabelId> LabelIndex::ListIndices() const {
@@ -525,46 +418,32 @@ void LabelPropertyIndex::UpdateOnSetProperty(PropertyId property, const Property
   }
 }
 
-bool LabelPropertyIndex::CreateIndex(LabelId label, PropertyId property, utils::SkipList<Vertex>::Accessor vertices,
-                                     const std::optional<ParalellizedIndexCreationInfo> &paralell_exec_info) {
-  auto create_index_seq = [this](LabelId label, PropertyId property, utils::SkipList<Vertex>::Accessor &vertices,
-                                 std::map<std::pair<LabelId, PropertyId>, utils::SkipList<Entry>>::iterator it) {
-    using IndexAccessor = decltype(it->second.access());
-
-    CreateIndexOnSingleThread(vertices, it, index_, std::make_pair(label, property),
-                              [](Vertex &vertex, std::pair<LabelId, PropertyId> key, IndexAccessor &index_accessor) {
-                                TryInsertLabelPropertyIndex(vertex, key, index_accessor);
-                              });
-
-    return true;
-  };
-
-  auto create_index_par =
-      [this](LabelId label, PropertyId property, utils::SkipList<Vertex>::Accessor &vertices,
-             std::map<std::pair<LabelId, PropertyId>, utils::SkipList<Entry>>::iterator label_property_it,
-             const ParalellizedIndexCreationInfo &paralell_exec_info) {
-        using IndexAccessor = decltype(label_property_it->second.access());
-
-        CreateIndexOnMultipleThreads(
-            vertices, label_property_it, index_, std::make_pair(label, property), paralell_exec_info,
-            [](Vertex &vertex, std::pair<LabelId, PropertyId> key, IndexAccessor &index_accessor) {
-              TryInsertLabelPropertyIndex(vertex, key, index_accessor);
-            });
-
-        return true;
-      };
-
+bool LabelPropertyIndex::CreateIndex(LabelId label, PropertyId property, utils::SkipList<Vertex>::Accessor vertices) {
+  utils::MemoryTracker::OutOfMemoryExceptionEnabler oom_exception;
   auto [it, emplaced] =
       index_.emplace(std::piecewise_construct, std::forward_as_tuple(label, property), std::forward_as_tuple());
   if (!emplaced) {
     // Index already exists.
     return false;
   }
-
-  if (paralell_exec_info) {
-    return create_index_par(label, property, vertices, it, *paralell_exec_info);
+  try {
+    auto acc = it->second.access();
+    for (Vertex &vertex : vertices) {
+      if (vertex.deleted || !utils::Contains(vertex.labels, label)) {
+        continue;
+      }
+      auto value = vertex.properties.GetProperty(property);
+      if (value.IsNull()) {
+        continue;
+      }
+      acc.insert(Entry{std::move(value), &vertex, 0});
+    }
+  } catch (const utils::OutOfMemoryException &) {
+    utils::MemoryTracker::OutOfMemoryExceptionBlocker oom_exception_blocker;
+    index_.erase(it);
+    throw;
   }
-  return create_index_seq(label, property, vertices, it);
+  return true;
 }
 
 std::vector<std::pair<LabelId, PropertyId>> LabelPropertyIndex::ListIndices() const {

src/storage/v2/indices.hpp

@@ -28,9 +28,6 @@ namespace memgraph::storage {
 struct Indices;
 struct Constraints;
 
-using ParalellizedIndexCreationInfo =
-    std::pair<std::vector<std::pair<Gid, uint64_t>> /*vertex_recovery_info*/, uint64_t /*thread_count*/>;
-
 class LabelIndex {
  private:
   struct Entry {
@@ -61,8 +58,7 @@ class LabelIndex {
   void UpdateOnAddLabel(LabelId label, Vertex *vertex, const Transaction &tx);
 
   /// @throw std::bad_alloc
-  bool CreateIndex(LabelId label, utils::SkipList<Vertex>::Accessor vertices,
-                   const std::optional<ParalellizedIndexCreationInfo> &paralell_exec_info = std::nullopt);
+  bool CreateIndex(LabelId label, utils::SkipList<Vertex>::Accessor vertices);
 
   /// Returns false if there was no index to drop
   bool DropIndex(LabelId label) { return index_.erase(label) > 0; }
@@ -164,8 +160,7 @@ class LabelPropertyIndex {
   void UpdateOnSetProperty(PropertyId property, const PropertyValue &value, Vertex *vertex, const Transaction &tx);
 
   /// @throw std::bad_alloc
-  bool CreateIndex(LabelId label, PropertyId property, utils::SkipList<Vertex>::Accessor vertices,
-                   const std::optional<ParalellizedIndexCreationInfo> &paralell_exec_info = std::nullopt);
+  bool CreateIndex(LabelId label, PropertyId property, utils::SkipList<Vertex>::Accessor vertices);
 
   bool DropIndex(LabelId label, PropertyId property) { return index_.erase({label, property}) > 0; }
 

src/storage/v2/isolation_level.cpp

@@ -1,34 +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.
-
-#include "isolation_level.hpp"
-
-namespace memgraph::storage {
-
-std::string_view IsolationLevelToString(IsolationLevel isolation_level) {
-  switch (isolation_level) {
-    case IsolationLevel::READ_COMMITTED:
-      return "READ_COMMITTED";
-    case IsolationLevel::READ_UNCOMMITTED:
-      return "READ_UNCOMMITTED";
-    case IsolationLevel::SNAPSHOT_ISOLATION:
-      return "SNAPSHOT_ISOLATION";
-  }
-}
-
-std::string_view IsolationLevelToString(std::optional<IsolationLevel> isolation_level) {
-  if (isolation_level) {
-    return IsolationLevelToString(*isolation_level);
-  }
-  return "";
-}
-
-}  // namespace memgraph::storage

src/storage/v2/isolation_level.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 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
@@ -12,14 +12,9 @@
 #pragma once
 
 #include <cstdint>
-#include <optional>
-#include <string_view>
 
 namespace memgraph::storage {
 
 enum class IsolationLevel : std::uint8_t { SNAPSHOT_ISOLATION, READ_COMMITTED, READ_UNCOMMITTED };
 
-std::string_view IsolationLevelToString(IsolationLevel isolation_level);
-std::string_view IsolationLevelToString(std::optional<IsolationLevel> isolation_level);
-
 }  // namespace memgraph::storage

src/storage/v2/property_store.cpp

@@ -1144,8 +1144,7 @@ bool PropertyStore::SetProperty(PropertyId property, const PropertyValue &value)
   return !existed;
 }
 
-template <typename TContainer>
-bool PropertyStore::DoInitProperties(const TContainer &properties) {
+bool PropertyStore::InitProperties(const std::map<storage::PropertyId, storage::PropertyValue> &properties) {
   uint64_t size = 0;
   uint8_t *data = nullptr;
   std::tie(size, data) = GetSizeData(buffer_);
@@ -1202,20 +1201,6 @@ bool PropertyStore::DoInitProperties(const TContainer &properties) {
 
   return true;
 }
-template bool PropertyStore::DoInitProperties<std::map<PropertyId, PropertyValue>>(
-    const std::map<PropertyId, PropertyValue> &);
-template bool PropertyStore::DoInitProperties<std::vector<std::pair<PropertyId, PropertyValue>>>(
-    const std::vector<std::pair<PropertyId, PropertyValue>> &);
-
-bool PropertyStore::InitProperties(const std::map<storage::PropertyId, storage::PropertyValue> &properties) {
-  return DoInitProperties(properties);
-}
-
-bool PropertyStore::InitProperties(std::vector<std::pair<storage::PropertyId, storage::PropertyValue>> properties) {
-  std::sort(properties.begin(), properties.end());
-
-  return DoInitProperties(properties);
-}
 
 bool PropertyStore::ClearProperties() {
   bool in_local_buffer = false;

src/storage/v2/property_store.hpp

@@ -60,17 +60,11 @@ class PropertyStore {
   bool SetProperty(PropertyId property, const PropertyValue &value);
 
   /// Init property values and return `true` if insertion took place. `false` is
-  /// returned if there is any existing property in property store and insertion couldn't take place. The time
-  /// complexity of this function is O(n).
+  /// returned if there exists property in property store and insertion couldn't take place. The time complexity of this
+  /// function is O(n).
   /// @throw std::bad_alloc
   bool InitProperties(const std::map<storage::PropertyId, storage::PropertyValue> &properties);
 
-  /// Init property values and return `true` if insertion took place. `false` is
-  /// returned if there is any existing property in property store and insertion couldn't take place. The time
-  /// complexity of this function is O(n*log(n)):
-  /// @throw std::bad_alloc
-  bool InitProperties(std::vector<std::pair<storage::PropertyId, storage::PropertyValue>> properties);
-
   /// Remove all properties and return `true` if any removal took place.
   /// `false` is returned if there were no properties to remove. The time
   /// complexity of this function is O(1).
@@ -78,9 +72,6 @@ class PropertyStore {
   bool ClearProperties();
 
  private:
-  template <typename TContainer>
-  bool DoInitProperties(const TContainer &properties);
-
   uint8_t buffer_[sizeof(uint64_t) + sizeof(uint8_t *)];
 };
 

src/storage/v2/replication/replication_client.cpp

@@ -399,8 +399,7 @@ std::vector<Storage::ReplicationClient::RecoveryStep> Storage::ReplicationClient
     // we cannot know if the difference is only in the current WAL or we need
     // to send the snapshot.
     if (latest_snapshot) {
-      const auto lock_success = locker_acc.AddPath(latest_snapshot->path);
-      MG_ASSERT(!lock_success.HasError(), "Tried to lock a nonexistant path.");
+      locker_acc.AddPath(latest_snapshot->path);
       recovery_steps.emplace_back(std::in_place_type_t<RecoverySnapshot>{}, std::move(latest_snapshot->path));
     }
     // if there are no finalized WAL files, snapshot left the current WAL
@@ -447,8 +446,7 @@ std::vector<Storage::ReplicationClient::RecoveryStep> Storage::ReplicationClient
       // We need to lock these files and add them to the chain
       for (auto result_wal_it = wal_files->begin() + distance_from_first; result_wal_it != wal_files->end();
            ++result_wal_it) {
-        const auto lock_success = locker_acc.AddPath(result_wal_it->path);
-        MG_ASSERT(!lock_success.HasError(), "Tried to lock a nonexistant path.");
+        locker_acc.AddPath(result_wal_it->path);
         wal_chain.push_back(std::move(result_wal_it->path));
       }
 
@@ -466,8 +464,7 @@ std::vector<Storage::ReplicationClient::RecoveryStep> Storage::ReplicationClient
   MG_ASSERT(latest_snapshot, "Invalid durability state, missing snapshot");
   // We didn't manage to find a WAL chain, we need to send the latest snapshot
   // with its WALs
-  const auto lock_success = locker_acc.AddPath(latest_snapshot->path);
-  MG_ASSERT(!lock_success.HasError(), "Tried to lock a nonexistant path.");
+  locker_acc.AddPath(latest_snapshot->path);
   recovery_steps.emplace_back(std::in_place_type_t<RecoverySnapshot>{}, std::move(latest_snapshot->path));
 
   std::vector<std::filesystem::path> recovery_wal_files;
@@ -486,15 +483,13 @@ std::vector<Storage::ReplicationClient::RecoveryStep> Storage::ReplicationClient
   }
 
   for (; wal_it != wal_files->end(); ++wal_it) {
-    const auto lock_success = locker_acc.AddPath(wal_it->path);
-    MG_ASSERT(!lock_success.HasError(), "Tried to lock a nonexistant path.");
+    locker_acc.AddPath(wal_it->path);
     recovery_wal_files.push_back(std::move(wal_it->path));
   }
 
   // We only have a WAL before the snapshot
   if (recovery_wal_files.empty()) {
-    const auto lock_success = locker_acc.AddPath(wal_files->back().path);
-    MG_ASSERT(!lock_success.HasError(), "Tried to lock a nonexistant path.");
+    locker_acc.AddPath(wal_files->back().path);
     recovery_wal_files.push_back(std::move(wal_files->back().path));
   }
 

src/storage/v2/replication/replication_server.cpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 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
@@ -173,7 +173,7 @@ void Storage::ReplicationServer::SnapshotHandler(slk::Reader *req_reader, slk::B
     spdlog::debug("Loading snapshot");
     auto recovered_snapshot = durability::LoadSnapshot(*maybe_snapshot_path, &storage_->vertices_, &storage_->edges_,
                                                        &storage_->epoch_history_, &storage_->name_id_mapper_,
-                                                       &storage_->edge_count_, storage_->config_);
+                                                       &storage_->edge_count_, storage_->config_.items);
     spdlog::debug("Snapshot loaded successfully");
     // If this step is present it should always be the first step of
     // the recovery so we use the UUID we read from snasphost

src/storage/v2/storage.cpp

@@ -34,8 +34,6 @@
 #include "storage/v2/storage_mode.hpp"
 #include "storage/v2/transaction.hpp"
 #include "storage/v2/vertex_accessor.hpp"
-#include "utils/event_counter.hpp"
-#include "utils/event_histogram.hpp"
 #include "utils/file.hpp"
 #include "utils/logging.hpp"
 #include "utils/memory_tracker.hpp"
@@ -43,7 +41,6 @@
 #include "utils/rw_lock.hpp"
 #include "utils/spin_lock.hpp"
 #include "utils/stat.hpp"
-#include "utils/timer.hpp"
 #include "utils/uuid.hpp"
 
 /// REPLICATION ///
@@ -52,13 +49,6 @@
 #include "storage/v2/replication/rpc.hpp"
 #include "storage/v2/storage_error.hpp"
 
-namespace memgraph::metrics {
-extern const Event SnapshotCreationLatency_us;
-
-extern const Event ActiveLabelIndices;
-extern const Event ActiveLabelPropertyIndices;
-}  // namespace memgraph::metrics
-
 namespace memgraph::storage {
 
 using OOMExceptionEnabler = utils::MemoryTracker::OutOfMemoryExceptionEnabler;
@@ -370,7 +360,7 @@ Storage::Storage(Config config)
   if (config_.durability.recover_on_startup) {
     auto info = durability::RecoverData(snapshot_directory_, wal_directory_, &uuid_, &epoch_id_, &epoch_history_,
                                         &vertices_, &edges_, &edge_count_, &name_id_mapper_, &indices_, &constraints_,
-                                        config_, &wal_seq_num_);
+                                        config_.items, &wal_seq_num_);
     if (info) {
       vertex_id_ = info->next_vertex_id;
       edge_id_ = info->next_edge_id;
@@ -1223,9 +1213,6 @@ utils::BasicResult<StorageIndexDefinitionError, void> Storage::CreateIndex(
   commit_log_->MarkFinished(commit_timestamp);
   last_commit_timestamp_ = commit_timestamp;
 
-  // We don't care if there is a replication error because on main node the change will go through
-  memgraph::metrics::IncrementCounter(memgraph::metrics::ActiveLabelIndices);
-
   if (success) {
     return {};
   }
@@ -1245,9 +1232,6 @@ utils::BasicResult<StorageIndexDefinitionError, void> Storage::CreateIndex(
   commit_log_->MarkFinished(commit_timestamp);
   last_commit_timestamp_ = commit_timestamp;
 
-  // We don't care if there is a replication error because on main node the change will go through
-  memgraph::metrics::IncrementCounter(memgraph::metrics::ActiveLabelPropertyIndices);
-
   if (success) {
     return {};
   }
@@ -1267,9 +1251,6 @@ utils::BasicResult<StorageIndexDefinitionError, void> Storage::DropIndex(
   commit_log_->MarkFinished(commit_timestamp);
   last_commit_timestamp_ = commit_timestamp;
 
-  // We don't care if there is a replication error because on main node the change will go through
-  memgraph::metrics::DecrementCounter(memgraph::metrics::ActiveLabelIndices);
-
   if (success) {
     return {};
   }
@@ -1291,9 +1272,6 @@ utils::BasicResult<StorageIndexDefinitionError, void> Storage::DropIndex(
   commit_log_->MarkFinished(commit_timestamp);
   last_commit_timestamp_ = commit_timestamp;
 
-  // We don't care if there is a replication error because on main node the change will go through
-  memgraph::metrics::DecrementCounter(memgraph::metrics::ActiveLabelPropertyIndices);
-
   if (success) {
     return {};
   }
@@ -1965,18 +1943,14 @@ utils::BasicResult<Storage::CreateSnapshotError> Storage::CreateSnapshot(std::op
   }
 
   auto snapshot_creator = [this]() {
-    utils::Timer timer;
-
     auto transaction = CreateTransaction(IsolationLevel::SNAPSHOT_ISOLATION, storage_mode_);
     // Create snapshot.
     durability::CreateSnapshot(&transaction, snapshot_directory_, wal_directory_,
                                config_.durability.snapshot_retention_count, &vertices_, &edges_, &name_id_mapper_,
-                               &indices_, &constraints_, config_, uuid_, epoch_id_, epoch_history_, &file_retainer_);
+                               &indices_, &constraints_, config_.items, uuid_, epoch_id_, epoch_history_,
+                               &file_retainer_);
     // Finalize snapshot transaction.
     commit_log_->MarkFinished(transaction.start_timestamp);
-
-    memgraph::metrics::Measure(memgraph::metrics::SnapshotCreationLatency_us,
-                               std::chrono::duration_cast<std::chrono::microseconds>(timer.Elapsed()).count());
   };
 
   std::lock_guard snapshot_guard(snapshot_lock_);
@@ -2007,23 +1981,16 @@ utils::BasicResult<Storage::CreateSnapshotError> Storage::CreateSnapshot(std::op
   return CreateSnapshotError::ReachedMaxNumTries;
 }
 
-utils::FileRetainer::FileLockerAccessor::ret_type Storage::IsPathLocked() {
-  auto locker_accessor = global_locker_.Access();
-  return locker_accessor.IsPathLocked(config_.durability.storage_directory);
-}
-
-utils::FileRetainer::FileLockerAccessor::ret_type Storage::LockPath() {
+bool Storage::LockPath() {
   auto locker_accessor = global_locker_.Access();
   return locker_accessor.AddPath(config_.durability.storage_directory);
 }
 
-utils::FileRetainer::FileLockerAccessor::ret_type Storage::UnlockPath() {
+bool Storage::UnlockPath() {
   {
     auto locker_accessor = global_locker_.Access();
-    const auto ret = locker_accessor.RemovePath(config_.durability.storage_directory);
-    if (ret.HasError() || !ret.GetValue()) {
-      // Exit without cleaning the queue
-      return ret;
+    if (!locker_accessor.RemovePath(config_.durability.storage_directory)) {
+      return false;
     }
   }
 
@@ -2207,8 +2174,6 @@ utils::BasicResult<Storage::SetIsolationLevelError> Storage::SetIsolationLevel(I
   return {};
 }
 
-IsolationLevel Storage::GetIsolationLevel() const noexcept { return isolation_level_; }
-
 void Storage::SetStorageMode(StorageMode storage_mode) {
   std::unique_lock main_guard{main_lock_};
   storage_mode_ = storage_mode;

src/storage/v2/storage.hpp

@@ -39,7 +39,6 @@
 #include "storage/v2/vertex_accessor.hpp"
 #include "utils/file_locker.hpp"
 #include "utils/on_scope_exit.hpp"
-#include "utils/result.hpp"
 #include "utils/rw_lock.hpp"
 #include "utils/scheduler.hpp"
 #include "utils/skip_list.hpp"
@@ -468,9 +467,8 @@ class Storage final {
 
   StorageInfo GetInfo() const;
 
-  utils::FileRetainer::FileLockerAccessor::ret_type IsPathLocked();
-  utils::FileRetainer::FileLockerAccessor::ret_type LockPath();
-  utils::FileRetainer::FileLockerAccessor::ret_type UnlockPath();
+  bool LockPath();
+  bool UnlockPath();
 
   bool SetReplicaRole(io::network::Endpoint endpoint, const replication::ReplicationServerConfig &config = {});
 
@@ -515,7 +513,6 @@ class Storage final {
   enum class SetIsolationLevelError : uint8_t { DisabledForAnalyticalMode };
 
   utils::BasicResult<SetIsolationLevelError> SetIsolationLevel(IsolationLevel isolation_level);
-  IsolationLevel GetIsolationLevel() const noexcept;
 
   void SetStorageMode(StorageMode storage_mode);
 

src/storage/v2/storage_mode.cpp

@@ -1,25 +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.
-
-#include "storage_mode.hpp"
-
-namespace memgraph::storage {
-
-std::string_view StorageModeToString(memgraph::storage::StorageMode storage_mode) {
-  switch (storage_mode) {
-    case memgraph::storage::StorageMode::IN_MEMORY_ANALYTICAL:
-      return "IN_MEMORY_ANALYTICAL";
-    case memgraph::storage::StorageMode::IN_MEMORY_TRANSACTIONAL:
-      return "IN_MEMORY_TRANSACTIONAL";
-  }
-}
-
-}  // namespace memgraph::storage

src/storage/v2/storage_mode.hpp

@@ -1,23 +1,9 @@
-// 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>
-#include <string_view>
 
 namespace memgraph::storage {
 
 enum class StorageMode : std::uint8_t { IN_MEMORY_ANALYTICAL, IN_MEMORY_TRANSACTIONAL };
 
-std::string_view StorageModeToString(memgraph::storage::StorageMode storage_mode);
-
 }  // namespace memgraph::storage

src/utils/CMakeLists.txt

@@ -2,8 +2,6 @@ set(utils_src_files
     async_timer.cpp
     base64.cpp
     event_counter.cpp
-    event_gauge.cpp
-    event_histogram.cpp
     csv_parsing.cpp
     file.cpp
     file_locker.cpp
@@ -17,8 +15,7 @@ set(utils_src_files
     thread_pool.cpp
     tsc.cpp
     system_info.cpp
-    uuid.cpp
-    build_info.cpp)
+    uuid.cpp)
 
 find_package(Boost REQUIRED)
 find_package(fmt REQUIRED)

src/utils/build_info.cpp

@@ -1,26 +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.
-
-#include "build_info.hpp"
-
-namespace memgraph::utils {
-
-BuildInfo GetBuildInfo() {
-#ifdef CMAKE_BUILD_TYPE_NAME
-  constexpr const char *build_info_name = CMAKE_BUILD_TYPE_NAME;
-#else
-  constexpr const char *build_info_name = "unkown";
-#endif
-  BuildInfo info{build_info_name};
-  return info;
-}
-
-}  // namespace memgraph::utils

src/utils/build_info.hpp

@@ -1,24 +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 <string>
-
-namespace memgraph::utils {
-
-struct BuildInfo {
-  std::string build_name;
-};
-
-BuildInfo GetBuildInfo();
-
-}  // namespace memgraph::utils

src/utils/event_counter.cpp

@@ -11,86 +11,69 @@
 
 #include "utils/event_counter.hpp"
 
-// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define APPLY_FOR_COUNTERS(M)                                                                                        \
-  M(ReadQuery, QueryType, "Number of read-only queries executed.")                                                   \
-  M(WriteQuery, QueryType, "Number of write-only queries executed.")                                                 \
-  M(ReadWriteQuery, QueryType, "Number of read-write queries executed.")                                             \
-                                                                                                                     \
-  M(OnceOperator, Operator, "Number of times Once operator was used.")                                               \
-  M(CreateNodeOperator, Operator, "Number of times CreateNode operator was used.")                                   \
-  M(CreateExpandOperator, Operator, "Number of times CreateExpand operator was used.")                               \
-  M(ScanAllOperator, Operator, "Number of times ScanAll operator was used.")                                         \
-  M(ScanAllByLabelOperator, Operator, "Number of times ScanAllByLabel operator was used.")                           \
-  M(ScanAllByLabelPropertyRangeOperator, Operator, "Number of times ScanAllByLabelPropertyRange operator was used.") \
-  M(ScanAllByLabelPropertyValueOperator, Operator, "Number of times ScanAllByLabelPropertyValue operator was used.") \
-  M(ScanAllByLabelPropertyOperator, Operator, "Number of times ScanAllByLabelProperty operator was used.")           \
-  M(ScanAllByIdOperator, Operator, "Number of times ScanAllById operator was used.")                                 \
-  M(ExpandOperator, Operator, "Number of times Expand operator was used.")                                           \
-  M(ExpandVariableOperator, Operator, "Number of times ExpandVariable operator was used.")                           \
-  M(ConstructNamedPathOperator, Operator, "Number of times ConstructNamedPath operator was used.")                   \
-  M(FilterOperator, Operator, "Number of times Filter operator was used.")                                           \
-  M(ProduceOperator, Operator, "Number of times Produce operator was used.")                                         \
-  M(DeleteOperator, Operator, "Number of times Delete operator was used.")                                           \
-  M(SetPropertyOperator, Operator, "Number of times SetProperty operator was used.")                                 \
-  M(SetPropertiesOperator, Operator, "Number of times SetProperties operator was used.")                             \
-  M(SetLabelsOperator, Operator, "Number of times SetLabels operator was used.")                                     \
-  M(RemovePropertyOperator, Operator, "Number of times RemoveProperty operator was used.")                           \
-  M(RemoveLabelsOperator, Operator, "Number of times RemoveLabels operator was used.")                               \
-  M(EdgeUniquenessFilterOperator, Operator, "Number of times EdgeUniquenessFilter operator was used.")               \
-  M(EmptyResultOperator, Operator, "Number of times EmptyResult operator was used.")                                 \
-  M(AccumulateOperator, Operator, "Number of times Accumulate operator was used.")                                   \
-  M(AggregateOperator, Operator, "Number of times Aggregate operator was used.")                                     \
-  M(SkipOperator, Operator, "Number of times Skip operator was used.")                                               \
-  M(LimitOperator, Operator, "Number of times Limit operator was used.")                                             \
-  M(OrderByOperator, Operator, "Number of times OrderBy operator was used.")                                         \
-  M(MergeOperator, Operator, "Number of times Merge operator was used.")                                             \
-  M(OptionalOperator, Operator, "Number of times Optional operator was used.")                                       \
-  M(UnwindOperator, Operator, "Number of times Unwind operator was used.")                                           \
-  M(DistinctOperator, Operator, "Number of times Distinct operator was used.")                                       \
-  M(UnionOperator, Operator, "Number of times Union operator was used.")                                             \
-  M(CartesianOperator, Operator, "Number of times Cartesian operator was used.")                                     \
-  M(CallProcedureOperator, Operator, "Number of times CallProcedure operator was used.")                             \
-  M(ForeachOperator, Operator, "Number of times Foreach operator was used.")                                         \
-  M(EvaluatePatternFilterOperator, Operator, "Number of times EvaluatePatternFilter operator was used.")             \
-  M(ApplyOperator, Operator, "Number of times ApplyOperator operator was used.")                                     \
-                                                                                                                     \
-  M(ActiveLabelIndices, Index, "Number of active label indices in the system.")                                      \
-  M(ActiveLabelPropertyIndices, Index, "Number of active label property indices in the system<.")                    \
-                                                                                                                     \
-  M(StreamsCreated, Stream, "Number of Streams created.")                                                            \
-  M(MessagesConsumed, Stream, "Number of consumed streamed messages.")                                               \
-                                                                                                                     \
-  M(TriggersCreated, Trigger, "Number of Triggers created.")                                                         \
-  M(TriggersExecuted, Trigger, "Number of Triggers executed.")                                                       \
-                                                                                                                     \
-  M(ActiveSessions, Session, "Number of active connections.")                                                        \
-  M(ActiveBoltSessions, Session, "Number of active Bolt connections.")                                               \
-  M(ActiveTCPSessions, Session, "Number of active TCP connections.")                                                 \
-  M(ActiveSSLSessions, Session, "Number of active SSL connections.")                                                 \
-  M(ActiveWebSocketSessions, Session, "Number of active websocket connections.")                                     \
-  M(BoltMessages, Session, "Number of Bolt messages sent.")                                                          \
-                                                                                                                     \
-  M(ActiveTransactions, Transaction, "Number of active transactions.")                                               \
-  M(CommitedTransactions, Transaction, "Number of committed transactions.")                                          \
-  M(RollbackedTransactions, Transaction, "Number of rollbacked transactions.")                                       \
-  M(FailedQuery, Transaction, "Number of times executing a query failed.")
+#define APPLY_FOR_EVENTS(M)                                                                                \
+  M(ReadQuery, "Number of read-only queries executed.")                                                    \
+  M(WriteQuery, "Number of write-only queries executed.")                                                  \
+  M(ReadWriteQuery, "Number of read-write queries executed.")                                              \
+                                                                                                           \
+  M(OnceOperator, "Number of times Once operator was used.")                                               \
+  M(CreateNodeOperator, "Number of times CreateNode operator was used.")                                   \
+  M(CreateExpandOperator, "Number of times CreateExpand operator was used.")                               \
+  M(ScanAllOperator, "Number of times ScanAll operator was used.")                                         \
+  M(ScanAllByLabelOperator, "Number of times ScanAllByLabel operator was used.")                           \
+  M(ScanAllByLabelPropertyRangeOperator, "Number of times ScanAllByLabelPropertyRange operator was used.") \
+  M(ScanAllByLabelPropertyValueOperator, "Number of times ScanAllByLabelPropertyValue operator was used.") \
+  M(ScanAllByLabelPropertyOperator, "Number of times ScanAllByLabelProperty operator was used.")           \
+  M(ScanAllByIdOperator, "Number of times ScanAllById operator was used.")                                 \
+  M(ExpandOperator, "Number of times Expand operator was used.")                                           \
+  M(ExpandVariableOperator, "Number of times ExpandVariable operator was used.")                           \
+  M(ConstructNamedPathOperator, "Number of times ConstructNamedPath operator was used.")                   \
+  M(FilterOperator, "Number of times Filter operator was used.")                                           \
+  M(ProduceOperator, "Number of times Produce operator was used.")                                         \
+  M(DeleteOperator, "Number of times Delete operator was used.")                                           \
+  M(SetPropertyOperator, "Number of times SetProperty operator was used.")                                 \
+  M(SetPropertiesOperator, "Number of times SetProperties operator was used.")                             \
+  M(SetLabelsOperator, "Number of times SetLabels operator was used.")                                     \
+  M(RemovePropertyOperator, "Number of times RemoveProperty operator was used.")                           \
+  M(RemoveLabelsOperator, "Number of times RemoveLabels operator was used.")                               \
+  M(EdgeUniquenessFilterOperator, "Number of times EdgeUniquenessFilter operator was used.")               \
+  M(EmptyResultOperator, "Number of times EmptyResult operator was used.")                                 \
+  M(AccumulateOperator, "Number of times Accumulate operator was used.")                                   \
+  M(AggregateOperator, "Number of times Aggregate operator was used.")                                     \
+  M(SkipOperator, "Number of times Skip operator was used.")                                               \
+  M(LimitOperator, "Number of times Limit operator was used.")                                             \
+  M(OrderByOperator, "Number of times OrderBy operator was used.")                                         \
+  M(MergeOperator, "Number of times Merge operator was used.")                                             \
+  M(OptionalOperator, "Number of times Optional operator was used.")                                       \
+  M(UnwindOperator, "Number of times Unwind operator was used.")                                           \
+  M(DistinctOperator, "Number of times Distinct operator was used.")                                       \
+  M(UnionOperator, "Number of times Union operator was used.")                                             \
+  M(CartesianOperator, "Number of times Cartesian operator was used.")                                     \
+  M(CallProcedureOperator, "Number of times CallProcedure operator was used.")                             \
+  M(ForeachOperator, "Number of times Foreach operator was used.")                                         \
+  M(EvaluatePatternFilterOperator, "Number of times EvaluatePatternFilter operator was used.")             \
+  M(ApplyOperator, "Number of times ApplyOperator operator was used.")                                     \
+                                                                                                           \
+  M(FailedQuery, "Number of times executing a query failed.")                                              \
+  M(LabelIndexCreated, "Number of times a label index was created.")                                       \
+  M(LabelPropertyIndexCreated, "Number of times a label property index was created.")                      \
+  M(StreamsCreated, "Number of Streams created.")                                                          \
+  M(MessagesConsumed, "Number of consumed streamed messages.")                                             \
+  M(TriggersCreated, "Number of Triggers created.")                                                        \
+  M(TriggersExecuted, "Number of Triggers executed.")
+
+namespace EventCounter {
 
-namespace memgraph::metrics {
 // define every Event as an index in the array of counters
-// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define M(NAME, TYPE, DOCUMENTATION) extern const Event NAME = __COUNTER__;
-APPLY_FOR_COUNTERS(M)
+#define M(NAME, DOCUMENTATION) extern const Event NAME = __COUNTER__;
+APPLY_FOR_EVENTS(M)
 #undef M
 
 inline constexpr Event END = __COUNTER__;
 
 // Initialize array for the global counter with all values set to 0
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 Counter global_counters_array[END]{};
-
 // Initialize global counters
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 EventCounters global_counters(global_counters_array);
 
 const Event EventCounters::num_counters = END;
@@ -99,45 +82,28 @@ void EventCounters::Increment(const Event event, Count amount) {
   counters_[event].fetch_add(amount, std::memory_order_relaxed);
 }
 
-void EventCounters::Decrement(const Event event, Count amount) {
-  counters_[event].fetch_sub(amount, std::memory_order_relaxed);
-}
-
 void IncrementCounter(const Event event, Count amount) { global_counters.Increment(event, amount); }
-void DecrementCounter(const Event event, Count amount) { global_counters.Decrement(event, amount); }
 
-const char *GetCounterName(const Event event) {
+const char *GetName(const Event event) {
   static const char *strings[] = {
-  // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define M(NAME, TYPE, DOCUMENTATION) #NAME,
-      APPLY_FOR_COUNTERS(M)
+#define M(NAME, DOCUMENTATION) #NAME,
+      APPLY_FOR_EVENTS(M)
 #undef M
   };
 
   return strings[event];
 }
 
-const char *GetCounterDocumentation(const Event event) {
+const char *GetDocumentation(const Event event) {
   static const char *strings[] = {
-  // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define M(NAME, TYPE, DOCUMENTATION) DOCUMENTATION,
-      APPLY_FOR_COUNTERS(M)
+#define M(NAME, DOCUMENTATION) DOCUMENTATION,
+      APPLY_FOR_EVENTS(M)
 #undef M
   };
 
   return strings[event];
 }
 
-const char *GetCounterType(const Event event) {
-  static const char *strings[] = {
-  // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define M(NAME, TYPE, DOCUMENTATION) #TYPE,
-      APPLY_FOR_COUNTERS(M)
-#undef M
-  };
+Event End() { return END; }
 
-  return strings[event];
-}
-
-Event CounterEnd() { return END; }
-}  // namespace memgraph::metrics
+}  // namespace EventCounter

src/utils/event_counter.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2021 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
@@ -10,12 +10,11 @@
 // licenses/APL.txt.
 
 #pragma once
-
 #include <atomic>
 #include <cstdlib>
 #include <memory>
 
-namespace memgraph::metrics {
+namespace EventCounter {
 using Event = uint64_t;
 using Count = uint64_t;
 using Counter = std::atomic<Count>;
@@ -30,23 +29,19 @@ class EventCounters {
 
   void Increment(Event event, Count amount = 1);
 
-  void Decrement(Event event, Count amount = 1);
-
   static const Event num_counters;
 
  private:
   Counter *counters_;
 };
 
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 extern EventCounters global_counters;
 
 void IncrementCounter(Event event, Count amount = 1);
-void DecrementCounter(Event event, Count amount = 1);
 
-const char *GetCounterName(Event event);
-const char *GetCounterDocumentation(Event event);
-const char *GetCounterType(Event event);
+const char *GetName(Event event);
+const char *GetDocumentation(Event event);
 
-Event CounterEnd();
-}  // namespace memgraph::metrics
+Event End();
+
+}  // namespace EventCounter

src/utils/event_gauge.cpp

@@ -1,76 +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.
-
-#include "utils/event_gauge.hpp"
-
-// We don't have any gauges for now
-#define APPLY_FOR_GAUGES(M)
-
-namespace memgraph::metrics {
-
-// define every Event as an index in the array of gauges
-// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define M(NAME, TYPE, DOCUMENTATION) extern const Event NAME = __COUNTER__;
-APPLY_FOR_GAUGES(M)
-#undef M
-
-inline constexpr Event END = __COUNTER__;
-
-// Initialize array for the global gauges with all values set to 0
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-Gauge global_gauges_array[END]{};
-
-// Initialize global counters
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-EventGauges global_gauges(global_gauges_array);
-
-const Event EventGauges::num_gauges = END;
-
-void EventGauges::SetValue(const Event event, Value value) { gauges_[event].store(value, std::memory_order_seq_cst); }
-
-void SetGaugeValue(const Event event, Value value) { global_gauges.SetValue(event, value); }
-
-const char *GetGaugeName(const Event event) {
-  static const char *strings[] = {
-  // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define M(NAME, TYPE, DOCUMENTATION) #NAME,
-      APPLY_FOR_GAUGES(M)
-#undef M
-  };
-
-  return strings[event];
-}
-
-const char *GetGaugeDocumentation(const Event event) {
-  static const char *strings[] = {
-  // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define M(NAME, TYPE, DOCUMENTATION) DOCUMENTATION,
-      APPLY_FOR_GAUGES(M)
-#undef M
-  };
-
-  return strings[event];
-}
-
-const char *GetGaugeType(const Event event) {
-  static const char *strings[] = {
-  // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define M(NAME, TYPE, DOCUMENTATION) #TYPE,
-      APPLY_FOR_GAUGES(M)
-#undef M
-  };
-
-  return strings[event];
-}
-
-Event GaugeEnd() { return END; }
-
-}  // namespace memgraph::metrics

src/utils/event_gauge.hpp

@@ -1,49 +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 <atomic>
-#include <cstdlib>
-#include <memory>
-
-namespace memgraph::metrics {
-using Event = uint64_t;
-using Value = uint64_t;
-using Gauge = std::atomic<Value>;
-
-class EventGauges {
- public:
-  explicit EventGauges(Gauge *allocated_gauges) noexcept : gauges_(allocated_gauges) {}
-
-  auto &operator[](const Event event) { return gauges_[event]; }
-
-  const auto &operator[](const Event event) const { return gauges_[event]; }
-
-  void SetValue(Event event, Value value);
-
-  static const Event num_gauges;
-
- private:
-  Gauge *gauges_;
-};
-
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-extern EventGauges global_gauges;
-
-void SetGaugeValue(Event event, Value value);
-
-const char *GetGaugeName(Event event);
-const char *GetGaugeDocumentation(Event event);
-const char *GetGaugeType(Event event);
-
-Event GaugeEnd();
-}  // namespace memgraph::metrics

src/utils/event_histogram.cpp

@@ -1,84 +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.
-
-#include "utils/event_histogram.hpp"
-
-// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define APPLY_FOR_HISTOGRAMS(M)                                                                    \
-  M(QueryExecutionLatency_us, Query, "Query execution latency in microseconds", 50, 90, 99)        \
-  M(SnapshotCreationLatency_us, Snapshot, "Snapshot creation latency in microseconds", 50, 90, 99) \
-  M(SnapshotRecoveryLatency_us, Snapshot, "Snapshot recovery latency in microseconds", 50, 90, 99)
-
-namespace memgraph::metrics {
-
-// define every Event as an index in the array of counters
-// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define M(NAME, TYPE, DOCUMENTATION, ...) extern const Event NAME = __COUNTER__;
-APPLY_FOR_HISTOGRAMS(M)
-#undef M
-
-inline constexpr Event END = __COUNTER__;
-
-// Initialize array for the global histogram with all named histograms and their percentiles
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-Histogram global_histograms_array[END]{
-
-// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define M(NAME, TYPE, DOCUMENTATION, ...) Histogram({__VA_ARGS__}),
-    APPLY_FOR_HISTOGRAMS(M)
-#undef M
-};
-
-// Initialize global histograms
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-EventHistograms global_histograms(global_histograms_array);
-
-const Event EventHistograms::num_histograms = END;
-
-void Measure(const Event event, Value value) { global_histograms.Measure(event, value); }
-
-void EventHistograms::Measure(const Event event, Value value) { histograms_[event].Measure(value); }
-
-const char *GetHistogramName(const Event event) {
-  static const char *strings[] = {
-  // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define M(NAME, TYPE, DOCUMENTATION, ...) #NAME,
-      APPLY_FOR_HISTOGRAMS(M)
-#undef M
-  };
-
-  return strings[event];
-}
-
-const char *GetHistogramDocumentation(const Event event) {
-  static const char *strings[] = {
-  // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define M(NAME, TYPE, DOCUMENTATION, ...) DOCUMENTATION,
-      APPLY_FOR_HISTOGRAMS(M)
-#undef M
-  };
-
-  return strings[event];
-}
-
-const char *GetHistogramType(const Event event) {
-  static const char *strings[] = {
-  // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define M(NAME, TYPE, DOCUMENTATION, ...) #TYPE,
-      APPLY_FOR_HISTOGRAMS(M)
-#undef M
-  };
-
-  return strings[event];
-}
-
-Event HistogramEnd() { return END; }
-}  // namespace memgraph::metrics

src/utils/event_histogram.hpp

@@ -1,171 +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 <cmath>
-
-#include "utils/logging.hpp"
-
-namespace memgraph::metrics {
-using Event = uint64_t;
-using Value = uint64_t;
-using Measurement = std::atomic<uint64_t>;
-
-// This is a logarithmically bucketing histogram optimized
-// for collecting network response latency distributions.
-// It "compresses" values by mapping them to a point on a
-// logarithmic curve, which serves as the bucket index. This
-// compression technique allows for very accurate histograms
-// (unlike what is the case for sampling or lossy probabilistic
-// approaches) with the trade-off that we sacrifice around 1%
-// precision.
-//
-// properties:
-// * roughly 1% precision loss - can be higher for values
-//   less than 100, so if measuring latency, generally do
-//   so in microseconds.
-// * ~32kb constant space, single allocation per Histogram.
-// * Histogram::Percentile() will return 0 if there were no
-//   samples measured yet.
-class Histogram {
-  // This is the number of buckets that observed values
-  // will be logarithmically compressed into.
-  constexpr static auto kSampleLimit = 4096;
-
-  // This is roughly 1/error rate, where 100.0 is roughly
-  // a 1% error bound for measurements. This is less true
-  // for tiny measurements, but because we tend to measure
-  // microseconds, it is usually over 100, which is where
-  // the error bound starts to stabilize a bit. This has
-  // been tuned to allow the maximum uint64_t to compress
-  // within 4096 samples while still achieving a high accuracy.
-  constexpr static auto kPrecision = 92.0;
-
-  // samples_ stores per-bucket counts for measurements
-  // that have been mapped to a specific uint64_t in
-  // the "compression" logic below.
-  std::vector<uint64_t> samples_ = {};
-
-  std::vector<uint8_t> percentiles_;
-
-  // count_ is the number of measurements that have been
-  // included in this Histogram.
-  Measurement count_ = 0;
-
-  // sum_ is the summed value of all measurements that
-  // have been included in this Histogram.
-  Measurement sum_ = 0;
-
-  std::mutex samples_mutex_;
-
- public:
-  Histogram() {
-    samples_.resize(kSampleLimit, 0);
-    percentiles_ = {0, 25, 50, 75, 90, 100};
-  }
-
-  explicit Histogram(std::vector<uint8_t> percentiles) : percentiles_(percentiles) { samples_.resize(kSampleLimit, 0); }
-
-  uint64_t Count() const { return count_.load(std::memory_order_relaxed); }
-
-  uint64_t Sum() const { return sum_.load(std::memory_order_relaxed); }
-
-  std::vector<uint8_t> Percentiles() const { return percentiles_; }
-
-  void Measure(uint64_t value) {
-    // "compression" logic
-    double boosted = 1.0 + static_cast<double>(value);
-    double ln = std::log(boosted);
-    double compressed = (kPrecision * ln) + 0.5;
-
-    MG_ASSERT(compressed < kSampleLimit, "compressing value {} to {} is invalid", value, compressed);
-    auto sample_index = static_cast<uint16_t>(compressed);
-
-    count_.fetch_add(1, std::memory_order_relaxed);
-    sum_.fetch_add(value, std::memory_order_relaxed);
-
-    {
-      std::lock_guard<std::mutex> lock(samples_mutex_);
-      samples_[sample_index]++;
-    }
-  }
-
-  std::vector<std::pair<uint64_t, uint64_t>> YieldPercentiles() const {
-    std::vector<std::pair<uint64_t, uint64_t>> percentile_yield;
-    percentile_yield.reserve(percentiles_.size());
-
-    for (const auto percentile : percentiles_) {
-      percentile_yield.emplace_back(std::make_pair(percentile, Percentile(percentile)));
-    }
-
-    return percentile_yield;
-  }
-
-  uint64_t Percentile(double percentile) const {
-    MG_ASSERT(percentile <= 100.0, "percentiles must not exceed 100.0");
-    MG_ASSERT(percentile >= 0.0, "percentiles must be greater than or equal to 0.0");
-
-    auto count = Count();
-
-    if (count == 0) {
-      return 0;
-    }
-
-    const auto floated_count = static_cast<double>(count);
-    const auto target = std::max(floated_count * percentile / 100.0, 1.0);
-
-    auto scanned = 0.0;
-
-    for (int i = 0; i < kSampleLimit; i++) {
-      const auto samples_at_index = samples_[i];
-      scanned += static_cast<double>(samples_at_index);
-      if (scanned >= target) {
-        // "decompression" logic
-        auto floated = static_cast<double>(i);
-        auto unboosted = floated / kPrecision;
-        auto decompressed = std::exp(unboosted) - 1.0;
-        return static_cast<uint64_t>(decompressed);
-      }
-    }
-
-    LOG_FATAL("bug in Histogram::Percentile where it failed to return the {} percentile", percentile);
-    return 0;
-  }
-};
-
-class EventHistograms {
- public:
-  explicit EventHistograms(Histogram *allocated_histograms) noexcept : histograms_(allocated_histograms) {}
-
-  auto &operator[](const Event event) { return histograms_[event]; }
-
-  const auto &operator[](const Event event) const { return histograms_[event]; }
-
-  void Measure(Event event, Value value);
-
-  static const Event num_histograms;
-
- private:
-  Histogram *histograms_;
-};
-
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-extern EventHistograms global_histograms;
-
-void Measure(Event event, Value value);
-
-const char *GetHistogramName(Event event);
-const char *GetHistogramDocumentation(Event event);
-const char *GetHistogramType(Event event);
-
-Event HistogramEnd();
-}  // namespace memgraph::metrics

src/utils/file_locker.cpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 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
@@ -80,14 +80,13 @@ void FileRetainer::CleanQueue() {
 }
 
 ////// LockerEntry //////
-bool FileRetainer::LockerEntry::LockPath(const std::filesystem::path &path) {
+void FileRetainer::LockerEntry::LockPath(const std::filesystem::path &path) {
   auto absolute_path = std::filesystem::absolute(path);
   if (std::filesystem::is_directory(absolute_path)) {
-    const auto [itr, success] = directories_.emplace(std::move(absolute_path));
-    return success;
+    directories_.emplace(std::move(absolute_path));
+    return;
   }
-  const auto [itr, success] = files_.emplace(std::move(absolute_path));
-  return success;
+  files_.emplace(std::move(absolute_path));
 }
 
 bool FileRetainer::LockerEntry::RemovePath(const std::filesystem::path &path) {
@@ -141,27 +140,13 @@ FileRetainer::FileLockerAccessor::FileLockerAccessor(FileRetainer *retainer, siz
   file_retainer_->active_accessors_.fetch_add(1);
 }
 
-FileRetainer::FileLockerAccessor::ret_type FileRetainer::FileLockerAccessor::IsPathLocked(
-    const std::filesystem::path &path) {
-  if (!std::filesystem::exists(path)) {
-    return Error::NonexistentPath;
-  }
-  return file_retainer_->FileLocked(std::filesystem::absolute(path));
+bool FileRetainer::FileLockerAccessor::AddPath(const std::filesystem::path &path) {
+  if (!std::filesystem::exists(path)) return false;
+  file_retainer_->lockers_.WithLock([&](auto &lockers) { lockers[locker_id_].LockPath(path); });
+  return true;
 }
 
-FileRetainer::FileLockerAccessor::ret_type FileRetainer::FileLockerAccessor::AddPath(
-    const std::filesystem::path &path) {
-  if (!std::filesystem::exists(path)) {
-    return Error::NonexistentPath;
-  }
-  return file_retainer_->lockers_.WithLock([&](auto &lockers) { return lockers[locker_id_].LockPath(path); });
-}
-
-FileRetainer::FileLockerAccessor::ret_type FileRetainer::FileLockerAccessor::RemovePath(
-    const std::filesystem::path &path) {
-  if (!std::filesystem::exists(path)) {
-    return Error::NonexistentPath;
-  }
+bool FileRetainer::FileLockerAccessor::RemovePath(const std::filesystem::path &path) {
   return file_retainer_->lockers_.WithLock([&](auto &lockers) { return lockers[locker_id_].RemovePath(path); });
 }
 

src/utils/file_locker.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 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
@@ -18,7 +18,6 @@
 #include <unordered_map>
 
 #include "utils/file.hpp"
-#include "utils/result.hpp"
 #include "utils/rw_lock.hpp"
 #include "utils/spin_lock.hpp"
 #include "utils/synchronized.hpp"
@@ -115,26 +114,15 @@ class FileRetainer {
   struct FileLockerAccessor {
     friend FileLocker;
 
-    enum class Error : uint8_t {
-      NonexistentPath = 0,
-    };
-
-    using ret_type = utils::BasicResult<FileRetainer::FileLockerAccessor::Error, bool>;
-
-    /**
-     * Checks if a single path is in the current locker.
-     */
-    ret_type IsPathLocked(const std::filesystem::path &path);
-
     /**
      * Add a single path to the current locker.
      */
-    ret_type AddPath(const std::filesystem::path &path);
+    bool AddPath(const std::filesystem::path &path);
 
     /**
      * Remove a single path form the current locker.
      */
-    ret_type RemovePath(const std::filesystem::path &path);
+    bool RemovePath(const std::filesystem::path &path);
 
     FileLockerAccessor(const FileLockerAccessor &) = delete;
     FileLockerAccessor(FileLockerAccessor &&) = default;
@@ -194,7 +182,7 @@ class FileRetainer {
 
   class LockerEntry {
    public:
-    bool LockPath(const std::filesystem::path &path);
+    void LockPath(const std::filesystem::path &path);
     bool RemovePath(const std::filesystem::path &path);
     [[nodiscard]] bool LocksFile(const std::filesystem::path &path) const;
 

src/utils/memory.cpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 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
@@ -187,19 +187,14 @@ void *Pool::Allocate() {
   for (unsigned char i = 0U; i < blocks_per_chunk_; ++i) {
     *(data + (i * block_size_)) = i + 1U;
   }
-  Chunk chunk{data, 0, blocks_per_chunk_};
-  // Insert the big block in the sorted position.
-  auto it = std::lower_bound(chunks_.begin(), chunks_.end(), chunk,
-                             [](const auto &a, const auto &b) { return a.data < b.data; });
   try {
-    it = chunks_.insert(it, chunk);
+    chunks_.push_back(Chunk{data, 0, blocks_per_chunk_});
   } catch (...) {
     GetUpstreamResource()->Deallocate(data, data_size, alignment);
     throw;
   }
-
-  last_alloc_chunk_ = &*it;
-  last_dealloc_chunk_ = &*it;
+  last_alloc_chunk_ = &chunks_.back();
+  last_dealloc_chunk_ = &chunks_.back();
   return allocate_block_from_chunk(last_alloc_chunk_);
 }
 
@@ -228,20 +223,18 @@ void Pool::Deallocate(void *p) {
     deallocate_block_from_chunk(last_dealloc_chunk_);
     return;
   }
-
   // Find the chunk which served this allocation
-  Chunk chunk{reinterpret_cast<unsigned char *>(p) - blocks_per_chunk_ * block_size_, 0, 0};
-  auto it = std::lower_bound(chunks_.begin(), chunks_.end(), chunk,
-                             [](const auto &a, const auto &b) { return a.data <= b.data; });
-  MG_ASSERT(it != chunks_.end(), "Failed deallocation in utils::Pool");
-  MG_ASSERT(is_in_chunk(*it), "Failed deallocation in utils::Pool");
-
-  // Update last_alloc_chunk_ as well because it now has a free block.
-  // Additionally this corresponds with C++ pattern of allocations and
-  // deallocations being done in reverse order.
-  last_alloc_chunk_ = &*it;
-  last_dealloc_chunk_ = &*it;
-  deallocate_block_from_chunk(last_dealloc_chunk_);
+  for (auto &chunk : chunks_) {
+    if (is_in_chunk(chunk)) {
+      // Update last_alloc_chunk_ as well because it now has a free block.
+      // Additionally this corresponds with C++ pattern of allocations and
+      // deallocations being done in reverse order.
+      last_alloc_chunk_ = &chunk;
+      last_dealloc_chunk_ = &chunk;
+      deallocate_block_from_chunk(&chunk);
+      return;
+    }
+  }
   // TODO: We could release the Chunk to upstream memory
 }
 

src/utils/pmr/deque.hpp

@@ -1,23 +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 <deque>
-
-#include "utils/memory.hpp"
-
-namespace memgraph::utils::pmr {
-
-template <class T>
-using deque = std::deque<T, utils::Allocator<T>>;
-
-}  // namespace memgraph::utils::pmr

src/utils/typeinfo.hpp

@@ -118,10 +118,8 @@ enum class TypeId : uint64_t {
   AST_PRIMITIVE_LITERAL,
   AST_LIST_LITERAL,
   AST_MAP_LITERAL,
-  AST_MAP_PROJECTION_LITERAL,
   AST_IDENTIFIER,
   AST_PROPERTY_LOOKUP,
-  AST_ALL_PROPERTIES_LOOKUP,
   AST_LABELS_TEST,
   AST_FUNCTION,
   AST_REDUCE,

tests/benchmark/query/eval.cpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 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
@@ -60,8 +60,6 @@ BENCHMARK_TEMPLATE(MapLiteral, NewDeleteResource)->Range(512, 1U << 15U)->Unit(b
 
 BENCHMARK_TEMPLATE(MapLiteral, MonotonicBufferResource)->Range(512, 1U << 15U)->Unit(benchmark::kMicrosecond);
 
-// TODO ante benchmark template for MapProjectionLiteral
-
 template <class TMemory>
 // NOLINTNEXTLINE(google-runtime-references)
 static void AdditionOperator(benchmark::State &state) {

tests/e2e/configuration/CMakeLists.txt

@@ -4,4 +4,3 @@ endfunction()
 
 copy_configuration_check_e2e_python_files(default_config.py)
 copy_configuration_check_e2e_python_files(configuration_check.py)
-copy_configuration_check_e2e_python_files(storage_info.py)

tests/e2e/configuration/configuration_check.py

@@ -38,12 +38,7 @@ def test_does_default_config_match():
         flag_name = flag[0]
 
         # The default value of these is dependent on the given machine.
-        machine_dependent_configurations = [
-            "bolt_num_workers",
-            "data_directory",
-            "log_file",
-            "storage_recovery_thread_count",
-        ]
+        machine_dependent_configurations = ["bolt_num_workers", "data_directory", "log_file"]
         if flag_name in machine_dependent_configurations:
             continue
 

tests/e2e/configuration/default_config.py

@@ -92,23 +92,12 @@ startup_config_dict = {
         "1024",
         "Memory warning threshold, in MB. If Memgraph detects there is less available RAM it will log a warning. Set to 0 to disable.",
     ),
-    "metrics_address": (
-        "0.0.0.0",
-        "0.0.0.0",
-        "IP address on which the Memgraph server for exposing metrics should listen.",
-    ),
-    "metrics_port": ("9091", "9091", "Port on which the Memgraph server for exposing metrics should listen."),
     "monitoring_address": (
         "0.0.0.0",
         "0.0.0.0",
         "IP address on which the websocket server for Memgraph monitoring should listen.",
     ),
     "monitoring_port": ("7444", "7444", "Port on which the websocket server for Memgraph monitoring should listen."),
-    "storage_parallel_index_recovery": (
-        "false",
-        "false",
-        "Controls whether the index creation can be done in a multithreaded fashion.",
-    ),
     "password_encryption_algorithm": ("bcrypt", "bcrypt", "The password encryption algorithm used for authentication."),
     "pulsar_service_url": ("", "", "Default URL used while connecting to Pulsar brokers."),
     "query_execution_timeout_sec": (
@@ -127,18 +116,12 @@ startup_config_dict = {
         "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.",
     ),
     "storage_gc_cycle_sec": ("30", "30", "Storage garbage collector interval (in seconds)."),
-    "storage_items_per_batch": (
-        "1000000",
-        "1000000",
-        "The number of edges and vertices stored in a batch in a snapshot file.",
-    ),
     "storage_properties_on_edges": ("false", "true", "Controls whether edges have properties."),
     "storage_recover_on_startup": (
         "false",
         "false",
         "Controls whether the storage recovers persisted data on startup.",
     ),
-    "storage_recovery_thread_count": ("12", "12", "The number of threads used to recover persisted data from disk."),
     "storage_snapshot_interval_sec": (
         "0",
         "300",

tests/e2e/configuration/storage_info.py

@@ -1,109 +0,0 @@
-# Copyright 2022 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.
-
-import sys
-
-import default_config
-import mgclient
-import pytest
-
-default_storage_info_dict = {
-    "vertex_count": 0,
-    "edge_count": 0,
-    "average_degree": 0,
-    "memory_usage": "",  # machine dependent
-    "disk_usage": "",  # machine dependent
-    "memory_allocated": "",  # machine dependent
-    "allocation_limit": "",  # machine dependent
-    "global_isolation_level": "SNAPSHOT_ISOLATION",
-    "session_isolation_level": "",
-    "next_session_isolation_level": "",
-    "storage_mode": "IN_MEMORY_TRANSACTIONAL",
-}
-
-
-def apply_queries_and_check_for_storage_info(cursor, setup_query_list, expected_values):
-    for query in setup_query_list:
-        cursor.execute(query)
-
-    cursor.execute("SHOW STORAGE INFO")
-    config = cursor.fetchall()
-
-    for conf in config:
-        conf_name = conf[0]
-        if conf_name in expected_values:
-            assert expected_values[conf_name] == conf[1]
-
-
-def test_does_default_config_match():
-    connection = mgclient.connect(host="localhost", port=7687)
-    connection.autocommit = True
-
-    cursor = connection.cursor()
-    cursor.execute("SHOW STORAGE INFO")
-    config = cursor.fetchall()
-
-    # The default value of these is dependent on the given machine.
-    machine_dependent_configurations = ["memory_usage", "disk_usage", "memory_allocated", "allocation_limit"]
-
-    # Number of different data-points returned by SHOW STORAGE INFO
-    assert len(config) == 11
-
-    for conf in config:
-        conf_name = conf[0]
-        if conf_name in machine_dependent_configurations:
-            continue
-        assert default_storage_info_dict[conf_name] == conf[1]
-
-
-def test_info_change():
-    connection = mgclient.connect(host="localhost", port=7687)
-    connection.autocommit = True
-
-    cursor = connection.cursor()
-
-    # Check for vertex and edge changes
-    setup_query_list = [
-        "CREATE(n{id: 1}),(m{id: 2})",
-        "MATCH(n),(m) WHERE n.id = 1 AND m.id = 2 CREATE (n)-[r:relation]->(m)",
-    ]
-    expected_values = {
-        "vertex_count": 2,
-        "edge_count": 1,
-    }
-
-    apply_queries_and_check_for_storage_info(cursor, setup_query_list, expected_values)
-
-    # Check for isolation level changes
-    setup_query_list = [
-        "SET GLOBAL TRANSACTION ISOLATION LEVEL READ UNCOMMITTED",
-        "SET NEXT TRANSACTION ISOLATION LEVEL READ COMMITTED",
-        "SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED",
-    ]
-
-    expected_values = {
-        "global_isolation_level": "READ_UNCOMMITTED",
-        "session_isolation_level": "READ_COMMITTED",
-        "next_session_isolation_level": "READ_COMMITTED",
-    }
-
-    apply_queries_and_check_for_storage_info(cursor, setup_query_list, expected_values)
-
-    # Check for storage mode change
-    setup_query_list = ["STORAGE MODE IN_MEMORY_ANALYTICAL"]
-
-    expected_values = {"storage_mode": "IN_MEMORY_ANALYTICAL"}
-
-    apply_queries_and_check_for_storage_info(cursor, setup_query_list, expected_values)
-
-
-if __name__ == "__main__":
-    sys.exit(pytest.main([__file__, "-rA"]))

tests/e2e/configuration/workloads.yaml

@@ -18,8 +18,3 @@ workloads:
     binary: "tests/e2e/pytest_runner.sh"
     args: ["configuration/configuration_check.py"]
     <<: *template_cluster
-
-  - name: "SHOW STORAGE INFO check"
-    binary: "tests/e2e/pytest_runner.sh"
-    args: ["configuration/storage_info.py"]
-    <<: *template_cluster

tests/gql_behave/tests/memgraph_V1/features/map_projection.feature

@@ -1,76 +0,0 @@
-Feature: Map projection
-
-  Scenario: Returning an empty map projection
-    When executing query:
-      """
-      WITH {} AS map
-      RETURN map {} as result
-      """
-    Then the result should be:
-      | result |
-      | {}     |
-
-  Scenario: Returning a map projection with each type of map projection element
-    Given an empty graph
-    And having executed
-      """
-      CREATE (n:Actor {name: "Morgan", lastName: "Freeman"})
-      """
-    When executing query:
-      """
-      WITH 85 as age
-      MATCH (actor:Actor)
-      RETURN actor {.*, .name, age, oscars: 1} AS result
-      """
-    Then the result should be:
-      | result                                                    |
-      | {age: 85, lastName: 'Freeman', name: 'Morgan', oscars: 1} |
-
-  Scenario: Projecting a nonexistent property
-    When executing query:
-      """
-      WITH {name: "Morgan", lastName: "Freeman"} as actor
-      RETURN actor.age;
-      """
-    Then the result should be:
-      | actor.age |
-      | null      |
-
-  Scenario: Storing a map projection as a property
-    Given an empty graph
-    And having executed
-      """
-      WITH {name: "Morgan", lastName: "Freeman"} as person
-      WITH person {.*, wonOscars: true} as actor
-      CREATE (n:Movie {lead: actor});
-      """
-    When executing query:
-      """
-      MATCH (movie:Movie)
-      RETURN movie.lead
-      """
-    Then the result should be:
-      | movie.lead                                             |
-      | {lastName: 'Freeman', name: 'Morgan', wonOscars: true} |
-
-  Scenario: Looking up the properties of a map projection
-    When executing query:
-      """
-      WITH {name: "Morgan", lastName: "Freeman"} as actor, {oscars: 1} as awards
-      WITH actor {.*, awards: awards} AS actor
-      RETURN actor.name, actor.awards.oscars;
-      """
-    Then the result should be:
-      | actor.name | actor.awards.oscars |
-      | 'Morgan'   | 1                   |
-
-  Scenario: Indexing a map projection
-    When executing query:
-      """
-      WITH {name: "Morgan", lastName: "Freeman"} as actor, {oscars: 1} as awards
-      WITH actor {.*, awards: awards} AS actor
-      RETURN actor["name"], actor["awards"]["oscars"]
-      """
-    Then the result should be:
-      | actor["name"] | actor["awards"]["oscars"] |
-      | 'Morgan'      | 1                         |

tests/integration/durability/tests/v15/test_all/create_dataset.cypher

@@ -1,17 +0,0 @@
-// --storage-items-per-batch is set to 10
-CREATE INDEX ON :`label2`(`prop2`);
-CREATE INDEX ON :`label2`(`prop`);
-CREATE INDEX ON :`label`;
-CREATE INDEX ON :__mg_vertex__(__mg_id__);
-CREATE (:__mg_vertex__:`label2` {__mg_id__: 0, `prop2`: ["kaj", 2, Null, {`prop4`: -1.341}], `ext`: 2, `prop`: "joj"});
-CREATE (:__mg_vertex__:`label2`:`label` {__mg_id__: 1, `ext`: 2, `prop`: "joj"});
-CREATE (:__mg_vertex__:`label2` {__mg_id__: 2, `prop2`: 2, `prop`: 1});
-CREATE (:__mg_vertex__:`label2` {__mg_id__: 3, `prop2`: 2, `prop`: 2});
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 1 AND v.__mg_id__ = 0 CREATE (u)-[:`link` {`ext`: [false, {`k`: "l"}], `prop`: -1}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 1 AND v.__mg_id__ = 1 CREATE (u)-[:`link` {`ext`: [false, {`k`: "l"}], `prop`: -1}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 1 AND v.__mg_id__ = 2 CREATE (u)-[:`link` {`ext`: [false, {`k`: "l"}], `prop`: -1}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 1 AND v.__mg_id__ = 3 CREATE (u)-[:`link` {`ext`: [false, {`k`: "l"}], `prop`: -1}]->(v);
-CREATE CONSTRAINT ON (u:`label`) ASSERT EXISTS (u.`ext`);
-CREATE CONSTRAINT ON (u:`label2`) ASSERT u.`prop2`, u.`prop` IS UNIQUE;
-DROP INDEX ON :__mg_vertex__(__mg_id__);
-MATCH (u) REMOVE u:__mg_vertex__, u.__mg_id__;

tests/integration/durability/tests/v15/test_all/expected_snapshot.cypher

@@ -1,16 +0,0 @@
-CREATE INDEX ON :`label`;
-CREATE INDEX ON :`label2`(`prop2`);
-CREATE INDEX ON :`label2`(`prop`);
-CREATE INDEX ON :__mg_vertex__(__mg_id__);
-CREATE (:__mg_vertex__:`label2` {__mg_id__: 0, `prop2`: ["kaj", 2, Null, {`prop4`: -1.341}], `ext`: 2, `prop`: "joj"});
-CREATE (:__mg_vertex__:`label`:`label2` {__mg_id__: 1, `ext`: 2, `prop`: "joj"});
-CREATE (:__mg_vertex__:`label2` {__mg_id__: 2, `prop2`: 2, `prop`: 1});
-CREATE (:__mg_vertex__:`label2` {__mg_id__: 3, `prop2`: 2, `prop`: 2});
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 1 AND v.__mg_id__ = 0 CREATE (u)-[:`link` {`ext`: [false, {`k`: "l"}], `prop`: -1}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 1 AND v.__mg_id__ = 1 CREATE (u)-[:`link` {`ext`: [false, {`k`: "l"}], `prop`: -1}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 1 AND v.__mg_id__ = 2 CREATE (u)-[:`link` {`ext`: [false, {`k`: "l"}], `prop`: -1}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 1 AND v.__mg_id__ = 3 CREATE (u)-[:`link` {`ext`: [false, {`k`: "l"}], `prop`: -1}]->(v);
-CREATE CONSTRAINT ON (u:`label`) ASSERT EXISTS (u.`ext`);
-CREATE CONSTRAINT ON (u:`label2`) ASSERT u.`prop2`, u.`prop` IS UNIQUE;
-DROP INDEX ON :__mg_vertex__(__mg_id__);
-MATCH (u) REMOVE u:__mg_vertex__, u.__mg_id__;

tests/integration/durability/tests/v15/test_all/expected_wal.cypher

@@ -1,16 +0,0 @@
-CREATE INDEX ON :`label`;
-CREATE INDEX ON :`label2`(`prop2`);
-CREATE INDEX ON :`label2`(`prop`);
-CREATE CONSTRAINT ON (u:`label`) ASSERT EXISTS (u.`ext`);
-CREATE CONSTRAINT ON (u:`label2`) ASSERT u.`prop2`, u.`prop` IS UNIQUE;
-CREATE INDEX ON :__mg_vertex__(__mg_id__);
-CREATE (:__mg_vertex__:`label2` {__mg_id__: 0, `prop2`: ["kaj", 2, Null, {`prop4`: -1.341}], `prop`: "joj", `ext`: 2});
-CREATE (:__mg_vertex__:`label`:`label2` {__mg_id__: 1, `prop`: "joj", `ext`: 2});
-CREATE (:__mg_vertex__:`label2` {__mg_id__: 2, `prop2`: 2, `prop`: 1});
-CREATE (:__mg_vertex__:`label2` {__mg_id__: 3, `prop2`: 2, `prop`: 2});
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 1 AND v.__mg_id__ = 0 CREATE (u)-[:`link` {`prop`: -1, `ext`: [false, {`k`: "l"}]}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 1 AND v.__mg_id__ = 1 CREATE (u)-[:`link` {`prop`: -1, `ext`: [false, {`k`: "l"}]}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 1 AND v.__mg_id__ = 2 CREATE (u)-[:`link` {`prop`: -1, `ext`: [false, {`k`: "l"}]}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 1 AND v.__mg_id__ = 3 CREATE (u)-[:`link` {`prop`: -1, `ext`: [false, {`k`: "l"}]}]->(v);
-DROP INDEX ON :__mg_vertex__(__mg_id__);
-MATCH (u) REMOVE u:__mg_vertex__, u.__mg_id__;

tests/integration/durability/tests/v15/test_constraints/create_dataset.cypher

@@ -1,6 +0,0 @@
-CREATE CONSTRAINT ON (u:`label2`) ASSERT EXISTS (u.`ext2`);
-CREATE CONSTRAINT ON (u:`label`) ASSERT EXISTS (u.`ext`);
-CREATE CONSTRAINT ON (u:`label`) ASSERT u.`a` IS UNIQUE;
-CREATE CONSTRAINT ON (u:`label`) ASSERT u.`b` IS UNIQUE;
-CREATE CONSTRAINT ON (u:`label`) ASSERT u.`c` IS UNIQUE;
-CREATE CONSTRAINT ON (u:`label2`) ASSERT u.`a`, u.`b` IS UNIQUE;

tests/integration/durability/tests/v15/test_constraints/expected_snapshot.cypher

@@ -1,6 +0,0 @@
-CREATE CONSTRAINT ON (u:`label2`) ASSERT EXISTS (u.`ext2`);
-CREATE CONSTRAINT ON (u:`label`) ASSERT EXISTS (u.`ext`);
-CREATE CONSTRAINT ON (u:`label`) ASSERT u.`c` IS UNIQUE;
-CREATE CONSTRAINT ON (u:`label`) ASSERT u.`b` IS UNIQUE;
-CREATE CONSTRAINT ON (u:`label`) ASSERT u.`a` IS UNIQUE;
-CREATE CONSTRAINT ON (u:`label2`) ASSERT u.`b`, u.`a` IS UNIQUE;

tests/integration/durability/tests/v15/test_constraints/expected_wal.cypher

@@ -1,6 +0,0 @@
-CREATE CONSTRAINT ON (u:`label2`) ASSERT EXISTS (u.`ext2`);
-CREATE CONSTRAINT ON (u:`label`) ASSERT EXISTS (u.`ext`);
-CREATE CONSTRAINT ON (u:`label2`) ASSERT u.`a`, u.`b` IS UNIQUE;
-CREATE CONSTRAINT ON (u:`label`) ASSERT u.`a` IS UNIQUE;
-CREATE CONSTRAINT ON (u:`label`) ASSERT u.`b` IS UNIQUE;
-CREATE CONSTRAINT ON (u:`label`) ASSERT u.`c` IS UNIQUE;

tests/integration/durability/tests/v15/test_edges/create_dataset.cypher

@@ -1,59 +0,0 @@
-// --storage-items-per-batch is set to 7
-CREATE INDEX ON :__mg_vertex__(__mg_id__);
-CREATE (:__mg_vertex__ {__mg_id__: 0});
-CREATE (:__mg_vertex__ {__mg_id__: 1});
-CREATE (:__mg_vertex__ {__mg_id__: 2});
-CREATE (:__mg_vertex__ {__mg_id__: 3});
-CREATE (:__mg_vertex__ {__mg_id__: 4});
-CREATE (:__mg_vertex__ {__mg_id__: 5});
-CREATE (:__mg_vertex__ {__mg_id__: 6});
-CREATE (:__mg_vertex__ {__mg_id__: 7});
-CREATE (:__mg_vertex__ {__mg_id__: 8});
-CREATE (:__mg_vertex__ {__mg_id__: 9});
-CREATE (:__mg_vertex__ {__mg_id__: 10});
-CREATE (:__mg_vertex__ {__mg_id__: 11});
-CREATE (:__mg_vertex__ {__mg_id__: 12});
-CREATE (:__mg_vertex__ {__mg_id__: 13});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 14});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 15});
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 0 AND v.__mg_id__ = 1 CREATE (u)-[:`edge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 2 AND v.__mg_id__ = 3 CREATE (u)-[:`edge` {`prop`: 11}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 4 AND v.__mg_id__ = 5 CREATE (u)-[:`edge` {`prop`: true}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 6 AND v.__mg_id__ = 7 CREATE (u)-[:`edge2`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 8 AND v.__mg_id__ = 9 CREATE (u)-[:`edge2` {`prop`: -3.141}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 10 AND v.__mg_id__ = 11 CREATE (u)-[:`edgelink` {`prop`: {`prop`: 1, `prop2`: {`prop4`: 9}}}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 12 AND v.__mg_id__ = 13 CREATE (u)-[:`edgelink` {`prop`: [1, Null, false, "\n\n\n\n\\\"\"\n\t"]}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 0 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 1 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 2 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 3 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 4 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 5 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 6 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 7 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 8 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 9 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 10 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 11 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 12 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 13 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 14 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 15 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 0 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 1 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 2 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 3 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 4 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 5 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 6 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 7 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 8 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 9 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 10 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 11 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 12 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 13 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 14 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 15 CREATE (u)-[:`testedge`]->(v);
-DROP INDEX ON :__mg_vertex__(__mg_id__);
-MATCH (u) REMOVE u:__mg_vertex__, u.__mg_id__;

tests/integration/durability/tests/v15/test_edges/expected_snapshot.cypher

@@ -1,58 +0,0 @@
-CREATE INDEX ON :__mg_vertex__(__mg_id__);
-CREATE (:__mg_vertex__ {__mg_id__: 0});
-CREATE (:__mg_vertex__ {__mg_id__: 1});
-CREATE (:__mg_vertex__ {__mg_id__: 2});
-CREATE (:__mg_vertex__ {__mg_id__: 3});
-CREATE (:__mg_vertex__ {__mg_id__: 4});
-CREATE (:__mg_vertex__ {__mg_id__: 5});
-CREATE (:__mg_vertex__ {__mg_id__: 6});
-CREATE (:__mg_vertex__ {__mg_id__: 7});
-CREATE (:__mg_vertex__ {__mg_id__: 8});
-CREATE (:__mg_vertex__ {__mg_id__: 9});
-CREATE (:__mg_vertex__ {__mg_id__: 10});
-CREATE (:__mg_vertex__ {__mg_id__: 11});
-CREATE (:__mg_vertex__ {__mg_id__: 12});
-CREATE (:__mg_vertex__ {__mg_id__: 13});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 14});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 15});
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 0 AND v.__mg_id__ = 1 CREATE (u)-[:`edge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 2 AND v.__mg_id__ = 3 CREATE (u)-[:`edge` {`prop`: 11}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 4 AND v.__mg_id__ = 5 CREATE (u)-[:`edge` {`prop`: true}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 6 AND v.__mg_id__ = 7 CREATE (u)-[:`edge2`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 8 AND v.__mg_id__ = 9 CREATE (u)-[:`edge2` {`prop`: -3.141}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 10 AND v.__mg_id__ = 11 CREATE (u)-[:`edgelink` {`prop`: {`prop`: 1, `prop2`: {`prop4`: 9}}}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 12 AND v.__mg_id__ = 13 CREATE (u)-[:`edgelink` {`prop`: [1, Null, false, "\n\n\n\n\\\"\"\n\t"]}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 0 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 1 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 2 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 3 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 4 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 5 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 6 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 7 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 8 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 9 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 10 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 11 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 12 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 13 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 14 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 15 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 0 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 1 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 2 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 3 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 4 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 5 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 6 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 7 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 8 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 9 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 10 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 11 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 12 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 13 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 14 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 15 CREATE (u)-[:`testedge`]->(v);
-DROP INDEX ON :__mg_vertex__(__mg_id__);
-MATCH (u) REMOVE u:__mg_vertex__, u.__mg_id__;

tests/integration/durability/tests/v15/test_edges/expected_wal.cypher

@@ -1,58 +0,0 @@
-CREATE INDEX ON :__mg_vertex__(__mg_id__);
-CREATE (:__mg_vertex__ {__mg_id__: 0});
-CREATE (:__mg_vertex__ {__mg_id__: 1});
-CREATE (:__mg_vertex__ {__mg_id__: 2});
-CREATE (:__mg_vertex__ {__mg_id__: 3});
-CREATE (:__mg_vertex__ {__mg_id__: 4});
-CREATE (:__mg_vertex__ {__mg_id__: 5});
-CREATE (:__mg_vertex__ {__mg_id__: 6});
-CREATE (:__mg_vertex__ {__mg_id__: 7});
-CREATE (:__mg_vertex__ {__mg_id__: 8});
-CREATE (:__mg_vertex__ {__mg_id__: 9});
-CREATE (:__mg_vertex__ {__mg_id__: 10});
-CREATE (:__mg_vertex__ {__mg_id__: 11});
-CREATE (:__mg_vertex__ {__mg_id__: 12});
-CREATE (:__mg_vertex__ {__mg_id__: 13});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 14});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 15});
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 0 AND v.__mg_id__ = 1 CREATE (u)-[:`edge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 2 AND v.__mg_id__ = 3 CREATE (u)-[:`edge` {`prop`: 11}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 4 AND v.__mg_id__ = 5 CREATE (u)-[:`edge` {`prop`: true}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 6 AND v.__mg_id__ = 7 CREATE (u)-[:`edge2`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 8 AND v.__mg_id__ = 9 CREATE (u)-[:`edge2` {`prop`: -3.141}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 10 AND v.__mg_id__ = 11 CREATE (u)-[:`edgelink` {`prop`: {`prop`: 1, `prop2`: {`prop4`: 9}}}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 12 AND v.__mg_id__ = 13 CREATE (u)-[:`edgelink` {`prop`: [1, Null, false, "\n\n\n\n\\\"\"\n\t"]}]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 0 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 1 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 2 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 3 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 4 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 5 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 6 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 7 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 8 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 9 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 10 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 11 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 12 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 13 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 14 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 14 AND v.__mg_id__ = 15 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 0 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 1 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 2 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 3 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 4 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 5 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 6 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 7 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 8 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 9 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 10 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 11 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 12 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 13 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 14 CREATE (u)-[:`testedge`]->(v);
-MATCH (u:__mg_vertex__), (v:__mg_vertex__) WHERE u.__mg_id__ = 15 AND v.__mg_id__ = 15 CREATE (u)-[:`testedge`]->(v);
-DROP INDEX ON :__mg_vertex__(__mg_id__);
-MATCH (u) REMOVE u:__mg_vertex__, u.__mg_id__;

tests/integration/durability/tests/v15/test_indices/create_dataset.cypher

@@ -1,4 +0,0 @@
-CREATE INDEX ON :`label2`;
-CREATE INDEX ON :`label2`(`prop2`);
-CREATE INDEX ON :`label`(`prop2`);
-CREATE INDEX ON :`label`(`prop`);

tests/integration/durability/tests/v15/test_indices/expected_snapshot.cypher

@@ -1,4 +0,0 @@
-CREATE INDEX ON :`label2`;
-CREATE INDEX ON :`label`(`prop`);
-CREATE INDEX ON :`label`(`prop2`);
-CREATE INDEX ON :`label2`(`prop2`);

tests/integration/durability/tests/v15/test_indices/expected_wal.cypher

@@ -1,4 +0,0 @@
-CREATE INDEX ON :`label2`;
-CREATE INDEX ON :`label2`(`prop2`);
-CREATE INDEX ON :`label`(`prop2`);
-CREATE INDEX ON :`label`(`prop`);

tests/integration/durability/tests/v15/test_vertices/create_dataset.cypher

@@ -1,17 +0,0 @@
-// --storage-items-per-batch is set to 5
-CREATE INDEX ON :__mg_vertex__(__mg_id__);
-CREATE (:__mg_vertex__ {__mg_id__: 0});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 1});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 2, `prop`: false});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 3, `prop`: true});
-CREATE (:__mg_vertex__:`label2` {__mg_id__: 4, `prop`: 1});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 5, `prop2`: 3.141});
-CREATE (:__mg_vertex__:`label6` {__mg_id__: 6, `prop3`: true, `prop2`: -314000000});
-CREATE (:__mg_vertex__:`label3`:`label1`:`label2` {__mg_id__: 7});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 8, `prop3`: "str", `prop2`: 2, `prop`: 1});
-CREATE (:__mg_vertex__:`label2`:`label1` {__mg_id__: 9, `prop`: {`prop_nes`: "kaj je"}});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 10, `prop_array`: [1, false, Null, "str", {`prop2`: 2}]});
-CREATE (:__mg_vertex__:`label3`:`label` {__mg_id__: 11, `prop`: {`prop`: [1, false], `prop2`: {}, `prop3`: "test2", `prop4`: "test"}});
-CREATE (:__mg_vertex__ {__mg_id__: 12, `prop`: " \n\"\'\t\\%"});
-DROP INDEX ON :__mg_vertex__(__mg_id__);
-MATCH (u) REMOVE u:__mg_vertex__, u.__mg_id__;

tests/integration/durability/tests/v15/test_vertices/expected_snapshot.cypher

@@ -1,16 +0,0 @@
-CREATE INDEX ON :__mg_vertex__(__mg_id__);
-CREATE (:__mg_vertex__ {__mg_id__: 0});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 1});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 2, `prop`: false});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 3, `prop`: true});
-CREATE (:__mg_vertex__:`label2` {__mg_id__: 4, `prop`: 1});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 5, `prop2`: 3.141});
-CREATE (:__mg_vertex__:`label6` {__mg_id__: 6, `prop3`: true, `prop2`: -314000000});
-CREATE (:__mg_vertex__:`label2`:`label3`:`label1` {__mg_id__: 7});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 8, `prop3`: "str", `prop2`: 2, `prop`: 1});
-CREATE (:__mg_vertex__:`label1`:`label2` {__mg_id__: 9, `prop`: {`prop_nes`: "kaj je"}});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 10, `prop_array`: [1, false, Null, "str", {`prop2`: 2}]});
-CREATE (:__mg_vertex__:`label`:`label3` {__mg_id__: 11, `prop`: {`prop`: [1, false], `prop2`: {}, `prop3`: "test2", `prop4`: "test"}});
-CREATE (:__mg_vertex__ {__mg_id__: 12, `prop`: " \n\"\'\t\\%"});
-DROP INDEX ON :__mg_vertex__(__mg_id__);
-MATCH (u) REMOVE u:__mg_vertex__, u.__mg_id__;

tests/integration/durability/tests/v15/test_vertices/expected_wal.cypher

@@ -1,16 +0,0 @@
-CREATE INDEX ON :__mg_vertex__(__mg_id__);
-CREATE (:__mg_vertex__ {__mg_id__: 0});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 1});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 2, `prop`: false});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 3, `prop`: true});
-CREATE (:__mg_vertex__:`label2` {__mg_id__: 4, `prop`: 1});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 5, `prop2`: 3.141});
-CREATE (:__mg_vertex__:`label6` {__mg_id__: 6, `prop2`: -314000000, `prop3`: true});
-CREATE (:__mg_vertex__:`label2`:`label3`:`label1` {__mg_id__: 7});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 8, `prop`: 1, `prop2`: 2, `prop3`: "str"});
-CREATE (:__mg_vertex__:`label1`:`label2` {__mg_id__: 9, `prop`: {`prop_nes`: "kaj je"}});
-CREATE (:__mg_vertex__:`label` {__mg_id__: 10, `prop_array`: [1, false, Null, "str", {`prop2`: 2}]});
-CREATE (:__mg_vertex__:`label`:`label3` {__mg_id__: 11, `prop`: {`prop`: [1, false], `prop2`: {}, `prop3`: "test2", `prop4`: "test"}});
-CREATE (:__mg_vertex__ {__mg_id__: 12, `prop`: " \n\"\'\t\\%"});
-DROP INDEX ON :__mg_vertex__(__mg_id__);
-MATCH (u) REMOVE u:__mg_vertex__, u.__mg_id__;

tests/integration/storage_mode/tester.cpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 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