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

Switch to text indices that are named

Browse Source
This commit is contained in:
Ante Pušić 2024-01-09 20:46:30 +01:00
parent ce718c4646
commit 5fb9324239
12 changed files with 106 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
include/_mgp.hpp
View File

@ -326,8 +326,13 @@ inline mgp_vertex *graph_get_vertex_by_id(mgp_graph *g, mgp_vertex_id id, mgp_me
return MgInvoke<mgp_vertex *>(mgp_graph_get_vertex_by_id, g, id, memory); return MgInvoke<mgp_vertex *>(mgp_graph_get_vertex_by_id, g, id, memory);
} }
inline bool graph_has_text_index(mgp_graph *graph, const char *label) { inline bool graph_has_text_index(mgp_graph *graph, const char *index_name) {
return MgInvoke<int>(mgp_graph_has_text_index, graph, label); return MgInvoke<int>(mgp_graph_has_text_index, graph, index_name);
}
// TODO antepusic change result type
inline bool graph_search_text_index(mgp_graph *graph, const char *index_name) {
return MgInvoke<int>(mgp_graph_has_text_index, graph, index_name);
} }
inline mgp_vertices_iterator *graph_iter_vertices(mgp_graph *g, mgp_memory *memory) { inline mgp_vertices_iterator *graph_iter_vertices(mgp_graph *g, mgp_memory *memory) {

5
include/mg_procedure.h
View File

@ -891,7 +891,10 @@ enum mgp_error mgp_edge_iter_properties(struct mgp_edge *e, struct mgp_memory *m
enum mgp_error mgp_graph_get_vertex_by_id(struct mgp_graph *g, struct mgp_vertex_id id, struct mgp_memory *memory, enum mgp_error mgp_graph_get_vertex_by_id(struct mgp_graph *g, struct mgp_vertex_id id, struct mgp_memory *memory,
struct mgp_vertex **result); struct mgp_vertex **result);
enum mgp_error mgp_graph_has_text_index(mgp_graph *graph, const char *label); enum mgp_error mgp_graph_has_text_index(mgp_graph *graph, const char *label, int *result);
// TODO antepusic change result type
enum mgp_error mgp_graph_search_text_index(mgp_graph *graph, const char *index_name, int *result);
/// Creates label index for given label. /// Creates label index for given label.
/// mgp_error::MGP_ERROR_NO_ERROR is always returned. /// mgp_error::MGP_ERROR_NO_ERROR is always returned.

9
query_modules/text_search.cpp
View File

@ -24,22 +24,21 @@ void Search(mgp_list *args, mgp_graph *memgraph_graph, mgp_result *result, mgp_m
} // namespace TextSearch } // namespace TextSearch
void Search(mgp_list *args, mgp_graph *memgraph_graph, mgp_result *result, mgp_memory *memory) { void Search(mgp_list *args, mgp_graph *memgraph_graph, mgp_result *result, mgp_memory *memory) {
// CALL text_search.search("Label", "nekiQuery", searchFields, returnFields) RETURN node, score
mgp::MemoryDispatcherGuard guard{memory}; mgp::MemoryDispatcherGuard guard{memory};
const auto record_factory = mgp::RecordFactory(result); const auto record_factory = mgp::RecordFactory(result);
auto arguments = mgp::List(args); auto arguments = mgp::List(args);
auto label = arguments[0].ValueString(); auto label = arguments[0].ValueString();
auto search_string = arguments[1].ValueString(); auto search_string = arguments[1].ValueString();
// TODO antepusic: // 1. See if the given label is text-indexed
// 1. Match the label to the appropriate text index
// auto label_id = memgraph_graph->impl->NameToLabel(label); <- needs API method
if (!mgp::graph_has_text_index(memgraph_graph, label.data())) { if (!mgp::graph_has_text_index(memgraph_graph, label.data())) {
return; return;
} }
// 2. Run text search of that index // 2. Run text search of that index
// * Add metadata to the return fields before search mgp::graph_search_text_index(memgraph_graph, label.data());
// text_index.search(label, search_string); // text_index.search(label, search_string);

11
src/query/db_accessor.hpp
View File

@ -553,7 +553,7 @@ class DbAccessor final {
return accessor_->LabelPropertyIndexExists(label, prop); return accessor_->LabelPropertyIndexExists(label, prop);
} }
bool TextIndexExists(storage::LabelId label) const { return accessor_->TextIndexExists(label); } bool TextIndexExists(std::string index_name) const { return accessor_->TextIndexExists(index_name); }
std::optional<storage::LabelIndexStats> GetIndexStats(const storage::LabelId &label) const { std::optional<storage::LabelIndexStats> GetIndexStats(const storage::LabelId &label) const {
return accessor_->GetIndexStats(label); return accessor_->GetIndexStats(label);
@ -630,12 +630,13 @@ class DbAccessor final {
return accessor_->DropIndex(label, property); return accessor_->DropIndex(label, property);
} }
utils::BasicResult<storage::StorageIndexDefinitionError, void> CreateTextIndex(storage::LabelId label) { utils::BasicResult<storage::StorageIndexDefinitionError, void> CreateTextIndex(std::string index_name,
return accessor_->CreateTextIndex(label); storage::LabelId label) {
return accessor_->CreateTextIndex(index_name, label);
} }
utils::BasicResult<storage::StorageIndexDefinitionError, void> DropTextIndex(storage::LabelId label) { utils::BasicResult<storage::StorageIndexDefinitionError, void> DropTextIndex(std::string index_name) {
return accessor_->DropTextIndex(label); return accessor_->DropTextIndex(index_name);
} }
utils::BasicResult<storage::StorageExistenceConstraintDefinitionError, void> CreateExistenceConstraint( utils::BasicResult<storage::StorageExistenceConstraintDefinitionError, void> CreateExistenceConstraint(

5
src/query/frontend/ast/ast.hpp
View File

@ -2205,6 +2205,7 @@ class IndexQuery : public memgraph::query::Query {
memgraph::query::IndexQuery::Type type_; memgraph::query::IndexQuery::Type type_;
memgraph::query::LabelIx label_; memgraph::query::LabelIx label_;
std::vector<memgraph::query::PropertyIx> properties_; std::vector<memgraph::query::PropertyIx> properties_;
std::string index_name_;
IndexQuery *Clone(AstStorage *storage) const override { IndexQuery *Clone(AstStorage *storage) const override {
IndexQuery *object = storage->Create<IndexQuery>(); IndexQuery *object = storage->Create<IndexQuery>();
@ -2215,6 +2216,7 @@ class IndexQuery : public memgraph::query::Query {
for (auto i = 0; i < object->properties_.size(); ++i) { for (auto i = 0; i < object->properties_.size(); ++i) {
object->properties_[i] = storage->GetPropertyIx(properties_[i].name); object->properties_[i] = storage->GetPropertyIx(properties_[i].name);
} }
object->index_name_ = index_name_;
return object; return object;
} }
@ -2222,6 +2224,9 @@ class IndexQuery : public memgraph::query::Query {
IndexQuery(Action action, Type type, LabelIx label, std::vector<PropertyIx> properties) IndexQuery(Action action, Type type, LabelIx label, std::vector<PropertyIx> properties)
: action_(action), type_(type), label_(label), properties_(properties) {} : action_(action), type_(type), label_(label), properties_(properties) {}
IndexQuery(Action action, Type type, LabelIx label, std::vector<PropertyIx> properties, std::string index_name)
: action_(action), type_(type), label_(label), properties_(properties), index_name_(index_name) {}
private: private:
friend class AstStorage; friend class AstStorage;
}; };

3
src/query/frontend/ast/cypher_main_visitor.cpp
View File

@ -257,6 +257,7 @@ antlrcpp::Any CypherMainVisitor::visitCreateIndex(MemgraphCypher::CreateIndexCon
antlrcpp::Any CypherMainVisitor::visitCreateTextIndex(MemgraphCypher::CreateTextIndexContext *ctx) { antlrcpp::Any CypherMainVisitor::visitCreateTextIndex(MemgraphCypher::CreateTextIndexContext *ctx) {
auto *index_query = storage_->Create<IndexQuery>(); auto *index_query = storage_->Create<IndexQuery>();
index_query->index_name_ = std::any_cast<std::string>(ctx->indexName()->accept(this));
index_query->action_ = IndexQuery::Action::CREATE; index_query->action_ = IndexQuery::Action::CREATE;
index_query->type_ = IndexQuery::Type::TEXT; index_query->type_ = IndexQuery::Type::TEXT;
index_query->label_ = AddLabel(std::any_cast<std::string>(ctx->labelName()->accept(this))); index_query->label_ = AddLabel(std::any_cast<std::string>(ctx->labelName()->accept(this)));
@ -277,9 +278,9 @@ antlrcpp::Any CypherMainVisitor::visitDropIndex(MemgraphCypher::DropIndexContext
antlrcpp::Any CypherMainVisitor::visitDropTextIndex(MemgraphCypher::DropTextIndexContext *ctx) { antlrcpp::Any CypherMainVisitor::visitDropTextIndex(MemgraphCypher::DropTextIndexContext *ctx) {
auto *index_query = storage_->Create<IndexQuery>(); auto *index_query = storage_->Create<IndexQuery>();
index_query->index_name_ = std::any_cast<std::string>(ctx->indexName()->accept(this));
index_query->action_ = IndexQuery::Action::DROP; index_query->action_ = IndexQuery::Action::DROP;
index_query->type_ = IndexQuery::Type::TEXT; index_query->type_ = IndexQuery::Type::TEXT;
index_query->label_ = AddLabel(std::any_cast<std::string>(ctx->labelName()->accept(this)));
return index_query; return index_query;
} }

6
src/query/frontend/opencypher/grammar/Cypher.g4
View File

@ -339,9 +339,11 @@ createIndex : CREATE INDEX ON ':' labelName ( '(' propertyKeyName ')' )? ;
dropIndex : DROP INDEX ON ':' labelName ( '(' propertyKeyName ')' )? ; dropIndex : DROP INDEX ON ':' labelName ( '(' propertyKeyName ')' )? ;
createTextIndex : CREATE TEXT INDEX ON ':' labelName ; indexName : symbolicName ;
dropTextIndex : DROP TEXT INDEX ON ':' labelName ; createTextIndex : CREATE TEXT INDEX indexName ON ':' labelName ;
dropTextIndex : DROP TEXT INDEX indexName ;
doubleLiteral : FloatingLiteral ; doubleLiteral : FloatingLiteral ;

9
src/query/interpreter.cpp
View File

@ -2153,6 +2153,7 @@ PreparedQuery PrepareIndexQuery(ParsedQuery parsed_query, bool in_explicit_trans
auto *storage = db_acc->storage(); auto *storage = db_acc->storage();
auto label = storage->NameToLabel(index_query->label_.name); auto label = storage->NameToLabel(index_query->label_.name);
auto &index_name = index_query->index_name_;
std::vector<storage::PropertyId> properties; std::vector<storage::PropertyId> properties;
std::vector<std::string> properties_string; std::vector<std::string> properties_string;
@ -2176,7 +2177,7 @@ PreparedQuery PrepareIndexQuery(ParsedQuery parsed_query, bool in_explicit_trans
fmt::format("Created index on label {} on properties {}.", index_query->label_.name, properties_stringified); fmt::format("Created index on label {} on properties {}.", index_query->label_.name, properties_stringified);
// TODO: not just storage + invalidate_plan_cache. Need a DB transaction (for replication) // TODO: not just storage + invalidate_plan_cache. Need a DB transaction (for replication)
handler = [dba, index_type = index_query->type_, label, handler = [dba, index_type = index_query->type_, label, index_name,
properties_stringified = std::move(properties_stringified), label_name = index_query->label_.name, properties_stringified = std::move(properties_stringified), label_name = index_query->label_.name,
properties = std::move(properties), properties = std::move(properties),
invalidate_plan_cache = std::move(invalidate_plan_cache)](Notification &index_notification) { invalidate_plan_cache = std::move(invalidate_plan_cache)](Notification &index_notification) {
@ -2185,7 +2186,7 @@ PreparedQuery PrepareIndexQuery(ParsedQuery parsed_query, bool in_explicit_trans
if (index_type == IndexQuery::Type::LOOKUP) { if (index_type == IndexQuery::Type::LOOKUP) {
maybe_index_error = properties.empty() ? dba->CreateIndex(label) : dba->CreateIndex(label, properties[0]); maybe_index_error = properties.empty() ? dba->CreateIndex(label) : dba->CreateIndex(label, properties[0]);
} else if (index_type == IndexQuery::Type::TEXT) { } else if (index_type == IndexQuery::Type::TEXT) {
maybe_index_error = dba->CreateTextIndex(label); maybe_index_error = dba->CreateTextIndex(index_name, label);
} }
utils::OnScopeExit invalidator(invalidate_plan_cache); utils::OnScopeExit invalidator(invalidate_plan_cache);
@ -2203,7 +2204,7 @@ PreparedQuery PrepareIndexQuery(ParsedQuery parsed_query, bool in_explicit_trans
index_notification.title = fmt::format("Dropped index on label {} on properties {}.", index_query->label_.name, index_notification.title = fmt::format("Dropped index on label {} on properties {}.", index_query->label_.name,
utils::Join(properties_string, ", ")); utils::Join(properties_string, ", "));
// TODO: not just storage + invalidate_plan_cache. Need a DB transaction (for replication) // TODO: not just storage + invalidate_plan_cache. Need a DB transaction (for replication)
handler = [dba, index_type = index_query->type_, label, handler = [dba, index_type = index_query->type_, label, index_name,
properties_stringified = std::move(properties_stringified), label_name = index_query->label_.name, properties_stringified = std::move(properties_stringified), label_name = index_query->label_.name,
properties = std::move(properties), properties = std::move(properties),
invalidate_plan_cache = std::move(invalidate_plan_cache)](Notification &index_notification) { invalidate_plan_cache = std::move(invalidate_plan_cache)](Notification &index_notification) {
@ -2212,7 +2213,7 @@ PreparedQuery PrepareIndexQuery(ParsedQuery parsed_query, bool in_explicit_trans
if (index_type == IndexQuery::Type::LOOKUP) { if (index_type == IndexQuery::Type::LOOKUP) {
maybe_index_error = properties.empty() ? dba->DropIndex(label) : dba->DropIndex(label, properties[0]); maybe_index_error = properties.empty() ? dba->DropIndex(label) : dba->DropIndex(label, properties[0]);
} else if (index_type == IndexQuery::Type::TEXT) { } else if (index_type == IndexQuery::Type::TEXT) {
maybe_index_error = dba->DropTextIndex(label); maybe_index_error = dba->DropTextIndex(index_name);
} }
utils::OnScopeExit invalidator(invalidate_plan_cache); utils::OnScopeExit invalidator(invalidate_plan_cache);

21
src/query/procedure/mg_procedure_impl.cpp
View File

@ -3322,18 +3322,21 @@ mgp_error mgp_graph_delete_edge(struct mgp_graph *graph, mgp_edge *edge) {
}); });
} }
mgp_error mgp_graph_has_text_index(mgp_graph *graph, const char *label, int *result) { mgp_error mgp_graph_has_text_index(mgp_graph *graph, const char *index_name, int *result) {
return WrapExceptions([graph, label, result]() { return WrapExceptions([graph, index_name, result]() {
std::visit( std::visit(memgraph::utils::Overloaded{
memgraph::utils::Overloaded{ [&](memgraph::query::DbAccessor *impl) { *result = impl->TextIndexExists(index_name); },
[&](memgraph::query::DbAccessor *impl) { *result = impl->TextIndexExists(impl->NameToLabel(label)); }, [&](memgraph::query::SubgraphDbAccessor *impl) {
[&](memgraph::query::SubgraphDbAccessor *impl) { *result = impl->GetAccessor()->TextIndexExists(index_name);
*result = impl->GetAccessor()->TextIndexExists(impl->GetAccessor()->NameToLabel(label)); }},
}}, graph->impl);
graph->impl);
}); });
} }
mgp_error mgp_graph_search_text_index(mgp_graph *graph, const char *index_name, int *result) {
return WrapExceptions([graph, index_name, result]() { *result = 1; });
}
#ifdef MG_ENTERPRISE #ifdef MG_ENTERPRISE
namespace { namespace {
void NextPermitted(mgp_vertices_iterator &it) { void NextPermitted(mgp_vertices_iterator &it) {

28
src/storage/v2/indices/text_index.hpp
View File

@ -29,29 +29,31 @@ class TextIndex {
void UpdateOnRemoveLabel(LabelId removed_label, Vertex *vertex_after_update, const Transaction &tx) {} void UpdateOnRemoveLabel(LabelId removed_label, Vertex *vertex_after_update, const Transaction &tx) {}
/// @throw std::bad_alloc /// @throw std::bad_alloc
bool CreateIndex(LabelId label, const std::optional<durability::ParallelizedSchemaCreationInfo> &parallel_exec_info) { bool CreateIndex(std::string index_name, LabelId label,
const std::optional<durability::ParallelizedSchemaCreationInfo> &parallel_exec_info) {
auto index_config = mgcxx_mock::text_search::IndexConfig{.mappings = "TODO antepusic"}; auto index_config = mgcxx_mock::text_search::IndexConfig{.mappings = "TODO antepusic"};
auto new_index = mgcxx_mock::text_search::Mock::create_index(label.ToString(), index_config); auto new_index = mgcxx_mock::text_search::Mock::create_index(index_name, index_config);
index_[label] = new_index; index_[index_name] = new_index;
return true; return true;
// TODO add documents to index // TODO add documents to index
} }
bool DropIndex(LabelId label) { bool DropIndex(std::string index_name) {
mgcxx_mock::text_search::Mock::drop_index(label.ToString()); mgcxx_mock::text_search::Mock::drop_index(index_name);
index_.erase(label); index_.erase(index_name);
return true; return true;
} }
bool IndexExists(LabelId label) { return index_.contains(label); } bool IndexExists(std::string index_name) { return index_.contains(index_name); }
mgcxx_mock::text_search::SearchOutput Search(LabelId label, mgcxx_mock::text_search::SearchInput input) { mgcxx_mock::text_search::SearchOutput Search(std::string index_name, mgcxx_mock::text_search::SearchInput input) {
return mgcxx_mock::text_search::Mock::search(index_.at(label), input); // TODO antepusic: Add metadata to the return fields before search
return mgcxx_mock::text_search::Mock::search(index_.at(index_name), input);
} }
std::vector<LabelId> ListIndices() { std::vector<std::string> ListIndices() {
std::vector<LabelId> ret; std::vector<std::string> ret;
ret.reserve(index_.size()); ret.reserve(index_.size());
for (const auto &item : index_) { for (const auto &item : index_) {
ret.push_back(item.first); ret.push_back(item.first);
@ -59,9 +61,9 @@ class TextIndex {
return ret; return ret;
} }
uint64_t ApproximateVertexCount(LabelId label) { return 10; } uint64_t ApproximateVertexCount(std::string index_name) { return 10; }
std::map<LabelId, mgcxx_mock::text_search::IndexContext> index_; std::map<std::string, mgcxx_mock::text_search::IndexContext> index_;
}; };
} // namespace memgraph::storage } // namespace memgraph::storage

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

@ -212,7 +212,9 @@ class Storage {
virtual bool LabelPropertyIndexExists(LabelId label, PropertyId property) const = 0; virtual bool LabelPropertyIndexExists(LabelId label, PropertyId property) const = 0;
bool TextIndexExists(LabelId label) const { return storage_->indices_.text_index_->IndexExists(label); } bool TextIndexExists(std::string index_name) const {
return storage_->indices_.text_index_->IndexExists(index_name);
}
virtual IndicesInfo ListAllIndices() const = 0; virtual IndicesInfo ListAllIndices() const = 0;
@ -250,9 +252,9 @@ class Storage {
std::vector<EdgeTypeId> ListAllPossiblyPresentEdgeTypes() const; std::vector<EdgeTypeId> ListAllPossiblyPresentEdgeTypes() const;
mgcxx_mock::text_search::SearchOutput TextSearch(LabelId label, mgcxx_mock::text_search::SearchOutput TextSearch(std::string index_name,
mgcxx_mock::text_search::SearchInput &search_input) const { mgcxx_mock::text_search::SearchInput &search_input) const {
return storage_->indices_.text_index_->Search(label, search_input); return storage_->indices_.text_index_->Search(index_name, search_input);
} }
virtual utils::BasicResult<StorageIndexDefinitionError, void> CreateIndex(LabelId label) = 0; virtual utils::BasicResult<StorageIndexDefinitionError, void> CreateIndex(LabelId label) = 0;
@ -263,14 +265,15 @@ class Storage {
virtual utils::BasicResult<StorageIndexDefinitionError, void> DropIndex(LabelId label, PropertyId property) = 0; virtual utils::BasicResult<StorageIndexDefinitionError, void> DropIndex(LabelId label, PropertyId property) = 0;
virtual utils::BasicResult<StorageIndexDefinitionError, void> CreateTextIndex(LabelId label) { virtual utils::BasicResult<StorageIndexDefinitionError, void> CreateTextIndex(std::string index_name,
LabelId label) {
// TODO: pass vertices to CreateIndex // TODO: pass vertices to CreateIndex
storage_->indices_.text_index_->CreateIndex(label, std::nullopt); storage_->indices_.text_index_->CreateIndex(index_name, label, std::nullopt);
return {}; return {};
} }
virtual utils::BasicResult<StorageIndexDefinitionError, void> DropTextIndex(LabelId label) { virtual utils::BasicResult<StorageIndexDefinitionError, void> DropTextIndex(std::string index_name) {
storage_->indices_.text_index_->DropIndex(label); storage_->indices_.text_index_->DropIndex(index_name);
return {}; return {};
} }

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

@ -21,7 +21,7 @@
#include "storage/v2/edge_accessor.hpp" #include "storage/v2/edge_accessor.hpp"
#include "storage/v2/id_types.hpp" #include "storage/v2/id_types.hpp"
#include "storage/v2/indices/indices.hpp" #include "storage/v2/indices/indices.hpp"
#include "storage/v2/mgcxx.hpp" #include "storage/v2/mgcxx_mock.hpp"
#include "storage/v2/mvcc.hpp" #include "storage/v2/mvcc.hpp"
#include "storage/v2/property_value.hpp" #include "storage/v2/property_value.hpp"
#include "storage/v2/result.hpp" #include "storage/v2/result.hpp"
@ -274,13 +274,14 @@ Result<PropertyValue> VertexAccessor::SetProperty(PropertyId property, const Pro
utils::AtomicMemoryBlock atomic_memory_block{ utils::AtomicMemoryBlock atomic_memory_block{
[transaction = transaction_, storage = storage_, vertex = vertex_, &value, &property, &current_value]() { [transaction = transaction_, storage = storage_, vertex = vertex_, &value, &property, &current_value]() {
CreateAndLinkDelta(transaction, vertex, Delta::SetPropertyTag(), property, current_value); CreateAndLinkDelta(transaction, vertex, Delta::SetPropertyTag(), property, current_value);
// Option 1 (current) // // Option 1 (current)
if (std::ranges::any_of(vertex->labels, // if (std::ranges::any_of(vertex->labels,
[storage](auto &label) { return storage->indices_.text_index_->IndexExists(label); })) { // [storage](auto &label) { return storage->indices_.text_index_->IndexExists(label);
vertex->properties.SetProperty(property, value, true, vertex->gid); // })) {
} else { // vertex->properties.SetProperty(property, value, true, vertex->gid);
vertex->properties.SetProperty(property, value); // } else {
} // vertex->properties.SetProperty(property, value);
// }
// // Option 2 (proposed) // // Option 2 (proposed)
// if (flags::run_time::GetTextSearchEnabled()) { // if (flags::run_time::GetTextSearchEnabled()) {
@ -326,13 +327,15 @@ Result<bool> VertexAccessor::InitProperties(const std::map<storage::PropertyId,
bool result{false}; bool result{false};
utils::AtomicMemoryBlock atomic_memory_block{ utils::AtomicMemoryBlock atomic_memory_block{
[&result, &properties, storage = storage_, transaction = transaction_, vertex = vertex_]() { [&result, &properties, storage = storage_, transaction = transaction_, vertex = vertex_]() {
if (std::ranges::any_of(vertex->labels, // if (std::ranges::any_of(vertex->labels,
[storage](auto &label) { return storage->indices_.text_index_->IndexExists(label); })) { // [storage](auto &label) { return storage->indices_.text_index_->IndexExists(label);
if (!vertex->properties.InitProperties(properties, true, vertex->gid)) { // })) {
result = false; // if (!vertex->properties.InitProperties(properties, true, vertex->gid)) {
return; // result = false;
} // return;
} else if (!vertex->properties.InitProperties(properties)) { // }
// } else
if (!vertex->properties.InitProperties(properties)) {
result = false; result = false;
return; return;
} }
@ -370,12 +373,13 @@ Result<std::vector<std::tuple<PropertyId, PropertyValue, PropertyValue>>> Vertex
std::optional<ReturnType> id_old_new_change; std::optional<ReturnType> id_old_new_change;
utils::AtomicMemoryBlock atomic_memory_block{ utils::AtomicMemoryBlock atomic_memory_block{
[storage = storage_, transaction = transaction_, vertex = vertex_, &properties, &id_old_new_change]() { [storage = storage_, transaction = transaction_, vertex = vertex_, &properties, &id_old_new_change]() {
if (std::ranges::any_of(vertex->labels, // if (std::ranges::any_of(vertex->labels,
[storage](auto &label) { return storage->indices_.text_index_->IndexExists(label); })) { // [storage](auto &label) { return storage->indices_.text_index_->IndexExists(label);
id_old_new_change.emplace(vertex->properties.UpdateProperties(properties, true, vertex->gid)); // })) {
} else { // id_old_new_change.emplace(vertex->properties.UpdateProperties(properties, true, vertex->gid));
id_old_new_change.emplace(vertex->properties.UpdateProperties(properties)); // } else {
} id_old_new_change.emplace(vertex->properties.UpdateProperties(properties));
// }
if (!id_old_new_change.has_value()) { if (!id_old_new_change.has_value()) {
return; return;
@ -420,12 +424,13 @@ Result<std::map<PropertyId, PropertyValue>> VertexAccessor::ClearProperties() {
transaction->constraint_verification_info.RemovedProperty(vertex); transaction->constraint_verification_info.RemovedProperty(vertex);
transaction->manyDeltasCache.Invalidate(vertex, property); transaction->manyDeltasCache.Invalidate(vertex, property);
} }
if (std::ranges::any_of(vertex->labels, // if (std::ranges::any_of(vertex->labels,
[storage](auto &label) { return storage->indices_.text_index_->IndexExists(label); })) { // [storage](auto &label) { return storage->indices_.text_index_->IndexExists(label);
vertex->properties.ClearProperties(true, vertex->gid); // })) {
} else { // vertex->properties.ClearProperties(true, vertex->gid);
vertex->properties.ClearProperties(); // } else {
} vertex->properties.ClearProperties();
// }
}}; }};
std::invoke(atomic_memory_block); std::invoke(atomic_memory_block);