F update

Summary

Implements update for a single entity

See https://gitlab.indiscale.com/caosdb/customers/lfpb/management/-/issues/392

Focus

• Updating entities works like this: Retrieve an entity, copy it and put it in the update transaction.
• ResultSet has an iterator now
• I privatated SetId and SetVersionId (nobody should ever need to change it, because Entities which are to be updated have to be retrieved first anyway.)
• More fine-grained TransactionStatus (INITIAL -> GO_ON -> READY -> EXECUTE -> SUCCESS/ERROR) and corresponding StatusCodes

Test Environment

Use with server branch f-grpc-f-update

Check List for the Author

Please, prepare your MR for a review. Be sure to write a summary and a focus and create gitlab comments for the reviewer. They should guide the reviewer through the changes, explain your changes and also point out open questions. For further good practices have a look at our review guidelines

• All automated tests pass
• Reference related Issues
• Up-to-date CHANGELOG.md
• Annotations in code (Gitlab comments)
  • Intent of new code
  • Problems with old code
  • Why this implementation?

Check List for the Reviewer

• I understand the intent of this MR
• All automated tests pass
• Up-to-date CHANGELOG.md
• The test environment setup works and the intended behavior is reproducible in the test environment
• In-code documentation and comments are up-to-date.
• Check: Are there specifications? Are they satisfied?

For further good practices have a look at our review guidelines.

src/caosdb/transaction.cpp

@@ -42,8 +42,14 @@ namespace caosdb {
 auto get_status_description(int code) -> const std::string & {
   static const std::string MISSING_DESCRIPTION = "MISSING DESCRIPTION";
   static const std::map<int, std::string> descriptions = {
-    {StatusCode::INITIAL, "The transaction has not been executed yet and "
-                          "clients can stil change it."},
+    {StatusCode::INITIAL,
+     "The transaction has just been intialized. It has not been executed yet "
+     "and clients can still change it and add sub-transactions."},
+    {StatusCode::GO_ON,
+     "The transaction has a transaction_type yet and clients may add matching "
+     "sub-transaction or execute it right-away."},
+    {StatusCode::READY,
+     "The transaction is ready for execution and cannot be changed anymore."},
     {StatusCode::EXECUTING, "The transaction is currently being executed."},
     {StatusCode::SUCCESS, "The action was successful"},
     {StatusCode::CONNECTION_ERROR,
@@ -68,6 +74,11 @@ auto get_status_description(int code) -> const std::string & {
     {StatusCode::TRANSACTION_TYPE_ERROR,
      "The Transaction has a transaction type which does not allow the "
      "attempted action."},
+    {StatusCode::ORIGINAL_ENTITY_MISSING_ID,
+     "The attempt to update this entity failed because this entity does not "
+     "have "
+     "an id. This is the case when you did not retrieve it before applying any "
+     "changes and instantiated the Entity class explicitely."},
     {StatusCode::UNSUPPORTED_FEATURE,
      "This feature is not available in the this client implementation."}};
   try {
@@ -90,6 +101,36 @@ using grpc::ClientAsyncResponseReader;
 using ProtoEntity = caosdb::entity::v1alpha1::Entity;
 using grpc::CompletionQueue;
 
+ResultSet::iterator::iterator(const ResultSet *result_set_param, int index)
+  : current_index(index), result_set(result_set_param) {}
+
+auto ResultSet::iterator::operator*() const -> const Entity & {
+  return this->result_set->At(current_index);
+}
+
+auto ResultSet::iterator::operator++() -> ResultSet::iterator & {
+  current_index++;
+  return *this;
+}
+
+auto ResultSet::iterator::operator++(int) -> ResultSet::iterator {
+  iterator tmp(*this);
+  operator++();
+  return tmp;
+}
+
+auto ResultSet::iterator::operator!=(const iterator &rhs) const -> bool {
+  return this->current_index != rhs.current_index;
+}
+
+auto ResultSet::begin() const -> ResultSet::iterator {
+  return ResultSet::iterator(this, 0);
+}
+
+auto ResultSet::end() const -> ResultSet::iterator {
+  return ResultSet::iterator(this, Size());
+}
+
 MultiResultSet::MultiResultSet(MultiTransactionResponse *response) {
   auto *responses = response->mutable_responses();
   for (auto sub_response : *responses) {
@@ -133,16 +174,21 @@ auto Transaction::RetrieveById(const std::string &id) noexcept -> StatusCode {
   auto *sub_request = this->request->add_requests();
   sub_request->mutable_retrieve_request()->set_id(id);
 
-  return StatusCode::INITIAL;
+  this->status = TransactionStatus::GO_ON();
+  return this->status.GetCode();
 }
 
 auto Transaction::Query(const std::string &query) noexcept -> StatusCode {
-  ASSERT_CAN_ADD_RETRIEVAL
+  ASSERT_CAN_ADD_QUERY
 
+  // currently, the server can only process one query at a time (but mixed with
+  // other retrievals).
+  this->has_query = true;
   auto *sub_request = this->request->add_requests();
   sub_request->mutable_retrieve_request()->mutable_query()->set_query(query);
 
-  return StatusCode::INITIAL;
+  this->status = TransactionStatus::GO_ON();
+  return this->status.GetCode();
 }
 
 auto Transaction::DeleteById(const std::string &id) noexcept -> StatusCode {
@@ -151,7 +197,8 @@ auto Transaction::DeleteById(const std::string &id) noexcept -> StatusCode {
   auto *sub_request = this->request->add_requests();
   sub_request->mutable_delete_request()->set_id(id);
 
-  return StatusCode::INITIAL;
+  this->status = TransactionStatus::READY();
+  return this->status.GetCode();
 }
 
 auto Transaction::InsertEntity(Entity *entity) noexcept -> StatusCode {
@@ -162,18 +209,33 @@ auto Transaction::InsertEntity(Entity *entity) noexcept -> StatusCode {
 
   // copy the original entity for the transaction
   entity->CopyTo(proto_entity);
-  return StatusCode::INITIAL;
+  this->status = TransactionStatus::READY();
+  return this->status.GetCode();
+}
+
+auto Transaction::UpdateEntity(Entity *entity) noexcept -> StatusCode {
+  ASSERT_CAN_ADD_UPDATE
+
+  auto *sub_request = this->request->add_requests();
+  auto *proto_entity = sub_request->mutable_update_request();
+
+  entity->CopyTo(proto_entity);
+  this->status = TransactionStatus::READY();
+  return this->status.GetCode();
 }
 
 auto Transaction::Execute() -> TransactionStatus {
-  ExecuteAsynchronously();
+  auto status_code = ExecuteAsynchronously();
+  TransactionStatus::ThrowExceptionIfError(
+    status_code, caosdb::get_status_description(status_code));
   auto status = WaitForIt();
   status.ThrowExceptionIfError();
   return status;
 }
 
 auto Transaction::ExecuteAsynchronously() noexcept -> StatusCode {
-  if (!IsStatus(TransactionStatus::INITIAL())) {
+  if (!IsStatus(TransactionStatus::READY()) &&
+      !IsStatus(TransactionStatus::GO_ON())) {
     return StatusCode::TRANSACTION_STATUS_ERROR;
   }
   switch (this->transaction_type) {
@@ -245,6 +307,14 @@ auto Transaction::WaitForIt() const noexcept -> TransactionStatus {
       }
       this->result_set = std::make_unique<UniqueResult>(entity);
     } break;
+    case WrappedResponseCase::kUpdateResponse: {
+      auto *updatedIdResponse = responses->mutable_update_response();
+      if (!updatedIdResponse->entity_errors().empty()) {
+        this->status = TransactionStatus::TRANSACTION_ERROR(
+          "The request returned with errors.");
+      }
+      this->result_set = std::make_unique<UniqueResult>(updatedIdResponse);
+    } break;
     case WrappedResponseCase::kInsertResponse: {
       auto *insertedIdResponse = responses->mutable_insert_response();
       if (!insertedIdResponse->entity_errors().empty()) {