tursom/memgraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

DBMS now returns a unique pointer to a GraphDbAccessor

Browse Source 
Summary: See above.

Reviewers: mislav.bradac

Reviewed By: mislav.bradac

Subscribers: pullbot

Differential Revision: https://phabricator.memgraph.io/D120
This commit is contained in:
florijan 2017-03-14 13:26:48 +01:00
parent 09999e877f
commit 1a6aaaed58
9 changed files with 190 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/communication/bolt/v1/states/executor.hpp
View File

@ -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(

9
src/database/graph_db_accessor.hpp
View File

@ -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.
*/

9
src/dbms/dbms.cpp
View File

@ -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);
}

6
src/dbms/dbms.hpp
View File

@ -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

2
tests/integration/query_engine_common.hpp
View File

@ -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);
}
}

52
tests/manual/compiler_prototype.cpp
View File

@ -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 (...) {

2
tests/manual/query_engine.cpp
View File

@ -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) {

218
tests/unit/graph_db_accessor.cpp
View File

@ -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) {

66
tests/unit/record_edge_vertex_accessor.cpp
View File

@ -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);