robusttransaction.hxx

#ifndef PQXX_H_ROBUSTTRANSACTION
#define PQXX_H_ROBUSTTRANSACTION

#include "pqxx/compiler-public.hxx"
#include "pqxx/compiler-internal-pre.hxx"

#include "pqxx/dbtransaction.hxx"


// Methods tested in eg. test module test01 are marked with "//[t01]".

namespace pqxx
{

namespace internal
{
class PQXX_LIBEXPORT PQXX_NOVTABLE basic_robusttransaction :
  public dbtransaction
{
public:
  using isolation_tag = isolation_traits<read_committed>;

  virtual ~basic_robusttransaction() =0;                                //[t16]

protected:
  basic_robusttransaction(
        connection_base &C,
        const std::string &IsolationLevel,
        const std::string &table_name=std::string{});                   //[t16]

private:
  using IDType = unsigned long;
  IDType m_record_id = 0;
  std::string m_xid;
  std::string m_log_table;
  std::string m_sequence;
  int m_backendpid = -1;

  virtual void do_begin() override;                                     //[t18]
  virtual void do_commit() override;                                    //[t16]
  virtual void do_abort() override;                                     //[t18]

  PQXX_PRIVATE void CreateLogTable();
  PQXX_PRIVATE void CreateTransactionRecord();
  PQXX_PRIVATE std::string sql_delete() const;
  PQXX_PRIVATE void DeleteTransactionRecord() noexcept;
  PQXX_PRIVATE bool CheckTransactionRecord();
};
} // namespace internal



template<isolation_level ISOLATIONLEVEL=read_committed>
class robusttransaction : public internal::basic_robusttransaction
{
public:
  using isolation_tag = isolation_traits<ISOLATIONLEVEL>;


  explicit robusttransaction(
        connection_base &C,
        const std::string &Name=std::string{}) :
    namedclass{fullname("robusttransaction",isolation_tag::name()), Name},
    internal::basic_robusttransaction(C, isolation_tag::name())
        { Begin(); }

  virtual ~robusttransaction() noexcept
        { End(); }
};

} // namespace pqxx

#include "pqxx/compiler-internal-post.hxx"
#endif