pqxx Namespace Reference

The home of all libpqxx classes, functions, templates, etc. More...


Classes

class  basic_connection
 The ultimate template that defines a connection type. More...
class  binarystring
class  cachedresult
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 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  connectionpolicy
class  Cursor
 SQL cursor class. More...
class  cursor_base
 Common definitions for cursor types. More...
class  basic_cursor
 The simplest form of cursor, with no concept of position or stride. More...
class  absolute_cursor
 Cursor that knows its position. 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  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...
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  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...
class  subtransaction
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
class  trigger
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 cachedresult CachedResult
typedef connection Connection
typedef lazyconnection LazyConnection
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 connection_base ConnectionItf
typedef basic_cursor< cursor_base::random_access,
cursor_base::read_only > 
cursor
 Convenience typedef: the most common cursor type (read-only, random access).
typedef largeobject LargeObject
typedef largeobjectaccess LargeObjectAccess
typedef basic_ilostream< char > ilostream
typedef basic_olostream< char > olostream
typedef basic_lostream< char > lostream
typedef unsigned int oid
 PostgreSQL database row identifier.
typedef nontransaction NonTransaction
typedef binarystring BinaryString
typedef result Result
typedef basic_fieldstream<
char > 
fieldstream
typedef robusttransaction<
read_committed > 
RobustTransaction
typedef tablereader TableReader
typedef tablestream TableStream
typedef tablewriter TableWriter
typedef transaction< read_committed > Transaction
typedef transaction work
 Bog-standard, default transaction type.
typedef transaction_base TransactionItf
typedef transactor< transaction<
read_committed > > 
Transactor
typedef trigger Trigger

Enumerations

enum  isolation_level { read_committed, serializable }
 Transaction isolation levels; PostgreSQL doesn't implement all SQL levels. More...

Functions

PGSTD::string PQXX_LIBEXPORT escape_binary (const PGSTD::string &bin)
 Escape binary string for inclusion in SQL.
PGSTD::string PQXX_LIBEXPORT escape_binary (const char bin[])
 Escape binary string for inclusion in SQL.
PGSTD::string PQXX_LIBEXPORT escape_binary (const char bin[], size_t len)
 Escape binary string for inclusion in SQL.
PGSTD::string PQXX_LIBEXPORT escape_binary (const unsigned char bin[])
 Escape binary string for inclusion in SQL.
PGSTD::string PQXX_LIBEXPORT escape_binary (const unsigned char bin[], size_t len)
 Escape binary string for inclusion in SQL.
template<>
void cursor_base::check_displacement< cursor_base::forward_only > (difference_type) const
template<typename STREAM>
STREAM & operator<< (STREAM &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<>
PGSTD::string to_string (const result::field &Obj)
 Convert a field to a string.
template<>
bool result::field::to< PGSTD::string > (PGSTD::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 error_unsupported_type_in_string_conversion (T)
 Dummy name, used by libpqxx in deliberate link errors.
template<typename T>
PGSTD::string error_ambiguous_string_conversion (T)
 Dummy name, used to generate meaningful link errors.
template<typename T>
void from_string (const char Str[], T &Obj)
 Attempt to convert postgres-generated string to given built-in type.
template<>
void PQXX_LIBEXPORT from_string (const char Str[], long &)
template<>
void PQXX_LIBEXPORT from_string (const char Str[], unsigned long &)
template<>
void PQXX_LIBEXPORT from_string (const char Str[], int &)
template<>
void PQXX_LIBEXPORT from_string (const char Str[], unsigned int &)
template<>
void PQXX_LIBEXPORT from_string (const char Str[], short &)
template<>
void PQXX_LIBEXPORT from_string (const char Str[], unsigned short &)
template<>
void PQXX_LIBEXPORT from_string (const char Str[], float &)
template<>
void PQXX_LIBEXPORT from_string (const char Str[], double &)
template<>
void PQXX_LIBEXPORT from_string (const char Str[], bool &)
template<>
void from_string (const char Str[], PGSTD::string &Obj)
template<>
void from_string (const char Str[], PGSTD::stringstream &Obj)
template<typename T>
void from_string (const PGSTD::string &Str, T &Obj)
template<typename T>
void from_string (const PGSTD::stringstream &Str, T &Obj)
template<>
void from_string (const PGSTD::string &Str, PGSTD::string &Obj)
template<>
void from_string (const char[], char &Obj)
template<>
void from_string (const char[], signed char &Obj)
template<>
void from_string (const char[], unsigned char &Obj)
template<>
void from_string (const PGSTD::string &, char &Obj)
template<>
void from_string (const PGSTD::string &, signed char &Obj)
template<>
void from_string (const PGSTD::string &, unsigned char &Obj)
template<typename T>
PGSTD::string to_string (const T &)
 Convert built-in type to a readable string that PostgreSQL will understand.
template<>
PGSTD::string PQXX_LIBEXPORT to_string (const short &)
template<>
PGSTD::string PQXX_LIBEXPORT to_string (const unsigned short &)
template<>
PGSTD::string PQXX_LIBEXPORT to_string (const int &)
template<>
PGSTD::string PQXX_LIBEXPORT to_string (const unsigned int &)
template<>
PGSTD::string PQXX_LIBEXPORT to_string (const long &)
template<>
PGSTD::string PQXX_LIBEXPORT to_string (const unsigned long &)
template<>
PGSTD::string PQXX_LIBEXPORT to_string (const float &)
template<>
PGSTD::string PQXX_LIBEXPORT to_string (const double &)
template<>
PGSTD::string PQXX_LIBEXPORT to_string (const bool &)
PGSTD::string to_string (const char Obj[])
PGSTD::string to_string (const PGSTD::stringstream &Obj)
PGSTD::string to_string (const PGSTD::string &Obj)
template<>
PGSTD::string PQXX_LIBEXPORT to_string (const char &)
template<>
PGSTD::string to_string (const signed char &Obj)
template<>
PGSTD::string to_string (const unsigned char &Obj)
template<typename ITER, typename ACCESS>
PGSTD::string separated_list (const PGSTD::string &sep, ITER begin, ITER end, ACCESS access)
 Access iterators using ACCESS functor, returning separator-separated list.
template<typename ITER>
PGSTD::string separated_list (const PGSTD::string &sep, ITER begin, ITER end)
 Render sequence as a string, using given separator between items.
template<typename OBJ>
PGSTD::string separated_list (const PGSTD::string &sep, OBJ *begin, OBJ *end)
 Render array as a string, using given separator between items.
template<typename CONTAINER>
PGSTD::string separated_list (const PGSTD::string &sep, const CONTAINER &c)
 Render items in a container as a string, using given separator.
template<typename T>
PGSTD::string ToString (const T &Obj) PQXX_DEPRECATED
 Convert object of built-in type to string.
template<>
PGSTD::string ToString (const PGSTD::string &Obj)
template<>
PGSTD::string ToString (const char *const &Obj)
template<>
PGSTD::string ToString (char *const &Obj)
template<>
PGSTD::string ToString (const unsigned char *const &Obj)
template<>
PGSTD::string ToString (const bool &Obj)
template<>
PGSTD::string ToString (const short &Obj)
template<>
PGSTD::string ToString (const unsigned short &Obj)
template<typename T>
void FromString (const char Str[], T &Obj) PQXX_DEPRECATED
 Convert string to object of built-in type.
template<>
void FromString (const char Str[], PGSTD::string &Obj)
template<>
void FromString (const char Str[], const char *&Obj)
template<>
void FromString (const char Str[], const unsigned char *&Obj)
template<>
void FromString (const char Str[], bool &Obj)
PGSTD::string PQXX_LIBEXPORT sqlesc (const char str[])
 Escape nul-terminated string for inclusion in SQL strings.
PGSTD::string PQXX_LIBEXPORT sqlesc (const char str[], size_t maxlen)
 Escape string for inclusion in SQL strings.
PGSTD::string PQXX_LIBEXPORT sqlesc (const PGSTD::string &)
 Escape string for inclusion in SQL strings.
template<typename T>
PGSTD::string Quote (const T &Obj, bool EmptyIsNull) PQXX_DEPRECATED
 Quote string for use in SQL.
template<>
PGSTD::string Quote (const PGSTD::string &Obj, bool EmptyIsNull) PQXX_DEPRECATED
 std::string version, on which the other versions are built
template<>
PGSTD::string Quote (const char *const &Obj, bool EmptyIsNull) PQXX_DEPRECATED
 Special case for const char *, accepting null pointer as null value.
template<int LEN>
PGSTD::string Quote (const char(&Obj)[LEN], bool EmptyIsNull) PQXX_DEPRECATED
 Specialization for string constants.
template<typename T>
PGSTD::string Quote (T Obj) PQXX_DEPRECATED
 Quote string for use in SQL.
string escape_binary (const unsigned char bin[], size_t len)
 Escape binary string for inclusion in SQL.
string escape_binary (const unsigned char bin[])
 Escape binary string for inclusion in SQL.
string escape_binary (const char bin[], size_t len)
 Escape binary string for inclusion in SQL.
string escape_binary (const char bin[])
 Escape binary string for inclusion in SQL.
string escape_binary (const string &bin)
string sqlesc (const char str[])
 Escape nul-terminated string for inclusion in SQL strings.
string sqlesc (const char str[], size_t maxlen)
 Escape string for inclusion in SQL strings.
string sqlesc (const string &str)

Variables

const oid oid_none = 0
 The "null" oid.


Detailed Description

The home of all libpqxx classes, functions, templates, etc.

Typedef Documentation

typedef binarystring pqxx::BinaryString
 

Deprecated:
For compatibility with old BinaryString class

typedef cachedresult pqxx::CachedResult
 

Deprecated:
For compatibility with the old CachedResult class

typedef connection pqxx::Connection
 

Deprecated:
For compatibility with old Connection class

typedef connection_base pqxx::ConnectionItf
 

What is now connection_base used to be called ConnectionItf. This was changed to convey its role in a way more consistent with the C++ standard library.

typedef basic_cursor<cursor_base::random_access, cursor_base::read_only> pqxx::cursor
 

Convenience typedef: the most common cursor type (read-only, random access).

typedef basic_fieldstream<char> pqxx::fieldstream
 

typedef basic_ilostream<char> pqxx::ilostream
 

typedef largeobject pqxx::LargeObject
 

Deprecated:
For compatibility with old LargeObject class

typedef largeobjectaccess pqxx::LargeObjectAccess
 

Deprecated:
For compatibility with old LargeObjectAccess class

typedef lazyconnection pqxx::LazyConnection
 

Deprecated:
For compatibility with old LazyConnection class

typedef basic_lostream<char> pqxx::lostream
 

typedef nontransaction pqxx::NonTransaction
 

Deprecated:
For compatibility with the old NonTransaction class

typedef unsigned int pqxx::oid
 

PostgreSQL database row identifier.

typedef basic_olostream<char> pqxx::olostream
 

typedef result pqxx::Result
 

Deprecated:
For compatibility with old Result class

typedef robusttransaction<read_committed> pqxx::RobustTransaction
 

Deprecated:
For compatibility with old RobustTransaction class

typedef tablereader pqxx::TableReader
 

Deprecated:
For compatibility with the old TableReader class

typedef tablestream pqxx::TableStream
 

Deprecated:
For compatibility with the old TableStream class

typedef tablewriter pqxx::TableWriter
 

Deprecated:
For compatibility with the old TableWriter class

typedef transaction<read_committed> pqxx::Transaction
 

Deprecated:
Compatibility with the old Transaction class

typedef transaction_base pqxx::TransactionItf
 

What is now transaction_base used to be called TransactionItf. This was changed to convey its role in a way more consistent with the C++ standard library.

typedef transactor<transaction<read_committed> > pqxx::Transactor
 

Deprecated:
For compatibility with the old Transactor class

typedef trigger pqxx::Trigger
 

Deprecated:
For compatibility with the old Trigger class


Enumeration Type Documentation

enum pqxx::isolation_level
 

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.

Enumerator:
read_committed 
serializable 


Function Documentation

template<>
void pqxx::cursor_base::check_displacement< cursor_base::forward_only > difference_type   )  const
 

string pqxx::escape_binary const string &  bin  ) 
 

template<typename T>
void pqxx::from_string const result::field &  F,
T &  Obj
 

Convert a field's string contents to another type.

template<>
void pqxx::FromString const char  Str[],
bool &  Obj
 

template<>
void pqxx::FromString const char  Str[],
const unsigned char *&  Obj
 

template<>
void pqxx::FromString const char  Str[],
const char *&  Obj
 

template<>
void pqxx::FromString const char  Str[],
PGSTD::string &  Obj
 

template<typename T>
void pqxx::FromString const char  Str[],
T &  Obj
 

Convert string to object of built-in type.

Deprecated:
Use the stricter, safer from_string instead.
Warning:
The conversion is done using the currently active locale, whereas PostgreSQL delivers values in the "default" (C) locale. This means that if you intend to use this function from a locale that doesn't understand the data types in question (particularly numeric types like float and int) in default C format, you'll need to switch back to the C locale before the call. This problem does not exist with the newer from_string function template.

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
 

result::const_iterator pqxx::operator+ result::const_iterator::difference_type  o,
result::const_iterator  i
 

template<typename STREAM>
STREAM& pqxx::operator<< STREAM &  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;

template<>
bool pqxx::result::field::to< PGSTD::string > PGSTD::string &  Obj  )  const
 

Specialization: to(string &).

template<typename ITER, typename ACCESS>
PGSTD::string pqxx::separated_list const PGSTD::string &  sep,
ITER  begin,
ITER  end,
ACCESS  access
 

Access iterators using ACCESS functor, returning separator-separated list.

Parameters:
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

string pqxx::sqlesc const string &  str  ) 
 

template<>
PGSTD::string pqxx::to_string const result::field &  Obj  ) 
 

Convert a field to a string.

template<>
PGSTD::string pqxx::ToString const unsigned short &  Obj  ) 
 

template<>
PGSTD::string pqxx::ToString const short &  Obj  ) 
 

template<>
PGSTD::string pqxx::ToString const bool &  Obj  ) 
 

template<>
PGSTD::string pqxx::ToString const unsigned char *const &  Obj  ) 
 

template<>
PGSTD::string pqxx::ToString char *const &  Obj  ) 
 

template<>
PGSTD::string pqxx::ToString const char *const &  Obj  ) 
 

template<>
PGSTD::string pqxx::ToString const PGSTD::string &  Obj  ) 
 

template<typename T>
PGSTD::string pqxx::ToString const T &  Obj  ) 
 

Convert object of built-in type to string.

Deprecated:
Use the newer, rewritten to_string() instead.
Warning:
The conversion is done using the currently active locale, whereas PostgreSQL expects values in the "default" (C) locale. This means that if you intend to use this function from a locale that renders the data types in question (particularly numeric types like float and int) differently from the C default, you'll need to switch back to the C locale before the call. This problem does not exist with the newer to_string function template.


Variable Documentation

const oid pqxx::oid_none = 0
 

The "null" oid.


Generated on Sun Jun 18 15:06:42 2006 for libpqxx by  doxygen 1.4.6