pqxx::transaction< ISOLATIONLEVEL, READWRITE > Class Template Reference
Transaction classes

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

`#include <transaction.hxx>`

Inheritance diagram for pqxx::transaction< ISOLATIONLEVEL, READWRITE >:
[legend]

## Public Types

using | isolation_tag = isolation_traits< ISOLATIONLEVEL >
Public Types inherited from pqxx::transaction_base
using | isolation_tag = isolation_traits< read_committed >
| 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 () noexcept
Public Member Functions inherited from pqxx::dbtransaction
virtual | ~dbtransaction ()
Public Member Functions inherited from pqxx::transaction_base
| transaction_base ()=delete
| transaction_base (const transaction_base &)=delete
transaction_base & | operator= (const transaction_base &)=delete
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...
std::string | esc_like (const std::string &str, char escape_char='\\') const
| Escape string for literal LIKE match. 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{})
result | exec0 (const std::string &Query, const std::string &Desc=std::string{})
| Execute query, which should zero rows of data. More...
row | exec1 (const std::string &Query, const std::string &Desc=std::string{})
| Execute query returning a single row of data. More...
result | exec_n (size_t rows, const std::string &Query, const std::string &Desc=std::string{})
| Execute query, expect given number of rows. More...
template<typename ... Args>
result | exec_params (const std::string &query, Args &&...args)
| Execute an SQL statement with parameters. More...
template<typename ... Args>
row | exec_params1 (const std::string &query, Args &&... args)
template<typename ... Args>
result | exec_params0 (const std::string &query, Args &&...args)
template<typename ... Args>
result | exec_params_n (size_t rows, const std::string &query, Args &&...args)
internal::parameterized_invocation | parameterized (const std::string &query)
| Parameterize a statement. More...
template<typename ... Args>
result | exec_prepared (const std::string &statement, Args &&... args)
| Execute a prepared statement, with optional arguments. More...
template<typename ... Args>
row | exec_prepared1 (const std::string &statement, Args &&... args)
| Execute a prepared statement, and expect a single-row result. More...
template<typename ... Args>
result | exec_prepared0 (const std::string &statement, Args &&... args)
| Execute a prepared statement, and expect a result with zero rows. More...
template<typename ... Args>
result | exec_prepared_n (size_t rows, const std::string &statement, Args &&... args)
| Execute a prepared statement, expect a result with given number of rows. 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...
connection_base & | conn () 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...
Public Member Functions inherited from pqxx::internal::namedclass
| namedclass (const std::string &Classname)
| namedclass (const std::string &Classname, const std::string &Name)
const std::string & | name () const noexcept
| Object name, or the empty string if no name was given. More...
const std::string & | classname () const noexcept
| Class name. More...
std::string | description () const
| Combination of class name and object name; or just class name. More...

## Additional Inherited Members

Protected Member Functions inherited from pqxx::internal::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 () override
| Sensible default implemented here: begin backend transaction. More...
virtual result | do_exec (const char Query[]) override
| Sensible default implemented here: perform query. More...
virtual void | do_abort () 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 () noexcept
| End transaction. To be called by implementing class' destructor. More...
result | direct_exec (const char C[], int Retries=0)
| Execute query on connection directly. More...
void | reactivation_avoidance_clear () 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

## isolation_tag

template<isolation_level ISOLATIONLEVEL = read_committed, readwrite_policy READWRITE = read_write>

using pqxx::transaction< ISOLATIONLEVEL, READWRITE >::isolation_tag = isolation_traits<ISOLATIONLEVEL>

## Constructor & Destructor Documentation

## transaction() [1/2]

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

  C | Connection for this transaction to operate on
  TName | Optional name for transaction; must begin with a letter and may contain letters and digits only

References pqxx::dbtransaction::fullname(), and pqxx::isolation_traits< LEVEL >::name().

## transaction() [2/2]

template<isolation_level ISOLATIONLEVEL = read_committed, readwrite_policy READWRITE = read_write>

pqxx::transaction< ISOLATIONLEVEL, READWRITE >::transaction | ( | connection_base & | C | ) |

explicit

## ~transaction()

template<isolation_level ISOLATIONLEVEL = read_committed, readwrite_policy READWRITE = read_write>

virtual pqxx::transaction< ISOLATIONLEVEL, READWRITE >::~transaction | ( |  | ) |

virtual noexcept

References pqxx::transaction_base::End().

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

- transaction.hxx

pqxx::connection
basic_connection_base< connect_direct > connection
The "standard" connection type: connect to database right now.
Definition: connection.hxx:97
pqxx::work
transaction<> work
The default transaction type.
Definition: transaction.hxx:107