robusttransaction.hxx

Go to the documentation of this file.

/* Definition of the pqxx::robusttransaction class.
 *
 * pqxx::robusttransaction is a slower but safer transaction class.
 *
 * DO NOT INCLUDE THIS FILE DIRECTLY; include pqxx/robusttransaction instead.
 *
 * Copyright (c) 2000-2026, Jeroen T. Vermeulen.
 *
 * See COPYING for copyright license.  If you did not receive a file called
 * COPYING with this source code, please notify the distributor of this
 * mistake, or contact the author.
 */
#ifndef PQXX_ROBUSTTRANSACTION_HXX
#define PQXX_ROBUSTTRANSACTION_HXX
 
#if !defined(PQXX_HEADER_PRE)
#  error "Include libpqxx headers as <pqxx/header>, not <pqxx/header.hxx>."
#endif
 
#include "pqxx/dbtransaction.hxx"
 
namespace pqxx::internal
{
class PQXX_LIBEXPORT PQXX_NOVTABLE basic_robusttransaction
        : public dbtransaction
{
public:
  basic_robusttransaction(basic_robusttransaction const &) = delete;
  basic_robusttransaction(basic_robusttransaction &&) = delete;
  ~basic_robusttransaction() override = 0;
 
  basic_robusttransaction &operator=(basic_robusttransaction const &) = delete;
  basic_robusttransaction &operator=(basic_robusttransaction &&) = delete;
 
protected:
  basic_robusttransaction(connection &cx, zview begin_command, sl);
 
private:
  using IDType = unsigned long;
 
  std::string m_conn_string;
  std::string m_xid;
  int m_backendpid = -1;
 
  void init(zview begin_command, sl);
 
  // @warning This function will become `final`.
  void do_commit(sl) override;
};
} // namespace pqxx::internal
 
 
namespace pqxx
{
 
template<isolation_level ISOLATION = read_committed>
class robusttransaction final : public internal::basic_robusttransaction
{
public:
  robusttransaction(connection &cx, std::string_view tname) :
          internal::basic_robusttransaction{
            cx, pqxx::internal::begin_cmd<ISOLATION, write_policy::read_write>,
            tname}
  {}
 
  robusttransaction(connection &cx, std::string &&tname) :
          internal::basic_robusttransaction{
            cx, pqxx::internal::begin_cmd<ISOLATION, write_policy::read_write>,
            std::move(tname)}
  {}
 
  explicit robusttransaction(connection &cx, sl loc = sl::current()) :
          internal::basic_robusttransaction{
            cx, pqxx::internal::begin_cmd<ISOLATION, write_policy::read_write>,
            loc}
  {}
 
  robusttransaction(robusttransaction const &) = delete;
  robusttransaction(robusttransaction &&) = delete;
 
  ~robusttransaction() noexcept override { close(sl::current()); }
 
  robusttransaction &operator=(robusttransaction const &) = delete;
  robusttransaction &operator=(robusttransaction &&) = delete;
};
 
} // namespace pqxx
#endif