PK ZWR|\F \F libpqxx-7.4.0/a01058.html
libpqxx
7.4.0
|
Stream that reads and writes a large object. More...
#include <largeobject.hxx>
Public Types | |
using | char_type = CHAR |
using | traits_type = TRAITS |
using | int_type = typename traits_type::int_type |
using | pos_type = typename traits_type::pos_type |
using | off_type = typename traits_type::off_type |
Public Member Functions | |
Use blob instead | basic_lostream (dbtransaction &t, largeobject o, largeobject::size_type buf_size=512) |
Create a basic_lostream. More... | |
Use blob instead | basic_lostream (dbtransaction &t, oid o, largeobject::size_type buf_size=512) |
Create a basic_lostream. More... | |
~basic_lostream () | |
Stream that reads and writes a large object.
blob
class.This worked like a std::iostream, but to read data from, or write data to, a large object. It supported all formatting and streaming operations of std::iostream
.
This functionality was considered too fragile and complex, so it has been replaced with a single, much simpler class.
using pqxx::basic_lostream< CHAR, TRAITS >::char_type = CHAR |
using pqxx::basic_lostream< CHAR, TRAITS >::int_type = typename traits_type::int_type |
using pqxx::basic_lostream< CHAR, TRAITS >::off_type = typename traits_type::off_type |
using pqxx::basic_lostream< CHAR, TRAITS >::pos_type = typename traits_type::pos_type |
using pqxx::basic_lostream< CHAR, TRAITS >::traits_type = TRAITS |
Use blob instead pqxx::basic_lostream< CHAR, TRAITS >::basic_lostream | ( | dbtransaction & | t, |
largeobject | o, | ||
largeobject::size_type | buf_size = 512 |
||
) |
Create a basic_lostream.
t | Transaction in which this stream is to exist. |
o | Large object to access. |
buf_size | Size of buffer to use internally (optional). |
Use blob instead pqxx::basic_lostream< CHAR, TRAITS >::basic_lostream | ( | dbtransaction & | t, |
oid | o, | ||
largeobject::size_type | buf_size = 512 |
||
) |
Create a basic_lostream.
t | Transaction in which this stream is to exist. |
o | Large object to access. |
buf_size | Size of buffer to use internally (optional). |
pqxx::basic_lostream< CHAR, TRAITS >::~basic_lostream | ( | ) |
libpqxx
7.4.0
|
▼Npqxx | The home of all libpqxx classes, functions, templates, etc |
▼Ninternal | Internal items for libpqxx' own use. Do not use these yourself |
Cbasic_robusttransaction | Helper base class for the robusttransaction class template |
Cbasic_transaction | Helper base class for the transaction class template |
Cenum_traits | Helper class for defining enum conversions |
Cresult_iter | |
Cargument_error | Invalid argument passed to libpqxx, similar to std::invalid_argument |
Carray_parser | Low-level array parser |
Cbasic_fieldstream | Input stream that gets its data from a result field |
Cbasic_ilostream | Input stream that gets its data from a large object |
Cbasic_lostream | Stream that reads and writes a large object |
Cbasic_olostream | Output stream that writes data back to a large object |
Cbinarystring | Binary data corresponding to PostgreSQL's "BYTEA" binary-string type |
Cblob | |
Cblob_already_exists | |
Cbroken_connection | Exception class for lost or failed backend connection |
Ccheck_violation | |
Cconnection | Connection to a database |
Cconst_result_iterator | Iterator for rows in a result. Use as result::const_iterator |
Cconst_reverse_result_iterator | Reverse iterator for result. Use as result::const_reverse_iterator |
Cconst_reverse_row_iterator | Reverse iterator for a row. Use as row::const_reverse_iterator |
Cconst_row_iterator | Iterator for fields in a row. Use as row::const_iterator |
Cconversion_error | Value conversion failed, e.g. when converting "Hello" to int |
Cconversion_overrun | Could not convert value to string: not enough buffer space |
Ccursor_base | Common definitions for cursor types |
Cdata_exception | Error in data provided to SQL statement |
Cdbtransaction | Abstract transaction base class: bracket transactions on the database |
Cdeadlock_detected | The ongoing transaction has deadlocked. Retrying it may help |
Cdisk_full | |
Cerrorhandler | Base class for error-handler callbacks |
Cfailure | Run-time failure encountered by libpqxx, similar to std::runtime_error |
Cfeature_not_supported | Database feature not supported in current setup |
Cfield | Reference to a field in a result set |
Cfield_streambuf | |
Cforeign_key_violation | |
Cfrom_query_t | Marker for stream_from constructors: "stream from query." |
Cfrom_table_t | Marker for stream_from constructors: "stream from table." |
Cicursor_iterator | Approximate istream_iterator for icursorstream |
Cicursorstream | Simple read-only cursor represented as a stream of results |
Cin_doubt_error | "Help, I don't know whether transaction was committed successfully!" |
Cinsufficient_privilege | |
Cinsufficient_resources | Resource shortage on the server |
Cintegrity_constraint_violation | |
Cinternal_error | Internal error in libpqxx library |
Cinvalid_cursor_name | |
Cinvalid_cursor_state | |
Cinvalid_sql_statement_name | |
Clargeobject | Identity of a large object |
Clargeobject_streambuf | Streambuf to use large objects in standard I/O streams |
Clargeobjectaccess | Accessor for large object's contents |
Cno_null | Nullness traits describing a type which does not have a null value |
Cnontransaction | Simple "transaction" class offering no transactional integrity |
Cnot_null_violation | |
Cnotification_receiver | |
Cnullness | Traits describing a type's "null value," if any |
Cnullness< binarystring > | |
Cnullness< ENUM, std::enable_if_t< std::is_enum_v< ENUM > > > | Nullness: Enums do not have an inherent null value |
Cout_of_memory | |
Cpipeline | Processes several queries in FIFO manner, optimized for high throughput |
Cplpgsql_error | PL/pgSQL error |
Cplpgsql_no_data_found | |
Cplpgsql_raise | Exception raised in PL/pgSQL procedure |
Cplpgsql_too_many_rows | |
Cquiet_errorhandler | An error handler that suppresses any previously registered error handlers |
Crange_error | Something is out of range, similar to std::out_of_range |
Crestrict_violation | |
Cresult | Result set containing data returned by a query or command |
Crobusttransaction | Slightly slower, better-fortified version of transaction |
Crow | Reference to one row in a result |
Cserialization_failure | Transaction failed to serialize. Please retry it |
Csql_error | Exception class for failed queries |
Cstateless_cursor | "Stateless cursor" class: easy API for retrieving parts of result sets |
Cstatement_completion_unknown | We can't tell whether our last statement succeeded |
Cstream_from | Stream data from the database |
Cstream_to | Efficiently write data directly to a database table |
Cstring_traits | Traits class for use in string conversions |
Cstring_traits< binarystring > | String conversion traits for binarystring |
Csubtransaction | "Transaction" nested within another transaction |
Csyntax_error | |
Cthread_safety_model | Descriptor of library's thread-safety model |
Ctoo_many_connections | |
Ctransaction | Standard back-end transaction, templatised on isolation level |
Ctransaction_base | Interface definition (and common code) for "transaction" classes |
Ctransaction_focus | Base class for things that monopolise a transaction's attention |
Ctransaction_rollback | The backend saw itself forced to roll back the ongoing transaction |
Cundefined_column | |
Cundefined_function | |
Cundefined_table | |
Cunexpected_rows | Query returned an unexpected number of rows |
Cunique_violation | |
Cusage_error | Error in usage of libpqxx library, similar to std::logic_error |
Czview | Marker-type wrapper: zero-terminated std::string_view |
libpqxx
7.4.0
|
Interface definition (and common code) for "transaction" classes. More...
#include <transaction_base.hxx>
Public Member Functions | |
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... | |
Command execution | |
There are many functions for executing (or "performing") a command (or "query"). This is the most fundamental thing you can do with the library, and you always do it from a transaction class. Command execution can throw many types of exception, including sql_error, broken_connection, and many sql_error subtypes such as feature_not_supported or insufficient_privilege. But any exception thrown by the C++ standard library may also occur here. All exceptions you will see libpqxx are derived from std::exception. One unusual feature in libpqxx is that you can give your query a name or description. This does not mean anything to the database, but sometimes it can help libpqxx produce more helpful error messages, making problems in your code easier to debug. | |
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... | |
Parameterized statements | |
You'll often need parameters in the queries you execute: "select the car with this licence plate." If the parameter is a string, you need to quote it and escape any special characters inside it, or it may become a target for an SQL injection attack. If it's an integer (for example), you need to convert it to a string, but in the database's format, without locale-specific niceties like "," separators between the thousands. Parameterised statements are an easier and safer way to do this. They're like prepared statements, but for a single use. You don't need to name them, and you don't need to prepare them first. Your query will include placeholders like Pass the exact right number of parameters, and in the right order. The parameters in the query don't have to be neatly ordered from
| |
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) |
Prepared statements | |
These are very similar to parameterised statements. The difference is that you prepare them in advance, giving them identifying names. You can then call them by these names, passing in the argument values appropriate for that call. You prepare a statement on the connection, using Never try to prepare, execute, or unprepare a prepared statement manually using direct SQL queries when you also use the libpqxx equivalents. For any given statement, either prepare, manage, and execute it through the dedicated libpqxx functions; or do it all directly in SQL. Don't mix the two, or the code may get confused. See Prepared statements for a full discussion.
| |
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... | |
Error/warning output | |
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... | |
Protected Member Functions | |
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) |
Friends | |
class | pqxx::internal::gate::transaction_transaction_focus |
Interface definition (and common code) for "transaction" classes.
Abstract base class for all transaction types.
|
delete |
|
delete |
|
delete |
|
pure virtual |
References conn(), pqxx::connection::process_notice(), and process_notice().
|
protected |
Create a transaction (to be called by implementation classes only).
The name, if nonempty, must begin with a letter and may contain letters and digits only.
|
protected |
Create a transaction (to be called by implementation classes only).
Its rollback command will be "ROLLBACK".
The name, if nonempty, must begin with a letter and may contain letters and digits only.
|
explicitprotected |
Create a transaction (to be called by implementation classes only).
void pqxx::transaction_base::abort | ( | ) |
Abort the transaction.
No special effort is required to call this function; it will be called implicitly when the transaction is destructed.
References close(), do_abort(), and pqxx::connection::process_notice().
Referenced by close().
|
protectednoexcept |
End transaction. To be called by implementing class' destructor.
References abort(), pqxx::internal::check_unique_register(), pqxx::internal::check_unique_unregister(), pqxx::transaction_focus::classname(), conn(), and pqxx::transaction_focus::name().
Referenced by abort(), commit(), and pqxx::subtransaction::~subtransaction().
void pqxx::transaction_base::commit | ( | ) |
Commit the transaction.
Unless this function is called explicitly, the transaction will not be committed (actually the nontransaction implementation breaks this rule, hence the name).
Once this function returns, the whole transaction will typically be irrevocably completed in the database. There is also, however, a minute risk that the connection to the database may be lost at just the wrong moment. In that case, libpqxx may be unable to determine whether the transaction was completed or aborted and an in_doubt_error will be thrown to make this fact known to the caller. The robusttransaction implementation takes some special precautions to reduce this risk.
References close(), pqxx::transaction_focus::description(), do_commit(), pqxx::connection::is_open(), and pqxx::connection::process_notice().
connection& pqxx::transaction_base::conn | ( | ) | const |
The connection in which this transaction lives.
Referenced by pqxx::internal::basic_robusttransaction::basic_robusttransaction(), pqxx::internal::basic_transaction::basic_transaction(), pqxx::pipeline::cancel(), close(), pqxx::blob::create(), direct_exec(), esc_raw(), exec_n(), pqxx::blob::from_buf(), get_variable(), pqxx::largeobject::largeobject(), quote_raw(), pqxx::largeobject::raw_connection(), pqxx::stream_from::raw_table(), register_transaction(), pqxx::blob::remove(), pqxx::largeobject::remove(), pqxx::pipeline::resume(), set_variable(), pqxx::subtransaction::subtransaction(), pqxx::stream_to::table(), pqxx::largeobjectaccess::tell(), pqxx::largeobject::to_file(), and ~transaction_base().
|
protected |
Execute query on connection directly.
References conn().
Referenced by pqxx::internal::basic_robusttransaction::basic_robusttransaction(), pqxx::internal::basic_transaction::basic_transaction(), do_abort(), exec(), pqxx::subtransaction::subtransaction(), and pqxx::subtransaction::~subtransaction().
|
protected |
References conn(), pqxx::internal::describe_object(), name(), and process_notice().
|
protectedvirtual |
Transaction type-specific way of aborting a transaction.
References direct_exec().
Referenced by abort(), and pqxx::internal::basic_robusttransaction::basic_robusttransaction().
|
protectedpure virtual |
To be implemented by derived implementation class: commit transaction.
Referenced by commit().
pqxx::result pqxx::transaction_base::exec | ( | std::string_view | query, |
std::string_view | desc = std::string_view{} |
||
) |
Execute a command.
query | Query or command to execute. |
desc | Optional identifier for query, to help pinpoint SQL errors. |
References direct_exec().
Referenced by exec_n(), and pqxx::pipeline::resume().
result pqxx::transaction_base::exec | ( | std::stringstream const & | query, |
std::string_view | desc = std::string_view{} |
||
) |
Execute a command.
query | Query or command to execute. |
desc | Optional identifier for query, to help pinpoint SQL errors. |
Execute command, which should return zero rows of data.
Works like exec, but fails if the result contains data. It still returns a result, however, which may contain useful metadata.
unexpected_rows | If the query returned the wrong number of rows. |
Execute command returning a single row of data.
Works like exec, but requires the result to contain exactly one row. The row can be addressed directly, without the need to find the first row in a result set.
unexpected_rows | If the query returned the wrong number of rows. |
References pqxx::row::front().
pqxx::result pqxx::transaction_base::exec_n | ( | result::size_type | rows, |
zview | query, | ||
std::string_view | desc = std::string_view{} |
||
) |
Execute command, expect given number of rows.
Works like exec, but checks that the number of rows is exactly what's expected.
unexpected_rows | If the query returned the wrong number of rows. |
result pqxx::transaction_base::exec_params | ( | zview | query, |
Args &&... | args | ||
) |
Execute an SQL statement with parameters.
result pqxx::transaction_base::exec_params0 | ( | zview | query, |
Args &&... | args | ||
) |
unexpected_rows | if the result contains rows. |
row pqxx::transaction_base::exec_params1 | ( | zview | query, |
Args &&... | args | ||
) |
unexpected_rows | if the result does not consist of exactly one row. |
References pqxx::row::front().
result pqxx::transaction_base::exec_params_n | ( | std::size_t | rows, |
zview | query, | ||
Args &&... | args | ||
) |
unexpected_rows | if the result contains the wrong number of rows. |
result pqxx::transaction_base::exec_prepared | ( | zview | statement, |
Args &&... | args | ||
) |
Execute a prepared statement, with optional arguments.
result pqxx::transaction_base::exec_prepared0 | ( | zview | statement, |
Args &&... | args | ||
) |
Execute a prepared statement, and expect a result with zero rows.
pqxx::unexpected_rows | if the result contained rows. |
row pqxx::transaction_base::exec_prepared1 | ( | zview | statement, |
Args &&... | args | ||
) |
Execute a prepared statement, and expect a single-row result.
pqxx::unexpected_rows | if the result was not exactly 1 row. |
References pqxx::row::front().
result pqxx::transaction_base::exec_prepared_n | ( | result::size_type | rows, |
zview | statement, | ||
Args &&... | args | ||
) |
Execute a prepared statement, expect a result with given number of rows.
pqxx::unexpected_rows | if the result did not contain exactly the given number of rows. |
std::string pqxx::transaction_base::get_variable | ( | std::string_view | var | ) |
Read session variable using SQL "SHOW" command.
References conn(), and pqxx::connection::get_variable().
|
noexcept |
Transaction name, if you passed one to the constructor; or empty string.
Referenced by pqxx::internal::basic_robusttransaction::basic_robusttransaction(), pqxx::internal::basic_transaction::basic_transaction(), pqxx::connection::close(), and direct_exec().
|
delete |
|
delete |
void pqxx::transaction_base::process_notice | ( | char const | msg[] | ) | const |
Have connection process a warning message.
Referenced by pqxx::internal::basic_transaction::basic_transaction(), direct_exec(), pqxx::largeobjectaccess::process_notice(), and ~transaction_base().
void pqxx::transaction_base::process_notice | ( | zview | msg | ) | const |
Have connection process a warning message.
TYPE pqxx::transaction_base::query_value | ( | zview | query, |
std::string_view | desc = std::string_view{} |
||
) |
Perform query, expecting exactly 1 row with 1 field, and convert it.
This is convenience shorthand for querying exactly one value from the database. It returns that value, converted to the type you specify.
Forbidden specialisation: underlying buffer immediately goes out of scope.
|
protected |
Register this transaction with the connection.
References conn().
Referenced by pqxx::internal::basic_transaction::basic_transaction().
|
protected |
Set the rollback command.
Referenced by pqxx::subtransaction::subtransaction().
void pqxx::transaction_base::set_variable | ( | std::string_view | var, |
std::string_view | value | ||
) |
Set session variable using SQL "SET" command.
The new value is typically forgotten if the transaction aborts. Not for nontransaction though: in that case the set value will be kept regardless.
var | The variable to set. |
value | The new value to store in the variable. |
References conn(), and pqxx::connection::set_variable().
auto pqxx::transaction_base::stream | ( | std::string_view | query | ) |
Execute a query, and loop over the results row by row.
Converts the rows to std::tuple
, of the column types you specify.
Use this with a range-based "for" loop. It executes the query, and directly maps the resulting rows onto a std::tuple
of the types you specify. It starts before all the data from the server is in, so if your network connection to the server breaks while you're iterating, you'll get an exception partway through.
The tuple may contain std::string_view
fields, but the strings to which they point will only remain valid until you extract the next row. After that, the memory holding the string may be overwritten or deallocated.
If any of the columns can be null, and the C++ type to which it translates does not have a null value, wrap the type in std::optional
(or if you prefer, std::shared_ptr
or std::unique_ptr
). These templates do recognise null values, and libpqxx will know how to convert to them.
The connection is in a special state until the iteration finishes. So if it does not finish due to a break
or a return
or an exception, then the entire connection becomes effectively unusable.
Querying in this way is faster than the exec()
methods for larger results (but probably slower for small ones). Also, you can start processing rows before the full result is in. Also, stream()
scales better in terms of memory usage. Where exec()
reads the entire result into memory at once, stream()
will read and process one row at at a time.
Your query executes as part of a COPY command, not as a stand-alone query, so there are limitations to what you can do in the query. It can be either a SELECT or VALUES query; or an INSERT, UPDATE, or DELETE with a RETURNING clause. See the documentation for PostgreSQL's COPY command for the details:
https://www.postgresql.org/docs/current/sql-copy.html
Iterating in this way does require each of the field types you pass to be default-constructible, copy-constructible, and assignable. These requirements may be loosened once libpqxx moves on to C++20.
|
friend |
libpqxx
7.4.0
|
libpqxx
7.4.0
|
This is the complete list of members for pqxx::deadlock_detected, including all inherited members.
deadlock_detected(std::string const &whatarg, std::string const &q, char const sqlstate[]=nullptr) | pqxx::deadlock_detected | explicit |
failure(std::string const &) | pqxx::failure | explicit |
query() const noexcept | pqxx::sql_error | |
sql_error(std::string const &whatarg="", std::string const &Q="", char const sqlstate[]=nullptr) | pqxx::sql_error | explicit |
sqlstate() const noexcept | pqxx::sql_error | |
transaction_rollback(std::string const &whatarg, std::string const &q="", char const sqlstate[]=nullptr) | pqxx::transaction_rollback | explicit |
~sql_error() noexcept override | pqxx::sql_error | virtual |
t |