pqxx::robusttransaction< ISOLATION > Class Template Referencefinal
Slightly slower, better-fortified version of transaction. More...
#include <robusttransaction.hxx>
Inheritance diagram for pqxx::robusttransaction< ISOLATION >:
Public Member Functions | |
| robusttransaction (connection &c, std::string_view name=std::string_view{}) | |
| virtual | ~robusttransaction () noexcept override |
 Public Member Functions inherited from pqxx::internal::basic_robusttransaction | |
| virtual | ~basic_robusttransaction () override=0 |
| Public Member Functions inherited from pqxx::transaction_base | |
| transaction_base ()=delete | |
| transaction_base (transaction_base const &)=delete | |
| transaction_base & | operator= (transaction_base const &)=delete |
| virtual | ~transaction_base ()=0 |
| void | commit () |
| Commit the transaction. More... | |
| void | abort () |
| Abort the transaction. More... | |
| result | exec (std::string_view query, std::string const &desc=std::string{}) |
| Execute query. More... | |
| result | exec (std::stringstream const &query, std::string const &desc=std::string{}) |
| result | exec0 (std::string const &query, std::string const &desc=std::string{}) |
| Execute query, which should zero rows of data. More... | |
| row | exec1 (std::string const &query, std::string const &desc=std::string{}) |
| Execute query returning a single row of data. More... | |
| result | exec_n (result::size_type rows, std::string const &query, std::string const &desc=std::string{}) |
| Execute query, expect given number of rows. More... | |
| template<typename TYPE > | |
| TYPE | query_value (std::string const &query, std::string const &desc=std::string{}) |
| Execute query, expecting exactly 1 row with 1 field. More... | |
| template<typename... TYPE> | |
| auto | stream (std::string_view query) |
| Execute a query, and loop over the results row by row. More... | |
| connection & | conn () const |
| The connection in which this transaction lives. More... | |
| void | set_variable (std::string_view var, std::string_view value) |
| Set session variable using SQL "SET" command. More... | |
| std::string | get_variable (std::string_view) |
| Read session variable using SQL "SHOW" command. More... | |
| std::string | esc (char const text[]) const |
| Escape string for use as SQL string literal in this transaction. More... | |
| std::string | esc (char const text[], std::size_t maxlen) const |
| Escape string for use as SQL string literal in this transaction. More... | |
| std::string | esc (std::string const &text) const |
| Escape string for use as SQL string literal in this transaction. More... | |
| std::string | esc (std::string_view text) const |
| Escape string for use as SQL string literal in this transaction. More... | |
| std::string | esc_raw (unsigned char const data[], std::size_t len) const |
| Escape binary data for use as SQL string literal in this transaction. More... | |
| std::string | esc_raw (std::string const &) const |
| Escape binary data for use as SQL string literal in this transaction. More... | |
| std::string | unesc_raw (std::string const &text) const |
| Unescape binary data, e.g. from a table field or notification payload. More... | |
| std::string | unesc_raw (char const *text) const |
| Unescape binary data, e.g. from a table field or notification payload. More... | |
| template<typename T > | |
| std::string | quote (T const &t) const |
| Represent object as SQL string, including quoting & escaping. More... | |
| std::string | quote_raw (unsigned char const bin[], std::size_t len) const |
| Binary-escape and quote a binarystring for use as an SQL constant. More... | |
| std::string | quote_raw (std::string const &bin) const |
| std::string | quote_name (std::string_view identifier) const |
| Escape an SQL identifier for use in a query. More... | |
| std::string | esc_like (std::string const &bin, char escape_char='\\') const |
| Escape string for literal LIKE match. More... | |
| template<typename... Args> | |
| result | exec_params (std::string const &query, Args &&... args) |
| Execute an SQL statement with parameters. More... | |
| template<typename... Args> | |
| row | exec_params1 (std::string const &query, Args &&... args) |
| template<typename... Args> | |
| result | exec_params0 (std::string const &query, Args &&... args) |
| template<typename... Args> | |
| result | exec_params_n (std::size_t rows, std::string const &query, Args &&... args) |
| template<typename... Args> | |
| result | exec_prepared (std::string const &statement, Args &&... args) |
| Execute a prepared statement, with optional arguments. More... | |
| template<typename... Args> | |
| result | exec_prepared (zview statement, Args &&... args) |
| template<typename... Args> | |
| row | exec_prepared1 (std::string const &statement, Args &&... args) |
| Execute a prepared statement, and expect a single-row result. More... | |
| template<typename... Args> | |
| row | exec_prepared1 (zview statement, Args &&... args) |
| template<typename... Args> | |
| result | exec_prepared0 (std::string const &statement, Args &&... args) |
| Execute a prepared statement, and expect a result with zero rows. More... | |
| template<typename... Args> | |
| result | exec_prepared0 (zview statement, Args &&... args) |
| template<typename... Args> | |
| result | exec_prepared_n (result::size_type rows, std::string const &statement, Args &&... args) |
| Execute a prepared statement, expect a result with given number of rows. More... | |
| template<typename... Args> | |
| result | exec_prepared_n (result::size_type rows, zview statement, Args &&... args) |
| void | process_notice (char const msg[]) const |
| Have connection process a warning message. More... | |
| void | process_notice (std::string const &msg) const |
| Have connection process a warning message. More... | |
| Public Member Functions inherited from pqxx::internal::namedclass | |
| namedclass (std::string_view classname) | |
| namedclass (std::string_view classname, std::string_view name) | |
| namedclass (std::string_view classname, char const name[]) | |
| namedclass (std::string_view classname, std::string &&name) | |
| std::string const & | name () const noexcept |
| Object name, or the empty string if no name was given. More... | |
| std::string const & | 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_robusttransaction | |
| basic_robusttransaction (connection &c, char const begin_command[]) | |
| Protected Member Functions inherited from pqxx::dbtransaction | |
| dbtransaction (connection &c) | |
| Protected Member Functions inherited from pqxx::transaction_base | |
| transaction_base (connection &c) | |
| Create a transaction (to be called by implementation classes only). More... | |
| void | register_transaction () |
| Register this transaction with the connection. More... | |
| void | close () noexcept |
| End transaction. To be called by implementing class' destructor. More... | |
| result | direct_exec (std::string_view) |
| Execute query on connection directly. More... | |
| result | direct_exec (std::shared_ptr< std::string >) |
Detailed Description
template<isolation_level ISOLATION = read_committed>
class pqxx::robusttransaction< ISOLATION >
Slightly slower, better-fortified version of transaction.
Requires PostgreSQL 10 or better.
robusttransaction is similar to transaction, but spends more time and effort to deal with the hopefully rare case that the connection to the backend is lost just while it's trying to commit. In such cases, the client does not know whether the backend (on the other side of the broken connection) managed to commit the transaction.
Whe this happens, robusttransaction tries to reconnect to the database and figure out what happened.
This service level was made optional since you may not want to pay the overhead where it is not necessary. Certainly the use of this class makes no sense for local connections, or for transactions that read the database but never modify it, or for noncritical database manipulations.
Besides being slower, it's also more complex. Which means that in practice a robusttransaction could actually fail more instead of less often than a normal transaction. What robusttransaction tries to achieve is to give you certainty, not just be more successful per se.
Constructor & Destructor Documentation
◆ robusttransaction()
template<isolation_level ISOLATION = read_committed>
|
explicit |
Create robusttransaction of given name.
- Parameters
-
c Connection inside which this robusttransaction should live. name optional human-readable name for this transaction.
◆ ~robusttransaction()
template<isolation_level ISOLATION = read_committed>
|
overridevirtualnoexcept |
The documentation for this class was generated from the following file:
