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

First step in database accessor refactoring done.

Browse Source 
It's compiling.
All tests with exception of integration_querys pass
This commit is contained in:
Kruno Tomola Fabro 2016-08-12 23:01:39 +01:00
parent 2113546b9c
commit 1849514159
20 changed files with 359 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
CMakeLists.txt
View File

@ -15,7 +15,7 @@ find_package(Threads REQUIRED)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++1y")
# glibcxx debug (useful for gdb)
# the problem is that the query engine doesn't work as it should work if
# the problem is that the query engine doesn't work as it should work if
# this flag is present
# TODO: find more appropriate way to use this flag only when it is needed
# set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -D_GLIBCXX_DEBUG")
@ -288,7 +288,7 @@ endif()
# release flags
set(CMAKE_CXX_FLAGS_RELEASE
"${CMAKE_CXX_FLAGS_RELEASE} -march=native -Wall -Werror")
"${CMAKE_CXX_FLAGS_RELEASE} -march=native -Wall")
# -- configure defines -- default is ON | true | enabled ----------------------
# -- logging ------------------------------------------------------------------
@ -412,6 +412,10 @@ set(memgraph_src_files
${src_dir}/logging/default.cpp
${src_dir}/logging/log.cpp
${src_dir}/io/network/tls.cpp
${src_dir}/database/db.cpp
${src_dir}/database/db_accessor.cpp
${src_dir}/database/db_transaction.cpp
${src_dir}/storage/edge_accessor.cpp
)
# STATIC library used by memgraph executables
@ -434,7 +438,7 @@ endif()
# memgraph build name
execute_process(
OUTPUT_VARIABLE COMMIT_NO
OUTPUT_VARIABLE COMMIT_NO
COMMAND git rev-list --count HEAD
)
execute_process(

72
include/communication/bolt/v1/serialization/bolt_serializer.hpp
View File

@ -1,13 +1,13 @@
#pragma once
#include "communication/bolt/v1/transport/bolt_encoder.hpp"
#include "communication/bolt/v1/packing/codes.hpp"
#include "communication/bolt/v1/transport/bolt_encoder.hpp"
#include "storage/vertex_accessor.hpp"
#include "storage/edge_accessor.hpp"
#include "storage/vertex_accessor.hpp"
#include "storage/model/properties/properties.hpp"
#include "storage/model/properties/all.hpp"
#include "storage/model/properties/properties.hpp"
namespace bolt
{
@ -22,7 +22,7 @@ class BoltSerializer
// friend void accept(const Property &property, Handler &h);
public:
BoltSerializer(Stream& stream) : encoder(stream) {}
BoltSerializer(Stream &stream) : encoder(stream) {}
/* Serializes the vertex accessor into the packstream format
*
@ -33,7 +33,7 @@ public:
* }
*
*/
void write(const Vertex::Accessor& vertex)
void write(const Vertex::Accessor &vertex)
{
// write signatures for the node struct and node data type
encoder.write_struct_header(3);
@ -47,7 +47,7 @@ public:
encoder.write_list_header(labels.size());
for(auto& label : labels)
for (auto &label : labels)
encoder.write_string(label.get());
// write the property map
@ -55,7 +55,7 @@ public:
encoder.write_map_header(props.size());
for(auto& prop : props) {
for (auto &prop : props) {
write(prop.first);
write(*prop.second);
}
@ -72,7 +72,7 @@ public:
* }
*
*/
void write(const Edge::Accessor& edge)
void write(const Edge::Accessor &edge)
{
// write signatures for the edge struct and edge data type
encoder.write_struct_header(5);
@ -82,8 +82,8 @@ public:
encoder.write_integer(edge.id());
// TODO refactor when from() and to() start returning Accessors
encoder.write_integer(edge.from()->id);
encoder.write_integer(edge.to()->id);
encoder.write_integer(edge.from_record()->id);
encoder.write_integer(edge.to_record()->id);
// write the type of the edge
encoder.write_string(edge.edge_type());
@ -93,65 +93,37 @@ public:
encoder.write_map_header(props.size());
for(auto& prop : props) {
for (auto &prop : props) {
write(prop.first);
write(*prop.second);
}
}
void write(const Property& prop)
{
accept(prop, *this);
}
void write(const Property &prop) { accept(prop, *this); }
void write_null()
{
encoder.write_null();
}
void write_null() { encoder.write_null(); }
void write(const Bool& prop)
{
encoder.write_bool(prop.value());
}
void write(const Bool &prop) { encoder.write_bool(prop.value()); }
void write(const Float& prop)
{
encoder.write_double(prop.value);
}
void write(const Float &prop) { encoder.write_double(prop.value); }
void write(const Double& prop)
{
encoder.write_double(prop.value);
}
void write(const Double &prop) { encoder.write_double(prop.value); }
void write(const Int32& prop)
{
encoder.write_integer(prop.value);
}
void write(const Int32 &prop) { encoder.write_integer(prop.value); }
void write(const Int64& prop)
{
encoder.write_integer(prop.value);
}
void write(const Int64 &prop) { encoder.write_integer(prop.value); }
void write(const std::string& value)
{
encoder.write_string(value);
}
void write(const std::string &value) { encoder.write_string(value); }
void write(const String& prop)
{
encoder.write_string(prop.value);
}
void write(const String &prop) { encoder.write_string(prop.value); }
template <class T>
void handle(const T& prop)
void handle(const T &prop)
{
write(prop);
}
protected:
Stream& encoder;
Stream &encoder;
};
}

13
include/database/db.hpp
View File

@ -1,25 +1,22 @@
#pragma once
#include "storage/graph.hpp"
// #include "transactions/commit_log.hpp"
#include "transactions/engine.hpp"
#include "transactions/commit_log.hpp"
class Db
{
public:
using sptr = std::shared_ptr<Db>;
Db() = default;
Db(const std::string& name) : name_(name) {}
Db(const Db& db) = delete;
Db();
Db(const std::string &name);
Db(const Db &db) = delete;
Graph graph;
tx::Engine tx_engine;
std::string& name()
{
return name_;
}
std::string &name();
private:
std::string name_;

50
include/database/db_accessor.hpp Normal file
View File

@ -0,0 +1,50 @@
#pragma once
#include "database/db.hpp"
#include "database/db_accessor.hpp"
#include "storage/record_accessor.hpp"
#include "storage/vertex.hpp"
#include "storage/vertex_accessor.hpp"
#include "storage/vertices.hpp"
#include "transactions/transaction.hpp"
class DbAccessor
{
public:
DbAccessor(Db &db);
// VERTEX METHODS
Vertices::vertices_t::Accessor vertex_access();
const Vertex::Accessor vertex_find(const Id &id);
const Vertex::Accessor vertex_first();
Vertex::Accessor vertex_insert();
// EDGE METHODS
Edge::Accessor edge_find(const Id &id);
Edge::Accessor edge_insert(VertexRecord *from, VertexRecord *to);
// LABEL METHODS
const Label &label_find_or_create(const std::string &name);
bool label_contains(const std::string &name);
VertexIndexRecordCollection &label_find_index(const Label &label);
// TYPE METHODS
const EdgeType &type_find_or_create(const std::string &name);
bool type_contains(const std::string &name);
// TRANSACTION METHODS
void commit();
void abort();
// EASE OF USE METHODS
tx::Transaction &operator*();
DbTransaction db;
};

26
include/database/db_transaction.hpp Normal file
View File

@ -0,0 +1,26 @@
#pragma once
#include "storage/indexes/index_record.hpp"
#include "storage/label/label.hpp"
#include "transactions/transaction.hpp"
class Db;
class DbAccessor;
// Inner structures local to transaction can hold ref to this structure and use
// its methods.
class DbTransaction
{
friend DbAccessor;
public:
DbTransaction(Db &db, tx::Transaction &trans) : db(db), trans(trans) {}
void update_label_index(const Label &label,
VertexIndexRecord &&index_record);
// protected:
// TRANSACTION METHODS
tx::Transaction &trans;
Db &db;
};

72
include/query_engine/hardcode/queries.hpp
View File

@ -1,6 +1,7 @@
#pragma once
#include "database/db.hpp"
#include "database/db_accessor.hpp"
#include "query_engine/query_stripper.hpp"
#include "query_engine/util.hpp"
#include "storage/model/properties/property.hpp"
@ -12,8 +13,8 @@ auto load_queries(Db &db)
// CREATE (n {prop: 0}) RETURN n)
auto create_node = [&db](const properties_t &args) {
auto &t = db.tx_engine.begin();
auto vertex_accessor = db.graph.vertices.insert(t);
DbAccessor t(db);
auto vertex_accessor = t.vertex_insert();
vertex_accessor.property("prop", args[0]);
t.commit();
return true;
@ -21,10 +22,10 @@ auto load_queries(Db &db)
queries[11597417457737499503u] = create_node;
auto create_labeled_and_named_node = [&db](const properties_t &args) {
auto &t = db.tx_engine.begin();
auto vertex_accessor = db.graph.vertices.insert(t);
DbAccessor t(db);
auto vertex_accessor = t.vertex_insert();
vertex_accessor.property("name", args[0]);
auto &label = db.graph.label_store.find_or_create("LABEL");
auto &label = t.label_find_or_create("LABEL");
vertex_accessor.add_label(label);
cout_properties(vertex_accessor.properties());
t.commit();
@ -32,13 +33,13 @@ auto load_queries(Db &db)
};
auto create_account = [&db](const properties_t &args) {
auto &t = db.tx_engine.begin();
auto vertex_accessor = db.graph.vertices.insert(t);
DbAccessor t(db);
auto vertex_accessor = t.vertex_insert();
vertex_accessor.property("id", args[0]);
vertex_accessor.property("name", args[1]);
vertex_accessor.property("country", args[2]);
vertex_accessor.property("created_at", args[3]);
auto &label = db.graph.label_store.find_or_create("ACCOUNT");
auto &label = t.label_find_or_create("ACCOUNT");
vertex_accessor.add_label(label);
cout_properties(vertex_accessor.properties());
t.commit();
@ -46,9 +47,9 @@ auto load_queries(Db &db)
};
auto find_node_by_internal_id = [&db](const properties_t &args) {
auto &t = db.tx_engine.begin();
DbAccessor t(db);
auto id = static_cast<Int32 &>(*args[0]);
auto vertex_accessor = db.graph.vertices.find(t, Id(id.value));
auto vertex_accessor = t.vertex_find(Id(id.value));
if (!vertex_accessor) {
cout << "vertex doesn't exist" << endl;
t.commit();
@ -64,20 +65,17 @@ auto load_queries(Db &db)
};
auto create_edge = [&db](const properties_t &args) {
auto &t = db.tx_engine.begin();
DbAccessor t(db);
auto v1 = db.graph.vertices.find(t, args[0]->as<Int32>().value);
auto v1 = t.vertex_find(args[0]->as<Int32>().value);
if (!v1) return t.commit(), false;
auto v2 = db.graph.vertices.find(t, args[1]->as<Int32>().value);
auto v2 = t.vertex_find(args[1]->as<Int32>().value);
if (!v2) return t.commit(), false;
auto edge_accessor = db.graph.edges.insert(t, v1.vlist, v2.vlist);
auto edge_accessor = t.edge_insert(v1.vlist, v2.vlist);
v1.vlist->update(t)->data.out.add(edge_accessor.vlist);
v2.vlist->update(t)->data.in.add(edge_accessor.vlist);
auto &edge_type = db.graph.edge_type_store.find_or_create("IS");
auto &edge_type = t.type_find_or_create("IS");
edge_accessor.edge_type(edge_type);
t.commit();
@ -90,8 +88,8 @@ auto load_queries(Db &db)
};
auto find_edge_by_internal_id = [&db](const properties_t &args) {
auto &t = db.tx_engine.begin();
auto edge_accessor = db.graph.edges.find(t, args[0]->as<Int32>().value);
DbAccessor t(db);
auto edge_accessor = t.edge_find(args[0]->as<Int32>().value);
if (!edge_accessor) return t.commit(), false;
// print edge type and properties
@ -99,11 +97,11 @@ auto load_queries(Db &db)
auto from = edge_accessor.from();
cout << "FROM:" << endl;
cout_properties(from->find(t)->data.props);
cout_properties(from.record->data.props);
auto to = edge_accessor.to();
cout << "TO:" << endl;
cout_properties(to->find(t)->data.props);
cout_properties(to.record->data.props);
t.commit();
@ -111,9 +109,9 @@ auto load_queries(Db &db)
};
auto update_node = [&db](const properties_t &args) {
auto &t = db.tx_engine.begin();
DbAccessor t(db);
auto v = db.graph.vertices.find(t, args[0]->as<Int32>().value);
auto v = t.vertex_find(args[0]->as<Int32>().value);
if (!v) return t.commit(), false;
v.property("name", args[1]);
@ -127,18 +125,17 @@ auto load_queries(Db &db)
// MATCH (n1), (n2) WHERE ID(n1)=0 AND ID(n2)=1 CREATE (n1)<-[r:IS {age: 25,
// weight: 70}]-(n2) RETURN r
auto create_edge_v2 = [&db](const properties_t &args) {
auto &t = db.tx_engine.begin();
auto n1 = db.graph.vertices.find(t, args[0]->as<Int64>().value);
DbAccessor t(db);
auto n1 = t.vertex_find(args[0]->as<Int64>().value);
if (!n1) return t.commit(), false;
auto n2 = db.graph.vertices.find(t, args[1]->as<Int64>().value);
auto n2 = t.vertex_find(args[1]->as<Int64>().value);
if (!n2) return t.commit(), false;
auto r = db.graph.edges.insert(t, n2.vlist, n1.vlist);
auto r = t.edge_insert(n2.vlist, n1.vlist);
r.property("age", args[2]);
r.property("weight", args[3]);
auto &IS = db.graph.edge_type_store.find_or_create("IS");
auto &IS = t.type_find_or_create("IS");
r.edge_type(IS);
n2.vlist->update(t)->data.out.add(r.vlist);
n1.vlist->update(t)->data.in.add(r.vlist);
t.commit();
return true;
};
@ -146,11 +143,11 @@ auto load_queries(Db &db)
// MATCH (n) RETURN n
auto match_all_nodes = [&db](const properties_t &args) {
auto &t = db.tx_engine.begin();
DbAccessor t(db);
auto vertices_accessor = db.graph.vertices.access();
auto vertices_accessor = t.vertex_access();
for (auto &it : vertices_accessor) {
auto vertex = it.second.find(t);
auto vertex = it.second.find(*t);
if (vertex == nullptr) continue;
cout_properties(vertex->data.props);
}
@ -166,12 +163,11 @@ auto load_queries(Db &db)
// MATCH (n:LABEL) RETURN n
auto find_by_label = [&db](const properties_t &args) {
auto &t = db.tx_engine.begin();
DbAccessor t(db);
auto &label = db.graph.label_store.find_or_create("LABEL");
auto &label = t.label_find_or_create("LABEL");
auto &index_record_collection =
db.graph.vertices.find_label_index(label);
auto &index_record_collection = t.label_find_index(label);
auto accessor = index_record_collection.access();
cout << "VERTICES" << endl;
for (auto &v : accessor) {

24
include/storage/edge_accessor.hpp
View File

@ -3,31 +3,27 @@
#include "storage/edge.hpp"
#include "storage/edge_record.hpp"
#include "storage/record_accessor.hpp"
#include "storage/vertex_accessor.hpp"
#include "utils/assert.hpp"
#include "utils/reference_wrapper.hpp"
class Edges;
// TODO: Edge, Db, Edge::Accessor
class Edge::Accessor
: public RecordAccessor<Edge, Edges, Edge::Accessor, EdgeRecord>
class Edge::Accessor : public RecordAccessor<Edge, Edge::Accessor, EdgeRecord>
{
public:
using RecordAccessor::RecordAccessor;
void edge_type(edge_type_ref_t edge_type)
{
this->record->data.edge_type = &edge_type.get();
}
void edge_type(edge_type_ref_t edge_type);
edge_type_ref_t edge_type() const
{
runtime_assert(this->record->data.edge_type != nullptr,
"EdgeType is null");
return edge_type_ref_t(*this->record->data.edge_type);
}
edge_type_ref_t edge_type() const;
auto from() const { return this->vlist->from(); }
Vertex::Accessor from() const;
auto to() const { return this->vlist->to(); }
Vertex::Accessor to() const;
VertexRecord *from_record() const;
VertexRecord *to_record() const;
};

4
include/storage/edges.hpp
View File

@ -8,8 +8,8 @@
class Edges
{
public:
Edge::Accessor find(tx::Transaction &t, const Id &id);
Edge::Accessor insert(tx::Transaction &t, VertexRecord *from,
Edge::Accessor find(DbTransaction &t, const Id &id);
Edge::Accessor insert(DbTransaction &t, VertexRecord *from,
VertexRecord *to);
private:

28
include/storage/record_accessor.hpp
View File

@ -1,23 +1,29 @@
#pragma once
#include "database/db_transaction.hpp"
#include "mvcc/version_list.hpp"
#include "storage/model/properties/properties.hpp"
#include "storage/model/properties/property.hpp"
#include "transactions/transaction.hpp"
template <class T, class Store, class Derived,
class vlist_t = mvcc::VersionList<T>>
template <class T, class Derived, class vlist_t = mvcc::VersionList<T>>
class RecordAccessor
{
public:
RecordAccessor() = default;
RecordAccessor(DbTransaction &db) : db(db){};
RecordAccessor(T *record, vlist_t *vlist, Store *store)
: record(record), vlist(vlist), store(store)
RecordAccessor(T *t, vlist_t *vlist, DbTransaction &db)
: record(t), vlist(vlist), db(db)
{
assert(record != nullptr);
assert(vlist != nullptr);
}
RecordAccessor(vlist_t *vlist, DbTransaction &db)
: record(vlist->find(db.trans)), vlist(vlist), db(db)
{
assert(record != nullptr);
assert(vlist != nullptr);
assert(store != nullptr);
}
bool empty() const { return record == nullptr; }
@ -28,18 +34,18 @@ public:
return vlist->id;
}
Derived update(tx::Transaction &t) const
Derived update() const
{
assert(!empty());
return Derived(vlist->update(t), vlist, store);
return Derived(vlist->update(db.trans), vlist, db);
}
bool remove(tx::Transaction &t) const
bool remove() const
{
assert(!empty());
return vlist->remove(record, t);
return vlist->remove(record, db.trans);
}
const Property &property(const std::string &key) const
@ -65,5 +71,5 @@ public:
// protected:
T *const record{nullptr};
vlist_t *const vlist{nullptr};
Store *const store{nullptr};
DbTransaction &db;
};

5
include/storage/vertex_accessor.hpp
View File

@ -5,8 +5,7 @@
class Vertices;
class Vertex::Accessor
: public RecordAccessor<Vertex, Vertices, Vertex::Accessor>
class Vertex::Accessor : public RecordAccessor<Vertex, Vertex::Accessor>
{
public:
using RecordAccessor::RecordAccessor;
@ -21,5 +20,5 @@ public:
bool has_label(const Label &label) const;
const std::set<label_ref_t>& labels() const;
const std::set<label_ref_t> &labels() const;
};

11
include/storage/vertices.hpp
View File

@ -1,6 +1,7 @@
#pragma once
#include "data_structures/concurrent/concurrent_map.hpp"
#include "database/db_transaction.hpp"
#include "storage/common.hpp"
#include "storage/indexes/index.hpp"
#include "storage/indexes/index_record_collection.hpp"
@ -13,17 +14,17 @@ public:
vertices_t::Accessor access();
const Vertex::Accessor find(tx::Transaction &t, const Id &id);
const Vertex::Accessor find(DbTransaction &t, const Id &id);
const Vertex::Accessor first(tx::Transaction &t);
const Vertex::Accessor first(DbTransaction &t);
Vertex::Accessor insert(tx::Transaction &t);
Vertex::Accessor insert(DbTransaction &t);
void update_label_index(const Label &label,
VertexIndexRecord &&index_record);
VertexIndexRecordCollection& find_label_index(const Label& label);
VertexIndexRecordCollection &find_label_index(const Label &label);
private:
vertices_t vertices;
Index<label_ref_t, VertexIndexRecordCollection> label_index;

57
poc/astar.cpp
View File

@ -10,6 +10,7 @@
#include "data_structures/map/rh_hashmap.hpp"
#include "database/db.hpp"
#include "database/db_accessor.hpp"
using namespace std;
@ -92,20 +93,20 @@ double calc_heuristic_cost_dummy(Edge *edge, Vertex *vertex)
return 1 - vertex->data.props.at("score").as<Double>().value;
}
typedef bool (*EdgeFilter)(tx::Transaction &t, EdgeRecord *, Node *before);
typedef bool (*VertexFilter)(tx::Transaction &t, Vertex *, Node *before);
typedef bool (*EdgeFilter)(DbAccessor &t, EdgeRecord *, Node *before);
typedef bool (*VertexFilter)(DbAccessor &t, Vertex *, Node *before);
bool edge_filter_dummy(tx::Transaction &t, EdgeRecord *e, Node *before)
bool edge_filter_dummy(DbAccessor &t, EdgeRecord *e, Node *before)
{
return true;
}
bool vertex_filter_dummy(tx::Transaction &t, Vertex *v, Node *before)
bool vertex_filter_dummy(DbAccessor &t, Vertex *v, Node *before)
{
return true;
}
bool vertex_filter_contained_dummy(tx::Transaction &t, Vertex *v, Node *before)
bool vertex_filter_contained_dummy(DbAccessor &t, Vertex *v, Node *before)
{
bool found;
do {
@ -115,7 +116,7 @@ bool vertex_filter_contained_dummy(tx::Transaction &t, Vertex *v, Node *before)
return true;
}
for (auto edge : before->vertex->data.out) {
Vertex *e_v = edge->to()->find(t);
Vertex *e_v = edge->to()->find(*t);
if (e_v == v) {
found = true;
break;
@ -125,7 +126,7 @@ bool vertex_filter_contained_dummy(tx::Transaction &t, Vertex *v, Node *before)
return false;
}
bool vertex_filter_contained(tx::Transaction &t, Vertex *v, Node *before)
bool vertex_filter_contained(DbAccessor &t, Vertex *v, Node *before)
{
bool found;
do {
@ -146,14 +147,14 @@ void a_star(Db &db, int64_t sys_id_start, uint max_depth, EdgeFilter e_filter[],
double (*calc_heuristic_cost)(Edge *edge, Vertex *vertex),
int limit)
{
auto &t = db.tx_engine.begin();
DbAccessor t(db);
RhHashMap<VertexRecord *, Node> visited;
auto cmp = [](Node *left, Node *right) { return left->cost > right->cost; };
std::priority_queue<Node *, std::vector<Node *>, decltype(cmp)> queue(cmp);
auto start_vr = db.graph.vertices.find(t, sys_id_start).vlist;
Node *start = new Node(start_vr->find(t), start_vr, 0);
auto start_vr = t.vertex_find(sys_id_start).vlist;
Node *start = new Node(start_vr->find(*t), start_vr, 0);
queue.push(start);
int count = 0;
do {
@ -175,11 +176,12 @@ void a_star(Db &db, int64_t sys_id_start, uint max_depth, EdgeFilter e_filter[],
for (auto edge : now->vertex->data.out) {
if (e_filter[now->depth](t, edge, now)) {
Vertex *v = edge->to()->find(t);
Vertex *v = edge->to()->find(*t);
if (v_filter[now->depth](t, v, now)) {
Node *n = new Node(
v, edge->to(),
now->cost + calc_heuristic_cost(edge->find(t), v), now);
now->cost + calc_heuristic_cost(edge->find(*t), v),
now);
queue.push(n);
}
}
@ -207,7 +209,7 @@ void a_star(Db &db, int64_t sys_id_start, uint max_depth, EdgeFilter e_filter[],
int main()
{
Db db;
load_csv(db, "neo4j_nodes_export_2000.csv", "neo4j_edges_export_2000.csv");
load_csv(db, "graph_nodes_export.csv", "graph_edges_export.csv");
//
// load_graph_dummy(db);
//
@ -266,7 +268,7 @@ void load_csv(Db &db, char *file_path, char *edge_file_path)
std::string line;
auto &t = db.tx_engine.begin();
DbAccessor t(db);
int max_score = 1000000;
// VERTEX import
@ -276,7 +278,7 @@ void load_csv(Db &db, char *file_path, char *edge_file_path)
start_vertex_id = id;
}
auto vertex_accessor = db.graph.vertices.insert(t);
auto vertex_accessor = t.vertex_insert();
vertex_accessor.property("id", std::make_shared<Int32>(id));
vertex_accessor.property("garment_id", std::make_shared<Int32>(gar_id));
vertex_accessor.property("garment_category_id",
@ -286,7 +288,7 @@ void load_csv(Db &db, char *file_path, char *edge_file_path)
"score", std::make_shared<Double>((std::rand() % max_score) /
(max_score + 0.0)));
for (auto l_name : labels) {
auto &label = db.graph.label_store.find_or_create(l_name);
auto &label = t.label_find_or_create(l_name);
vertex_accessor.add_label(label);
}
return vertex_accessor.id();
@ -309,7 +311,7 @@ void load_csv(Db &db, char *file_path, char *edge_file_path)
stoi(splited[splited.size() - 1]));
assert(va.size() == (uint64_t)id);
va.push_back(db.graph.vertices.find(t, id));
va.push_back(t.vertex_find(id));
}
// EDGE IMPORT
@ -318,12 +320,9 @@ void load_csv(Db &db, char *file_path, char *edge_file_path)
auto v2 = va[to - start_vertex_id];
auto edge_accessor = db.graph.edges.insert(t, v1.vlist, v2.vlist);
auto edge_accessor = t.edge_insert(v1.vlist, v2.vlist);
v1.vlist->update(t)->data.out.add(edge_accessor.vlist);
v2.vlist->update(t)->data.in.add(edge_accessor.vlist);
auto &edge_type = db.graph.edge_type_store.find_or_create(type);
auto &edge_type = t.type_find_or_create(type);
edge_accessor.edge_type(edge_type);
};
@ -343,9 +342,9 @@ void load_csv(Db &db, char *file_path, char *edge_file_path)
void load_graph_dummy(Db &db)
{
auto &t = db.tx_engine.begin();
DbAccessor t(db);
auto v = [&](auto id, auto score) {
auto vertex_accessor = db.graph.vertices.insert(t);
auto vertex_accessor = t.vertex_insert();
vertex_accessor.property("id", std::make_shared<Int32>(id));
vertex_accessor.property("score", std::make_shared<Double>(score));
return vertex_accessor.id();
@ -356,15 +355,13 @@ void load_graph_dummy(Db &db)
};
auto e = [&](auto from, auto type, auto to) {
auto v1 = db.graph.vertices.find(t, va[from]);
auto v1 = t.vertex_find(va[from]);
auto v2 = db.graph.vertices.find(t, va[to]);
auto v2 = t.vertex_find(va[to]);
auto edge_accessor = db.graph.edges.insert(t, v1.vlist, v2.vlist);
v1.vlist->update(t)->data.out.add(edge_accessor.vlist);
v2.vlist->update(t)->data.in.add(edge_accessor.vlist);
auto edge_accessor = t.edge_insert(v1.vlist, v2.vlist);
auto &edge_type = db.graph.edge_type_store.find_or_create(type);
auto &edge_type = t.type_find_or_create(type);
edge_accessor.edge_type(edge_type);
};

4
src/cypher/tokenizer/cypher_lexer.hpp
View File

@ -73,6 +73,6 @@ public:
build();
}
CypherLexer(CypherLexer& other) = delete;
CypherLexer(CypherLexer&& other) = default;
CypherLexer(CypherLexer &other) = delete;
CypherLexer(CypherLexer &&other) = default;
};

6
src/database/db.cpp Normal file
View File

@ -0,0 +1,6 @@
#include "database/db.hpp"
Db::Db() = default;
Db::Db(const std::string &name) : name_(name) {}
std::string &Db::name() { return name_; }

77
src/database/db_accessor.cpp Normal file
View File

@ -0,0 +1,77 @@
#include "database/db_accessor.hpp"
DbAccessor::DbAccessor(Db &db) : db(DbTransaction(db, db.tx_engine.begin())) {}
// VERTEX METHODS
Vertices::vertices_t::Accessor DbAccessor::vertex_access()
{
return this->db.db.graph.vertices.access();
}
const Vertex::Accessor DbAccessor::vertex_find(const Id &id)
{
return this->db.db.graph.vertices.find(db, id);
}
const Vertex::Accessor DbAccessor::vertex_first()
{
return this->db.db.graph.vertices.first(db);
}
Vertex::Accessor DbAccessor::vertex_insert()
{
return this->db.db.graph.vertices.insert(db);
}
// EDGE METHODS
Edge::Accessor DbAccessor::edge_find(const Id &id)
{
return db.db.graph.edges.find(db, id);
}
Edge::Accessor DbAccessor::edge_insert(VertexRecord *from, VertexRecord *to)
{
auto edge_accessor = db.db.graph.edges.insert(db, from, to);
from->update(db.trans)->data.out.add(edge_accessor.vlist);
to->update(db.trans)->data.in.add(edge_accessor.vlist);
return edge_accessor;
}
// LABEL METHODS
const Label &DbAccessor::label_find_or_create(const std::string &name)
{
return db.db.graph.label_store.find_or_create(
std::forward<const std::string &>(name));
}
bool DbAccessor::label_contains(const std::string &name)
{
return db.db.graph.label_store.contains(
std::forward<const std::string &>(name));
}
VertexIndexRecordCollection &DbAccessor::label_find_index(const Label &label)
{
return db.db.graph.vertices.find_label_index(label);
}
// TYPE METHODS
const EdgeType &DbAccessor::type_find_or_create(const std::string &name)
{
return db.db.graph.edge_type_store.find_or_create(
std::forward<const std::string &>(name));
}
bool DbAccessor::type_contains(const std::string &name)
{
return db.db.graph.edge_type_store.contains(
std::forward<const std::string &>(name));
}
// TRANSACTION METHODS
void DbAccessor::commit() { db.trans.commit(); }
void DbAccessor::abort() { db.trans.abort(); }
// EASE OF USE METHODS
tx::Transaction &DbAccessor::operator*() { return db.trans; }

8
src/database/db_transaction.cpp Normal file
View File

@ -0,0 +1,8 @@
#include "database/db.hpp"
#include "database/db_transaction.hpp"
void DbTransaction::update_label_index(const Label &label,
VertexIndexRecord &&index_record)
{
db.graph.vertices.update_label_index(label, std::move(index_record));
}

29
src/storage/edge_accessor.cpp Normal file
View File

@ -0,0 +1,29 @@
#include "storage/edge_accessor.hpp"
void Edge::Accessor::edge_type(edge_type_ref_t edge_type)
{
this->record->data.edge_type = &edge_type.get();
}
edge_type_ref_t Edge::Accessor::edge_type() const
{
runtime_assert(this->record->data.edge_type != nullptr, "EdgeType is null");
return edge_type_ref_t(*this->record->data.edge_type);
}
Vertex::Accessor Edge::Accessor::from() const
{
return Vertex::Accessor(this->vlist->from(), this->db);
}
Vertex::Accessor Edge::Accessor::to() const
{
return Vertex::Accessor(this->vlist->to(), this->db);
}
VertexRecord *Edge::Accessor::from_record() const
{
return this->vlist->from();
}
VertexRecord *Edge::Accessor::to_record() const { return this->vlist->to(); }

16
src/storage/edges.cpp
View File

@ -1,21 +1,21 @@
#include "storage/edges.hpp"
Edge::Accessor Edges::find(tx::Transaction &t, const Id &id)
Edge::Accessor Edges::find(DbTransaction &t, const Id &id)
{
auto edges_accessor = edges.access();
auto edges_iterator = edges_accessor.find(id);
if (edges_iterator == edges_accessor.end()) return Edge::Accessor();
if (edges_iterator == edges_accessor.end()) return Edge::Accessor(t);
// find edge
auto edge = edges_iterator->second.find(t);
auto edge = edges_iterator->second.find(t.trans);
if (edge == nullptr) return Edge::Accessor();
if (edge == nullptr) return Edge::Accessor(t);
return Edge::Accessor(edge, &edges_iterator->second, this);
return Edge::Accessor(edge, &edges_iterator->second, t);
}
Edge::Accessor Edges::insert(tx::Transaction &t, VertexRecord *from,
Edge::Accessor Edges::insert(DbTransaction &t, VertexRecord *from,
VertexRecord *to)
{
// get next vertex id
@ -30,7 +30,7 @@ Edge::Accessor Edges::insert(tx::Transaction &t, VertexRecord *from,
// create new vertex
auto inserted_edge_record = result.first;
auto edge = inserted_edge_record->second.insert(t);
auto edge = inserted_edge_record->second.insert(t.trans);
return Edge::Accessor(edge, &inserted_edge_record->second, this);
return Edge::Accessor(edge, &inserted_edge_record->second, t);
}

13
src/storage/vertex_accessor.cpp
View File

@ -1,5 +1,5 @@
#include "database/db.hpp"
#include "storage/vertex_accessor.hpp"
#include "storage/vertices.hpp"
size_t Vertex::Accessor::out_degree() const
@ -12,10 +12,7 @@ size_t Vertex::Accessor::in_degree() const
return this->record->data.in.degree();
}
size_t Vertex::Accessor::degree() const
{
return in_degree() + out_degree();
}
size_t Vertex::Accessor::degree() const { return in_degree() + out_degree(); }
void Vertex::Accessor::add_label(const Label &label)
{
@ -23,8 +20,8 @@ void Vertex::Accessor::add_label(const Label &label)
this->record->data.labels.add(label);
// update index
this->store->update_label_index(
label, VertexIndexRecord(this->record, this->vlist));
this->db.update_label_index(label,
VertexIndexRecord(this->record, this->vlist));
}
bool Vertex::Accessor::has_label(const Label &label) const
@ -32,7 +29,7 @@ bool Vertex::Accessor::has_label(const Label &label) const
return this->record->data.labels.has(label);
}
const std::set<label_ref_t>& Vertex::Accessor::labels() const
const std::set<label_ref_t> &Vertex::Accessor::labels() const
{
return this->record->data.labels();
}

33
src/storage/vertices.cpp
View File

@ -1,41 +1,40 @@
#include "storage/vertices.hpp"
Vertices::vertices_t::Accessor Vertices::access()
{
return vertices.access();
}
Vertices::vertices_t::Accessor Vertices::access() { return vertices.access(); }
const Vertex::Accessor Vertices::find(tx::Transaction &t, const Id &id)
const Vertex::Accessor Vertices::find(DbTransaction &t, const Id &id)
{
auto vertices_accessor = vertices.access();
auto vertices_iterator = vertices_accessor.find(id);
if (vertices_iterator == vertices_accessor.end()) return Vertex::Accessor();
if (vertices_iterator == vertices_accessor.end())
return Vertex::Accessor(t);
// find vertex
auto vertex = vertices_iterator->second.find(t);
auto vertex = vertices_iterator->second.find(t.trans);
if (vertex == nullptr) return Vertex::Accessor();
if (vertex == nullptr) return Vertex::Accessor(t);
return Vertex::Accessor(vertex, &vertices_iterator->second, this);
return Vertex::Accessor(vertex, &vertices_iterator->second, t);
}
// TODO
const Vertex::Accessor Vertices::first(tx::Transaction &t)
const Vertex::Accessor Vertices::first(DbTransaction &t)
{
auto vertices_accessor = vertices.access();
auto vertices_iterator = vertices_accessor.begin();
if (vertices_iterator == vertices_accessor.end()) return Vertex::Accessor();
if (vertices_iterator == vertices_accessor.end())
return Vertex::Accessor(t);
auto vertex = vertices_iterator->second.find(t);
auto vertex = vertices_iterator->second.find(t.trans);
if (vertex == nullptr) return Vertex::Accessor();
if (vertex == nullptr) return Vertex::Accessor(t);
return Vertex::Accessor(vertex, &vertices_iterator->second, this);
return Vertex::Accessor(vertex, &vertices_iterator->second, t);
}
Vertex::Accessor Vertices::insert(tx::Transaction &t)
Vertex::Accessor Vertices::insert(DbTransaction &t)
{
// get next vertex id
auto next = counter.next();
@ -50,9 +49,9 @@ Vertex::Accessor Vertices::insert(tx::Transaction &t)
// create new vertex
auto inserted_vertex_record = result.first;
auto vertex = inserted_vertex_record->second.insert(t);
auto vertex = inserted_vertex_record->second.insert(t.trans);
return Vertex::Accessor(vertex, &inserted_vertex_record->second, this);
return Vertex::Accessor(vertex, &inserted_vertex_record->second, t);
}
void Vertices::update_label_index(const Label &label,