Classes | |
class | basic_connection |
The ultimate template that defines a connection type. More... | |
class | binarystring |
class | connect_direct |
Connection policy; creates an immediate connection to a database. More... | |
class | connect_lazy |
Lazy connection policy; causes connection to be deferred until first use. More... | |
class | connect_async |
Asynchronous connection policy; connects "in the background". More... | |
class | connect_null |
Nonfunctional, always-down connection policy for testing/debugging purposes. More... | |
struct | noticer |
Base class for user-definable error/warning message processor. More... | |
struct | nonnoticer |
No-op message noticer; produces no output. More... | |
class | connection_base |
connection_base abstract base class; represents a connection to a database. More... | |
class | scoped_noticer |
Temporarily set different noticer for connection, then restore old one. More... | |
class | disable_noticer |
Temporarily disable the notice processor. More... | |
class | connectionpolicy |
class | cursor_base |
Common definitions for cursor types. More... | |
class | stateless_cursor |
"Stateless cursor" class: easy API for retrieving parts of result sets More... | |
class | icursorstream |
Simple read-only cursor represented as a stream of results. More... | |
class | icursor_iterator |
Approximate istream_iterator for icursorstream. More... | |
class | dbtransaction |
class | pqxx_exception |
Mixin base class to identify libpqxx-specific exception types. More... | |
class | failure |
Run-time failure encountered by libpqxx, similar to std::runtime_error. More... | |
class | broken_connection |
Exception class for lost or failed backend connection. More... | |
class | sql_error |
Exception class for failed queries. More... | |
class | in_doubt_error |
"Help, I don't know whether transaction was committed successfully!" More... | |
class | internal_error |
Internal error in libpqxx library. More... | |
class | usage_error |
Error in usage of libpqxx library, similar to std::logic_error. More... | |
class | argument_error |
Invalid argument passed to libpqxx, similar to std::invalid_argument. More... | |
class | conversion_error |
class | range_error |
Something is out of range, similar to std::out_of_range. More... | |
class | feature_not_supported |
Database feature not supported in current setup. More... | |
class | data_exception |
Error in data provided to SQL statement. More... | |
class | integrity_constraint_violation |
class | restrict_violation |
class | not_null_violation |
class | foreign_key_violation |
class | unique_violation |
class | check_violation |
class | invalid_cursor_state |
class | invalid_sql_statement_name |
class | invalid_cursor_name |
class | syntax_error |
class | undefined_column |
class | undefined_function |
class | undefined_table |
class | insufficient_privilege |
class | insufficient_resources |
Resource shortage on the server. More... | |
class | disk_full |
class | out_of_memory |
class | too_many_connections |
class | plpgsql_error |
PL/pgSQL error. More... | |
class | plpgsql_raise |
Exception raised in PL/pgSQL procedure. More... | |
class | plpgsql_no_data_found |
class | plpgsql_too_many_rows |
struct | isolation_traits |
Traits class to describe an isolation level; primarly for libpqxx's own use. More... | |
class | largeobject |
Identity of a large object. More... | |
class | largeobjectaccess |
Accessor for large object's contents. More... | |
class | largeobject_streambuf |
Streambuf to use large objects in standard I/O streams. More... | |
class | basic_ilostream |
Input stream that gets its data from a large object. More... | |
class | basic_olostream |
Output stream that writes data back to a large object. More... | |
class | basic_lostream |
Stream that reads and writes a large object. More... | |
class | nontransaction |
class | notify_listener |
class | pipeline |
Processes several queries in FIFO manner, optimized for high throughput. More... | |
class | result |
Query or command result set. More... | |
class | field_streambuf |
class | basic_fieldstream |
Input stream that gets its data from a result field. More... | |
class | basic_robusttransaction |
class | robusttransaction |
Slightly slower, better-fortified version of transaction. More... | |
struct | string_traits |
Traits class for use in string conversions. More... | |
struct | pqxx::string_traits< const char * > |
String traits for C-style string ("pointer to const char"). More... | |
struct | pqxx::string_traits< char * > |
String traits for non-const C-style string ("pointer to char"). More... | |
struct | pqxx::string_traits< char[N]> |
String traits for C-style string constant ("array of char"). More... | |
struct | pqxx::string_traits< std::string > |
struct | pqxx::string_traits< const std::string > |
struct | pqxx::string_traits< std::stringstream > |
class | subtransaction |
"Transaction" nested within another transaction More... | |
class | tablereader |
Efficiently pull data directly out of a table. More... | |
class | tablestream |
Base class for streaming data to/from database tables. More... | |
class | tablewriter |
Efficiently write data directly to a database table. More... | |
class | basic_transaction |
class | transaction |
Standard back-end transaction, templatized on isolation level. More... | |
class | transaction_base |
class | transactor |
struct | thread_safety_model |
Descriptor of library's thread-safety model. More... | |
class | items |
Container of items with easy contents initialization and string rendering. More... | |
Namespaces | |
namespace | internal |
Private namespace for libpqxx's internal use; do not access. | |
namespace | prepare |
Dedicated namespace for helper types related to prepared statements. | |
Typedefs | |
typedef basic_connection < connect_direct > | connection |
The "standard" connection type: connect to database right now. | |
typedef basic_connection < connect_lazy > | lazyconnection |
A "lazy" connection type: connect to database only when needed. | |
typedef basic_connection < connect_async > | asyncconnection |
"Asynchronous" connection type: start connecting, but don't wait for it | |
typedef basic_connection < connect_null > | nullconnection |
A "dummy" connection type: don't connect to any database at all. | |
typedef basic_ilostream< char > | ilostream |
typedef basic_olostream< char > | olostream |
typedef basic_lostream< char > | lostream |
typedef unsigned int | oid |
PostgreSQL database row identifier. | |
typedef basic_fieldstream< char > | fieldstream |
typedef transaction | work |
Bog-standard, default transaction type. | |
typedef transaction < read_committed, read_only > | read_transaction |
Read-only transaction. | |
typedef notify_listener | trigger |
Enumerations | |
enum | readwrite_policy { read_only, read_write } |
enum | isolation_level { read_committed, serializable } |
Transaction isolation levels; PostgreSQL doesn't implement all SQL levels. More... | |
Functions | |
std::string | escape_binary (const std::string &bin) |
Escape binary string for inclusion in SQL. | |
std::string | escape_binary (const char bin[]) |
Escape binary string for inclusion in SQL. | |
std::string | escape_binary (const char bin[], size_t len) |
Escape binary string for inclusion in SQL. | |
std::string | escape_binary (const unsigned char bin[]) |
Escape binary string for inclusion in SQL. | |
std::string | escape_binary (const unsigned char bin[], size_t len) |
Escape binary string for inclusion in SQL. | |
std::string | encrypt_password (const std::string &user, const std::string &password) |
Encrypt password for given user. Requires libpq 8.2 or better. | |
template<typename CHAR> | |
std::basic_ostream< CHAR > & | operator<< (std::basic_ostream< CHAR > &S, const pqxx::result::field &F) |
Write a result field to any type of stream. | |
template<typename T> | |
void | from_string (const result::field &F, T &Obj) |
Convert a field's string contents to another type. | |
template<> | |
std::string | to_string (const result::field &Obj) |
Convert a field to a string. | |
template<> | |
bool | result::field::to< std::string > (std::string &Obj) const |
Specialization: to(string &) . | |
result::const_iterator | operator+ (result::const_iterator::difference_type o, result::const_iterator i) |
result::const_reverse_iterator | operator+ (result::const_reverse_iterator::difference_type n, const result::const_reverse_iterator &i) |
result::const_fielditerator | operator+ (result::const_fielditerator::difference_type o, result::const_fielditerator i) |
template<typename T> | |
void | from_string (const char Str[], T &Obj) |
Attempt to convert postgres-generated string to given built-in type. | |
template<typename T> | |
void | from_string (const char Str[], T &Obj, size_t) |
Conversion with known string length (for strings that may contain nuls). | |
template<> | |
void | from_string< std::string > (const char Str[], std::string &Obj, size_t len) |
template<typename T> | |
void | from_string (const std::string &Str, T &Obj) |
template<typename T> | |
void | from_string (const std::stringstream &Str, T &Obj) |
template<> | |
void | from_string (const std::string &Str, std::string &Obj) |
template<typename T> | |
std::string | to_string (const T &Obj) |
Convert built-in type to a readable string that PostgreSQL will understand. | |
std::string | to_string (const char Obj[]) |
thread_safety_model | describe_thread_safety () throw () |
Describe thread safety available in this build. | |
template<typename ITER, typename ACCESS> | |
std::string | separated_list (const std::string &sep, ITER begin, ITER end, ACCESS access) |
Access iterators using ACCESS functor, returning separator-separated list. | |
template<typename ITER> | |
std::string | separated_list (const std::string &sep, ITER begin, ITER end) |
Render sequence as a string, using given separator between items. | |
template<typename OBJ> | |
std::string | separated_list (const std::string &sep, OBJ *begin, OBJ *end) |
Render array as a string, using given separator between items. | |
template<typename CONTAINER> | |
std::string | separated_list (const std::string &sep, const CONTAINER &c) |
Render items in a container as a string, using given separator. | |
string | escape_binary (const string &bin) |
Variables | |
const oid | oid_none = 0 |
The "null" oid. |
typedef basic_fieldstream<char> pqxx::fieldstream |
typedef basic_ilostream<char> pqxx::ilostream |
typedef basic_lostream<char> pqxx::lostream |
typedef unsigned int pqxx::oid |
PostgreSQL database row identifier.
typedef basic_olostream<char> pqxx::olostream |
typedef notify_listener pqxx::trigger |
Transaction isolation levels; PostgreSQL doesn't implement all SQL levels.
The only levels implemented in postgres are read_committed and serializable; SQL also defines read_uncommitted and repeatable_read. Unless you're bent on using nasty tricks to communicate between ongoing transactions and such, you won't really need isolation levels for anything except performance optimization. In that case, you can safely emulate read_uncommitted by using read_committed and repeatable_read by using serializable. In general, serializable is the safest choice.
pqxx::thread_safety_model pqxx::describe_thread_safety | ( | ) | throw () |
Describe thread safety available in this build.
References pqxx::thread_safety_model::description, pqxx::thread_safety_model::have_strerror_r, pqxx::thread_safety_model::safe_kerberos, pqxx::thread_safety_model::safe_libpq, pqxx::thread_safety_model::safe_query_cancel, and pqxx::thread_safety_model::safe_result_copy.
std ::string pqxx::encrypt_password | ( | const std::string & | user, | |
const std::string & | password | |||
) |
Encrypt password for given user. Requires libpq 8.2 or better.
Use this when setting a new password for the user if password encryption is enabled. Inputs are the username the password is for, and the plaintext password.
void setpw(transaction_base &t, const string &user, const string &pw) { t.exec("ALTER USER " + user + " " "PASSWORD '" + encrypt_password(user,pw) + "'"); }
string pqxx::escape_binary | ( | const string & | bin | ) |
References escape_binary().
void pqxx::from_string | ( | const result::field & | F, | |
T & | Obj | |||
) |
Convert a field's string contents to another type.
References pqxx::result::field::c_str(), and pqxx::result::field::size().
Referenced by from_string(), pqxx::internal::sql_cursor::move(), and pqxx::result::field::to().
result::const_fielditerator pqxx::operator+ | ( | result::const_fielditerator::difference_type | o, | |
result::const_fielditerator | i | |||
) |
result::const_reverse_iterator pqxx::operator+ | ( | result::const_reverse_iterator::difference_type | n, | |
const result::const_reverse_iterator & | i | |||
) |
References pqxx::result::const_reverse_iterator::base().
result::const_iterator pqxx::operator+ | ( | result::const_iterator::difference_type | o, | |
result::const_iterator | i | |||
) |
std ::basic_ostream<CHAR>& pqxx::operator<< | ( | std::basic_ostream< CHAR > & | S, | |
const pqxx::result::field & | F | |||
) |
Write a result field to any type of stream.
This can be convenient when writing a field to an output stream. More importantly, it lets you write a field to e.g. a stringstream
which you can then use to read, format and convert the field in ways that to() does not support.
Example: parse a field into a variable of the nonstandard "<tt>long long</tt>" type.
extern result R; long long L; stringstream S; // Write field's string into S S << R[0][0]; // Parse contents of S into L S >> L;
bool pqxx::result::field::to< std::string > | ( | std::string & | Obj | ) | const |
Specialization: to(string &)
.
std ::string pqxx::separated_list | ( | const std::string & | sep, | |
ITER | begin, | |||
ITER | end, | |||
ACCESS | access | |||
) |
Access iterators using ACCESS functor, returning separator-separated list.
sep | separator string (to be placed between items) | |
begin | beginning of items sequence | |
end | end of items sequence | |
access | functor defining how to dereference sequence elements |
References to_string().
Referenced by pqxx::tablestream::columnlist(), pqxx::tablewriter::generate(), and separated_list().
std ::string pqxx::to_string | ( | const result::field & | Obj | ) |
Convert a field to a string.
References pqxx::result::field::c_str(), and pqxx::result::field::size().
Referenced by pqxx::connection_base::adorn_name(), pqxx::binarystring::at(), pqxx::result::column_name(), pqxx::result::column_type(), pqxx::internal::EscapeAny(), pqxx::pipeline::is_finished(), pqxx::connection_base::quote(), pqxx::largeobjectaccess::read(), pqxx::largeobject::remove(), pqxx::pipeline::retain(), separated_list(), pqxx::icursorstream::set_stride(), pqxx::internal::sleep_seconds(), pqxx::largeobject::to_file(), and pqxx::largeobjectaccess::write().
const oid pqxx::oid_none = 0 |
The "null" oid.
Referenced by pqxx::result::column_type(), pqxx::largeobject::largeobject(), and pqxx::largeobject::Reason().