libpqxx
7.9.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... | |
template<typename... ARGS> | |
auto | esc (ARGS &&...args) const |
Escape string for use as SQL string literal in this transaction. More... | |
template<typename... ARGS> | |
auto | esc_raw (ARGS &&...args) 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... | |
bytes | unesc_bin (zview text) |
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... | |
bytes | unesc_bin (char const text[]) |
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 (binarystring const &t) const |
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... | |
template<> | |
zview | query_value (zview query, std::string_view desc)=delete |
Forbidden specialisation: underlying buffer immediately goes out of scope. More... | |
Command execution | |
There are many functions for executing (or "performing") a command (or "query"). This is the most fundamental thing you can do in libpqxx, and it always starts at 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 throw are derived from std::exception. Most of the differences between the query execution functions are in how they return the query's results.
Some of these functions also give you the option to specify how many rows of data you expect to get: | |
result | exec (std::string_view query, std::string_view desc) |
Execute a command. More... | |
result | exec (std::string_view query) |
Execute a command. More... | |
result | exec (std::stringstream const &query, std::string_view desc) |
Execute a command. More... | |
result | exec0 (zview query, std::string_view desc) |
Execute command, which should return zero rows of data. More... | |
result | exec0 (zview query) |
Execute command, which should return zero rows of data. More... | |
row | exec1 (zview query, std::string_view desc) |
Execute command returning a single row of data. More... | |
row | exec1 (zview query) |
Execute command returning a single row of data. More... | |
result | exec_n (result::size_type rows, zview query, std::string_view desc) |
Execute command, expect given number of rows. More... | |
result | exec_n (result::size_type rows, zview query) |
Execute command, expect given number of rows. More... | |
template<typename TYPE > | |
TYPE | query_value (zview query, std::string_view desc) |
Perform query, expecting exactly 1 row with 1 field, and convert it. More... | |
template<typename TYPE > | |
TYPE | query_value (zview query) |
Perform query, expecting exactly 1 row with 1 field, and convert it. More... | |
template<typename... TYPE> | |
std::tuple< TYPE... > | query1 (zview query) |
Perform query returning exactly one row, and convert its fields. More... | |
template<typename... TYPE> | |
std::optional< std::tuple< TYPE... > > | query01 (zview query) |
Query at most one row of data, and if there is one, convert it. More... | |
template<typename... TYPE> | |
auto | stream (std::string_view query) & |
Execute a query, in streaming fashion; loop over the results row by row. More... | |
template<typename CALLABLE > | |
auto | for_stream (std::string_view query, CALLABLE &&func) |
Perform a streaming query, and for each result row, call func . More... | |
template<typename CALLABLE > | |
auto | for_each (std::string_view query, CALLABLE &&func) |
template<typename... TYPE> | |
auto | query (zview query) |
Execute query, read full results, then iterate rows of data. More... | |
template<typename... TYPE> | |
auto | query_n (result::size_type rows, zview query) |
Perform query, expect given number of rows, iterate results. More... | |
template<typename CALLABLE > | |
void | for_query (zview query, CALLABLE &&func) |
Execute a query, load the full result, and perform func for each 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) |
template<typename... Args> | |
result | exec_params_n (result::size_type rows, zview query, Args &&...args) |
template<typename... TYPE> | |
auto | query (zview query, params const &parms) |
Execute parameterised query, read full results, iterate rows of data. More... | |
template<typename... TYPE> | |
auto | query_n (result::size_type rows, zview query, params const &parms) |
template<typename TYPE > | |
TYPE | query_value (zview query, params const &parms) |
Perform query, expecting exactly 1 row with 1 field, and convert it. More... | |
template<typename... TYPE> | |
std::tuple< TYPE... > | query1 (zview query, params const &parms) |
Perform query returning exactly one row, and convert its fields. More... | |
template<typename... TYPE> | |
std::optional< std::tuple< TYPE... > > | query01 (zview query, params const &parms) |
Query at most one row of data, and if there is one, convert it. More... | |
template<typename CALLABLE > | |
void | for_query (zview query, CALLABLE &&func, params const &parms) |
Execute a query, load the full result, and perform func for each row. More... | |
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 pqxx::connection::prepare(). But you then call the statement in a transaction, using the functions you see here. 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 | |
class | pqxx::internal::gate::transaction_transaction_focus |
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... | |
constexpr connection & | conn () const noexcept |
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... | |
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) |
Interface definition (and common code) for "transaction" classes.
Abstract base class for all transaction types.
|
delete |
|
delete |
|
delete |
|
pure virtual |
|
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.
|
protectednoexcept |
End transaction. To be called by implementing class' destructor.
Referenced by pqxx::robusttransaction< ISOLATION >::~robusttransaction().
void pqxx::transaction_base::commit | ( | ) |
Commit the transaction.
Make the effects of this transaction definite. If you destroy a transaction without invoking its commit() first, that will implicitly abort it. (For the nontransaction class though, "commit" and "abort" really don't do anything, hence its name.)
There is, however, a minute risk that you might lose your connection to the database at just the wrong moment here. In that case, libpqxx may be unable to determine whether the database was able to complete the transaction, or had to roll it back. In that scenario, commit() will throw an in_doubt_error. There is a different transaction class called robusttransaction which takes some special precautions to reduce this risk.
|
constexprnoexcept |
The connection in which this transaction lives.
Referenced by pqxx::blob::create(), pqxx::blob::from_buf(), pqxx::largeobject::largeobject(), pqxx::largeobject::raw_connection(), pqxx::blob::remove(), pqxx::stream_from::table(), and pqxx::largeobject::to_file().
|
protected |
|
protected |
Execute query on connection directly.
Referenced by pqxx::internal::basic_transaction::basic_transaction().
|
protectedvirtual |
Transaction type-specific way of aborting a transaction.
|
protectedpure virtual |
To be implemented by derived implementation class: commit transaction.
std::string pqxx::transaction_base::esc_like | ( | std::string_view | bin, |
char | escape_char = '\\' |
||
) | const |
Escape string for literal LIKE match.
auto pqxx::transaction_base::esc_raw | ( | ARGS &&... | args | ) | const |
Escape binary data for use as SQL string literal in this transaction.
Raw, binary data is treated differently from regular strings. Binary strings are never interpreted as text, so they may safely include byte values or byte sequences that don't happen to represent valid characters in the character encoding being used.
The binary string does not stop at the first zero byte, as is the case with textual strings. Instead, it may contain zero bytes anywhere. If it happens to contain bytes that look like quote characters, or other things that can disrupt their use in SQL queries, they will be replaced with special escape sequences.
result pqxx::transaction_base::exec | ( | std::string_view | query | ) |
Execute a command.
query | Query or command to execute. |
pqxx::result pqxx::transaction_base::exec | ( | std::string_view | query, |
std::string_view | desc | ||
) |
Execute a command.
query | Query or command to execute. |
desc | Optional identifier for query, to help pinpoint SQL errors. |
result pqxx::transaction_base::exec | ( | std::stringstream const & | query, |
std::string_view | desc | ||
) |
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, 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. |
Referenced by pqxx::stream_from::stream_from().
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().
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().
result pqxx::transaction_base::exec_n | ( | result::size_type | rows, |
zview | query | ||
) |
Execute command, expect given number of rows.
Works like exec, but checks that the result has exactly the expected number of rows.
unexpected_rows | If the query returned the wrong number of rows. |
pqxx::result pqxx::transaction_base::exec_n | ( | result::size_type | rows, |
zview | query, | ||
std::string_view | desc | ||
) |
Execute command, expect given number of rows.
Works like exec, but checks that the result has exactly the expected number of rows.
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.
This is like calling exec()
, except it will substitute the first parameter after query
(the first in args
) for a $1
in the query, the next one for $2
, etc.
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 | ( | result::size_type | rows, |
zview | query, | ||
Args &&... | args | ||
) |
unexpected_rows | if the result contains the wrong number of rows. |
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.
References pqxx::params::make_c_params().
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. |
auto pqxx::transaction_base::for_each | ( | std::string_view | query, |
CALLABLE && | func | ||
) |
void pqxx::transaction_base::for_query | ( | zview | query, |
CALLABLE && | func | ||
) |
Execute a query, load the full result, and perform func
for each row.
Converts each row to data types matching func
's parameter types. The number of columns in the result set must match the number of parameters.
This is a lot like for_stream(). The differences are:
exec
functions are faster for small results, but slower for large results. void pqxx::transaction_base::for_query | ( | zview | query, |
CALLABLE && | func, | ||
params const & | parms | ||
) |
Execute a query, load the full result, and perform func
for each row.
The query may use parameters. So for example, the query may contain $1
to denote the first parameter value in parms
, and so on.
Converts each row to data types matching func
's parameter types. The number of columns in the result set must match the number of parameters.
This is a lot like for_stream(). The differences are:
exec
functions are faster for small results, but slower for large results. auto pqxx::transaction_base::for_stream | ( | std::string_view | query, |
CALLABLE && | func | ||
) |
Perform a streaming query, and for each result row, call func
.
Here, func
can be a function, a std::function
, a lambda, or an object that supports the function call operator. Of course func
must have an unambiguous signature; it can't be overloaded or generic.
The for_stream
function executes query
in a stream similar to stream. Every time a row of data comes in from the server, it converts the row's fields to the types of func
's respective parameters, and calls func
with those values.
This will not work for all queries, but straightforward SELECT
and UPDATE ... RETURNING
queries should work. Consult the documentation for pqxx::internal::stream_query and PostgreSQL's underlying COPY
command for the full details.
Streaming a query like this is likely to be slower than the exec() functions for small result sets, but faster for larger result sets. So if performance matters, you'll want to use for_stream
if you query large amounts of data, but not if you do lots of queries with small outputs.
However, the transaction and the connection are in a special state while the iteration is ongoing. If func
throws an exception, or the iteration fails in some way, the only way out is to destroy the transaction and the connection.
Each of the parameter types must have a conversion from PostgreSQL's text format defined. To define conversions for additional types, see Supporting additional data types.
std::string pqxx::transaction_base::get_variable | ( | std::string_view | var | ) |
Read session variable using SQL "SHOW" command.
|
noexcept |
Transaction name, if you passed one to the constructor; or empty string.
|
delete |
|
delete |
void pqxx::transaction_base::process_notice | ( | char const | msg[] | ) | const |
Have connection process a warning message.
void pqxx::transaction_base::process_notice | ( | zview | msg | ) | const |
Have connection process a warning message.
auto pqxx::transaction_base::query | ( | zview | query | ) |
Execute query, read full results, then iterate rows of data.
Converts each row of the result to a std::tuple
of the types you pass as template arguments. (The number of template arguments must match the number of columns in the query's result.)
Example:
You can't normally convert a field value to std::string_view
, but this is one of the places where you can. The underlying string to which the string_view
points exists only for the duration of the one iteration. After that, the buffer that holds the actual string may have disappeared, or it may contain a new string value.
If you expect a lot of rows from your query, it's probably faster to use transaction_base::stream() instead. Or if you need to access metadata of the result, such as the number of rows in the result, or the number of rows that your query updates, then you'll need to use transaction_base::exec() instead.
Execute parameterised query, read full results, iterate rows of data.
Like query, but the query can contain parameters.
Converts each row of the result to a std::tuple
of the types you pass as template arguments. (The number of template arguments must match the number of columns in the query's result.)
Example:
You can't normally convert a field value to std::string_view
, but this is one of the places where you can. The underlying string to which the string_view
points exists only for the duration of the one iteration. After that, the buffer that holds the actual string may have disappeared, or it may contain a new string value.
If you expect a lot of rows from your query, it's probably faster to use transaction_base::stream() instead. Or if you need to access metadata of the result, such as the number of rows in the result, or the number of rows that your query updates, then you'll need to use transaction_base::exec() instead.
std::optional<std::tuple<TYPE...> > pqxx::transaction_base::query01 | ( | zview | query | ) |
Query at most one row of data, and if there is one, convert it.
If the query produced a row of data, this converts it to a tuple of the C++ types you specify. Otherwise, this returns no tuple.
unexpected_rows | If the query returned more than 1 row. |
usage_error | If the number of columns in the result does not match the number of fields in the tuple. |
std::optional<std::tuple<TYPE...> > pqxx::transaction_base::query01 | ( | zview | query, |
params const & | parms | ||
) |
Query at most one row of data, and if there is one, convert it.
If the query produced a row of data, this converts it to a tuple of the C++ types you specify. Otherwise, this returns no tuple.
unexpected_rows | If the query returned more than 1 row. |
usage_error | If the number of columns in the result does not match the number of fields in the tuple. |
std::tuple<TYPE...> pqxx::transaction_base::query1 | ( | zview | query | ) |
Perform query returning exactly one row, and convert its fields.
This is a convenient way of querying one row's worth of data, and converting its fields to a tuple of the C++-side types you specify.
unexpected_rows | If the query did not return exactly 1 row. |
usage_error | If the number of columns in the result does not match the number of fields in the tuple. |
std::tuple<TYPE...> pqxx::transaction_base::query1 | ( | zview | query, |
params const & | parms | ||
) |
Perform query returning exactly one row, and convert its fields.
This is a convenient way of querying one row's worth of data, and converting its fields to a tuple of the C++-side types you specify.
unexpected_rows | If the query did not return exactly 1 row. |
usage_error | If the number of columns in the result does not match the number of fields in the tuple. |
auto pqxx::transaction_base::query_n | ( | result::size_type | rows, |
zview | query | ||
) |
Perform query, expect given number of rows, iterate results.
Works like query, but checks that the result has exactly the expected number of rows.
unexpected_rows | If the query returned the wrong number of rows. |
auto pqxx::transaction_base::query_n | ( | result::size_type | rows, |
zview | query, | ||
params const & | parms | ||
) |
Perform query parameterised, expect given number of rows, iterate results. Works like query, but checks that the result has exactly the expected number of rows.
unexpected_rows | If the query returned the wrong number of rows. |
TYPE pqxx::transaction_base::query_value | ( | zview | query | ) |
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.
unexpected_rows | If the query did not return exactly 1 row. |
usage_error | If the row did not contain exactly 1 field. |
TYPE pqxx::transaction_base::query_value | ( | zview | query, |
params const & | parms | ||
) |
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.
unexpected_rows | If the query did not return exactly 1 row. |
usage_error | If the row did not contain exactly 1 field. |
TYPE pqxx::transaction_base::query_value | ( | zview | query, |
std::string_view | desc | ||
) |
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.
std::string pqxx::transaction_base::quote | ( | binarystring const & | t | ) | const |
References pqxx::binarystring::bytes_view().
std::string pqxx::transaction_base::quote | ( | T const & | t | ) | const |
Represent object as SQL string, including quoting & escaping.
Nulls are recognized and represented as SQL nulls.
std::string pqxx::transaction_base::quote_name | ( | std::string_view | identifier | ) | const |
Escape an SQL identifier for use in a query.
Referenced by pqxx::stream_from::stream_from(), and pqxx::stream_to::stream_to().
std::string pqxx::transaction_base::quote_raw | ( | unsigned char const | bin[], |
std::size_t | len | ||
) | const |
Binary-escape and quote a binary string for use as an SQL constant.
References pqxx::binary_cast().
std::string PQXX_COLD pqxx::transaction_base::quote_raw | ( | zview | bin | ) | const |
Binary-escape and quote a binary string for use as an SQL constant.
References pqxx::binary_cast().
|
protected |
Register this transaction with the connection.
Referenced by pqxx::internal::basic_transaction::basic_transaction().
|
protected |
Set the rollback command.
void pqxx::transaction_base::set_variable | ( | std::string_view | var, |
std::string_view | value | ||
) |
Set session variable using SQL "SET" command.
SET
command. To set a session variable, use the connection's set_session_var function.var | The variable to set. |
value | The new value to store in the variable. This can be any SQL expression. |
auto pqxx::transaction_base::stream | ( | std::string_view | query | ) | & |
Execute a query, in streaming fashion; 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. Unlike with the "exec" functions, processing can start before all the data from the server is in.
Streaming is also documented in Streams.
The column types must all be types that have conversions from PostgreSQL's text format defined. Many built-in types such as int
or std::string
have pre-defined conversions; if you want to define your own conversions for additional types, see Supporting additional data types.
As a special case, 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 you're translating it does not have a null value, wrap the type in a std::optional<>
(or if you prefer, a std::shared_ptr<>
or a std::unique_ptr
). These templates do support null values, and libpqxx will know how to convert to them.
The stream lives entirely within the lifetime of the transaction. Make sure you complete the stream before you destroy the transaction. Until the stream has finished, the transaction and the connection are in a special state where they cannot be used for anything else.
Streaming your query is likely to be faster than the exec()
methods for larger results (but slower for small results), and start useful processing sooner. Also, stream()
scales better in terms of memory usage: it only needs to keep the current row in memory. The "exec" functions read the entire result into memory at once.
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 exact restrictions.
Iterating in this way does require each of the field types you pass to be default-constructible, copy-constructible, and assignable. These requirements may loosen a bit once libpqxx moves on to C++20.
bytes pqxx::transaction_base::unesc_bin | ( | char const | text[] | ) |
Unescape binary data, e.g. from a table field or notification payload.
Takes a binary string as escaped by PostgreSQL, and returns a restored copy of the original binary data.
References pqxx::text.
Unescape binary data, e.g. from a table field or notification payload.
Takes a binary string as escaped by PostgreSQL, and returns a restored copy of the original binary data.
References pqxx::text.
std::string pqxx::transaction_base::unesc_raw | ( | char const * | text | ) | const |
Unescape binary data, e.g. from a table field or notification payload.
Takes a binary string as escaped by PostgreSQL, and returns a restored copy of the original binary data.
References pqxx::text.
std::string pqxx::transaction_base::unesc_raw | ( | zview | text | ) | const |
Unescape binary data, e.g. from a table field or notification payload.
Takes a binary string as escaped by PostgreSQL, and returns a restored copy of the original binary data.
References pqxx::text.
|
friend |