diff --git a/src/communication/bolt/v1/states/executor.hpp b/src/communication/bolt/v1/states/executor.hpp
index 07058fc37..e97da2c5d 100644
--- a/src/communication/bolt/v1/states/executor.hpp
+++ b/src/communication/bolt/v1/states/executor.hpp
@@ -37,10 +37,10 @@ State state_executor_run(RecordStream<Socket> &output_stream, BoltDecoder &decod
       logger.trace("[Run] '{}'", query.statement);
 
       auto db_accessor = dmbs.active();
-      logger.debug("[ActiveDB] '{}'", db_accessor.name());
+      logger.debug("[ActiveDB] '{}'", db_accessor->name());
 
       auto is_successfully_executed =
-          query_engine.Run(query.statement, db_accessor, output_stream);
+          query_engine.Run(query.statement, *db_accessor, output_stream);
 
       if (!is_successfully_executed) {
         output_stream.write_failure(
diff --git a/src/database/graph_db_accessor.hpp b/src/database/graph_db_accessor.hpp
index 9f2632eb8..2d7f836e8 100644
--- a/src/database/graph_db_accessor.hpp
+++ b/src/database/graph_db_accessor.hpp
@@ -33,6 +33,15 @@ class GraphDbAccessor {
   GraphDbAccessor(GraphDb& db);
   ~GraphDbAccessor();
 
+  // the GraphDbAccessor can NOT be copied nor moved because
+  // 1. it ensures transaction cleanup once it's destructed
+  // 2. it will contain index and side-effect bookkeeping data
+  //    which is unique to the transaction (shared_ptr works but slower)
+  GraphDbAccessor(const GraphDbAccessor &other) = delete;
+  GraphDbAccessor(GraphDbAccessor &&other) = delete;
+  GraphDbAccessor &operator=(const GraphDbAccessor &other) = delete;
+  GraphDbAccessor &operator=(GraphDbAccessor &&other) = delete;
+
   /**
    * Returns the name of the database of this accessor.
    */
diff --git a/src/dbms/dbms.cpp b/src/dbms/dbms.cpp
index a72435c4c..94119e59c 100644
--- a/src/dbms/dbms.cpp
+++ b/src/dbms/dbms.cpp
@@ -1,10 +1,11 @@
 #include "dbms/dbms.hpp"
 
-GraphDbAccessor Dbms::active() {
-  return GraphDbAccessor(*active_db.load(std::memory_order_acquire));
+std::unique_ptr<GraphDbAccessor> Dbms::active() {
+  return std::make_unique<GraphDbAccessor>(
+      *active_db.load(std::memory_order_acquire));
 }
 
-GraphDbAccessor Dbms::active(const std::string &name) {
+std::unique_ptr<GraphDbAccessor> Dbms::active(const std::string &name) {
   auto acc = dbs.access();
   // create db if it doesn't exist
   auto it = acc.find(name);
@@ -17,5 +18,5 @@ GraphDbAccessor Dbms::active(const std::string &name) {
   // set and return active db
   auto &db = it->second;
   active_db.store(&db, std::memory_order_release);
-  return GraphDbAccessor(db);
+  return std::make_unique<GraphDbAccessor>(db);
 }
diff --git a/src/dbms/dbms.hpp b/src/dbms/dbms.hpp
index 6d4b4e2be..38945880f 100644
--- a/src/dbms/dbms.hpp
+++ b/src/dbms/dbms.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <memory>
+
 #include "config/config.hpp"
 #include "data_structures/concurrent/concurrent_map.hpp"
 #include "database/graph_db.hpp"
@@ -18,7 +20,7 @@ class Dbms {
   /**
    * Returns an accessor to the active database.
    */
-  GraphDbAccessor active();
+  std::unique_ptr<GraphDbAccessor> active();
 
   /**
    * Set the database with the given name to be active.
@@ -27,7 +29,7 @@ class Dbms {
    *
    * @return an accessor to the database with the given name.
    */
-  GraphDbAccessor active(const std::string &name);
+  std::unique_ptr<GraphDbAccessor> active(const std::string &name);
 
   // TODO: DELETE action
 
diff --git a/tests/integration/query_engine_common.hpp b/tests/integration/query_engine_common.hpp
index 770c80996..a7ed5aa74 100644
--- a/tests/integration/query_engine_common.hpp
+++ b/tests/integration/query_engine_common.hpp
@@ -139,7 +139,7 @@ auto ExecuteQueryPlans(Logger &log, QueryEngineT &engine, Dbms &dbms,
     // Create new db_accessor since one query is associated with one
     // transaction.
     auto db_accessor = dbms.active();
-    engine.Run(query, db_accessor, stream);
+    engine.Run(query, *db_accessor, stream);
   }
 }
 
diff --git a/tests/manual/compiler_prototype.cpp b/tests/manual/compiler_prototype.cpp
index 256285809..b123192d1 100644
--- a/tests/manual/compiler_prototype.cpp
+++ b/tests/manual/compiler_prototype.cpp
@@ -28,55 +28,55 @@ int main(int argc, char* argv[]) {
   auto dba = dbms.active();
 
     // labels
-    auto company = dba.label("Company");
-    auto person = dba.label("Person");
-    auto device = dba.label("Device");
+    auto company = dba->label("Company");
+    auto person = dba->label("Person");
+    auto device = dba->label("Device");
 
   // props
-  auto name = dba.property("name");
-  auto age = dba.property("age");
-  auto type = dba.property("type");
+  auto name = dba->property("name");
+  auto age = dba->property("age");
+  auto type = dba->property("type");
 
   // vertices
-  auto memgraph = dba.insert_vertex();
+  auto memgraph = dba->insert_vertex();
   memgraph.PropsSet(name, "Memgraph");
     memgraph.add_label(company);
-  auto teon = dba.insert_vertex();
+  auto teon = dba->insert_vertex();
   memgraph.PropsSet(name, "Teon");
   memgraph.PropsSet(age, 26);
     teon.add_label(person);
-  auto mislav = dba.insert_vertex();
+  auto mislav = dba->insert_vertex();
   memgraph.PropsSet(name, "Mislav");
   memgraph.PropsSet(age, 22);
     mislav.add_label(person);
-  auto florijan = dba.insert_vertex();
+  auto florijan = dba->insert_vertex();
   memgraph.PropsSet(name, "Florijan");
   memgraph.PropsSet(age, 31);
     florijan.add_label(person);
-  auto xps_15 = dba.insert_vertex();
+  auto xps_15 = dba->insert_vertex();
   memgraph.PropsSet(type, "PC");
   memgraph.PropsSet(name, "Dell XPS 15");
     xps_15.add_label(device);
 
   // edges
-  dba.insert_edge(teon, memgraph, dba.edge_type("MEMBER_OF"));
-  dba.insert_edge(mislav, memgraph, dba.edge_type("MEMBER_OF"));
-  dba.insert_edge(florijan, memgraph, dba.edge_type("MEMBER_OF"));
+  dba->insert_edge(teon, memgraph, dba->edge_type("MEMBER_OF"));
+  dba->insert_edge(mislav, memgraph, dba->edge_type("MEMBER_OF"));
+  dba->insert_edge(florijan, memgraph, dba->edge_type("MEMBER_OF"));
 
-  dba.insert_edge(teon, mislav, dba.edge_type("FRIEND_OF"));
-  dba.insert_edge(mislav, teon, dba.edge_type("FRIEND_OF"));
-  dba.insert_edge(florijan, mislav, dba.edge_type("FRIEND_OF"));
-  dba.insert_edge(mislav, florijan, dba.edge_type("FRIEND_OF"));
-  dba.insert_edge(florijan, teon, dba.edge_type("FRIEND_OF"));
-  dba.insert_edge(teon, florijan, dba.edge_type("FRIEND_OF"));
+  dba->insert_edge(teon, mislav, dba->edge_type("FRIEND_OF"));
+  dba->insert_edge(mislav, teon, dba->edge_type("FRIEND_OF"));
+  dba->insert_edge(florijan, mislav, dba->edge_type("FRIEND_OF"));
+  dba->insert_edge(mislav, florijan, dba->edge_type("FRIEND_OF"));
+  dba->insert_edge(florijan, teon, dba->edge_type("FRIEND_OF"));
+  dba->insert_edge(teon, florijan, dba->edge_type("FRIEND_OF"));
 
-  dba.insert_edge(memgraph, xps_15, dba.edge_type("OWNS"));
+  dba->insert_edge(memgraph, xps_15, dba->edge_type("OWNS"));
 
-  dba.insert_edge(teon, xps_15, dba.edge_type("USES"));
-  dba.insert_edge(mislav, xps_15, dba.edge_type("USES"));
-  dba.insert_edge(florijan, xps_15, dba.edge_type("USES"));
+  dba->insert_edge(teon, xps_15, dba->edge_type("USES"));
+  dba->insert_edge(mislav, xps_15, dba->edge_type("USES"));
+  dba->insert_edge(florijan, xps_15, dba->edge_type("USES"));
 
-  dba.advance_command();
+  dba->advance_command();
 
   cout << "-- Memgraph Query Engine --" << endl;
 
@@ -89,7 +89,7 @@ int main(int argc, char* argv[]) {
     // execute command / query
     // try {
       // auto db_accessor = dbms.active();
-      query_engine.Execute(command, dba, stream);
+      query_engine.Execute(command, *dba, stream);
     // } catch (const std::exception& e) {
     //   cout << e.what() << endl;
     // } catch (...) {
diff --git a/tests/manual/query_engine.cpp b/tests/manual/query_engine.cpp
index 34f68eb5b..ed479db58 100644
--- a/tests/manual/query_engine.cpp
+++ b/tests/manual/query_engine.cpp
@@ -61,7 +61,7 @@ int main(int argc, char* argv[]) {
             try {
               query_engine.ReloadCustom(query, event.path);
               auto db_accessor = dbms.active();
-              query_engine.Run(query, db_accessor, stream);
+              query_engine.Run(query, *db_accessor, stream);
             } catch (PlanCompilationException& e) {
               log.info("Query compilation failed: {}", e.what());
             } catch (std::exception& e) {
diff --git a/tests/unit/graph_db_accessor.cpp b/tests/unit/graph_db_accessor.cpp
index 8145bccd8..9ef403a9f 100644
--- a/tests/unit/graph_db_accessor.cpp
+++ b/tests/unit/graph_db_accessor.cpp
@@ -23,72 +23,72 @@ size_t CountEdges(GraphDbAccessor &db_accessor) {
 
 TEST(GraphDbAccessorTest, DbmsCreateDefault) {
   Dbms dbms;
-  GraphDbAccessor accessor = dbms.active();
-  EXPECT_EQ(accessor.name(), "default");
+  auto accessor = dbms.active();
+  EXPECT_EQ(accessor->name(), "default");
 }
 
 TEST(GraphDbAccessorTest, InsertVertex) {
   Dbms dbms;
-  GraphDbAccessor accessor = dbms.active();
+  auto accessor = dbms.active();
 
-  EXPECT_EQ(CountVertices(accessor), 0);
+  EXPECT_EQ(CountVertices(*accessor), 0);
 
-  accessor.insert_vertex();
-  EXPECT_EQ(CountVertices(accessor), 1);
+  accessor->insert_vertex();
+  EXPECT_EQ(CountVertices(*accessor), 1);
 
-  accessor.insert_vertex();
-  EXPECT_EQ(CountVertices(accessor), 2);
+  accessor->insert_vertex();
+  EXPECT_EQ(CountVertices(*accessor), 2);
 }
 
 TEST(GraphDbAccessorTest, RemoveVertexSameTransaction) {
   Dbms dbms;
-  GraphDbAccessor accessor = dbms.active();
+  auto accessor = dbms.active();
 
-  EXPECT_EQ(CountVertices(accessor), 0);
+  EXPECT_EQ(CountVertices(*accessor), 0);
 
-  auto va1 = accessor.insert_vertex();
-  EXPECT_EQ(CountVertices(accessor), 1);
+  auto va1 = accessor->insert_vertex();
+  EXPECT_EQ(CountVertices(*accessor), 1);
 
-  EXPECT_TRUE(accessor.remove_vertex(va1));
-  EXPECT_EQ(CountVertices(accessor), 1);
-  accessor.advance_command();
-  EXPECT_EQ(CountVertices(accessor), 0);
+  EXPECT_TRUE(accessor->remove_vertex(va1));
+  EXPECT_EQ(CountVertices(*accessor), 1);
+  accessor->advance_command();
+  EXPECT_EQ(CountVertices(*accessor), 0);
 }
 
 TEST(GraphDbAccessorTest, RemoveVertexDifferentTransaction) {
   Dbms dbms;
 
   // first transaction creates a vertex
-  GraphDbAccessor accessor1 = dbms.active();
-  accessor1.insert_vertex();
-  accessor1.commit();
+  auto accessor1 = dbms.active();
+  accessor1->insert_vertex();
+  accessor1->commit();
 
   // second transaction checks that it sees it, and deletes it
-  GraphDbAccessor accessor2 = dbms.active();
-  EXPECT_EQ(CountVertices(accessor2), 1);
-  for (auto vertex_accessor : accessor2.vertices())
-    accessor2.remove_vertex(vertex_accessor);
-  accessor2.commit();
+  auto accessor2 = dbms.active();
+  EXPECT_EQ(CountVertices(*accessor2), 1);
+  for (auto vertex_accessor : accessor2->vertices())
+    accessor2->remove_vertex(vertex_accessor);
+  accessor2->commit();
 
   // third transaction checks that it does not see the vertex
-  GraphDbAccessor accessor3 = dbms.active();
-  EXPECT_EQ(CountVertices(accessor3), 0);
+  auto accessor3 = dbms.active();
+  EXPECT_EQ(CountVertices(*accessor3), 0);
 }
 
 TEST(GraphDbAccessorTest, InsertEdge) {
   Dbms dbms;
-  GraphDbAccessor dba = dbms.active();
+  auto dba = dbms.active();
 
-  auto va1 = dba.insert_vertex();
-  auto va2 = dba.insert_vertex();
+  auto va1 = dba->insert_vertex();
+  auto va2 = dba->insert_vertex();
   EXPECT_EQ(va1.in_degree(), 0);
   EXPECT_EQ(va1.out_degree(), 0);
   EXPECT_EQ(va2.in_degree(), 0);
   EXPECT_EQ(va2.out_degree(), 0);
 
   // setup (v1) - [:likes] -> (v2)
-  dba.insert_edge(va1, va2, dba.edge_type("likes"));
-  EXPECT_EQ(CountEdges(dba), 1);
+  dba->insert_edge(va1, va2, dba->edge_type("likes"));
+  EXPECT_EQ(CountEdges(*dba), 1);
   EXPECT_EQ(va1.out().begin()->to(), va2);
   EXPECT_EQ(va2.in().begin()->from(), va1);
   EXPECT_EQ(va1.in_degree(), 0);
@@ -97,9 +97,9 @@ TEST(GraphDbAccessorTest, InsertEdge) {
   EXPECT_EQ(va2.out_degree(), 0);
 
   // setup (v1) - [:likes] -> (v2) <- [:hates] - (v3)
-  auto va3 = dba.insert_vertex();
-  dba.insert_edge(va3, va2, dba.edge_type("hates"));
-  EXPECT_EQ(CountEdges(dba), 2);
+  auto va3 = dba->insert_vertex();
+  dba->insert_edge(va3, va2, dba->edge_type("hates"));
+  EXPECT_EQ(CountEdges(*dba), 2);
   EXPECT_EQ(va3.out().begin()->to(), va2);
   EXPECT_EQ(va1.in_degree(), 0);
   EXPECT_EQ(va1.out_degree(), 1);
@@ -111,35 +111,35 @@ TEST(GraphDbAccessorTest, InsertEdge) {
 
 TEST(GraphDbAccessorTest, RemoveEdge) {
   Dbms dbms;
-  GraphDbAccessor dba1 = dbms.active();
+  auto dba1 = dbms.active();
 
   // setup (v1) - [:likes] -> (v2) <- [:hates] - (v3)
-  auto va1 = dba1.insert_vertex();
-  auto va2 = dba1.insert_vertex();
-  auto va3 = dba1.insert_vertex();
-  dba1.insert_edge(va1, va2, dba1.edge_type("likes"));
-  dba1.insert_edge(va3, va2, dba1.edge_type("hates"));
-  EXPECT_EQ(CountEdges(dba1), 2);
+  auto va1 = dba1->insert_vertex();
+  auto va2 = dba1->insert_vertex();
+  auto va3 = dba1->insert_vertex();
+  dba1->insert_edge(va1, va2, dba1->edge_type("likes"));
+  dba1->insert_edge(va3, va2, dba1->edge_type("hates"));
+  EXPECT_EQ(CountEdges(*dba1), 2);
 
   // remove all [:hates] edges
-  dba1.commit();
-  GraphDbAccessor dba2 = dbms.active();
-  EXPECT_EQ(CountEdges(dba2), 2);
-  for (auto edge : dba2.edges())
-    if (edge.edge_type() == dba2.edge_type("hates")) dba2.remove_edge(edge);
+  dba1->commit();
+  auto dba2 = dbms.active();
+  EXPECT_EQ(CountEdges(*dba2), 2);
+  for (auto edge : dba2->edges())
+    if (edge.edge_type() == dba2->edge_type("hates")) dba2->remove_edge(edge);
 
   // current state: (v1) - [:likes] -> (v2), (v3)
-  dba2.commit();
-  GraphDbAccessor dba3 = dbms.active();
-  EXPECT_EQ(CountEdges(dba3), 1);
-  EXPECT_EQ(CountVertices(dba3), 3);
-  for (auto edge : dba3.edges()) {
-    EXPECT_EQ(edge.edge_type(), dba3.edge_type("likes"));
+  dba2->commit();
+  auto dba3 = dbms.active();
+  EXPECT_EQ(CountEdges(*dba3), 1);
+  EXPECT_EQ(CountVertices(*dba3), 3);
+  for (auto edge : dba3->edges()) {
+    EXPECT_EQ(edge.edge_type(), dba3->edge_type("likes"));
     auto v1 = edge.from();
     auto v2 = edge.to();
 
     // ensure correct connectivity for all the vertices
-    for (auto vertex : dba3.vertices()) {
+    for (auto vertex : dba3->vertices()) {
       if (vertex == v1) {
         EXPECT_EQ(vertex.in_degree(), 0);
         EXPECT_EQ(vertex.out_degree(), 1);
@@ -156,102 +156,102 @@ TEST(GraphDbAccessorTest, RemoveEdge) {
 
 TEST(GraphDbAccessorTest, DetachRemoveVertex) {
   Dbms dbms;
-  GraphDbAccessor dba1 = dbms.active();
+  auto dba1 = dbms.active();
 
   // setup (v1) - [:likes] -> (v2) <- [:hates] - (v3)
-  auto va1 = dba1.insert_vertex();
-  auto va2 = dba1.insert_vertex();
-  auto va3 = dba1.insert_vertex();
-  dba1.insert_edge(va1, va2, dba1.edge_type("likes"));
-  dba1.insert_edge(va1, va3, dba1.edge_type("likes"));
+  auto va1 = dba1->insert_vertex();
+  auto va2 = dba1->insert_vertex();
+  auto va3 = dba1->insert_vertex();
+  dba1->insert_edge(va1, va2, dba1->edge_type("likes"));
+  dba1->insert_edge(va1, va3, dba1->edge_type("likes"));
 
   // ensure that plain remove does NOT work
-  EXPECT_EQ(CountVertices(dba1), 3);
-  EXPECT_EQ(CountEdges(dba1), 2);
-  EXPECT_FALSE(dba1.remove_vertex(va1));
-  EXPECT_FALSE(dba1.remove_vertex(va2));
-  EXPECT_FALSE(dba1.remove_vertex(va3));
-  EXPECT_EQ(CountVertices(dba1), 3);
-  EXPECT_EQ(CountEdges(dba1), 2);
+  EXPECT_EQ(CountVertices(*dba1), 3);
+  EXPECT_EQ(CountEdges(*dba1), 2);
+  EXPECT_FALSE(dba1->remove_vertex(va1));
+  EXPECT_FALSE(dba1->remove_vertex(va2));
+  EXPECT_FALSE(dba1->remove_vertex(va3));
+  EXPECT_EQ(CountVertices(*dba1), 3);
+  EXPECT_EQ(CountEdges(*dba1), 2);
 
   // make a new transaction because at the moment deletions
   // in the same transaction are not visible
   // DETACH REMOVE V3
   // new situation: (v1) - [:likes] -> (v2)
-  dba1.detach_remove_vertex(va3);
-  dba1.commit();
-  GraphDbAccessor dba2 = dbms.active();
+  dba1->detach_remove_vertex(va3);
+  dba1->commit();
+  auto dba2 = dbms.active();
 
-  EXPECT_EQ(CountVertices(dba2), 2);
-  EXPECT_EQ(CountEdges(dba2), 1);
-  for (auto va : dba2.vertices()) EXPECT_FALSE(dba2.remove_vertex(va));
+  EXPECT_EQ(CountVertices(*dba2), 2);
+  EXPECT_EQ(CountEdges(*dba2), 1);
+  for (auto va : dba2->vertices()) EXPECT_FALSE(dba2->remove_vertex(va));
 
-  dba2.commit();
-  GraphDbAccessor dba3 = dbms.active();
-  EXPECT_EQ(CountVertices(dba3), 2);
-  EXPECT_EQ(CountEdges(dba3), 1);
+  dba2->commit();
+  auto dba3 = dbms.active();
+  EXPECT_EQ(CountVertices(*dba3), 2);
+  EXPECT_EQ(CountEdges(*dba3), 1);
 
-  for (auto va : dba3.vertices()) {
-    EXPECT_FALSE(dba3.remove_vertex(va));
-    dba3.detach_remove_vertex(va);
+  for (auto va : dba3->vertices()) {
+    EXPECT_FALSE(dba3->remove_vertex(va));
+    dba3->detach_remove_vertex(va);
     break;
   }
 
-  dba3.commit();
-  GraphDbAccessor dba4 = dbms.active();
-  EXPECT_EQ(CountVertices(dba4), 1);
-  EXPECT_EQ(CountEdges(dba4), 0);
+  dba3->commit();
+  auto dba4 = dbms.active();
+  EXPECT_EQ(CountVertices(*dba4), 1);
+  EXPECT_EQ(CountEdges(*dba4), 0);
 
   // remove the last vertex, it has no connections
   // so that should work
-  for (auto va : dba4.vertices()) EXPECT_TRUE(dba4.remove_vertex(va));
+  for (auto va : dba4->vertices()) EXPECT_TRUE(dba4->remove_vertex(va));
 
-  dba4.commit();
-  GraphDbAccessor dba5 = dbms.active();
-  EXPECT_EQ(CountVertices(dba5), 0);
-  EXPECT_EQ(CountEdges(dba5), 0);
+  dba4->commit();
+  auto dba5 = dbms.active();
+  EXPECT_EQ(CountVertices(*dba5), 0);
+  EXPECT_EQ(CountEdges(*dba5), 0);
 }
 
 TEST(GraphDbAccessorTest, Labels) {
   Dbms dbms;
-  GraphDbAccessor dba1 = dbms.active();
+  auto dba1 = dbms.active();
 
-  GraphDb::Label label_friend = dba1.label("friend");
-  EXPECT_EQ(label_friend, dba1.label("friend"));
-  EXPECT_NE(label_friend, dba1.label("friend2"));
-  EXPECT_EQ(dba1.label_name(label_friend), "friend");
+  GraphDb::Label label_friend = dba1->label("friend");
+  EXPECT_EQ(label_friend, dba1->label("friend"));
+  EXPECT_NE(label_friend, dba1->label("friend2"));
+  EXPECT_EQ(dba1->label_name(label_friend), "friend");
 
   // test that getting labels through a different accessor works
-  EXPECT_EQ(label_friend, dbms.active().label("friend"));
-  EXPECT_NE(label_friend, dbms.active().label("friend2"));
+  EXPECT_EQ(label_friend, dbms.active()->label("friend"));
+  EXPECT_NE(label_friend, dbms.active()->label("friend2"));
 }
 
 TEST(GraphDbAccessorTest, EdgeTypes) {
   Dbms dbms;
-  GraphDbAccessor dba1 = dbms.active();
+  auto dba1 = dbms.active();
 
-  GraphDb::EdgeType edge_type = dba1.edge_type("likes");
-  EXPECT_EQ(edge_type, dba1.edge_type("likes"));
-  EXPECT_NE(edge_type, dba1.edge_type("hates"));
-  EXPECT_EQ(dba1.edge_type_name(edge_type), "likes");
+  GraphDb::EdgeType edge_type = dba1->edge_type("likes");
+  EXPECT_EQ(edge_type, dba1->edge_type("likes"));
+  EXPECT_NE(edge_type, dba1->edge_type("hates"));
+  EXPECT_EQ(dba1->edge_type_name(edge_type), "likes");
 
   // test that getting labels through a different accessor works
-  EXPECT_EQ(edge_type, dbms.active().edge_type("likes"));
-  EXPECT_NE(edge_type, dbms.active().edge_type("hates"));
+  EXPECT_EQ(edge_type, dbms.active()->edge_type("likes"));
+  EXPECT_NE(edge_type, dbms.active()->edge_type("hates"));
 }
 
 TEST(GraphDbAccessorTest, Properties) {
   Dbms dbms;
-  GraphDbAccessor dba1 = dbms.active();
+  auto dba1 = dbms.active();
 
-  GraphDb::EdgeType prop = dba1.property("name");
-  EXPECT_EQ(prop, dba1.property("name"));
-  EXPECT_NE(prop, dba1.property("surname"));
-  EXPECT_EQ(dba1.property_name(prop), "name");
+  GraphDb::EdgeType prop = dba1->property("name");
+  EXPECT_EQ(prop, dba1->property("name"));
+  EXPECT_NE(prop, dba1->property("surname"));
+  EXPECT_EQ(dba1->property_name(prop), "name");
 
   // test that getting labels through a different accessor works
-  EXPECT_EQ(prop, dbms.active().property("name"));
-  EXPECT_NE(prop, dbms.active().property("surname"));
+  EXPECT_EQ(prop, dbms.active()->property("name"));
+  EXPECT_NE(prop, dbms.active()->property("surname"));
 }
 
 int main(int argc, char **argv) {
diff --git a/tests/unit/record_edge_vertex_accessor.cpp b/tests/unit/record_edge_vertex_accessor.cpp
index b8660bd10..5f2f46c7b 100644
--- a/tests/unit/record_edge_vertex_accessor.cpp
+++ b/tests/unit/record_edge_vertex_accessor.cpp
@@ -12,13 +12,13 @@
 
 TEST(RecordAccessor, Properties) {
   Dbms dbms;
-  GraphDbAccessor dba = dbms.active();
+  auto dba = dbms.active();
 
-  auto vertex = dba.insert_vertex();
+  auto vertex = dba->insert_vertex();
   auto& properties = vertex.Properties();
 
-  auto property = dba.property("PropName");
-  auto property_other = dba.property("Other");
+  auto property = dba->property("PropName");
+  auto property_other = dba->property("Other");
   EXPECT_EQ(vertex.PropsAt(property).type(), PropertyValue::Type::Null);
 
   vertex.PropsSet(property, 42);
@@ -34,42 +34,42 @@ TEST(RecordAccessor, Properties) {
 
 TEST(RecordAccessor, DbAccessor) {
   Dbms dbms;
-  GraphDbAccessor dba = dbms.active();
+  auto dba = dbms.active();
 
-  auto vertex = dba.insert_vertex();
+  auto vertex = dba->insert_vertex();
   const auto& const_vertex_dba = vertex.db_accessor();
-  EXPECT_EQ(&dba, &const_vertex_dba);
+  EXPECT_EQ(dba.get(), &const_vertex_dba);
   auto& vertex_dba = vertex.db_accessor();
-  EXPECT_EQ(&dba, &vertex_dba);
+  EXPECT_EQ(dba.get(), &vertex_dba);
 }
 
 TEST(RecordAccessor, RecordEquality) {
   Dbms dbms;
-  GraphDbAccessor dba = dbms.active();
+  auto dba = dbms.active();
 
-  auto v1 = dba.insert_vertex();
-  auto v2 = dba.insert_vertex();
+  auto v1 = dba->insert_vertex();
+  auto v2 = dba->insert_vertex();
   EXPECT_EQ(v1, v1);
   EXPECT_NE(v1, v2);
 
-  auto e1 = dba.insert_edge(v1, v2, dba.edge_type("type"));
-  auto e2 = dba.insert_edge(v1, v2, dba.edge_type("type"));
+  auto e1 = dba->insert_edge(v1, v2, dba->edge_type("type"));
+  auto e2 = dba->insert_edge(v1, v2, dba->edge_type("type"));
   EXPECT_EQ(e1, e1);
   EXPECT_NE(e1, e2);
 }
 
 TEST(RecordAccessor, RecordLessThan) {
   Dbms dbms;
-  GraphDbAccessor dba = dbms.active();
+  auto dba = dbms.active();
 
-  auto v1 = dba.insert_vertex();
-  auto v2 = dba.insert_vertex();
+  auto v1 = dba->insert_vertex();
+  auto v2 = dba->insert_vertex();
   EXPECT_NE(v1, v2);
   EXPECT_TRUE(v1 < v2 || v2 < v1);
   EXPECT_FALSE(v1 < v1);
   EXPECT_FALSE(v2 < v2);
-  auto e1 = dba.insert_edge(v1, v2, dba.edge_type("type"));
-  auto e2 = dba.insert_edge(v1, v2, dba.edge_type("type"));
+  auto e1 = dba->insert_edge(v1, v2, dba->edge_type("type"));
+  auto e2 = dba->insert_edge(v1, v2, dba->edge_type("type"));
   EXPECT_NE(e1, e2);
   EXPECT_TRUE(e1 < e2 || e2 < e1);
   EXPECT_FALSE(e1 < e1);
@@ -78,14 +78,14 @@ TEST(RecordAccessor, RecordLessThan) {
 
 TEST(RecordAccessor, VertexLabels) {
   Dbms dbms;
-  GraphDbAccessor dba = dbms.active();
-  auto v1 = dba.insert_vertex();
+  auto dba = dbms.active();
+  auto v1 = dba->insert_vertex();
   auto& labels = v1.labels();
 
   EXPECT_EQ(v1.labels().size(), 0);
 
-  GraphDb::Label l1 = dba.label("label1");
-  GraphDb::Label l2 = dba.label("label2");
+  GraphDb::Label l1 = dba->label("label1");
+  GraphDb::Label l2 = dba->label("label2");
 
   // adding labels
   EXPECT_FALSE(v1.has_label(l1));
@@ -105,7 +105,7 @@ TEST(RecordAccessor, VertexLabels) {
   EXPECT_EQ(labels.size(), 2);
 
   // removing labels
-  GraphDb::Label l3 = dba.label("label3");
+  GraphDb::Label l3 = dba->label("label3");
   EXPECT_EQ(v1.remove_label(l3), 0);
   EXPECT_EQ(labels.size(), 2);
 
@@ -119,14 +119,14 @@ TEST(RecordAccessor, VertexLabels) {
 
 TEST(RecordAccessor, EdgeType) {
   Dbms dbms;
-  GraphDbAccessor dba = dbms.active();
-  auto v1 = dba.insert_vertex();
-  auto v2 = dba.insert_vertex();
+  auto dba = dbms.active();
+  auto v1 = dba->insert_vertex();
+  auto v2 = dba->insert_vertex();
 
-  GraphDb::EdgeType likes = dba.edge_type("likes");
-  GraphDb::EdgeType hates = dba.edge_type("hates");
+  GraphDb::EdgeType likes = dba->edge_type("likes");
+  GraphDb::EdgeType hates = dba->edge_type("hates");
 
-  auto edge = dba.insert_edge(v1, v2, likes);
+  auto edge = dba->insert_edge(v1, v2, likes);
   EXPECT_EQ(edge.edge_type(), likes);
   EXPECT_NE(edge.edge_type(), hates);
 
@@ -137,10 +137,10 @@ TEST(RecordAccessor, EdgeType) {
 
 TEST(RecordAccessor, VertexEdgeConnections) {
   Dbms dbms;
-  GraphDbAccessor dba = dbms.active();
-  auto v1 = dba.insert_vertex();
-  auto v2 = dba.insert_vertex();
-  auto edge = dba.insert_edge(v1, v2, dba.edge_type("likes"));
+  auto dba = dbms.active();
+  auto v1 = dba->insert_vertex();
+  auto v2 = dba->insert_vertex();
+  auto edge = dba->insert_edge(v1, v2, dba->edge_type("likes"));
 
   EXPECT_EQ(edge.from(), v1);
   EXPECT_NE(edge.from(), v2);