transactor.hxx

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 *   FILE
 *      pqxx/transactor.hxx
 *
 *   DESCRIPTION
 *      definition of the pqxx::transactor class.
 *   pqxx::transactor is a framework-style wrapper for safe transactions
 *   DO NOT INCLUDE THIS FILE DIRECTLY; include pqxx/transactor instead.
 *
 * Copyright (c) 2001-2004, Jeroen T. Vermeulen <jtv@xs4all.nl>
 *
 * 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.
 *
 *-------------------------------------------------------------------------
 */
#include "pqxx/connection_base"
#include "pqxx/transaction"


/* Methods tested in eg. self-test program test001 are marked with "//[t1]"
 */

#define PQXX_DEPRECATED_TRANSACTION_CALLBACKS

namespace pqxx
{


template<typename TRANSACTION=transaction<read_committed> > 
  class transactor : 
    public PGSTD::unary_function<TRANSACTION, void>
{
public:
  explicit transactor(const PGSTD::string &TName="transactor") :        //[t4]
    m_Name(TName) { }


  void operator()(TRANSACTION &T);                                      //[t4]

  // Overridable member functions, called by connection_base::perform() if an
  // attempt to run transaction fails/succeeds, respectively, or if the 
  // connection is lost at just the wrong moment, goes into an indeterminate 
  // state.  Use these to patch up runtime state to match events, if needed, or
  // to report failure conditions.


  void on_abort(const char[]) throw () {}                               //[t13]


  void on_commit() {}                                                   //[t6]


  void on_doubt() throw () {}                                           //[t13]

#ifdef PQXX_DEPRECATED_TRANSACTION_CALLBACKS


  void OnCommit() {}

  void OnAbort(const char[]) throw () {}

  void OnDoubt() throw () {}
#endif

  // TODO: Rename Name()--is there a compatible way?
  PGSTD::string Name() const { return m_Name; }                         //[t13]

private:
  PGSTD::string m_Name;
};


}


template<typename TRANSACTOR> 
inline void pqxx::connection_base::perform(const TRANSACTOR &T,
                                           int Attempts)
{
  if (Attempts <= 0) return;

  bool Done = false;

  // Make attempts to perform T
  // TODO: Differentiate between db-related exceptions and other exceptions?
  do
  {
    --Attempts;

    // Work on a copy of T2 so we can restore the starting situation if need be
    TRANSACTOR T2(T);
    try
    {
      typename TRANSACTOR::argument_type X(*this, T2.Name());
      T2(X);
      X.commit();
      Done = true;
    }
    catch (const in_doubt_error &)
    {
      // Not sure whether transaction went through or not.  The last thing in
      // the world that we should do now is retry.
      T2.OnDoubt();
      throw;
    }
    catch (const PGSTD::exception &e)
    {
      // Could be any kind of error.  
#ifdef PQXX_DEPRECATED_TRANSACTION_CALLBACKS
      T2.OnAbort(e.what());
#endif
      T2.on_abort(e.what());
      if (Attempts <= 0) throw;
      continue;
    }
    catch (...)
    {
      // Don't try to forge ahead if we don't even know what happened
      T2.OnAbort("Unknown exception");
      throw;
    }

#ifdef PQXX_DEPRECATED_TRANSACTION_CALLBACKS
    T2.OnCommit();
#endif
    T2.on_commit();
  } while (!Done);
}

---