Distinct

Protocol for retrieving distinct values of a specific field. The payload document must contain the field for which distinct values are to be retrieved. An optional filter field can be used to specify the filter query to use when retrieving distinct values.

Data model that represents the payload to be submitted to the service for retrieving distinct values. 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/distinct.hpp"
#include "action.hpp"

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

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

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

      BEGIN_VISITABLES(Payload);
      VISITABLE(std::optional<Document>, filter);
      VISITABLE(std::string, field);
      END_VISITABLES;
    };

    explicit Distinct( Document&& document ) : document{ std::forward<Document>( document ) } {}
    Distinct() = default;
    ~Distinct() = default;
    Distinct(Distinct&&) = default;
    Distinct& operator=(Distinct&&) = default;

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

    BEGIN_VISITABLES(Distinct);
    VISITABLE(std::optional<Payload>, document);
    VISITABLE(std::optional<options::Distinct>, options);
    std::string database;
    std::string collection;
    std::string application;
    std::string correlationId;
    Action action{Action::distinct};
    bool skipMetric{false};
    END_VISITABLES;
  };
}

Data model that represents the payload that the service responds with when returning distinct values.

//
// Distinctd 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

#include <cstdint>
#include <string>
#include <vector>

namespace spt::mongoservice::api::model::response
{
  struct Distinct
  {
    struct Value
    {
      Value() = default;
      ~Value() = default;
      Value(Value&&) = default;
      Value& operator=(Value&&) = default;
      bool operator==(const Value& other) const = default;

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

      BEGIN_VISITABLES(Value);
      VISITABLE(std::vector<std::string>, values);
      VISITABLE(int64_t, ok);
      END_VISITABLES;
    };

    explicit Distinct( bsoncxx::document::view document ) { util::unmarshall( *this, document ); }
    Distinct() = default;
    ~Distinct() = default;
    Distinct(Distinct&&) = default;
    Distinct& operator=(Distinct&&) = default;

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

    BEGIN_VISITABLES(Distinct);
    VISITABLE(std::vector<Value>, results);
    END_VISITABLES;
  };
}

Sample code illustrating the distinct action.

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

namespace example
{
  struct Query
  {
    bool operator==(const Query&) const = default;
    BEGIN_VISITABLES(Query);
    VISITABLE(std::string, str);
    END_VISITABLES;
  };
}

int main()
{
  using namespace spt::mongoservice::api;
  auto distinct = model::request::Distinct{ example::Query{} };
  distinct.database = "test";
  distinct.collection = "test";
  distinct.document->filter = std::nullopt;
  distinct.document->field = "str";
  distinct.emplace();
  distinct.options->maxTime = std::chrono::milliseconds{ 1000 };

  auto result = repository::distinct( distinct );
  if ( !result.has_value() )
  {
    LOG_WARN << "Error retrieving distinct values. " << magic_enum::enum_name( result.error().cause ) << ". " << result.error().message;
  }
}

Last modified: 18 February 2025