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

Implement explicit types in storage v2

Browse Source 
Reviewers: teon.banek, mtomic

Reviewed By: teon.banek

Subscribers: pullbot

Differential Revision: https://phabricator.memgraph.io/D2224
This commit is contained in:
Matej Ferencevic 2019-07-22 13:35:36 +02:00
parent e83abaaa5a
commit d7d0963434
15 changed files with 1483 additions and 1003 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
src/storage/v2/delta.hpp
View File

@ -4,6 +4,7 @@
#include <glog/logging.h> #include <glog/logging.h>
#include "storage/v2/id_types.hpp"
#include "storage/v2/property_value.hpp" #include "storage/v2/property_value.hpp"
namespace storage { namespace storage {
@ -128,49 +129,49 @@ struct Delta {
timestamp(timestamp), timestamp(timestamp),
command_id(command_id) {} command_id(command_id) {}
Delta(AddLabelTag, uint64_t label, std::atomic<uint64_t> *timestamp, Delta(AddLabelTag, LabelId label, std::atomic<uint64_t> *timestamp,
uint64_t command_id) uint64_t command_id)
: action(Action::ADD_LABEL), : action(Action::ADD_LABEL),
timestamp(timestamp), timestamp(timestamp),
command_id(command_id), command_id(command_id),
label(label) {} label(label) {}
Delta(RemoveLabelTag, uint64_t label, std::atomic<uint64_t> *timestamp, Delta(RemoveLabelTag, LabelId label, std::atomic<uint64_t> *timestamp,
uint64_t command_id) uint64_t command_id)
: action(Action::REMOVE_LABEL), : action(Action::REMOVE_LABEL),
timestamp(timestamp), timestamp(timestamp),
command_id(command_id), command_id(command_id),
label(label) {} label(label) {}
Delta(SetPropertyTag, uint64_t key, const PropertyValue &value, Delta(SetPropertyTag, PropertyId key, const PropertyValue &value,
std::atomic<uint64_t> *timestamp, uint64_t command_id) std::atomic<uint64_t> *timestamp, uint64_t command_id)
: action(Action::SET_PROPERTY), : action(Action::SET_PROPERTY),
timestamp(timestamp), timestamp(timestamp),
command_id(command_id), command_id(command_id),
property({key, value}) {} property({key, value}) {}
Delta(AddInEdgeTag, uint64_t edge_type, Vertex *vertex, Edge *edge, Delta(AddInEdgeTag, EdgeTypeId edge_type, Vertex *vertex, Edge *edge,
std::atomic<uint64_t> *timestamp, uint64_t command_id) std::atomic<uint64_t> *timestamp, uint64_t command_id)
: action(Action::ADD_IN_EDGE), : action(Action::ADD_IN_EDGE),
timestamp(timestamp), timestamp(timestamp),
command_id(command_id), command_id(command_id),
vertex_edge({edge_type, vertex, edge}) {} vertex_edge({edge_type, vertex, edge}) {}
Delta(AddOutEdgeTag, uint64_t edge_type, Vertex *vertex, Edge *edge, Delta(AddOutEdgeTag, EdgeTypeId edge_type, Vertex *vertex, Edge *edge,
std::atomic<uint64_t> *timestamp, uint64_t command_id) std::atomic<uint64_t> *timestamp, uint64_t command_id)
: action(Action::ADD_OUT_EDGE), : action(Action::ADD_OUT_EDGE),
timestamp(timestamp), timestamp(timestamp),
command_id(command_id), command_id(command_id),
vertex_edge({edge_type, vertex, edge}) {} vertex_edge({edge_type, vertex, edge}) {}
Delta(RemoveInEdgeTag, uint64_t edge_type, Vertex *vertex, Edge *edge, Delta(RemoveInEdgeTag, EdgeTypeId edge_type, Vertex *vertex, Edge *edge,
std::atomic<uint64_t> *timestamp, uint64_t command_id) std::atomic<uint64_t> *timestamp, uint64_t command_id)
: action(Action::REMOVE_IN_EDGE), : action(Action::REMOVE_IN_EDGE),
timestamp(timestamp), timestamp(timestamp),
command_id(command_id), command_id(command_id),
vertex_edge({edge_type, vertex, edge}) {} vertex_edge({edge_type, vertex, edge}) {}
Delta(RemoveOutEdgeTag, uint64_t edge_type, Vertex *vertex, Edge *edge, Delta(RemoveOutEdgeTag, EdgeTypeId edge_type, Vertex *vertex, Edge *edge,
std::atomic<uint64_t> *timestamp, uint64_t command_id) std::atomic<uint64_t> *timestamp, uint64_t command_id)
: action(Action::REMOVE_OUT_EDGE), : action(Action::REMOVE_OUT_EDGE),
timestamp(timestamp), timestamp(timestamp),
@ -223,13 +224,13 @@ struct Delta {
std::atomic<Delta *> next{nullptr}; std::atomic<Delta *> next{nullptr};
union { union {
uint64_t label; LabelId label;
struct { struct {
uint64_t key; PropertyId key;
storage::PropertyValue value; storage::PropertyValue value;
} property; } property;
struct { struct {
uint64_t edge_type; EdgeTypeId edge_type;
Vertex *vertex; Vertex *vertex;
Edge *edge; Edge *edge;
} vertex_edge; } vertex_edge;

4
src/storage/v2/edge.hpp
View File

@ -6,7 +6,7 @@
#include "utils/spin_lock.hpp" #include "utils/spin_lock.hpp"
#include "storage/v2/delta.hpp" #include "storage/v2/delta.hpp"
#include "storage/v2/gid.hpp" #include "storage/v2/id_types.hpp"
namespace storage { namespace storage {
@ -20,7 +20,7 @@ struct Edge {
Gid gid; Gid gid;
std::map<uint64_t, storage::PropertyValue> properties; std::map<PropertyId, storage::PropertyValue> properties;
utils::SpinLock lock; utils::SpinLock lock;
bool deleted; bool deleted;

14
src/storage/v2/edge_accessor.cpp
View File

@ -15,7 +15,7 @@ VertexAccessor EdgeAccessor::ToVertex() {
return VertexAccessor{to_vertex_, transaction_}; return VertexAccessor{to_vertex_, transaction_};
} }
Result<bool> EdgeAccessor::SetProperty(uint64_t property, Result<bool> EdgeAccessor::SetProperty(PropertyId property,
const PropertyValue &value) { const PropertyValue &value) {
std::lock_guard<utils::SpinLock> guard(edge_->lock); std::lock_guard<utils::SpinLock> guard(edge_->lock);
@ -47,7 +47,8 @@ Result<bool> EdgeAccessor::SetProperty(uint64_t property,
return Result<bool>{existed}; return Result<bool>{existed};
} }
Result<PropertyValue> EdgeAccessor::GetProperty(uint64_t property, View view) { Result<PropertyValue> EdgeAccessor::GetProperty(PropertyId property,
View view) {
bool deleted = false; bool deleted = false;
PropertyValue value; PropertyValue value;
Delta *delta = nullptr; Delta *delta = nullptr;
@ -90,8 +91,9 @@ Result<PropertyValue> EdgeAccessor::GetProperty(uint64_t property, View view) {
return Result<PropertyValue>{std::move(value)}; return Result<PropertyValue>{std::move(value)};
} }
Result<std::map<uint64_t, PropertyValue>> EdgeAccessor::Properties(View view) { Result<std::map<PropertyId, PropertyValue>> EdgeAccessor::Properties(
std::map<uint64_t, PropertyValue> properties; View view) {
std::map<PropertyId, PropertyValue> properties;
bool deleted = false; bool deleted = false;
Delta *delta = nullptr; Delta *delta = nullptr;
{ {
@ -136,9 +138,9 @@ Result<std::map<uint64_t, PropertyValue>> EdgeAccessor::Properties(View view) {
} }
}); });
if (deleted) { if (deleted) {
return Result<std::map<uint64_t, PropertyValue>>{Error::DELETED_OBJECT}; return Result<std::map<PropertyId, PropertyValue>>{Error::DELETED_OBJECT};
} }
return Result<std::map<uint64_t, PropertyValue>>{std::move(properties)}; return Result<std::map<PropertyId, PropertyValue>>{std::move(properties)};
} }
} // namespace storage } // namespace storage

12
src/storage/v2/edge_accessor.hpp
View File

@ -19,7 +19,7 @@ class EdgeAccessor final {
friend class Storage; friend class Storage;
public: public:
EdgeAccessor(Edge *edge, uint64_t edge_type, Vertex *from_vertex, EdgeAccessor(Edge *edge, EdgeTypeId edge_type, Vertex *from_vertex,
Vertex *to_vertex, Transaction *transaction) Vertex *to_vertex, Transaction *transaction)
: edge_(edge), : edge_(edge),
edge_type_(edge_type), edge_type_(edge_type),
@ -31,13 +31,13 @@ class EdgeAccessor final {
VertexAccessor ToVertex(); VertexAccessor ToVertex();
uint64_t EdgeType() const { return edge_type_; } EdgeTypeId EdgeType() const { return edge_type_; }
Result<bool> SetProperty(uint64_t property, const PropertyValue &value); Result<bool> SetProperty(PropertyId property, const PropertyValue &value);
Result<PropertyValue> GetProperty(uint64_t property, View view); Result<PropertyValue> GetProperty(PropertyId property, View view);
Result<std::map<uint64_t, PropertyValue>> Properties(View view); Result<std::map<PropertyId, PropertyValue>> Properties(View view);
Gid Gid() const { return edge_->gid; } Gid Gid() const { return edge_->gid; }
@ -48,7 +48,7 @@ class EdgeAccessor final {
private: private:
Edge *edge_; Edge *edge_;
uint64_t edge_type_; EdgeTypeId edge_type_;
Vertex *from_vertex_; Vertex *from_vertex_;
Vertex *to_vertex_; Vertex *to_vertex_;
Transaction *transaction_; Transaction *transaction_;

45
src/storage/v2/gid.hpp
View File

@ -1,45 +0,0 @@
#pragma once
#include "utils/cast.hpp"
namespace storage {
class Gid final {
private:
explicit Gid(uint64_t gid) : gid_(gid) {}
public:
static Gid FromUint(uint64_t gid) { return Gid{gid}; }
static Gid FromInt(int64_t gid) {
return Gid{utils::MemcpyCast<uint64_t>(gid)};
}
uint64_t AsUint() const { return gid_; }
int64_t AsInt() const { return utils::MemcpyCast<int64_t>(gid_); }
private:
uint64_t gid_;
};
inline bool operator==(const Gid &first, const Gid &second) {
return first.AsUint() == second.AsUint();
}
inline bool operator!=(const Gid &first, const Gid &second) {
return first.AsUint() != second.AsUint();
}
inline bool operator<(const Gid &first, const Gid &second) {
return first.AsUint() < second.AsUint();
}
inline bool operator>(const Gid &first, const Gid &second) {
return first.AsUint() > second.AsUint();
}
inline bool operator<=(const Gid &first, const Gid &second) {
return first.AsUint() <= second.AsUint();
}
inline bool operator>=(const Gid &first, const Gid &second) {
return first.AsUint() >= second.AsUint();
}
} // namespace storage

53
src/storage/v2/id_types.hpp Normal file
View File

@ -0,0 +1,53 @@
#pragma once
#include <type_traits>
#include "utils/cast.hpp"
namespace storage {
#define STORAGE_DEFINE_ID_TYPE(name) \
class name final { \
private: \
explicit name(uint64_t id) : id_(id) {} \
\
public: \
static name FromUint(uint64_t id) { return name{id}; } \
static name FromInt(int64_t id) { \
return name{utils::MemcpyCast<uint64_t>(id)}; \
} \
uint64_t AsUint() const { return id_; } \
int64_t AsInt() const { return utils::MemcpyCast<int64_t>(id_); } \
\
private: \
uint64_t id_; \
}; \
static_assert(std::is_trivially_copyable<name>::value, \
"storage::" #name " must be trivially copyable!"); \
inline bool operator==(const name &first, const name &second) { \
return first.AsUint() == second.AsUint(); \
} \
inline bool operator!=(const name &first, const name &second) { \
return first.AsUint() != second.AsUint(); \
} \
inline bool operator<(const name &first, const name &second) { \
return first.AsUint() < second.AsUint(); \
} \
inline bool operator>(const name &first, const name &second) { \
return first.AsUint() > second.AsUint(); \
} \
inline bool operator<=(const name &first, const name &second) { \
return first.AsUint() <= second.AsUint(); \
} \
inline bool operator>=(const name &first, const name &second) { \
return first.AsUint() >= second.AsUint(); \
}
STORAGE_DEFINE_ID_TYPE(Gid);
STORAGE_DEFINE_ID_TYPE(LabelId);
STORAGE_DEFINE_ID_TYPE(PropertyId);
STORAGE_DEFINE_ID_TYPE(EdgeTypeId);
#undef STORAGE_DEFINE_ID_TYPE
} // namespace storage

45
src/storage/v2/storage.cpp
View File

@ -91,8 +91,8 @@ Result<bool> Storage::Accessor::DetachDeleteVertex(VertexAccessor *vertex) {
"accessor when deleting a vertex!"; "accessor when deleting a vertex!";
auto vertex_ptr = vertex->vertex_; auto vertex_ptr = vertex->vertex_;
std::vector<std::tuple<uint64_t, Vertex *, Edge *>> in_edges; std::vector<std::tuple<EdgeTypeId, Vertex *, Edge *>> in_edges;
std::vector<std::tuple<uint64_t, Vertex *, Edge *>> out_edges; std::vector<std::tuple<EdgeTypeId, Vertex *, Edge *>> out_edges;
{ {
std::lock_guard<utils::SpinLock> guard(vertex_ptr->lock); std::lock_guard<utils::SpinLock> guard(vertex_ptr->lock);
@ -146,7 +146,7 @@ Result<bool> Storage::Accessor::DetachDeleteVertex(VertexAccessor *vertex) {
Result<EdgeAccessor> Storage::Accessor::CreateEdge(VertexAccessor *from, Result<EdgeAccessor> Storage::Accessor::CreateEdge(VertexAccessor *from,
VertexAccessor *to, VertexAccessor *to,
uint64_t edge_type) { EdgeTypeId edge_type) {
CHECK(from->transaction_ == to->transaction_) CHECK(from->transaction_ == to->transaction_)
<< "VertexAccessors must be from the same transaction when creating " << "VertexAccessors must be from the same transaction when creating "
"an edge!"; "an edge!";
@ -251,7 +251,8 @@ Result<bool> Storage::Accessor::DeleteEdge(EdgeAccessor *edge) {
CreateAndLinkDelta(&transaction_, from_vertex, Delta::AddOutEdgeTag(), CreateAndLinkDelta(&transaction_, from_vertex, Delta::AddOutEdgeTag(),
edge_type, to_vertex, edge_ptr); edge_type, to_vertex, edge_ptr);
{ {
std::tuple<uint64_t, Vertex *, Edge *> link{edge_type, to_vertex, edge_ptr}; std::tuple<EdgeTypeId, Vertex *, Edge *> link{edge_type, to_vertex,
edge_ptr};
auto it = std::find(from_vertex->out_edges.begin(), auto it = std::find(from_vertex->out_edges.begin(),
from_vertex->out_edges.end(), link); from_vertex->out_edges.end(), link);
CHECK(it != from_vertex->out_edges.end()) << "Invalid database state!"; CHECK(it != from_vertex->out_edges.end()) << "Invalid database state!";
@ -262,8 +263,8 @@ Result<bool> Storage::Accessor::DeleteEdge(EdgeAccessor *edge) {
CreateAndLinkDelta(&transaction_, to_vertex, Delta::AddInEdgeTag(), edge_type, CreateAndLinkDelta(&transaction_, to_vertex, Delta::AddInEdgeTag(), edge_type,
from_vertex, edge_ptr); from_vertex, edge_ptr);
{ {
std::tuple<uint64_t, Vertex *, Edge *> link{edge_type, from_vertex, std::tuple<EdgeTypeId, Vertex *, Edge *> link{edge_type, from_vertex,
edge_ptr}; edge_ptr};
auto it = auto it =
std::find(to_vertex->in_edges.begin(), to_vertex->in_edges.end(), link); std::find(to_vertex->in_edges.begin(), to_vertex->in_edges.end(), link);
CHECK(it != to_vertex->in_edges.end()) << "Invalid database state!"; CHECK(it != to_vertex->in_edges.end()) << "Invalid database state!";
@ -274,24 +275,24 @@ Result<bool> Storage::Accessor::DeleteEdge(EdgeAccessor *edge) {
return Result<bool>{true}; return Result<bool>{true};
} }
const std::string &Storage::Accessor::LabelToName(uint64_t label) { const std::string &Storage::Accessor::LabelToName(LabelId label) {
return storage_->name_id_mapper_.IdToName(label); return storage_->name_id_mapper_.IdToName(label.AsUint());
} }
const std::string &Storage::Accessor::PropertyToName(uint64_t property) { const std::string &Storage::Accessor::PropertyToName(PropertyId property) {
return storage_->name_id_mapper_.IdToName(property); return storage_->name_id_mapper_.IdToName(property.AsUint());
} }
const std::string &Storage::Accessor::EdgeTypeToName(uint64_t edge_type) { const std::string &Storage::Accessor::EdgeTypeToName(EdgeTypeId edge_type) {
return storage_->name_id_mapper_.IdToName(edge_type); return storage_->name_id_mapper_.IdToName(edge_type.AsUint());
} }
uint64_t Storage::Accessor::NameToLabel(const std::string &name) { LabelId Storage::Accessor::NameToLabel(const std::string &name) {
return storage_->name_id_mapper_.NameToId(name); return LabelId::FromUint(storage_->name_id_mapper_.NameToId(name));
} }
uint64_t Storage::Accessor::NameToProperty(const std::string &name) { PropertyId Storage::Accessor::NameToProperty(const std::string &name) {
return storage_->name_id_mapper_.NameToId(name); return PropertyId::FromUint(storage_->name_id_mapper_.NameToId(name));
} }
uint64_t Storage::Accessor::NameToEdgeType(const std::string &name) { EdgeTypeId Storage::Accessor::NameToEdgeType(const std::string &name) {
return storage_->name_id_mapper_.NameToId(name); return EdgeTypeId::FromUint(storage_->name_id_mapper_.NameToId(name));
} }
void Storage::Accessor::AdvanceCommand() { ++transaction_.command_id; } void Storage::Accessor::AdvanceCommand() { ++transaction_.command_id; }
@ -392,7 +393,7 @@ void Storage::Accessor::Abort() {
break; break;
} }
case Delta::Action::ADD_IN_EDGE: { case Delta::Action::ADD_IN_EDGE: {
std::tuple<uint64_t, Vertex *, Edge *> link{ std::tuple<EdgeTypeId, Vertex *, Edge *> link{
current->vertex_edge.edge_type, current->vertex_edge.vertex, current->vertex_edge.edge_type, current->vertex_edge.vertex,
current->vertex_edge.edge}; current->vertex_edge.edge};
auto it = std::find(vertex->in_edges.begin(), auto it = std::find(vertex->in_edges.begin(),
@ -402,7 +403,7 @@ void Storage::Accessor::Abort() {
break; break;
} }
case Delta::Action::ADD_OUT_EDGE: { case Delta::Action::ADD_OUT_EDGE: {
std::tuple<uint64_t, Vertex *, Edge *> link{ std::tuple<EdgeTypeId, Vertex *, Edge *> link{
current->vertex_edge.edge_type, current->vertex_edge.vertex, current->vertex_edge.edge_type, current->vertex_edge.vertex,
current->vertex_edge.edge}; current->vertex_edge.edge};
auto it = std::find(vertex->out_edges.begin(), auto it = std::find(vertex->out_edges.begin(),
@ -412,7 +413,7 @@ void Storage::Accessor::Abort() {
break; break;
} }
case Delta::Action::REMOVE_IN_EDGE: { case Delta::Action::REMOVE_IN_EDGE: {
std::tuple<uint64_t, Vertex *, Edge *> link{ std::tuple<EdgeTypeId, Vertex *, Edge *> link{
current->vertex_edge.edge_type, current->vertex_edge.vertex, current->vertex_edge.edge_type, current->vertex_edge.vertex,
current->vertex_edge.edge}; current->vertex_edge.edge};
auto it = std::find(vertex->in_edges.begin(), auto it = std::find(vertex->in_edges.begin(),
@ -423,7 +424,7 @@ void Storage::Accessor::Abort() {
break; break;
} }
case Delta::Action::REMOVE_OUT_EDGE: { case Delta::Action::REMOVE_OUT_EDGE: {
std::tuple<uint64_t, Vertex *, Edge *> link{ std::tuple<EdgeTypeId, Vertex *, Edge *> link{
current->vertex_edge.edge_type, current->vertex_edge.vertex, current->vertex_edge.edge_type, current->vertex_edge.vertex,
current->vertex_edge.edge}; current->vertex_edge.edge};
auto it = std::find(vertex->out_edges.begin(), auto it = std::find(vertex->out_edges.begin(),

14
src/storage/v2/storage.hpp
View File

@ -76,17 +76,17 @@ class Storage final {
Result<bool> DetachDeleteVertex(VertexAccessor *vertex); Result<bool> DetachDeleteVertex(VertexAccessor *vertex);
Result<EdgeAccessor> CreateEdge(VertexAccessor *from, VertexAccessor *to, Result<EdgeAccessor> CreateEdge(VertexAccessor *from, VertexAccessor *to,
uint64_t edge_type); EdgeTypeId edge_type);
Result<bool> DeleteEdge(EdgeAccessor *edge); Result<bool> DeleteEdge(EdgeAccessor *edge);
const std::string &LabelToName(uint64_t label); const std::string &LabelToName(LabelId label);
const std::string &PropertyToName(uint64_t property); const std::string &PropertyToName(PropertyId property);
const std::string &EdgeTypeToName(uint64_t edge_type); const std::string &EdgeTypeToName(EdgeTypeId edge_type);
uint64_t NameToLabel(const std::string &name); LabelId NameToLabel(const std::string &name);
uint64_t NameToProperty(const std::string &name); PropertyId NameToProperty(const std::string &name);
uint64_t NameToEdgeType(const std::string &name); EdgeTypeId NameToEdgeType(const std::string &name);
void AdvanceCommand(); void AdvanceCommand();

10
src/storage/v2/vertex.hpp
View File

@ -9,7 +9,7 @@
#include "storage/v2/delta.hpp" #include "storage/v2/delta.hpp"
#include "storage/v2/edge.hpp" #include "storage/v2/edge.hpp"
#include "storage/v2/gid.hpp" #include "storage/v2/id_types.hpp"
namespace storage { namespace storage {
@ -21,11 +21,11 @@ struct Vertex {
Gid gid; Gid gid;
std::vector<uint64_t> labels; std::vector<LabelId> labels;
std::map<uint64_t, storage::PropertyValue> properties; std::map<PropertyId, storage::PropertyValue> properties;
std::vector<std::tuple<uint64_t, Vertex *, Edge *>> in_edges; std::vector<std::tuple<EdgeTypeId, Vertex *, Edge *>> in_edges;
std::vector<std::tuple<uint64_t, Vertex *, Edge *>> out_edges; std::vector<std::tuple<EdgeTypeId, Vertex *, Edge *>> out_edges;
utils::SpinLock lock; utils::SpinLock lock;
bool deleted; bool deleted;

46
src/storage/v2/vertex_accessor.cpp
View File

@ -42,7 +42,7 @@ std::optional<VertexAccessor> VertexAccessor::Create(Vertex *vertex,
return VertexAccessor{vertex, transaction}; return VertexAccessor{vertex, transaction};
} }
Result<bool> VertexAccessor::AddLabel(uint64_t label) { Result<bool> VertexAccessor::AddLabel(LabelId label) {
std::lock_guard<utils::SpinLock> guard(vertex_->lock); std::lock_guard<utils::SpinLock> guard(vertex_->lock);
if (!PrepareForWrite(transaction_, vertex_)) if (!PrepareForWrite(transaction_, vertex_))
@ -60,7 +60,7 @@ Result<bool> VertexAccessor::AddLabel(uint64_t label) {
return Result<bool>{true}; return Result<bool>{true};
} }
Result<bool> VertexAccessor::RemoveLabel(uint64_t label) { Result<bool> VertexAccessor::RemoveLabel(LabelId label) {
std::lock_guard<utils::SpinLock> guard(vertex_->lock); std::lock_guard<utils::SpinLock> guard(vertex_->lock);
if (!PrepareForWrite(transaction_, vertex_)) if (!PrepareForWrite(transaction_, vertex_))
@ -78,7 +78,7 @@ Result<bool> VertexAccessor::RemoveLabel(uint64_t label) {
return Result<bool>{true}; return Result<bool>{true};
} }
Result<bool> VertexAccessor::HasLabel(uint64_t label, View view) { Result<bool> VertexAccessor::HasLabel(LabelId label, View view) {
bool deleted = false; bool deleted = false;
bool has_label = false; bool has_label = false;
Delta *delta = nullptr; Delta *delta = nullptr;
@ -126,9 +126,9 @@ Result<bool> VertexAccessor::HasLabel(uint64_t label, View view) {
return Result<bool>{has_label}; return Result<bool>{has_label};
} }
Result<std::vector<uint64_t>> VertexAccessor::Labels(View view) { Result<std::vector<LabelId>> VertexAccessor::Labels(View view) {
bool deleted = false; bool deleted = false;
std::vector<uint64_t> labels; std::vector<LabelId> labels;
Delta *delta = nullptr; Delta *delta = nullptr;
{ {
std::lock_guard<utils::SpinLock> guard(vertex_->lock); std::lock_guard<utils::SpinLock> guard(vertex_->lock);
@ -170,11 +170,11 @@ Result<std::vector<uint64_t>> VertexAccessor::Labels(View view) {
break; break;
} }
}); });
if (deleted) return Result<std::vector<uint64_t>>{Error::DELETED_OBJECT}; if (deleted) return Result<std::vector<LabelId>>{Error::DELETED_OBJECT};
return Result<std::vector<uint64_t>>{std::move(labels)}; return Result<std::vector<LabelId>>{std::move(labels)};
} }
Result<bool> VertexAccessor::SetProperty(uint64_t property, Result<bool> VertexAccessor::SetProperty(PropertyId property,
const PropertyValue &value) { const PropertyValue &value) {
std::lock_guard<utils::SpinLock> guard(vertex_->lock); std::lock_guard<utils::SpinLock> guard(vertex_->lock);
@ -206,7 +206,7 @@ Result<bool> VertexAccessor::SetProperty(uint64_t property,
return Result<bool>{existed}; return Result<bool>{existed};
} }
Result<PropertyValue> VertexAccessor::GetProperty(uint64_t property, Result<PropertyValue> VertexAccessor::GetProperty(PropertyId property,
View view) { View view) {
bool deleted = false; bool deleted = false;
PropertyValue value; PropertyValue value;
@ -250,9 +250,9 @@ Result<PropertyValue> VertexAccessor::GetProperty(uint64_t property,
return Result<PropertyValue>{std::move(value)}; return Result<PropertyValue>{std::move(value)};
} }
Result<std::map<uint64_t, PropertyValue>> VertexAccessor::Properties( Result<std::map<PropertyId, PropertyValue>> VertexAccessor::Properties(
View view) { View view) {
std::map<uint64_t, PropertyValue> properties; std::map<PropertyId, PropertyValue> properties;
bool deleted = false; bool deleted = false;
Delta *delta = nullptr; Delta *delta = nullptr;
{ {
@ -297,14 +297,14 @@ Result<std::map<uint64_t, PropertyValue>> VertexAccessor::Properties(
} }
}); });
if (deleted) { if (deleted) {
return Result<std::map<uint64_t, PropertyValue>>{Error::DELETED_OBJECT}; return Result<std::map<PropertyId, PropertyValue>>{Error::DELETED_OBJECT};
} }
return Result<std::map<uint64_t, PropertyValue>>{std::move(properties)}; return Result<std::map<PropertyId, PropertyValue>>{std::move(properties)};
} }
Result<std::vector<EdgeAccessor>> Result<std::vector<EdgeAccessor>> VertexAccessor::InEdges(
VertexAccessor::InEdges(const std::vector<uint64_t> &edge_types, View view) { const std::vector<EdgeTypeId> &edge_types, View view) {
std::vector<std::tuple<uint64_t, Vertex *, Edge *>> in_edges; std::vector<std::tuple<EdgeTypeId, Vertex *, Edge *>> in_edges;
bool deleted = false; bool deleted = false;
Delta *delta = nullptr; Delta *delta = nullptr;
{ {
@ -318,7 +318,7 @@ VertexAccessor::InEdges(const std::vector<uint64_t> &edge_types, View view) {
switch (delta.action) { switch (delta.action) {
case Delta::Action::ADD_IN_EDGE: { case Delta::Action::ADD_IN_EDGE: {
// Add the edge because we don't see the removal. // Add the edge because we don't see the removal.
std::tuple<uint64_t, Vertex *, Edge *> link{ std::tuple<EdgeTypeId, Vertex *, Edge *> link{
delta.vertex_edge.edge_type, delta.vertex_edge.vertex, delta.vertex_edge.edge_type, delta.vertex_edge.vertex,
delta.vertex_edge.edge}; delta.vertex_edge.edge};
auto it = std::find(in_edges.begin(), in_edges.end(), link); auto it = std::find(in_edges.begin(), in_edges.end(), link);
@ -328,7 +328,7 @@ VertexAccessor::InEdges(const std::vector<uint64_t> &edge_types, View view) {
} }
case Delta::Action::REMOVE_IN_EDGE: { case Delta::Action::REMOVE_IN_EDGE: {
// Remove the label because we don't see the addition. // Remove the label because we don't see the addition.
std::tuple<uint64_t, Vertex *, Edge *> link{ std::tuple<EdgeTypeId, Vertex *, Edge *> link{
delta.vertex_edge.edge_type, delta.vertex_edge.vertex, delta.vertex_edge.edge_type, delta.vertex_edge.vertex,
delta.vertex_edge.edge}; delta.vertex_edge.edge};
auto it = std::find(in_edges.begin(), in_edges.end(), link); auto it = std::find(in_edges.begin(), in_edges.end(), link);
@ -368,9 +368,9 @@ VertexAccessor::InEdges(const std::vector<uint64_t> &edge_types, View view) {
return Result<decltype(ret)>(std::move(ret)); return Result<decltype(ret)>(std::move(ret));
} }
Result<std::vector<EdgeAccessor>> Result<std::vector<EdgeAccessor>> VertexAccessor::OutEdges(
VertexAccessor::OutEdges(const std::vector<uint64_t> &edge_types, View view) { const std::vector<EdgeTypeId> &edge_types, View view) {
std::vector<std::tuple<uint64_t, Vertex *, Edge *>> out_edges; std::vector<std::tuple<EdgeTypeId, Vertex *, Edge *>> out_edges;
bool deleted = false; bool deleted = false;
Delta *delta = nullptr; Delta *delta = nullptr;
{ {
@ -384,7 +384,7 @@ VertexAccessor::OutEdges(const std::vector<uint64_t> &edge_types, View view) {
switch (delta.action) { switch (delta.action) {
case Delta::Action::ADD_OUT_EDGE: { case Delta::Action::ADD_OUT_EDGE: {
// Add the edge because we don't see the removal. // Add the edge because we don't see the removal.
std::tuple<uint64_t, Vertex *, Edge *> link{ std::tuple<EdgeTypeId, Vertex *, Edge *> link{
delta.vertex_edge.edge_type, delta.vertex_edge.vertex, delta.vertex_edge.edge_type, delta.vertex_edge.vertex,
delta.vertex_edge.edge}; delta.vertex_edge.edge};
auto it = std::find(out_edges.begin(), out_edges.end(), link); auto it = std::find(out_edges.begin(), out_edges.end(), link);
@ -394,7 +394,7 @@ VertexAccessor::OutEdges(const std::vector<uint64_t> &edge_types, View view) {
} }
case Delta::Action::REMOVE_OUT_EDGE: { case Delta::Action::REMOVE_OUT_EDGE: {
// Remove the label because we don't see the addition. // Remove the label because we don't see the addition.
std::tuple<uint64_t, Vertex *, Edge *> link{ std::tuple<EdgeTypeId, Vertex *, Edge *> link{
delta.vertex_edge.edge_type, delta.vertex_edge.vertex, delta.vertex_edge.edge_type, delta.vertex_edge.vertex,
delta.vertex_edge.edge}; delta.vertex_edge.edge};
auto it = std::find(out_edges.begin(), out_edges.end(), link); auto it = std::find(out_edges.begin(), out_edges.end(), link);

22
src/storage/v2/vertex_accessor.hpp
View File

@ -25,25 +25,25 @@ class VertexAccessor final {
Transaction *transaction, Transaction *transaction,
View view); View view);
Result<bool> AddLabel(uint64_t label); Result<bool> AddLabel(LabelId label);
Result<bool> RemoveLabel(uint64_t label); Result<bool> RemoveLabel(LabelId label);
Result<bool> HasLabel(uint64_t label, View view); Result<bool> HasLabel(LabelId label, View view);
Result<std::vector<uint64_t>> Labels(View view); Result<std::vector<LabelId>> Labels(View view);
Result<bool> SetProperty(uint64_t property, const PropertyValue &value); Result<bool> SetProperty(PropertyId property, const PropertyValue &value);
Result<PropertyValue> GetProperty(uint64_t property, View view); Result<PropertyValue> GetProperty(PropertyId property, View view);
Result<std::map<uint64_t, PropertyValue>> Properties(View view); Result<std::map<PropertyId, PropertyValue>> Properties(View view);
Result<std::vector<EdgeAccessor>> Result<std::vector<EdgeAccessor>> InEdges(
InEdges(const std::vector<uint64_t> &edge_types, View view); const std::vector<EdgeTypeId> &edge_types, View view);
Result<std::vector<EdgeAccessor>> Result<std::vector<EdgeAccessor>> OutEdges(
OutEdges(const std::vector<uint64_t> &edge_types, View view); const std::vector<EdgeTypeId> &edge_types, View view);
Gid Gid() const { return vertex_->gid; } Gid Gid() const { return vertex_->gid; }

3
tests/benchmark/storage_v2_gc.cpp
View File

@ -44,7 +44,8 @@ void UpdateLabelFunc(int thread_id, storage::Storage *storage,
acc.FindVertex(gid, storage::View::OLD); acc.FindVertex(gid, storage::View::OLD);
CHECK(vertex.has_value()) CHECK(vertex.has_value())
<< "Vertex with GID " << gid.AsUint() << " doesn't exist"; << "Vertex with GID " << gid.AsUint() << " doesn't exist";
if (vertex->AddLabel(label_dist(gen)).HasValue()) { if (vertex->AddLabel(storage::LabelId::FromUint(label_dist(gen)))
.HasValue()) {
acc.Commit(); acc.Commit();
} else { } else {
acc.Abort(); acc.Abort();

732
tests/unit/storage_v2.cpp
View File

File diff suppressed because it is too large Load Diff

1435
tests/unit/storage_v2_edge.cpp
View File

File diff suppressed because it is too large Load Diff

30
tests/unit/storage_v2_gc.cpp
View File

@ -57,9 +57,12 @@ TEST(StorageV2Gc, Sanity) {
EXPECT_EQ(vertex.has_value(), i % 5 != 0); EXPECT_EQ(vertex.has_value(), i % 5 != 0);
if (vertex.has_value()) { if (vertex.has_value()) {
EXPECT_FALSE(vertex->AddLabel(3 * i).HasError()); EXPECT_FALSE(
EXPECT_FALSE(vertex->AddLabel(3 * i + 1).HasError()); vertex->AddLabel(storage::LabelId::FromUint(3 * i)).HasError());
EXPECT_FALSE(vertex->AddLabel(3 * i + 2).HasError()); EXPECT_FALSE(
vertex->AddLabel(storage::LabelId::FromUint(3 * i + 1)).HasError());
EXPECT_FALSE(
vertex->AddLabel(storage::LabelId::FromUint(3 * i + 2)).HasError());
} }
} }
@ -78,8 +81,11 @@ TEST(StorageV2Gc, Sanity) {
auto labels_new = vertex->Labels(storage::View::NEW); auto labels_new = vertex->Labels(storage::View::NEW);
EXPECT_TRUE(labels_new.HasValue()); EXPECT_TRUE(labels_new.HasValue());
EXPECT_THAT(labels_new.GetValue(), EXPECT_THAT(
UnorderedElementsAre(3 * i, 3 * i + 1, 3 * i + 2)); labels_new.GetValue(),
UnorderedElementsAre(storage::LabelId::FromUint(3 * i),
storage::LabelId::FromUint(3 * i + 1),
storage::LabelId::FromUint(3 * i + 2)));
} }
} }
@ -97,7 +103,8 @@ TEST(StorageV2Gc, Sanity) {
EXPECT_EQ(to_vertex.has_value(), (i + 1) % 5 != 0); EXPECT_EQ(to_vertex.has_value(), (i + 1) % 5 != 0);
if (from_vertex.has_value() && to_vertex.has_value()) { if (from_vertex.has_value() && to_vertex.has_value()) {
EXPECT_FALSE(acc.CreateEdge(&from_vertex.value(), &to_vertex.value(), i) EXPECT_FALSE(acc.CreateEdge(&from_vertex.value(), &to_vertex.value(),
storage::EdgeTypeId::FromUint(i))
.HasError()); .HasError());
} }
} }
@ -121,20 +128,19 @@ TEST(StorageV2Gc, Sanity) {
auto vertex = acc.FindVertex(vertices[i], storage::View::NEW); auto vertex = acc.FindVertex(vertices[i], storage::View::NEW);
EXPECT_EQ(vertex.has_value(), i % 5 != 0 && i % 3 != 0); EXPECT_EQ(vertex.has_value(), i % 5 != 0 && i % 3 != 0);
if (vertex.has_value()) { if (vertex.has_value()) {
auto out_edges = auto out_edges = vertex->OutEdges({}, storage::View::NEW);
vertex->OutEdges(std::vector<uint64_t>{}, storage::View::NEW);
if (i % 5 != 4 && i % 3 != 2) { if (i % 5 != 4 && i % 3 != 2) {
EXPECT_EQ(out_edges.GetValue().size(), 1); EXPECT_EQ(out_edges.GetValue().size(), 1);
EXPECT_EQ(out_edges.GetValue().at(0).EdgeType(), i); EXPECT_EQ(out_edges.GetValue().at(0).EdgeType().AsUint(), i);
} else { } else {
EXPECT_TRUE(out_edges->empty()); EXPECT_TRUE(out_edges->empty());
} }
auto in_edges = auto in_edges = vertex->InEdges({}, storage::View::NEW);
vertex->InEdges(std::vector<uint64_t>{}, storage::View::NEW);
if (i % 5 != 1 && i % 3 != 1) { if (i % 5 != 1 && i % 3 != 1) {
EXPECT_EQ(in_edges.GetValue().size(), 1); EXPECT_EQ(in_edges.GetValue().size(), 1);
EXPECT_EQ(in_edges.GetValue().at(0).EdgeType(), (i + 999) % 1000); EXPECT_EQ(in_edges.GetValue().at(0).EdgeType().AsUint(),
(i + 999) % 1000);
} else { } else {
EXPECT_TRUE(in_edges->empty()); EXPECT_TRUE(in_edges->empty());
} }