transactor.hxx

Go to the documentation of this file.

/* Transactor framework, a wrapper for safely retryable transactions.
 *
 * DO NOT INCLUDE THIS FILE DIRECTLY; include pqxx/transactor 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_TRANSACTOR_HXX
#define PQXX_TRANSACTOR_HXX
 
#if !defined(PQXX_HEADER_PRE)
#  error "Include libpqxx headers as <pqxx/header>, not <pqxx/header.hxx>."
#endif
 
#include <functional>
#include <type_traits>
 
#include "pqxx/connection.hxx"
#include "pqxx/transaction.hxx"
 
namespace pqxx
{
 
 
template<typename TRANSACTION_CALLBACK>
inline std::invoke_result_t<TRANSACTION_CALLBACK>
perform(TRANSACTION_CALLBACK &&callback, int attempts, sl loc = sl::current())
 
{
  if (attempts <= 0)
    throw std::invalid_argument{
      "Zero or negative number of attempts passed to pqxx::perform()."};
 
  for (; attempts > 0; --attempts)
  {
    try
    {
      return std::invoke(callback);
    }
    catch (in_doubt_error const &)
    {
      // Not sure whether transaction went through or not.  The last thing in
      // the world that we should do now is try again!
      throw;
    }
    catch (statement_completion_unknown const &)
    {
      // Not sure whether our last statement succeeded.  Don't risk running it
      // again.
      throw;
    }
    catch (protocol_violation const &)
    {
      // This is a subclass of broken_connection, but it's not one where
      // retrying is likely to do us any good.
      throw;
    }
    catch (broken_connection const &)
    {
      // Connection failed.  May be worth retrying, if the transactor opens its
      // own connection.
      if (attempts <= 1)
        throw;
      continue;
    }
    catch (transaction_rollback const &)
    {
      // Some error that may well be transient, such as serialization failure
      // or deadlock.  Worth retrying.
      if (attempts <= 1)
        throw;
      continue;
    }
  }
  throw pqxx::internal_error{"No outcome reached on perform().", loc};
}
 
 
 
template<typename TRANSACTION_CALLBACK>
inline std::invoke_result_t<TRANSACTION_CALLBACK>
perform(TRANSACTION_CALLBACK &&callback, sl loc = sl::current())
{
  return perform(callback, 3, loc);
}
} // namespace pqxx
#endif