Retrieve

Protocol for retrieving document(s).

Data model that represents the payload to be submitted to the service for retrieving documents. Model supports raw BSON document queries as well as structures that can be serialised to BSON.

//
// Created by Rakesh on 13/12/2024.
//

#pragma once

#include "../../options/find.hpp"
#include "action.hpp"

#include <bsoncxx/builder/stream/document.hpp>

namespace spt::mongoservice::api::model::request
{
  template <util::Visitable Document>
  struct Retrieve
  {
    explicit Retrieve( Document&& document ) : document{ std::forward<Document>( document ) } {}
    Retrieve() = default;
    ~Retrieve() = default;
    Retrieve(Retrieve&&) = default;
    Retrieve& operator=(Retrieve&&) = default;

    Retrieve(const Retrieve&) = delete;
    Retrieve& operator=(const Retrieve&) = delete;

    BEGIN_VISITABLES(Retrieve);
    VISITABLE(std::optional<Document>, document);
    VISITABLE(std::optional<options::Find>, options);
    std::string database;
    std::string collection;
    std::string application;
    std::string correlationId;
    Action action{Action::retrieve};
    bool skipMetric{false};
    END_VISITABLES;
  };
}

Data model that represents the payload that the service responds with when retrieving documents.

//
// Retrieved by Rakesh on 17/12/2024.
//

#pragma once

#if defined __has_include
  #if __has_include("../../../common/visit_struct/visit_struct_intrusive.hpp")
    #include "../../../common/visit_struct/visit_struct_intrusive.hpp"
    #include "../../../common/util/serialise.hpp"
  #else
    #include <mongo-service/common/visit_struct/visit_struct_intrusive.hpp>
    #include <mongo-service/common/util/serialise.hpp>
  #endif
#endif

namespace spt::mongoservice::api::model::response
{
  template <util::Visitable Document>
  requires std::is_same_v<decltype(Document::id), bsoncxx::oid>
  struct Retrieve
  {
    explicit Retrieve( bsoncxx::document::view document ) { util::unmarshall( *this, document ); }
    Retrieve() = default;
    ~Retrieve() = default;
    Retrieve(Retrieve&&) = default;
    Retrieve& operator=(Retrieve&&) = default;

    Retrieve(const Retrieve&) = delete;
    Retrieve& operator=(const Retrieve&) = delete;

    BEGIN_VISITABLES(Retrieve);
    VISITABLE(std::optional<Document>, result);
    VISITABLE(std::vector<Document>, results);
    END_VISITABLES;
  };
}

Sample code illustrating the retrieve action.

#include <mongo-service/api/repository/repository.hpp>

namespace example
{
  struct Document
  {
    explicit Document( bsoncxx::document::view bson ) { spt::util::unmarshall( *this, bson ); }
    Document() = default;
    ~Document() = default;
    Document(Document&&) = default;
    Document& operator=(Document&&) = default;
    bool operator==(const Document&) const = default;

    Document(const Document&) = delete;
    Document& operator=(const Document&) = delete;

    BEGIN_VISITABLES(Document);
    VISITABLE(bsoncxx::oid, id);
    VISITABLE(std::string, str);
    VISITABLE_DIRECT_INIT(spt::util::DateTimeMs, created, {std::chrono::duration_cast<std::chrono::milliseconds>( std::chrono::system_clock::now().time_since_epoch() )});
    VISITABLE_DIRECT_INIT(int64_t, integer, {5});
    VISITABLE_DIRECT_INIT(double, floating, {10.345});
    VISITABLE_DIRECT_INIT(bool, boolean, {true});
    END_VISITABLES;
  };
}

int main()
{
  using namespace spt::mongoservice::api;

  {
    auto retrieve = model::request::Retrieve{ model::request::IdFilter{} };
    retrieve.database = database;
    retrieve.collection = collection;
    retrieve.document->id = oid;
    retrieve.options = options::Find{};
    retrieve.options->sort = document{} << "str" << 1 << "_id" << -1 << finalize;
    retrieve.options->maxTime = std::chrono::milliseconds{ 1000 };
    retrieve.options->limit = 1;

    auto resp = repository::retrieve<pmodel::Document>( retrieve );
    if ( !resp.has_value() )
    {
      LOG_WARN << "Error retrieving document " << db << ':' << M::Collection() << ':' << oid <<
        ". " << magic_enum::enum_name( resp.error().cause ) << ". " << resp.error().message;
    }
  }

  {
    auto retrieve = model::request::Retrieve<bsoncxx::document::value>{ document{} << "str" << "value modified update" << finalize  };
    retrieve.database = database;
    retrieve.collection = collection;
    retrieve.options = options::Find{};
    retrieve.options->sort = document{} << "str" << 1 << "_id" << -1 << finalize;
    retrieve.options->maxTime = std::chrono::milliseconds{ 1000 };
    retrieve.options->limit = 1000;

    auto result = repository::retrieve<pmodel::Document>( retrieve );
    if ( !resp.has_value() )
    {
      LOG_WARN << "Error retrieving documents " << db << ':' << M::Collection() << " using query. " <<
        ". " << magic_enum::enum_name( resp.error().cause ) << ". " << resp.error().message;
    }
  }
}

Last modified: 18 February 2025