cluster.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <memory>
 
#include <userver/clients/dns/resolver_fwd.hpp>
#include <userver/engine/task/task_processor_fwd.hpp>
#include <userver/engine/task/task_with_result.hpp>
#include <userver/error_injection/settings_fwd.hpp>
#include <userver/testsuite/postgres_control.hpp>
 
#include <userver/storages/postgres/cluster_types.hpp>
#include <userver/storages/postgres/database.hpp>
#include <userver/storages/postgres/detail/non_transaction.hpp>
#include <userver/storages/postgres/options.hpp>
#include <userver/storages/postgres/query.hpp>
#include <userver/storages/postgres/statistics.hpp>
#include <userver/storages/postgres/transaction.hpp>
 
 
USERVER_NAMESPACE_BEGIN
 
namespace components {
class Postgres;
}  // namespace components
 
namespace storages::postgres {
 
namespace detail {
 
class ClusterImpl;
using ClusterImplPtr = std::unique_ptr<ClusterImpl>;
 
}  // namespace detail
 
class Cluster {
 public:
  Cluster(DsnList dsns, clients::dns::Resolver* resolver,
          engine::TaskProcessor& bg_task_processor,
          const ClusterSettings& cluster_settings,
          DefaultCommandControls&& default_cmd_ctls,
          const testsuite::PostgresControl& testsuite_pg_ctl,
          const error_injection::Settings& ei_settings);
  ~Cluster();
 
  ClusterStatisticsPtr GetStatistics() const;
 
 
  Transaction Begin(const TransactionOptions&, OptionalCommandControl = {});
 
  Transaction Begin(ClusterHostTypeFlags, const TransactionOptions&,
                    OptionalCommandControl = {});
 
  Transaction Begin(const std::string& name, const TransactionOptions&);
 
  Transaction Begin(const std::string& name, ClusterHostTypeFlags,
                    const TransactionOptions&);
 
 
  template <typename... Args>
  ResultSet Execute(ClusterHostTypeFlags, const Query& query,
                    const Args&... args);
 
  template <typename... Args>
  ResultSet Execute(ClusterHostTypeFlags, OptionalCommandControl,
                    const Query& query, const Args&... args);
 
  ResultSet Execute(ClusterHostTypeFlags flags, const Query& query,
                    const ParameterStore& store);
 
  ResultSet Execute(ClusterHostTypeFlags flags,
                    OptionalCommandControl statement_cmd_ctl,
                    const Query& query, const ParameterStore& store);
 
  void SetDefaultCommandControl(CommandControl);
 
  CommandControl GetDefaultCommandControl() const;
 
  void SetHandlersCommandControl(
      const CommandControlByHandlerMap& handlers_command_control);
 
  void SetQueriesCommandControl(
      const CommandControlByQueryMap& queries_command_control);
 
  void ApplyGlobalCommandControlUpdate(CommandControl);
 
  void SetConnectionSettings(const ConnectionSettings& settings);
 
  void SetPoolSettings(const PoolSettings& settings);
 
  void SetStatementMetricsSettings(const StatementMetricsSettings& settings);
 
 private:
  detail::NonTransaction Start(ClusterHostTypeFlags, OptionalCommandControl);
 
  OptionalCommandControl GetQueryCmdCtl(const std::string& query_name) const;
  OptionalCommandControl GetHandlersCmdCtl(
      OptionalCommandControl cmd_ctl) const;
 
  detail::ClusterImplPtr pimpl_;
};
 
template <typename... Args>
ResultSet Cluster::Execute(ClusterHostTypeFlags flags, const Query& query,
                           const Args&... args) {
  return Execute(flags, OptionalCommandControl{}, query, args...);
}
 
template <typename... Args>
ResultSet Cluster::Execute(ClusterHostTypeFlags flags,
                           OptionalCommandControl statement_cmd_ctl,
                           const Query& query, const Args&... args) {
  if (!statement_cmd_ctl && query.GetName()) {
    statement_cmd_ctl = GetQueryCmdCtl(query.GetName()->GetUnderlying());
  }
  statement_cmd_ctl = GetHandlersCmdCtl(statement_cmd_ctl);
  auto ntrx = Start(flags, statement_cmd_ctl);
  return ntrx.Execute(statement_cmd_ctl, query, args...);
}
 
}  // namespace storages::postgres
 
USERVER_NAMESPACE_END