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

Adapt storage to new erro handling

Browse Source
This commit is contained in:
jbajic 2022-11-15 18:25:12 +01:00
parent 3d66bbd988
commit 9c05910e68
10 changed files with 170 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/storage/v3/bindings/db_accessor.hpp
View File

@ -78,8 +78,8 @@ class DbAccessor final {
return VerticesIterable(accessor_->Vertices(label, property, lower, upper, view)); return VerticesIterable(accessor_->Vertices(label, property, lower, upper, view));
} }
storage::v3::Result<EdgeAccessor> InsertEdge(VertexAccessor *from, VertexAccessor *to, storage::v3::ShardResult<EdgeAccessor> InsertEdge(VertexAccessor *from, VertexAccessor *to,
const storage::v3::EdgeTypeId &edge_type) { const storage::v3::EdgeTypeId &edge_type) {
static constexpr auto kDummyGid = storage::v3::Gid::FromUint(0); static constexpr auto kDummyGid = storage::v3::Gid::FromUint(0);
auto maybe_edge = accessor_->CreateEdge(from->Id(storage::v3::View::NEW).GetValue(), auto maybe_edge = accessor_->CreateEdge(from->Id(storage::v3::View::NEW).GetValue(),
to->Id(storage::v3::View::NEW).GetValue(), edge_type, kDummyGid); to->Id(storage::v3::View::NEW).GetValue(), edge_type, kDummyGid);
@ -87,7 +87,7 @@ class DbAccessor final {
return EdgeAccessor(*maybe_edge); return EdgeAccessor(*maybe_edge);
} }
storage::v3::Result<std::optional<EdgeAccessor>> RemoveEdge(EdgeAccessor *edge) { storage::v3::ShardResult<std::optional<EdgeAccessor>> RemoveEdge(EdgeAccessor *edge) {
auto res = accessor_->DeleteEdge(edge->FromVertex(), edge->ToVertex(), edge->Gid()); auto res = accessor_->DeleteEdge(edge->FromVertex(), edge->ToVertex(), edge->Gid());
if (res.HasError()) { if (res.HasError()) {
return res.GetError(); return res.GetError();
@ -101,7 +101,7 @@ class DbAccessor final {
return std::make_optional<EdgeAccessor>(*value); return std::make_optional<EdgeAccessor>(*value);
} }
storage::v3::Result<std::optional<std::pair<VertexAccessor, std::vector<EdgeAccessor>>>> DetachRemoveVertex( storage::v3::ShardResult<std::optional<std::pair<VertexAccessor, std::vector<EdgeAccessor>>>> DetachRemoveVertex(
VertexAccessor *vertex_accessor) { VertexAccessor *vertex_accessor) {
using ReturnType = std::pair<VertexAccessor, std::vector<EdgeAccessor>>; using ReturnType = std::pair<VertexAccessor, std::vector<EdgeAccessor>>;
@ -125,7 +125,7 @@ class DbAccessor final {
return std::make_optional<ReturnType>(vertex, std::move(deleted_edges)); return std::make_optional<ReturnType>(vertex, std::move(deleted_edges));
} }
storage::v3::Result<std::optional<VertexAccessor>> RemoveVertex(VertexAccessor *vertex_accessor) { storage::v3::ShardResult<std::optional<VertexAccessor>> RemoveVertex(VertexAccessor *vertex_accessor) {
auto res = accessor_->DeleteVertex(vertex_accessor); auto res = accessor_->DeleteVertex(vertex_accessor);
if (res.HasError()) { if (res.HasError()) {
return res.GetError(); return res.GetError();

31
src/storage/v3/edge_accessor.cpp
View File

@ -15,6 +15,7 @@
#include "storage/v3/mvcc.hpp" #include "storage/v3/mvcc.hpp"
#include "storage/v3/property_value.hpp" #include "storage/v3/property_value.hpp"
#include "storage/v3/result.hpp"
#include "storage/v3/schema_validator.hpp" #include "storage/v3/schema_validator.hpp"
#include "storage/v3/vertex_accessor.hpp" #include "storage/v3/vertex_accessor.hpp"
#include "utils/memory_tracker.hpp" #include "utils/memory_tracker.hpp"
@ -54,13 +55,13 @@ const VertexId &EdgeAccessor::FromVertex() const { return from_vertex_; }
const VertexId &EdgeAccessor::ToVertex() const { return to_vertex_; } const VertexId &EdgeAccessor::ToVertex() const { return to_vertex_; }
Result<PropertyValue> EdgeAccessor::SetProperty(PropertyId property, const PropertyValue &value) { ShardResult<PropertyValue> EdgeAccessor::SetProperty(PropertyId property, const PropertyValue &value) {
utils::MemoryTracker::OutOfMemoryExceptionEnabler oom_exception; utils::MemoryTracker::OutOfMemoryExceptionEnabler oom_exception;
if (!config_.properties_on_edges) return Error::PROPERTIES_DISABLED; if (!config_.properties_on_edges) return SHARD_ERROR(ErrorCode::PROPERTIES_DISABLED);
if (!PrepareForWrite(transaction_, edge_.ptr)) return Error::SERIALIZATION_ERROR; if (!PrepareForWrite(transaction_, edge_.ptr)) return SHARD_ERROR(ErrorCode::SERIALIZATION_ERROR);
if (edge_.ptr->deleted) return Error::DELETED_OBJECT; if (edge_.ptr->deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
auto current_value = edge_.ptr->properties.GetProperty(property); auto current_value = edge_.ptr->properties.GetProperty(property);
// We could skip setting the value if the previous one is the same to the new // We could skip setting the value if the previous one is the same to the new
@ -75,12 +76,12 @@ Result<PropertyValue> EdgeAccessor::SetProperty(PropertyId property, const Prope
return std::move(current_value); return std::move(current_value);
} }
Result<std::map<PropertyId, PropertyValue>> EdgeAccessor::ClearProperties() { ShardResult<std::map<PropertyId, PropertyValue>> EdgeAccessor::ClearProperties() {
if (!config_.properties_on_edges) return Error::PROPERTIES_DISABLED; if (!config_.properties_on_edges) return SHARD_ERROR(ErrorCode::PROPERTIES_DISABLED);
if (!PrepareForWrite(transaction_, edge_.ptr)) return Error::SERIALIZATION_ERROR; if (!PrepareForWrite(transaction_, edge_.ptr)) return SHARD_ERROR(ErrorCode::SERIALIZATION_ERROR);
if (edge_.ptr->deleted) return Error::DELETED_OBJECT; if (edge_.ptr->deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
auto properties = edge_.ptr->properties.Properties(); auto properties = edge_.ptr->properties.Properties();
for (const auto &property : properties) { for (const auto &property : properties) {
@ -92,11 +93,11 @@ Result<std::map<PropertyId, PropertyValue>> EdgeAccessor::ClearProperties() {
return std::move(properties); return std::move(properties);
} }
Result<PropertyValue> EdgeAccessor::GetProperty(View view, PropertyId property) const { ShardResult<PropertyValue> EdgeAccessor::GetProperty(View view, PropertyId property) const {
return GetProperty(property, view); return GetProperty(property, view);
} }
Result<PropertyValue> EdgeAccessor::GetProperty(PropertyId property, View view) const { ShardResult<PropertyValue> EdgeAccessor::GetProperty(PropertyId property, View view) const {
if (!config_.properties_on_edges) return PropertyValue(); if (!config_.properties_on_edges) return PropertyValue();
auto exists = true; auto exists = true;
auto deleted = edge_.ptr->deleted; auto deleted = edge_.ptr->deleted;
@ -128,12 +129,12 @@ Result<PropertyValue> EdgeAccessor::GetProperty(PropertyId property, View view)
break; break;
} }
}); });
if (!exists) return Error::NONEXISTENT_OBJECT; if (!exists) return SHARD_ERROR(ErrorCode::NONEXISTENT_OBJECT);
if (!for_deleted_ && deleted) return Error::DELETED_OBJECT; if (!for_deleted_ && deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
return std::move(value); return std::move(value);
} }
Result<std::map<PropertyId, PropertyValue>> EdgeAccessor::Properties(View view) const { ShardResult<std::map<PropertyId, PropertyValue>> EdgeAccessor::Properties(View view) const {
if (!config_.properties_on_edges) return std::map<PropertyId, PropertyValue>{}; if (!config_.properties_on_edges) return std::map<PropertyId, PropertyValue>{};
auto exists = true; auto exists = true;
auto deleted = edge_.ptr->deleted; auto deleted = edge_.ptr->deleted;
@ -174,8 +175,8 @@ Result<std::map<PropertyId, PropertyValue>> EdgeAccessor::Properties(View view)
break; break;
} }
}); });
if (!exists) return Error::NONEXISTENT_OBJECT; if (!exists) return SHARD_ERROR(ErrorCode::NONEXISTENT_OBJECT);
if (!for_deleted_ && deleted) return Error::DELETED_OBJECT; if (!for_deleted_ && deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
return std::move(properties); return std::move(properties);
} }

10
src/storage/v3/edge_accessor.hpp
View File

@ -56,19 +56,19 @@ class EdgeAccessor final {
/// Set a property value and return the old value. /// Set a property value and return the old value.
/// @throw std::bad_alloc /// @throw std::bad_alloc
Result<PropertyValue> SetProperty(PropertyId property, const PropertyValue &value); ShardResult<PropertyValue> SetProperty(PropertyId property, const PropertyValue &value);
/// Remove all properties and return old values for each removed property. /// Remove all properties and return old values for each removed property.
/// @throw std::bad_alloc /// @throw std::bad_alloc
Result<std::map<PropertyId, PropertyValue>> ClearProperties(); ShardResult<std::map<PropertyId, PropertyValue>> ClearProperties();
/// @throw std::bad_alloc /// @throw std::bad_alloc
Result<PropertyValue> GetProperty(PropertyId property, View view) const; ShardResult<PropertyValue> GetProperty(PropertyId property, View view) const;
Result<PropertyValue> GetProperty(View view, PropertyId property) const; ShardResult<PropertyValue> GetProperty(View view, PropertyId property) const;
/// @throw std::bad_alloc /// @throw std::bad_alloc
Result<std::map<PropertyId, PropertyValue>> Properties(View view) const; ShardResult<std::map<PropertyId, PropertyValue>> Properties(View view) const;
Gid Gid() const noexcept { Gid Gid() const noexcept {
if (config_.properties_on_edges) { if (config_.properties_on_edges) {

4
src/storage/v3/result.hpp
View File

@ -40,6 +40,8 @@ struct ShardError {
ShardError(ErrorCode code, std::string message, std::string source) ShardError(ErrorCode code, std::string message, std::string source)
: code{code}, message{std::move(message)}, source{std::move(source)} {} : code{code}, message{std::move(message)}, source{std::move(source)} {}
ShardError(ErrorCode code, std::string source) : code{code}, source{std::move(source)} {}
ErrorCode code; ErrorCode code;
// TODO Maybe add category // TODO Maybe add category
std::string message; std::string message;
@ -49,6 +51,6 @@ struct ShardError {
#define SHARD_ERROR(...) memgraph::storage::v3::ShardError(__VA_ARGS__, fmt::format("{}:{}", __FILE__, __LINE__)) #define SHARD_ERROR(...) memgraph::storage::v3::ShardError(__VA_ARGS__, fmt::format("{}:{}", __FILE__, __LINE__))
template <class TValue> template <class TValue>
using Result = utils::BasicResult<ShardError, TValue>; using ShardResult = utils::BasicResult<ShardError, TValue>;
} // namespace memgraph::storage::v3 } // namespace memgraph::storage::v3

2
src/storage/v3/schema_validator.cpp
View File

@ -94,7 +94,7 @@ std::optional<ShardError> SchemaValidator::ValidateLabelUpdate(const LabelId lab
return std::nullopt; return std::nullopt;
} }
const Schemas::Schema *SchemaValidator::GetSchema(LabelId label) const { return schemas_.GetSchema(label); } const Schemas::Schema *SchemaValidator::GetSchema(LabelId label) const { return schemas_->GetSchema(label); }
VertexValidator::VertexValidator(const SchemaValidator &schema_validator, const LabelId primary_label) VertexValidator::VertexValidator(const SchemaValidator &schema_validator, const LabelId primary_label)
: schema_validator{&schema_validator}, primary_label_{primary_label} {} : schema_validator{&schema_validator}, primary_label_{primary_label} {}

42
src/storage/v3/shard.cpp
View File

@ -33,8 +33,8 @@
#include "storage/v3/mvcc.hpp" #include "storage/v3/mvcc.hpp"
#include "storage/v3/name_id_mapper.hpp" #include "storage/v3/name_id_mapper.hpp"
#include "storage/v3/property_value.hpp" #include "storage/v3/property_value.hpp"
#include "storage/v3/result.hpp"
#include "storage/v3/schema_validator.hpp" #include "storage/v3/schema_validator.hpp"
#include "storage/v3/shard_operation_result.hpp"
#include "storage/v3/transaction.hpp" #include "storage/v3/transaction.hpp"
#include "storage/v3/vertex.hpp" #include "storage/v3/vertex.hpp"
#include "storage/v3/vertex_accessor.hpp" #include "storage/v3/vertex_accessor.hpp"
@ -345,7 +345,7 @@ Shard::~Shard() {}
Shard::Accessor::Accessor(Shard &shard, Transaction &transaction) Shard::Accessor::Accessor(Shard &shard, Transaction &transaction)
: shard_(&shard), transaction_(&transaction), config_(shard_->config_.items) {} : shard_(&shard), transaction_(&transaction), config_(shard_->config_.items) {}
ShardOperationResult<VertexAccessor> Shard::Accessor::CreateVertexAndValidate( ShardResult<VertexAccessor> Shard::Accessor::CreateVertexAndValidate(
const std::vector<LabelId> &labels, const std::vector<PropertyValue> &primary_properties, const std::vector<LabelId> &labels, const std::vector<PropertyValue> &primary_properties,
const std::vector<std::pair<PropertyId, PropertyValue>> &properties) { const std::vector<std::pair<PropertyId, PropertyValue>> &properties) {
OOMExceptionEnabler oom_exception; OOMExceptionEnabler oom_exception;
@ -364,7 +364,7 @@ ShardOperationResult<VertexAccessor> Shard::Accessor::CreateVertexAndValidate(
VertexAccessor vertex_acc{&it->vertex, transaction_, &shard_->indices_, config_, shard_->vertex_validator_}; VertexAccessor vertex_acc{&it->vertex, transaction_, &shard_->indices_, config_, shard_->vertex_validator_};
if (!inserted) { if (!inserted) {
return {Error::VERTEX_ALREADY_INSERTED}; return SHARD_ERROR(ErrorCode::VERTEX_ALREADY_INSERTED);
} }
MG_ASSERT(it != acc.end(), "Invalid Vertex accessor!"); MG_ASSERT(it != acc.end(), "Invalid Vertex accessor!");
@ -395,19 +395,19 @@ std::optional<VertexAccessor> Shard::Accessor::FindVertex(std::vector<PropertyVa
return VertexAccessor::Create(&it->vertex, transaction_, &shard_->indices_, config_, shard_->vertex_validator_, view); return VertexAccessor::Create(&it->vertex, transaction_, &shard_->indices_, config_, shard_->vertex_validator_, view);
} }
Result<std::optional<VertexAccessor>> Shard::Accessor::DeleteVertex(VertexAccessor *vertex) { ShardResult<std::optional<VertexAccessor>> Shard::Accessor::DeleteVertex(VertexAccessor *vertex) {
MG_ASSERT(vertex->transaction_ == transaction_, MG_ASSERT(vertex->transaction_ == transaction_,
"VertexAccessor must be from the same transaction as the storage " "VertexAccessor must be from the same transaction as the storage "
"accessor when deleting a vertex!"); "accessor when deleting a vertex!");
auto *vertex_ptr = vertex->vertex_; auto *vertex_ptr = vertex->vertex_;
if (!PrepareForWrite(transaction_, vertex_ptr)) return Error::SERIALIZATION_ERROR; if (!PrepareForWrite(transaction_, vertex_ptr)) return SHARD_ERROR(ErrorCode::SERIALIZATION_ERROR);
if (vertex_ptr->deleted) { if (vertex_ptr->deleted) {
return std::optional<VertexAccessor>{}; return std::optional<VertexAccessor>{};
} }
if (!vertex_ptr->in_edges.empty() || !vertex_ptr->out_edges.empty()) return Error::VERTEX_HAS_EDGES; if (!vertex_ptr->in_edges.empty() || !vertex_ptr->out_edges.empty()) return SHARD_ERROR(ErrorCode::VERTEX_HAS_EDGES);
CreateAndLinkDelta(transaction_, vertex_ptr, Delta::RecreateObjectTag()); CreateAndLinkDelta(transaction_, vertex_ptr, Delta::RecreateObjectTag());
vertex_ptr->deleted = true; vertex_ptr->deleted = true;
@ -416,7 +416,7 @@ Result<std::optional<VertexAccessor>> Shard::Accessor::DeleteVertex(VertexAccess
shard_->vertex_validator_, true); shard_->vertex_validator_, true);
} }
Result<std::optional<std::pair<VertexAccessor, std::vector<EdgeAccessor>>>> Shard::Accessor::DetachDeleteVertex( ShardResult<std::optional<std::pair<VertexAccessor, std::vector<EdgeAccessor>>>> Shard::Accessor::DetachDeleteVertex(
VertexAccessor *vertex) { VertexAccessor *vertex) {
using ReturnType = std::pair<VertexAccessor, std::vector<EdgeAccessor>>; using ReturnType = std::pair<VertexAccessor, std::vector<EdgeAccessor>>;
@ -429,7 +429,7 @@ Result<std::optional<std::pair<VertexAccessor, std::vector<EdgeAccessor>>>> Shar
std::vector<Vertex::EdgeLink> out_edges; std::vector<Vertex::EdgeLink> out_edges;
{ {
if (!PrepareForWrite(transaction_, vertex_ptr)) return Error::SERIALIZATION_ERROR; if (!PrepareForWrite(transaction_, vertex_ptr)) return SHARD_ERROR(ErrorCode::SERIALIZATION_ERROR);
if (vertex_ptr->deleted) return std::optional<ReturnType>{}; if (vertex_ptr->deleted) return std::optional<ReturnType>{};
@ -444,7 +444,7 @@ Result<std::optional<std::pair<VertexAccessor, std::vector<EdgeAccessor>>>> Shar
EdgeAccessor e(edge, edge_type, from_vertex, vertex_id, transaction_, &shard_->indices_, config_); EdgeAccessor e(edge, edge_type, from_vertex, vertex_id, transaction_, &shard_->indices_, config_);
auto ret = DeleteEdge(e.FromVertex(), e.ToVertex(), e.Gid()); auto ret = DeleteEdge(e.FromVertex(), e.ToVertex(), e.Gid());
if (ret.HasError()) { if (ret.HasError()) {
MG_ASSERT(ret.GetError() == Error::SERIALIZATION_ERROR, "Invalid database state!"); MG_ASSERT(ret.GetError().code == ErrorCode::SERIALIZATION_ERROR, "Invalid database state!");
return ret.GetError(); return ret.GetError();
} }
@ -457,7 +457,7 @@ Result<std::optional<std::pair<VertexAccessor, std::vector<EdgeAccessor>>>> Shar
EdgeAccessor e(edge, edge_type, vertex_id, to_vertex, transaction_, &shard_->indices_, config_); EdgeAccessor e(edge, edge_type, vertex_id, to_vertex, transaction_, &shard_->indices_, config_);
auto ret = DeleteEdge(e.FromVertex(), e.ToVertex(), e.Gid()); auto ret = DeleteEdge(e.FromVertex(), e.ToVertex(), e.Gid());
if (ret.HasError()) { if (ret.HasError()) {
MG_ASSERT(ret.GetError() == Error::SERIALIZATION_ERROR, "Invalid database state!"); MG_ASSERT(ret.GetError().code == ErrorCode::SERIALIZATION_ERROR, "Invalid database state!");
return ret.GetError(); return ret.GetError();
} }
@ -470,7 +470,7 @@ Result<std::optional<std::pair<VertexAccessor, std::vector<EdgeAccessor>>>> Shar
// vertex. Some other transaction could have modified the vertex in the // vertex. Some other transaction could have modified the vertex in the
// meantime if we didn't have any edges to delete. // meantime if we didn't have any edges to delete.
if (!PrepareForWrite(transaction_, vertex_ptr)) return Error::SERIALIZATION_ERROR; if (!PrepareForWrite(transaction_, vertex_ptr)) return SHARD_ERROR(ErrorCode::SERIALIZATION_ERROR);
MG_ASSERT(!vertex_ptr->deleted, "Invalid database state!"); MG_ASSERT(!vertex_ptr->deleted, "Invalid database state!");
@ -482,8 +482,8 @@ Result<std::optional<std::pair<VertexAccessor, std::vector<EdgeAccessor>>>> Shar
std::move(deleted_edges)); std::move(deleted_edges));
} }
Result<EdgeAccessor> Shard::Accessor::CreateEdge(VertexId from_vertex_id, VertexId to_vertex_id, ShardResult<EdgeAccessor> Shard::Accessor::CreateEdge(VertexId from_vertex_id, VertexId to_vertex_id,
const EdgeTypeId edge_type, const Gid gid) { const EdgeTypeId edge_type, const Gid gid) {
OOMExceptionEnabler oom_exception; OOMExceptionEnabler oom_exception;
Vertex *from_vertex{nullptr}; Vertex *from_vertex{nullptr};
Vertex *to_vertex{nullptr}; Vertex *to_vertex{nullptr};
@ -507,12 +507,12 @@ Result<EdgeAccessor> Shard::Accessor::CreateEdge(VertexId from_vertex_id, Vertex
} }
if (from_is_local) { if (from_is_local) {
if (!PrepareForWrite(transaction_, from_vertex)) return Error::SERIALIZATION_ERROR; if (!PrepareForWrite(transaction_, from_vertex)) return SHARD_ERROR(ErrorCode::SERIALIZATION_ERROR);
if (from_vertex->deleted) return Error::DELETED_OBJECT; if (from_vertex->deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
} }
if (to_is_local && to_vertex != from_vertex) { if (to_is_local && to_vertex != from_vertex) {
if (!PrepareForWrite(transaction_, to_vertex)) return Error::SERIALIZATION_ERROR; if (!PrepareForWrite(transaction_, to_vertex)) return SHARD_ERROR(ErrorCode::SERIALIZATION_ERROR);
if (to_vertex->deleted) return Error::DELETED_OBJECT; if (to_vertex->deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
} }
EdgeRef edge(gid); EdgeRef edge(gid);
@ -541,8 +541,8 @@ Result<EdgeAccessor> Shard::Accessor::CreateEdge(VertexId from_vertex_id, Vertex
&shard_->indices_, config_); &shard_->indices_, config_);
} }
Result<std::optional<EdgeAccessor>> Shard::Accessor::DeleteEdge(VertexId from_vertex_id, VertexId to_vertex_id, ShardResult<std::optional<EdgeAccessor>> Shard::Accessor::DeleteEdge(VertexId from_vertex_id, VertexId to_vertex_id,
const Gid edge_id) { const Gid edge_id) {
Vertex *from_vertex{nullptr}; Vertex *from_vertex{nullptr};
Vertex *to_vertex{nullptr}; Vertex *to_vertex{nullptr};
@ -567,13 +567,13 @@ Result<std::optional<EdgeAccessor>> Shard::Accessor::DeleteEdge(VertexId from_ve
if (from_is_local) { if (from_is_local) {
if (!PrepareForWrite(transaction_, from_vertex)) { if (!PrepareForWrite(transaction_, from_vertex)) {
return Error::SERIALIZATION_ERROR; return SHARD_ERROR(ErrorCode::SERIALIZATION_ERROR);
} }
MG_ASSERT(!from_vertex->deleted, "Invalid database state!"); MG_ASSERT(!from_vertex->deleted, "Invalid database state!");
} }
if (to_is_local && to_vertex != from_vertex) { if (to_is_local && to_vertex != from_vertex) {
if (!PrepareForWrite(transaction_, to_vertex)) { if (!PrepareForWrite(transaction_, to_vertex)) {
return Error::SERIALIZATION_ERROR; return SHARD_ERROR(ErrorCode::SERIALIZATION_ERROR);
} }
MG_ASSERT(!to_vertex->deleted, "Invalid database state!"); MG_ASSERT(!to_vertex->deleted, "Invalid database state!");
} }

11
src/storage/v3/shard.hpp
View File

@ -38,7 +38,6 @@
#include "storage/v3/result.hpp" #include "storage/v3/result.hpp"
#include "storage/v3/schema_validator.hpp" #include "storage/v3/schema_validator.hpp"
#include "storage/v3/schemas.hpp" #include "storage/v3/schemas.hpp"
#include "storage/v3/shard_operation_result.hpp"
#include "storage/v3/transaction.hpp" #include "storage/v3/transaction.hpp"
#include "storage/v3/vertex.hpp" #include "storage/v3/vertex.hpp"
#include "storage/v3/vertex_accessor.hpp" #include "storage/v3/vertex_accessor.hpp"
@ -207,7 +206,7 @@ class Shard final {
public: public:
/// @throw std::bad_alloc /// @throw std::bad_alloc
ShardOperationResult<VertexAccessor> CreateVertexAndValidate( ShardResult<VertexAccessor> CreateVertexAndValidate(
const std::vector<LabelId> &labels, const std::vector<PropertyValue> &primary_properties, const std::vector<LabelId> &labels, const std::vector<PropertyValue> &primary_properties,
const std::vector<std::pair<PropertyId, PropertyValue>> &properties); const std::vector<std::pair<PropertyId, PropertyValue>> &properties);
@ -262,19 +261,19 @@ class Shard final {
/// @return Accessor to the deleted vertex if a deletion took place, std::nullopt otherwise /// @return Accessor to the deleted vertex if a deletion took place, std::nullopt otherwise
/// @throw std::bad_alloc /// @throw std::bad_alloc
Result<std::optional<VertexAccessor>> DeleteVertex(VertexAccessor *vertex); ShardResult<std::optional<VertexAccessor>> DeleteVertex(VertexAccessor *vertex);
/// @return Accessor to the deleted vertex and deleted edges if a deletion took place, std::nullopt otherwise /// @return Accessor to the deleted vertex and deleted edges if a deletion took place, std::nullopt otherwise
/// @throw std::bad_alloc /// @throw std::bad_alloc
Result<std::optional<std::pair<VertexAccessor, std::vector<EdgeAccessor>>>> DetachDeleteVertex( ShardResult<std::optional<std::pair<VertexAccessor, std::vector<EdgeAccessor>>>> DetachDeleteVertex(
VertexAccessor *vertex); VertexAccessor *vertex);
/// @throw std::bad_alloc /// @throw std::bad_alloc
Result<EdgeAccessor> CreateEdge(VertexId from_vertex_id, VertexId to_vertex_id, EdgeTypeId edge_type, Gid gid); ShardResult<EdgeAccessor> CreateEdge(VertexId from_vertex_id, VertexId to_vertex_id, EdgeTypeId edge_type, Gid gid);
/// Accessor to the deleted edge if a deletion took place, std::nullopt otherwise /// Accessor to the deleted edge if a deletion took place, std::nullopt otherwise
/// @throw std::bad_alloc /// @throw std::bad_alloc
Result<std::optional<EdgeAccessor>> DeleteEdge(VertexId from_vertex_id, VertexId to_vertex_id, Gid edge_id); ShardResult<std::optional<EdgeAccessor>> DeleteEdge(VertexId from_vertex_id, VertexId to_vertex_id, Gid edge_id);
LabelId NameToLabel(std::string_view name) const; LabelId NameToLabel(std::string_view name) const;

98
src/storage/v3/shard_rsm.cpp
View File

@ -34,6 +34,7 @@
#include "storage/v3/key_store.hpp" #include "storage/v3/key_store.hpp"
#include "storage/v3/property_value.hpp" #include "storage/v3/property_value.hpp"
#include "storage/v3/request_helper.hpp" #include "storage/v3/request_helper.hpp"
#include "storage/v3/result.hpp"
#include "storage/v3/schemas.hpp" #include "storage/v3/schemas.hpp"
#include "storage/v3/shard.hpp" #include "storage/v3/shard.hpp"
#include "storage/v3/shard_rsm.hpp" #include "storage/v3/shard_rsm.hpp"
@ -468,6 +469,37 @@ EdgeFiller InitializeEdgeFillerFunction(const msgs::ExpandOneRequest &req) {
return edge_filler; return edge_filler;
} }
void LogResultError(const ShardError &error, const std::string_view action = "") {
switch (error.code) {
case ErrorCode::DELETED_OBJECT:
spdlog::debug("{} failed with error: DELETED_OBJECT, at {}", action, error.source);
break;
case ErrorCode::NONEXISTENT_OBJECT:
spdlog::debug("{} failed with error: NONEXISTENT_OBJECT, at {}", action, error.source);
break;
case ErrorCode::SERIALIZATION_ERROR:
spdlog::debug("{} failed with error: SERIALIZATION_ERROR, at {}", action, error.source);
break;
case ErrorCode::PROPERTIES_DISABLED:
spdlog::debug("{} failed with error: PROPERTIES_DISABLED, at {}", action, error.source);
break;
case ErrorCode::VERTEX_HAS_EDGES:
spdlog::debug("{} failed with error: VERTEX_HAS_EDGES, at {}", action, error.source);
break;
case ErrorCode::VERTEX_ALREADY_INSERTED:
spdlog::debug("{} failed with error: VERTEX_ALREADY_INSERTED, at {}", action, error.source);
break;
case ErrorCode::SCHEMA_NO_SCHEMA_DEFINED_FOR_LABEL:
case ErrorCode::SCHEMA_VERTEX_PROPERTY_WRONG_TYPE:
case ErrorCode::SCHEMA_VERTEX_UPDATE_PRIMARY_KEY:
case ErrorCode::SCHEMA_VERTEX_UPDATE_PRIMARY_LABEL:
case ErrorCode::SCHEMA_VERTEX_SECONDARY_LABEL_IS_PRIMARY:
case ErrorCode::SCHEMA_VERTEX_PRIMARY_PROPERTIES_UNDEFINED:
spdlog::debug("Schema violation: {} at {}", error.message, error.source);
break;
}
}
}; // namespace }; // namespace
msgs::WriteResponses ShardRsm::ApplyWrite(msgs::CreateVerticesRequest &&req) { msgs::WriteResponses ShardRsm::ApplyWrite(msgs::CreateVerticesRequest &&req) {
auto acc = shard_->Access(req.transaction_id); auto acc = shard_->Access(req.transaction_id);
@ -494,38 +526,7 @@ msgs::WriteResponses ShardRsm::ApplyWrite(msgs::CreateVerticesRequest &&req) {
if (result_schema.HasError()) { if (result_schema.HasError()) {
auto &error = result_schema.GetError(); auto &error = result_schema.GetError();
spdlog::debug("Creating vertex failed with error: VERTEX_ALREADY_INSERTED");
std::visit(
[]<typename T>(T &&error) {
using ErrorType = std::remove_cvref_t<T>;
if constexpr (std::is_same_v<ErrorType, SchemaViolation>) {
spdlog::debug("Creating vertex failed with error: SchemaViolation");
} else if constexpr (std::is_same_v<ErrorType, Error>) {
switch (error) {
case Error::DELETED_OBJECT:
spdlog::debug("Creating vertex failed with error: DELETED_OBJECT");
break;
case Error::NONEXISTENT_OBJECT:
spdlog::debug("Creating vertex failed with error: NONEXISTENT_OBJECT");
break;
case Error::SERIALIZATION_ERROR:
spdlog::debug("Creating vertex failed with error: SERIALIZATION_ERROR");
break;
case Error::PROPERTIES_DISABLED:
spdlog::debug("Creating vertex failed with error: PROPERTIES_DISABLED");
break;
case Error::VERTEX_HAS_EDGES:
spdlog::debug("Creating vertex failed with error: VERTEX_HAS_EDGES");
break;
case Error::VERTEX_ALREADY_INSERTED:
spdlog::debug("Creating vertex failed with error: VERTEX_ALREADY_INSERTED");
break;
}
} else {
static_assert(kAlwaysFalse<T>, "Missing type from variant visitor");
}
},
error);
action_successful = false; action_successful = false;
break; break;
@ -558,38 +559,7 @@ msgs::WriteResponses ShardRsm::ApplyWrite(msgs::UpdateVerticesRequest &&req) {
vertex_to_update->SetPropertyAndValidate(update_prop.first, ToPropertyValue(std::move(update_prop.second))); vertex_to_update->SetPropertyAndValidate(update_prop.first, ToPropertyValue(std::move(update_prop.second)));
if (result_schema.HasError()) { if (result_schema.HasError()) {
auto &error = result_schema.GetError(); auto &error = result_schema.GetError();
LogResultError(error);
std::visit(
[]<typename T>(T &&error) {
using ErrorType = std::remove_cvref_t<T>;
if constexpr (std::is_same_v<ErrorType, SchemaViolation>) {
spdlog::debug("Updating vertex failed with error: SchemaViolation");
} else if constexpr (std::is_same_v<ErrorType, Error>) {
switch (error) {
case Error::DELETED_OBJECT:
spdlog::debug("Updating vertex failed with error: DELETED_OBJECT");
break;
case Error::NONEXISTENT_OBJECT:
spdlog::debug("Updating vertex failed with error: NONEXISTENT_OBJECT");
break;
case Error::SERIALIZATION_ERROR:
spdlog::debug("Updating vertex failed with error: SERIALIZATION_ERROR");
break;
case Error::PROPERTIES_DISABLED:
spdlog::debug("Updating vertex failed with error: PROPERTIES_DISABLED");
break;
case Error::VERTEX_HAS_EDGES:
spdlog::debug("Updating vertex failed with error: VERTEX_HAS_EDGES");
break;
case Error::VERTEX_ALREADY_INSERTED:
spdlog::debug("Updating vertex failed with error: VERTEX_ALREADY_INSERTED");
break;
}
} else {
static_assert(kAlwaysFalse<T>, "Missing type from variant visitor");
}
},
error);
action_successful = false; action_successful = false;

113
src/storage/v3/vertex_accessor.cpp
View File

@ -21,8 +21,8 @@
#include "storage/v3/key_store.hpp" #include "storage/v3/key_store.hpp"
#include "storage/v3/mvcc.hpp" #include "storage/v3/mvcc.hpp"
#include "storage/v3/property_value.hpp" #include "storage/v3/property_value.hpp"
#include "storage/v3/result.hpp"
#include "storage/v3/shard.hpp" #include "storage/v3/shard.hpp"
#include "storage/v3/shard_operation_result.hpp"
#include "storage/v3/vertex.hpp" #include "storage/v3/vertex.hpp"
#include "utils/logging.hpp" #include "utils/logging.hpp"
#include "utils/memory_tracker.hpp" #include "utils/memory_tracker.hpp"
@ -80,12 +80,12 @@ bool VertexAccessor::IsVisible(View view) const {
return exists && (for_deleted_ || !deleted); return exists && (for_deleted_ || !deleted);
} }
Result<bool> VertexAccessor::AddLabel(LabelId label) { ShardResult<bool> VertexAccessor::AddLabel(LabelId label) {
utils::MemoryTracker::OutOfMemoryExceptionEnabler oom_exception; utils::MemoryTracker::OutOfMemoryExceptionEnabler oom_exception;
if (!PrepareForWrite(transaction_, vertex_)) return Error::SERIALIZATION_ERROR; if (!PrepareForWrite(transaction_, vertex_)) return SHARD_ERROR(ErrorCode::SERIALIZATION_ERROR);
if (vertex_->deleted) return Error::DELETED_OBJECT; if (vertex_->deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
if (std::find(vertex_->labels.begin(), vertex_->labels.end(), label) != vertex_->labels.end()) return false; if (std::find(vertex_->labels.begin(), vertex_->labels.end(), label) != vertex_->labels.end()) return false;
@ -98,15 +98,15 @@ Result<bool> VertexAccessor::AddLabel(LabelId label) {
return true; return true;
} }
ShardOperationResult<bool> VertexAccessor::AddLabelAndValidate(LabelId label) { ShardResult<bool> VertexAccessor::AddLabelAndValidate(LabelId label) {
if (const auto maybe_violation_error = vertex_validator_->ValidateAddLabel(label); maybe_violation_error) { if (const auto maybe_violation_error = vertex_validator_->ValidateAddLabel(label); maybe_violation_error) {
return {*maybe_violation_error}; return {*maybe_violation_error};
} }
utils::MemoryTracker::OutOfMemoryExceptionEnabler oom_exception; utils::MemoryTracker::OutOfMemoryExceptionEnabler oom_exception;
if (!PrepareForWrite(transaction_, vertex_)) return {Error::SERIALIZATION_ERROR}; if (!PrepareForWrite(transaction_, vertex_)) return SHARD_ERROR(ErrorCode::SERIALIZATION_ERROR);
if (vertex_->deleted) return {Error::DELETED_OBJECT}; if (vertex_->deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
if (std::find(vertex_->labels.begin(), vertex_->labels.end(), label) != vertex_->labels.end()) return false; if (std::find(vertex_->labels.begin(), vertex_->labels.end(), label) != vertex_->labels.end()) return false;
@ -119,10 +119,10 @@ ShardOperationResult<bool> VertexAccessor::AddLabelAndValidate(LabelId label) {
return true; return true;
} }
Result<bool> VertexAccessor::RemoveLabel(LabelId label) { ShardResult<bool> VertexAccessor::RemoveLabel(LabelId label) {
if (!PrepareForWrite(transaction_, vertex_)) return Error::SERIALIZATION_ERROR; if (!PrepareForWrite(transaction_, vertex_)) return SHARD_ERROR(ErrorCode::SERIALIZATION_ERROR);
if (vertex_->deleted) return Error::DELETED_OBJECT; if (vertex_->deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
auto it = std::find(vertex_->labels.begin(), vertex_->labels.end(), label); auto it = std::find(vertex_->labels.begin(), vertex_->labels.end(), label);
if (it == vertex_->labels.end()) return false; if (it == vertex_->labels.end()) return false;
@ -134,14 +134,14 @@ Result<bool> VertexAccessor::RemoveLabel(LabelId label) {
return true; return true;
} }
ShardOperationResult<bool> VertexAccessor::RemoveLabelAndValidate(LabelId label) { ShardResult<bool> VertexAccessor::RemoveLabelAndValidate(LabelId label) {
if (const auto maybe_violation_error = vertex_validator_->ValidateRemoveLabel(label); maybe_violation_error) { if (const auto maybe_violation_error = vertex_validator_->ValidateRemoveLabel(label); maybe_violation_error) {
return {*maybe_violation_error}; return {*maybe_violation_error};
} }
if (!PrepareForWrite(transaction_, vertex_)) return {Error::SERIALIZATION_ERROR}; if (!PrepareForWrite(transaction_, vertex_)) return SHARD_ERROR(ErrorCode::SERIALIZATION_ERROR);
if (vertex_->deleted) return {Error::DELETED_OBJECT}; if (vertex_->deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
auto it = std::find(vertex_->labels.begin(), vertex_->labels.end(), label); auto it = std::find(vertex_->labels.begin(), vertex_->labels.end(), label);
if (it == vertex_->labels.end()) return false; if (it == vertex_->labels.end()) return false;
@ -153,9 +153,9 @@ ShardOperationResult<bool> VertexAccessor::RemoveLabelAndValidate(LabelId label)
return true; return true;
} }
Result<bool> VertexAccessor::HasLabel(View view, LabelId label) const { return HasLabel(label, view); } ShardResult<bool> VertexAccessor::HasLabel(View view, LabelId label) const { return HasLabel(label, view); }
Result<bool> VertexAccessor::HasLabel(LabelId label, View view) const { ShardResult<bool> VertexAccessor::HasLabel(LabelId label, View view) const {
bool exists = true; bool exists = true;
bool deleted = false; bool deleted = false;
bool has_label = false; bool has_label = false;
@ -197,12 +197,12 @@ Result<bool> VertexAccessor::HasLabel(LabelId label, View view) const {
break; break;
} }
}); });
if (!exists) return Error::NONEXISTENT_OBJECT; if (!exists) return SHARD_ERROR(ErrorCode::NONEXISTENT_OBJECT);
if (!for_deleted_ && deleted) return Error::DELETED_OBJECT; if (!for_deleted_ && deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
return has_label; return has_label;
} }
Result<LabelId> VertexAccessor::PrimaryLabel(const View view) const { ShardResult<LabelId> VertexAccessor::PrimaryLabel(const View view) const {
if (const auto result = CheckVertexExistence(view); result.HasError()) { if (const auto result = CheckVertexExistence(view); result.HasError()) {
return result.GetError(); return result.GetError();
} }
@ -210,21 +210,21 @@ Result<LabelId> VertexAccessor::PrimaryLabel(const View view) const {
return vertex_validator_->primary_label_; return vertex_validator_->primary_label_;
} }
Result<PrimaryKey> VertexAccessor::PrimaryKey(const View view) const { ShardResult<PrimaryKey> VertexAccessor::PrimaryKey(const View view) const {
if (const auto result = CheckVertexExistence(view); result.HasError()) { if (const auto result = CheckVertexExistence(view); result.HasError()) {
return result.GetError(); return result.GetError();
} }
return vertex_->keys.Keys(); return vertex_->keys.Keys();
} }
Result<VertexId> VertexAccessor::Id(View view) const { ShardResult<VertexId> VertexAccessor::Id(View view) const {
if (const auto result = CheckVertexExistence(view); result.HasError()) { if (const auto result = CheckVertexExistence(view); result.HasError()) {
return result.GetError(); return result.GetError();
} }
return VertexId{vertex_validator_->primary_label_, vertex_->keys.Keys()}; return VertexId{vertex_validator_->primary_label_, vertex_->keys.Keys()};
}; };
Result<std::vector<LabelId>> VertexAccessor::Labels(View view) const { ShardResult<std::vector<LabelId>> VertexAccessor::Labels(View view) const {
bool exists = true; bool exists = true;
bool deleted = false; bool deleted = false;
std::vector<LabelId> labels; std::vector<LabelId> labels;
@ -267,17 +267,17 @@ Result<std::vector<LabelId>> VertexAccessor::Labels(View view) const {
break; break;
} }
}); });
if (!exists) return Error::NONEXISTENT_OBJECT; if (!exists) return SHARD_ERROR(ErrorCode::NONEXISTENT_OBJECT);
if (!for_deleted_ && deleted) return Error::DELETED_OBJECT; if (!for_deleted_ && deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
return std::move(labels); return std::move(labels);
} }
Result<PropertyValue> VertexAccessor::SetProperty(PropertyId property, const PropertyValue &value) { ShardResult<PropertyValue> VertexAccessor::SetProperty(PropertyId property, const PropertyValue &value) {
utils::MemoryTracker::OutOfMemoryExceptionEnabler oom_exception; utils::MemoryTracker::OutOfMemoryExceptionEnabler oom_exception;
if (!PrepareForWrite(transaction_, vertex_)) return Error::SERIALIZATION_ERROR; if (!PrepareForWrite(transaction_, vertex_)) return SHARD_ERROR(ErrorCode::SERIALIZATION_ERROR);
if (vertex_->deleted) return Error::DELETED_OBJECT; if (vertex_->deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
auto current_value = vertex_->properties.GetProperty(property); auto current_value = vertex_->properties.GetProperty(property);
// We could skip setting the value if the previous one is the same to the new // We could skip setting the value if the previous one is the same to the new
@ -294,7 +294,7 @@ Result<PropertyValue> VertexAccessor::SetProperty(PropertyId property, const Pro
return std::move(current_value); return std::move(current_value);
} }
Result<void> VertexAccessor::CheckVertexExistence(View view) const { ShardResult<void> VertexAccessor::CheckVertexExistence(View view) const {
bool exists = true; bool exists = true;
bool deleted = false; bool deleted = false;
Delta *delta = nullptr; Delta *delta = nullptr;
@ -323,27 +323,26 @@ Result<void> VertexAccessor::CheckVertexExistence(View view) const {
} }
}); });
if (!exists) { if (!exists) {
return Error::NONEXISTENT_OBJECT; return SHARD_ERROR(ErrorCode::NONEXISTENT_OBJECT);
} }
if (!for_deleted_ && deleted) { if (!for_deleted_ && deleted) {
return Error::DELETED_OBJECT; return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
} }
return {}; return {};
} }
ShardOperationResult<PropertyValue> VertexAccessor::SetPropertyAndValidate(PropertyId property, ShardResult<PropertyValue> VertexAccessor::SetPropertyAndValidate(PropertyId property, const PropertyValue &value) {
const PropertyValue &value) {
if (auto maybe_violation_error = vertex_validator_->ValidatePropertyUpdate(property); maybe_violation_error) { if (auto maybe_violation_error = vertex_validator_->ValidatePropertyUpdate(property); maybe_violation_error) {
return {*maybe_violation_error}; return {*maybe_violation_error};
} }
utils::MemoryTracker::OutOfMemoryExceptionEnabler oom_exception; utils::MemoryTracker::OutOfMemoryExceptionEnabler oom_exception;
if (!PrepareForWrite(transaction_, vertex_)) { if (!PrepareForWrite(transaction_, vertex_)) {
return {Error::SERIALIZATION_ERROR}; return SHARD_ERROR(ErrorCode::SERIALIZATION_ERROR);
} }
if (vertex_->deleted) { if (vertex_->deleted) {
return {Error::DELETED_OBJECT}; return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
} }
auto current_value = vertex_->properties.GetProperty(property); auto current_value = vertex_->properties.GetProperty(property);
@ -361,10 +360,10 @@ ShardOperationResult<PropertyValue> VertexAccessor::SetPropertyAndValidate(Prope
return std::move(current_value); return std::move(current_value);
} }
Result<std::map<PropertyId, PropertyValue>> VertexAccessor::ClearProperties() { ShardResult<std::map<PropertyId, PropertyValue>> VertexAccessor::ClearProperties() {
if (!PrepareForWrite(transaction_, vertex_)) return Error::SERIALIZATION_ERROR; if (!PrepareForWrite(transaction_, vertex_)) return SHARD_ERROR(ErrorCode::SERIALIZATION_ERROR);
if (vertex_->deleted) return Error::DELETED_OBJECT; if (vertex_->deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
auto properties = vertex_->properties.Properties(); auto properties = vertex_->properties.Properties();
for (const auto &property : properties) { for (const auto &property : properties) {
@ -377,7 +376,7 @@ Result<std::map<PropertyId, PropertyValue>> VertexAccessor::ClearProperties() {
return std::move(properties); return std::move(properties);
} }
Result<PropertyValue> VertexAccessor::GetProperty(View view, PropertyId property) const { ShardResult<PropertyValue> VertexAccessor::GetProperty(View view, PropertyId property) const {
return GetProperty(property, view).GetValue(); return GetProperty(property, view).GetValue();
} }
@ -407,7 +406,7 @@ PropertyValue VertexAccessor::GetPropertyValue(PropertyId property, View view) c
return value; return value;
} }
Result<PropertyValue> VertexAccessor::GetProperty(PropertyId property, View view) const { ShardResult<PropertyValue> VertexAccessor::GetProperty(PropertyId property, View view) const {
bool exists = true; bool exists = true;
bool deleted = false; bool deleted = false;
PropertyValue value; PropertyValue value;
@ -442,12 +441,12 @@ Result<PropertyValue> VertexAccessor::GetProperty(PropertyId property, View view
break; break;
} }
}); });
if (!exists) return Error::NONEXISTENT_OBJECT; if (!exists) return SHARD_ERROR(ErrorCode::NONEXISTENT_OBJECT);
if (!for_deleted_ && deleted) return Error::DELETED_OBJECT; if (!for_deleted_ && deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
return std::move(value); return std::move(value);
} }
Result<std::map<PropertyId, PropertyValue>> VertexAccessor::Properties(View view) const { ShardResult<std::map<PropertyId, PropertyValue>> VertexAccessor::Properties(View view) const {
bool exists = true; bool exists = true;
bool deleted = false; bool deleted = false;
std::map<PropertyId, PropertyValue> properties; std::map<PropertyId, PropertyValue> properties;
@ -492,13 +491,13 @@ Result<std::map<PropertyId, PropertyValue>> VertexAccessor::Properties(View view
break; break;
} }
}); });
if (!exists) return Error::NONEXISTENT_OBJECT; if (!exists) return SHARD_ERROR(ErrorCode::NONEXISTENT_OBJECT);
if (!for_deleted_ && deleted) return Error::DELETED_OBJECT; if (!for_deleted_ && deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
return std::move(properties); return std::move(properties);
} }
Result<std::vector<EdgeAccessor>> VertexAccessor::InEdges(View view, const std::vector<EdgeTypeId> &edge_types, ShardResult<std::vector<EdgeAccessor>> VertexAccessor::InEdges(View view, const std::vector<EdgeTypeId> &edge_types,
const VertexId *destination_id) const { const VertexId *destination_id) const {
bool exists = true; bool exists = true;
bool deleted = false; bool deleted = false;
std::vector<Vertex::EdgeLink> in_edges; std::vector<Vertex::EdgeLink> in_edges;
@ -564,8 +563,8 @@ Result<std::vector<EdgeAccessor>> VertexAccessor::InEdges(View view, const std::
break; break;
} }
}); });
if (!exists) return Error::NONEXISTENT_OBJECT; if (!exists) return SHARD_ERROR(ErrorCode::NONEXISTENT_OBJECT);
if (deleted) return Error::DELETED_OBJECT; if (deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
std::vector<EdgeAccessor> ret; std::vector<EdgeAccessor> ret;
if (in_edges.empty()) { if (in_edges.empty()) {
return ret; return ret;
@ -579,8 +578,8 @@ Result<std::vector<EdgeAccessor>> VertexAccessor::InEdges(View view, const std::
return ret; return ret;
} }
Result<std::vector<EdgeAccessor>> VertexAccessor::OutEdges(View view, const std::vector<EdgeTypeId> &edge_types, ShardResult<std::vector<EdgeAccessor>> VertexAccessor::OutEdges(View view, const std::vector<EdgeTypeId> &edge_types,
const VertexId *destination_id) const { const VertexId *destination_id) const {
bool exists = true; bool exists = true;
bool deleted = false; bool deleted = false;
std::vector<Vertex::EdgeLink> out_edges; std::vector<Vertex::EdgeLink> out_edges;
@ -644,8 +643,8 @@ Result<std::vector<EdgeAccessor>> VertexAccessor::OutEdges(View view, const std:
break; break;
} }
}); });
if (!exists) return Error::NONEXISTENT_OBJECT; if (!exists) return SHARD_ERROR(ErrorCode::NONEXISTENT_OBJECT);
if (deleted) return Error::DELETED_OBJECT; if (deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
std::vector<EdgeAccessor> ret; std::vector<EdgeAccessor> ret;
if (out_edges.empty()) { if (out_edges.empty()) {
return ret; return ret;
@ -659,7 +658,7 @@ Result<std::vector<EdgeAccessor>> VertexAccessor::OutEdges(View view, const std:
return ret; return ret;
} }
Result<size_t> VertexAccessor::InDegree(View view) const { ShardResult<size_t> VertexAccessor::InDegree(View view) const {
bool exists = true; bool exists = true;
bool deleted = false; bool deleted = false;
size_t degree = 0; size_t degree = 0;
@ -691,12 +690,12 @@ Result<size_t> VertexAccessor::InDegree(View view) const {
break; break;
} }
}); });
if (!exists) return Error::NONEXISTENT_OBJECT; if (!exists) return SHARD_ERROR(ErrorCode::NONEXISTENT_OBJECT);
if (!for_deleted_ && deleted) return Error::DELETED_OBJECT; if (!for_deleted_ && deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
return degree; return degree;
} }
Result<size_t> VertexAccessor::OutDegree(View view) const { ShardResult<size_t> VertexAccessor::OutDegree(View view) const {
bool exists = true; bool exists = true;
bool deleted = false; bool deleted = false;
size_t degree = 0; size_t degree = 0;
@ -728,8 +727,8 @@ Result<size_t> VertexAccessor::OutDegree(View view) const {
break; break;
} }
}); });
if (!exists) return Error::NONEXISTENT_OBJECT; if (!exists) return SHARD_ERROR(ErrorCode::NONEXISTENT_OBJECT);
if (!for_deleted_ && deleted) return Error::DELETED_OBJECT; if (!for_deleted_ && deleted) return SHARD_ERROR(ErrorCode::DELETED_OBJECT);
return degree; return degree;
} }

48
src/storage/v3/vertex_accessor.hpp
View File

@ -17,7 +17,7 @@
#include "storage/v3/id_types.hpp" #include "storage/v3/id_types.hpp"
#include "storage/v3/key_store.hpp" #include "storage/v3/key_store.hpp"
#include "storage/v3/result.hpp" #include "storage/v3/result.hpp"
#include "storage/v3/shard_operation_result.hpp" #include "storage/v3/schema_validator.hpp"
#include "storage/v3/transaction.hpp" #include "storage/v3/transaction.hpp"
#include "storage/v3/vertex.hpp" #include "storage/v3/vertex.hpp"
#include "storage/v3/vertex_id.hpp" #include "storage/v3/vertex_id.hpp"
@ -55,61 +55,61 @@ class VertexAccessor final {
/// `false` is returned if the label already existed, or SchemaViolation /// `false` is returned if the label already existed, or SchemaViolation
/// if adding the label has violated one of the schema constraints. /// if adding the label has violated one of the schema constraints.
/// @throw std::bad_alloc /// @throw std::bad_alloc
ShardOperationResult<bool> AddLabelAndValidate(LabelId label); ShardResult<bool> AddLabelAndValidate(LabelId label);
/// Remove a label and return `true` if deletion took place. /// Remove a label and return `true` if deletion took place.
/// `false` is returned if the vertex did not have a label already. or SchemaViolation /// `false` is returned if the vertex did not have a label already. or SchemaViolation
/// if adding the label has violated one of the schema constraints. /// if adding the label has violated one of the schema constraints.
/// @throw std::bad_alloc /// @throw std::bad_alloc
ShardOperationResult<bool> RemoveLabelAndValidate(LabelId label); ShardResult<bool> RemoveLabelAndValidate(LabelId label);
Result<bool> HasLabel(View view, LabelId label) const; ShardResult<bool> HasLabel(View view, LabelId label) const;
Result<bool> HasLabel(LabelId label, View view) const; ShardResult<bool> HasLabel(LabelId label, View view) const;
/// @throw std::bad_alloc /// @throw std::bad_alloc
/// @throw std::length_error if the resulting vector exceeds /// @throw std::length_error if the resulting vector exceeds
/// std::vector::max_size(). /// std::vector::max_size().
Result<std::vector<LabelId>> Labels(View view) const; ShardResult<std::vector<LabelId>> Labels(View view) const;
Result<LabelId> PrimaryLabel(View view) const; ShardResult<LabelId> PrimaryLabel(View view) const;
Result<PrimaryKey> PrimaryKey(View view) const; ShardResult<PrimaryKey> PrimaryKey(View view) const;
Result<VertexId> Id(View view) const; ShardResult<VertexId> Id(View view) const;
/// Set a property value and return the old value or error. /// Set a property value and return the old value or error.
/// @throw std::bad_alloc /// @throw std::bad_alloc
ShardOperationResult<PropertyValue> SetPropertyAndValidate(PropertyId property, const PropertyValue &value); ShardResult<PropertyValue> SetPropertyAndValidate(PropertyId property, const PropertyValue &value);
/// Remove all properties and return the values of the removed properties. /// Remove all properties and return the values of the removed properties.
/// @throw std::bad_alloc /// @throw std::bad_alloc
Result<std::map<PropertyId, PropertyValue>> ClearProperties(); ShardResult<std::map<PropertyId, PropertyValue>> ClearProperties();
/// @throw std::bad_alloc /// @throw std::bad_alloc
Result<PropertyValue> GetProperty(PropertyId property, View view) const; ShardResult<PropertyValue> GetProperty(PropertyId property, View view) const;
// TODO Remove this // TODO Remove this
Result<PropertyValue> GetProperty(View view, PropertyId property) const; ShardResult<PropertyValue> GetProperty(View view, PropertyId property) const;
/// @throw std::bad_alloc /// @throw std::bad_alloc
Result<std::map<PropertyId, PropertyValue>> Properties(View view) const; ShardResult<std::map<PropertyId, PropertyValue>> Properties(View view) const;
/// @throw std::bad_alloc /// @throw std::bad_alloc
/// @throw std::length_error if the resulting vector exceeds /// @throw std::length_error if the resulting vector exceeds
/// std::vector::max_size(). /// std::vector::max_size().
Result<std::vector<EdgeAccessor>> InEdges(View view, const std::vector<EdgeTypeId> &edge_types = {}, ShardResult<std::vector<EdgeAccessor>> InEdges(View view, const std::vector<EdgeTypeId> &edge_types = {},
const VertexId *destination_id = nullptr) const; const VertexId *destination_id = nullptr) const;
/// @throw std::bad_alloc /// @throw std::bad_alloc
/// @throw std::length_error if the resulting vector exceeds /// @throw std::length_error if the resulting vector exceeds
/// std::vector::max_size(). /// std::vector::max_size().
Result<std::vector<EdgeAccessor>> OutEdges(View view, const std::vector<EdgeTypeId> &edge_types = {}, ShardResult<std::vector<EdgeAccessor>> OutEdges(View view, const std::vector<EdgeTypeId> &edge_types = {},
const VertexId *destination_id = nullptr) const; const VertexId *destination_id = nullptr) const;
Result<size_t> InDegree(View view) const; ShardResult<size_t> InDegree(View view) const;
Result<size_t> OutDegree(View view) const; ShardResult<size_t> OutDegree(View view) const;
const SchemaValidator *GetSchemaValidator() const; const SchemaValidator *GetSchemaValidator() const;
@ -122,20 +122,20 @@ class VertexAccessor final {
/// Add a label and return `true` if insertion took place. /// Add a label and return `true` if insertion took place.
/// `false` is returned if the label already existed. /// `false` is returned if the label already existed.
/// @throw std::bad_alloc /// @throw std::bad_alloc
Result<bool> AddLabel(LabelId label); ShardResult<bool> AddLabel(LabelId label);
/// Remove a label and return `true` if deletion took place. /// Remove a label and return `true` if deletion took place.
/// `false` is returned if the vertex did not have a label already. /// `false` is returned if the vertex did not have a label already.
/// @throw std::bad_alloc /// @throw std::bad_alloc
Result<bool> RemoveLabel(LabelId label); ShardResult<bool> RemoveLabel(LabelId label);
/// Set a property value and return the old value. /// Set a property value and return the old value.
/// @throw std::bad_alloc /// @throw std::bad_alloc
Result<PropertyValue> SetProperty(PropertyId property, const PropertyValue &value); ShardResult<PropertyValue> SetProperty(PropertyId property, const PropertyValue &value);
PropertyValue GetPropertyValue(PropertyId property, View view) const; PropertyValue GetPropertyValue(PropertyId property, View view) const;
Result<void> CheckVertexExistence(View view) const; ShardResult<void> CheckVertexExistence(View view) const;
Vertex *vertex_; Vertex *vertex_;
Transaction *transaction_; Transaction *transaction_;