pqxx::dbtransaction Class Reference
Abstract transaction base class: bracket transactions on the database. More...
#include <dbtransaction.hxx>
Inheritance diagram for pqxx::dbtransaction:
Protected Member Functions | |
| dbtransaction (connection &c) | |
| Begin transaction. More... | |
| dbtransaction (connection &c, std::string_view tname) | |
| Begin transaction. More... | |
| dbtransaction (connection &c, std::string_view tname, std::shared_ptr< std::string > rollback_cmd) | |
| Begin transaction. More... | |
 Protected Member Functions inherited from pqxx::transaction_base | |
| transaction_base (connection &c, std::string_view tname, std::shared_ptr< std::string > rollback_cmd) | |
| Create a transaction (to be called by implementation classes only). More... | |
| transaction_base (connection &c, std::string_view tname) | |
| Create a transaction (to be called by implementation classes only). More... | |
| 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... | |
| virtual void | do_commit ()=0 |
| To be implemented by derived implementation class: commit transaction. More... | |
| virtual void | do_abort () |
| Transaction type-specific way of aborting a transaction. More... | |
| void | set_rollback_cmd (std::shared_ptr< std::string > cmd) |
| Set the rollback command. More... | |
| result | direct_exec (std::string_view, std::string_view desc=""sv) |
| Execute query on connection directly. More... | |
| result | direct_exec (std::shared_ptr< std::string >, std::string_view desc=""sv) |
Additional Inherited Members | |
| Public Member Functions inherited from pqxx::transaction_base | |
| transaction_base ()=delete | |
| transaction_base (transaction_base const &)=delete | |
| transaction_base (transaction_base &&)=delete | |
| transaction_base & | operator= (transaction_base const &)=delete |
| transaction_base & | operator= (transaction_base &&)=delete |
| virtual | ~transaction_base ()=0 |
| void | commit () |
| Commit the transaction. More... | |
| void | abort () |
| Abort the transaction. 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_view | name () const noexcept |
| Transaction name, if you passed one to the constructor; or empty string. More... | |
| template<> | |
| zview | query_value (zview query, std::string_view desc)=delete |
| Forbidden specialisation: underlying buffer immediately goes out of scope. 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_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 (zview) const |
| Escape binary data for use as SQL string literal in this transaction. More... | |
| std::string | unesc_raw (zview 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 binary string for use as an SQL constant. More... | |
| std::string | quote_raw (zview bin) const |
| Binary-escape and quote a binary string for use as an SQL constant. More... | |
| 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_view bin, char escape_char='\\') const |
| Escape string for literal LIKE match. More... | |
| result | exec (std::string_view query, std::string_view desc=std::string_view{}) |
| Execute a command. More... | |
| result | exec (std::stringstream const &query, std::string_view desc=std::string_view{}) |
| Execute a command. More... | |
| result | exec0 (zview query, std::string_view desc=std::string_view{}) |
| Execute command, which should return zero rows of data. More... | |
| row | exec1 (zview query, std::string_view desc=std::string_view{}) |
| Execute command returning a single row of data. More... | |
| result | exec_n (result::size_type rows, zview query, std::string_view desc=std::string_view{}) |
| Execute command, expect given number of rows. More... | |
| template<typename TYPE > | |
| TYPE | query_value (zview query, std::string_view desc=std::string_view{}) |
| Perform query, expecting exactly 1 row with 1 field, and convert it. More... | |
| template<typename... TYPE> | |
| auto | stream (std::string_view query) |
| Execute a query, and loop over the results row by row. More... | |
| template<typename... Args> | |
| result | exec_params (zview query, Args &&...args) |
| Execute an SQL statement with parameters. More... | |
| template<typename... Args> | |
| row | exec_params1 (zview query, Args &&...args) |
| template<typename... Args> | |
| result | exec_params0 (zview query, Args &&...args) |
| template<typename... Args> | |
| result | exec_params_n (std::size_t rows, zview query, Args &&...args) |
| template<typename... Args> | |
| result | exec_prepared (zview statement, Args &&...args) |
| Execute a prepared statement, with optional arguments. More... | |
| template<typename... Args> | |
| row | exec_prepared1 (zview statement, Args &&...args) |
| Execute a prepared statement, and expect a single-row result. More... | |
| template<typename... Args> | |
| result | exec_prepared0 (zview statement, Args &&...args) |
| Execute a prepared statement, and expect a result with zero rows. More... | |
| template<typename... Args> | |
| result | exec_prepared_n (result::size_type rows, zview statement, Args &&...args) |
| Execute a prepared statement, expect a result with given number of rows. More... | |
| void | process_notice (char const msg[]) const |
| Have connection process a warning message. More... | |
| void | process_notice (zview msg) const |
| Have connection process a warning message. More... | |
Detailed Description
Abstract transaction base class: bracket transactions on the database.
Use a dbtransaction-derived object such as "work" (transaction<>) to enclose operations on a database in a single "unit of work." This ensures that the whole series of operations either succeeds as a whole or fails completely. In no case will it leave half-finished work behind in the database.
Once processing on a transaction has succeeded and any changes should be allowed to become permanent in the database, call commit(). If something has gone wrong and the changes should be forgotten, call abort() instead. If you do neither, an implicit abort() is executed at destruction time.
It is an error to abort a transaction that has already been committed, or to commit a transaction that has already been aborted. Aborting an already aborted transaction or committing an already committed one is allowed, to make error handling easier. Repeated aborts or commits have no effect after the first one.
Database transactions are not suitable for guarding long-running processes. If your transaction code becomes too long or too complex, consider ways to break it up into smaller ones. Unfortunately there is no universal recipe for this.
The actual operations for committing/aborting the backend transaction are implemented by a derived class. The implementing concrete class must also call close() from its destructor.
Constructor & Destructor Documentation
◆ dbtransaction() [1/3]
|
explicitprotected |
Begin transaction.
◆ dbtransaction() [2/3]
|
protected |
Begin transaction.
◆ dbtransaction() [3/3]
|
protected |
Begin transaction.
The documentation for this class was generated from the following file:
