libpqxx  5.0
pqxx::transaction< ISOLATIONLEVEL, READWRITE > Class Template Reference

Standard back-end transaction, templatized on isolation level. More...

#include <transaction.hxx>

Inheritance diagram for pqxx::transaction< ISOLATIONLEVEL, READWRITE >:

Public Types

typedef isolation_traits
< ISOLATIONLEVEL > 
isolation_tag
 
- Public Types inherited from pqxx::transaction_base
typedef isolation_traits
< read_committed
isolation_tag
 If nothing else is known, our isolation level is at least read_committed. More...
 

Public Member Functions

 transaction (connection_base &C, const std::string &TName)
 Create a transaction. More...
 
 transaction (connection_base &C)
 
virtual ~transaction () PQXX_NOEXCEPT
 
- Public Member Functions inherited from pqxx::dbtransaction
virtual ~dbtransaction ()
 
- Public Member Functions inherited from pqxx::transaction_base
virtual ~transaction_base ()=0
 
void commit ()
 Commit the transaction. More...
 
void abort ()
 Abort the transaction. More...
 
std::string esc (const char str[]) const
 Escape string for use as SQL string literal in this transaction. More...
 
std::string esc (const char str[], size_t maxlen) const
 Escape string for use as SQL string literal in this transaction. More...
 
std::string esc (const std::string &str) const
 Escape string for use as SQL string literal in this transaction. More...
 
std::string esc_raw (const unsigned char data[], size_t len) const
 Escape binary data for use as SQL string literal in this transaction. More...
 
std::string esc_raw (const std::string &) const
 Escape binary data for use as SQL string literal in this transaction. More...
 
std::string unesc_raw (const std::string &text) const
 Unescape binary data, e.g. from a table field or notification payload. More...
 
std::string unesc_raw (const char *text) const
 Unescape binary data, e.g. from a table field or notification payload. More...
 
template<typename T >
std::string quote (const T &t) const
 Represent object as SQL string, including quoting & escaping. More...
 
std::string quote_raw (const unsigned char str[], size_t len) const
 Binary-escape and quote a binarystring for use as an SQL constant. More...
 
std::string quote_raw (const std::string &str) const
 
std::string quote_name (const std::string &identifier) const
 Escape an SQL identifier for use in a query. More...
 
result exec (const std::string &Query, const std::string &Desc=std::string())
 Execute query. More...
 
result exec (const std::stringstream &Query, const std::string &Desc=std::string())
 
internal::parameterized_invocation parameterized (const std::string &query)
 Parameterize a statement. More...
 
connection_baseconn () const
 Connection this transaction is running in. More...
 
void set_variable (const std::string &Var, const std::string &Val)
 Set session variable in this connection. More...
 
std::string get_variable (const std::string &)
 Get currently applicable value of variable. More...
 
prepare::invocation prepared (const std::string &statement=std::string())
 Execute prepared statement. More...
 
void process_notice (const char Msg[]) const
 Have connection process warning message. More...
 
void process_notice (const std::string &Msg) const
 Have connection process warning message. More...
 
- Public Member Functions inherited from pqxx::internal::namedclass
 namedclass (const std::string &Classname, const std::string &Name="")
 
const std::string & name () const PQXX_NOEXCEPT
 
const std::string & classname () const PQXX_NOEXCEPT
 
std::string description () const
 

Additional Inherited Members

- Protected Member Functions inherited from pqxx::basic_transaction
 basic_transaction (connection_base &C, const std::string &IsolationLevel, readwrite_policy)
 
- Protected Member Functions inherited from pqxx::dbtransaction
 dbtransaction (connection_base &, const std::string &IsolationString, readwrite_policy rw=read_write)
 
 dbtransaction (connection_base &, bool direct=true, readwrite_policy rw=read_write)
 
void start_backend_transaction ()
 Start a transaction on the backend and set desired isolation level. More...
 
virtual void do_begin ()
 Sensible default implemented here: begin backend transaction. More...
 
virtual result do_exec (const char Query[])
 Sensible default implemented here: perform query. More...
 
virtual void do_abort () PQXX_OVERRIDE
 Sensible default implemented here: abort backend transaction. More...
 
- Protected Member Functions inherited from pqxx::transaction_base
 transaction_base (connection_base &c, bool direct=true)
 Create a transaction (to be called by implementation classes only) More...
 
void Begin ()
 Begin transaction (to be called by implementing class) More...
 
void End () PQXX_NOEXCEPT
 End transaction. To be called by implementing class' destructor. More...
 
result DirectExec (const char C[], int Retries=0)
 Execute query on connection directly. More...
 
void reactivation_avoidance_clear () PQXX_NOEXCEPT
 Forget about any reactivation-blocking resources we tried to allocate. More...
 
- Static Protected Member Functions inherited from pqxx::dbtransaction
static std::string fullname (const std::string &ttype, const std::string &isolation)
 
- Protected Attributes inherited from pqxx::transaction_base
internal::reactivation_avoidance_counter m_reactivation_avoidance
 Resources allocated in this transaction that make reactivation impossible. More...
 

Detailed Description

template<isolation_level ISOLATIONLEVEL = read_committed, readwrite_policy READWRITE = read_write>
class pqxx::transaction< ISOLATIONLEVEL, READWRITE >

Standard back-end transaction, templatized on isolation level.

This is the type you'll normally want to use to represent a transaction on the database.

While you may choose to create your own transaction object to interface to the database backend, it is recommended that you wrap your transaction code into a transactor code instead and let the transaction be created for you.

See Also
pqxx/transactor.hxx

If you should find that using a transactor makes your code less portable or too complex, go ahead, create your own transaction anyway.

Usage example: double all wages

* extern connection C;
* work T(C);
* try
* {
* T.exec("UPDATE employees SET wage=wage*2");
* T.commit(); // NOTE: do this inside try block
* }
* catch (const exception &e)
* {
* cerr << e.what() << endl;
* T.abort(); // Usually not needed; same happens when T's life ends.
* }
*

Member Typedef Documentation

template<isolation_level ISOLATIONLEVEL = read_committed, readwrite_policy READWRITE = read_write>
typedef isolation_traits<ISOLATIONLEVEL> pqxx::transaction< ISOLATIONLEVEL, READWRITE >::isolation_tag

Constructor & Destructor Documentation

template<isolation_level ISOLATIONLEVEL = read_committed, readwrite_policy READWRITE = read_write>
pqxx::transaction< ISOLATIONLEVEL, READWRITE >::transaction ( connection_base C,
const std::string &  TName 
)
explicit

Create a transaction.

Parameters
CConnection for this transaction to operate on
TNameOptional name for transaction; must begin with a letter and may contain letters and digits only

References pqxx::transaction_base::Begin().

template<isolation_level ISOLATIONLEVEL = read_committed, readwrite_policy READWRITE = read_write>
pqxx::transaction< ISOLATIONLEVEL, READWRITE >::transaction ( connection_base C)
explicit
template<isolation_level ISOLATIONLEVEL = read_committed, readwrite_policy READWRITE = read_write>
virtual pqxx::transaction< ISOLATIONLEVEL, READWRITE >::~transaction ( )
virtual

The documentation for this class was generated from the following file: