|
| | transaction (connection_base &C, const PGSTD::string &TName) |
| | Create a transaction. More...
|
| |
| | transaction (connection_base &C) |
| |
| virtual | ~transaction () throw () |
| |
| void | abort () |
| | Abort the transaction. More...
|
| |
| const PGSTD::string & | classname () const throw () |
| |
| void | commit () |
| | Commit the transaction. More...
|
| |
| connection_base & | conn () const |
| | Connection this transaction is running in. More...
|
| |
| PGSTD::string | description () const |
| |
| PGSTD::string | esc (const char str[]) const |
| | Escape string for use as SQL string literal in this transaction. More...
|
| |
| PGSTD::string | esc (const char str[], size_t maxlen) const |
| | Escape string for use as SQL string literal in this transaction. More...
|
| |
| PGSTD::string | esc (const PGSTD::string &str) const |
| | Escape string for use as SQL string literal in this transaction. More...
|
| |
| PGSTD::string | esc_raw (const unsigned char str[], size_t len) const |
| | Escape binary data for use as SQL string literal in this transaction. More...
|
| |
| PGSTD::string | esc_raw (const PGSTD::string &) const |
| | Escape binary data for use as SQL string literal in this transaction. More...
|
| |
| result | exec (const PGSTD::string &Query, const PGSTD::string &Desc=PGSTD::string()) |
| | Execute query. More...
|
| |
| result | exec (const PGSTD::stringstream &Query, const PGSTD::string &Desc=PGSTD::string()) |
| |
| PGSTD::string | get_variable (const PGSTD::string &) |
| | Get currently applicable value of variable. More...
|
| |
| const PGSTD::string & | name () const throw () |
| |
| internal::parameterized_invocation | parameterized (const PGSTD::string &query) |
| | Parameterize a statement. More...
|
| |
| template<typename T > |
| PGSTD::string | quote (const T &t) const |
| | Represent object as SQL string, including quoting & escaping. More...
|
| |
| PGSTD::string | quote_name (const PGSTD::string &identifier) const |
| | Escape an SQL identifier for use in a query. More...
|
| |
| PGSTD::string | quote_raw (const unsigned char str[], size_t len) const |
| | Binary-escape and quote a binarystring for use as an SQL constant. More...
|
| |
| PGSTD::string | quote_raw (const PGSTD::string &str) const |
| |
| void | set_variable (const PGSTD::string &Var, const PGSTD::string &Val) |
| | Set session variable in this connection. More...
|
| |
|
| prepare::invocation | prepared (const PGSTD::string &statement=PGSTD::string()) |
| | Execute prepared statement. More...
|
| |
|
| void | process_notice (const char Msg[]) const |
| | Have connection process warning message. More...
|
| |
| void | process_notice (const PGSTD::string &Msg) const |
| | Have connection process warning message. More...
|
| |
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
try
{
T.exec("UPDATE employees SET wage=wage*2");
T.commit();
}
catch (const exception &e)
{
cerr << e.what() << endl;
T.abort();
}
| void pqxx::transaction_base::commit |
( |
| ) |
|
|
inherited |
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.
| result pqxx::transaction_base::exec |
( |
const PGSTD::string & |
Query, |
|
|
const PGSTD::string & |
Desc = PGSTD::string() |
|
) |
| |
|
inherited |
Execute query.
Perform a query in this transaction.
This is one of the most important functions in libpqxx.
Most libpqxx exceptions can be thrown from here, 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 will be derived from std::exception, however, and all libpqxx-specific exception types are derived from pqxx::pqxx_exception.
- Parameters
-
| Query | Query or command to execute |
| Desc | Optional identifier for query, to help pinpoint SQL errors |
- Returns
- A result set describing the query's or command's result
| prepare::invocation pqxx::transaction_base::prepared |
( |
const PGSTD::string & |
statement = PGSTD::string() | ) |
|
|
inherited |
Execute prepared statement.
Prepared statements are defined using the connection classes' prepare() function, and continue to live on in the ongoing session regardless of the context they were defined in (unless explicitly dropped using the connection's unprepare() function). Their execution however, like other forms of query execution, requires a transaction object.
Just like param_declaration is a helper class that lets you tag parameter declarations onto the statement declaration, the invocation class returned here lets you tag parameter values onto the call:
{
return T.prepared("mystatement")("param1")(2)()(4).exec();
}
Here, parameter 1 (written as "<tt>$1</tt>" in the statement's body) is a string that receives the value "param1"; the second parameter is an integer with the value 2; the third receives a null, making its type irrelevant; and number 4 again is an integer. The ultimate invocation of exec() is essential; if you forget this, nothing happens.
To see whether any prepared statement has been defined under a given name, use:
T.prepared("mystatement").exists()
- Warning
- Do not try to execute a prepared statement manually through direct SQL statements. This is likely not to work, and even if it does, is likely to be slower than using the proper libpqxx functions. Also, libpqxx knows how to emulate prepared statements if some part of the infrastructure does not support them.
-
Actual definition of the prepared statement on the backend may be deferred until its first use, which means that any errors in the prepared statement may not show up until it is executed–and perhaps abort the ongoing transaction in the process.
If you leave out the statement name, the call refers to the nameless statement instead.
| void pqxx::transaction_base::set_variable |
( |
const PGSTD::string & |
Var, |
|
|
const PGSTD::string & |
Val |
|
) |
| |
|
inherited |
Set session variable in this connection.
The new value is typically forgotten if the transaction aborts. Known exceptions to this rule are nontransaction, and PostgreSQL versions prior to 7.3. In the case of nontransaction, the set value will be kept regardless; but in that case, if the connection ever needs to be recovered, the set value will not be restored.
- Parameters
-
| Var | The variable to set |
| Val | The new value to store in the variable |
1.8.3.1