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

Namespaces
	internal
	Internal items for libpqxx' own use. Do not use these yourself.

	prepare

Classes
struct	argument_error
	Invalid argument passed to libpqxx, similar to std::invalid_argument. More...

class	array
	An SQL array received from the database. More...

class	array_parser
	Low-level parser for C++ arrays. More...

class	basic_fieldstream
	Input stream that gets its data from a result field. More...

class	basic_ilostream
	Input stream that gets its data from a large object. More...

class	basic_lostream
	Stream that reads and writes a large object. More...

class	basic_olostream
	Output stream that writes data back to a large object. More...

class	binarystring
	Binary data corresponding to PostgreSQL's "BYTEA" binary-string type. More...

class	blob

struct	broken_connection
	Exception class for lost or failed backend connection. More...

struct	byte_char_traits
	Custom `std::char_trast` if the compiler does not provide one. More...

struct	check_violation

class	connecting
	An ongoing, non-blocking stepping stone to a connection. More...

class	connection
	Connection to a database. More...

class	const_result_iterator
	Iterator for rows in a result. Use as result::const_iterator. More...

class	const_reverse_result_iterator
	Reverse iterator for result. Use as result::const_reverse_iterator. More...

class	const_reverse_row_iterator
	Reverse iterator for a row. Use as row::const_reverse_iterator. More...

class	const_row_iterator
	Iterator for fields in a row. Use as row::const_iterator. More...

struct	conversion_error
	Value conversion failed, e.g. when converting "Hello" to int. More...

struct	conversion_overrun
	Could not convert value to string: not enough buffer space. More...

class	cursor_base
	Common definitions for cursor types. More...

struct	data_exception
	Error in data provided to SQL statement. More...

class	dbtransaction
	Abstract transaction base class: bracket transactions on the database. More...

struct	deadlock_detected
	The ongoing transaction has deadlocked. Retrying it may help. More...

struct	disk_full

class	errorhandler

class	exclusive_bound
	An exclusive boundary value to a pqxx::range. More...

struct	failure
	Run-time failure encountered by libpqxx, similar to std::runtime_error. More...

struct	feature_not_supported
	Database feature not supported in current setup. More...

class	field
	Reference to a field in a result set. More...

class	field_streambuf

struct	forbidden_conversion
	String traits for a forbidden type conversion. More...

struct	foreign_key_violation

struct	from_query_t
	Marker for stream_from constructors: "stream from query.". More...

struct	from_table_t
	Marker for stream_from constructors: "stream from table.". More...

struct	has_generic_char_traits

struct	has_generic_char_traits< TYPE, std::void_t< decltype(std::char_traits< TYPE >::eof)> >

class	icursor_iterator
	Approximate istream_iterator for icursorstream. More...

class	icursorstream
	Simple read-only cursor represented as a stream of results. More...

struct	in_doubt_error
	"Help, I don't know whether transaction was committed successfully!" More...

class	inclusive_bound
	An inclusive boundary value to a pqxx::range. More...

struct	insufficient_privilege

struct	insufficient_resources
	Resource shortage on the server. More...

struct	integrity_constraint_violation

struct	internal_error
	Internal error in libpqxx library. More...

struct	invalid_cursor_name

struct	invalid_cursor_state

struct	invalid_sql_statement_name

class	largeobject
	Identity of a large object. More...

class	largeobject_streambuf
	Streambuf to use large objects in standard I/O streams. More...

class	largeobjectaccess
	Accessor for large object's contents. More...

struct	no_bound
	An unlimited boundary value to a pqxx::range. More...

struct	no_null
	Nullness traits describing a type which does not have a null value. More...

class	nontransaction
	Simple "transaction" class offering no transactional integrity. More...

struct	not_null_violation

struct	notification
	An incoming notification. More...

class	notification_receiver

struct	nullness
	Traits describing a type's "null value," if any. More...

struct	nullness< binarystring >

struct	nullness< bytes >

struct	nullness< bytes_view >

struct	nullness< char * >

struct	nullness< char const * >

struct	nullness< char[N]>

struct	nullness< ENUM, std::enable_if_t< std::is_enum_v< ENUM > > >
	Nullness: Enums do not have an inherent null value. More...

struct	nullness< range< TYPE > >
	A range type does not have an innate null value. More...

struct	nullness< std::array< T, N > >

struct	nullness< std::monostate >

struct	nullness< std::nullopt_t >

struct	nullness< std::nullptr_t >

struct	nullness< std::optional< T > >

struct	nullness< std::shared_ptr< T > >

struct	nullness< std::string >

struct	nullness< std::string_view >
	There's no real null for `std::string_view`. More...

struct	nullness< std::stringstream >

struct	nullness< std::unique_ptr< T > >

struct	nullness< std::variant< T... > >

struct	nullness< std::vector< T, Args... > >

struct	nullness< T, std::enable_if_t< std::is_arithmetic_v< T > > >
	The built-in arithmetic types do not have inherent null values. More...

struct	nullness< zview >

struct	out_of_memory

class	params
	Build a parameter list for a parameterised or prepared statement. More...

class	pipeline
	Processes several queries in FIFO manner, optimized for high throughput. More...

class	placeholders
	Generate parameter placeholders for use in an SQL statement. More...

struct	plpgsql_error
	PL/pgSQL error. More...

struct	plpgsql_no_data_found

struct	plpgsql_raise
	Exception raised in PL/pgSQL procedure. More...

struct	plpgsql_too_many_rows

class	prepped
	A string that is the name of a prepared statement. More...

struct	protocol_violation
	Exception class for micommunication with the server. More...

class	quiet_errorhandler

class	range
	A C++ equivalent to PostgreSQL's range types. More...

class	range_bound
	A range boundary value. More...

struct	range_error
	Something is out of range, similar to std::out_of_range. More...

struct	restrict_violation

class	result
	Result set containing data returned by a query or command. More...

class	robusttransaction
	Slightly slower, better-fortified version of transaction. More...

class	row
	Reference to one row in a result. More...

struct	serialization_failure
	Transaction failed to serialize. Please retry it. More...

class	sql_error
	Exception class for failed queries. More...

class	stateless_cursor
	"Stateless cursor" class: easy API for retrieving parts of result sets More...

struct	statement_completion_unknown
	We can't tell whether our last statement succeeded. More...

class	stream_from
	Stream data from the database. More...

class	stream_query

class	stream_to
	Efficiently write data directly to a database table. More...

struct	string_traits
	Traits class for use in string conversions. More...

struct	string_traits< binarystring >
	String conversion traits for `binarystring`. More...

struct	string_traits< bool >

struct	string_traits< bytes >

struct	string_traits< bytes_view >

struct	string_traits< char * >
	String traits for non-const C-style string ("pointer to char"). More...

struct	string_traits< char >
	You cannot convert a `char` to/from SQL. More...

struct	string_traits< char const * >
	String traits for C-style string ("pointer to char const"). More...

struct	string_traits< char[N]>
	String traits for C-style string constant ("pointer to array of char"). More...

struct	string_traits< double >

struct	string_traits< float >

struct	string_traits< int >

struct	string_traits< long >

struct	string_traits< long double >

struct	string_traits< long long >

struct	string_traits< range< TYPE > >
	String conversions for a range type. More...

struct	string_traits< short >

struct	string_traits< signed char >
	You cannot convert a `signed char` to/from SQL. More...

struct	string_traits< std::array< T, N > >

struct	string_traits< std::byte >
	You cannot convert a `std::byte` to/from SQL. More...

struct	string_traits< std::monostate >

struct	string_traits< std::nullopt_t >

struct	string_traits< std::nullptr_t >

struct	string_traits< std::optional< T > >

struct	string_traits< std::shared_ptr< T > >

struct	string_traits< std::string >

struct	string_traits< std::string_view >
	String traits for `string_view`. More...

struct	string_traits< std::stringstream >

struct	string_traits< std::unique_ptr< T, Args... > >

struct	string_traits< std::variant< T... > >

struct	string_traits< std::vector< T, Args... > >

struct	string_traits< unsigned >

struct	string_traits< unsigned char >
	You cannot convert an `unsigned char` to/from SQL. More...

struct	string_traits< unsigned long >

struct	string_traits< unsigned long long >

struct	string_traits< unsigned short >

struct	string_traits< zview >
	String traits for `zview`. More...

class	subtransaction
	"Transaction" nested within another transaction More...

struct	syntax_error

struct	thread_safety_model
	Descriptor of library's thread-safety model. More...

struct	too_many_connections

class	transaction
	transaction Standard back-end transaction, templatised on isolation level. More...

class	transaction_base
	Interface definition (and common code) for "transaction" classes. More...

class	transaction_focus
	Base class for things that monopolise a transaction's attention. More...

struct	transaction_rollback
	The backend saw itself forced to roll back the ongoing transaction. More...

struct	undefined_column

struct	undefined_function

struct	undefined_table

struct	unexpected_null
	Could not convert null value: target type does not support null. More...

struct	unexpected_rows
	Query returned an unexpected number of rows. More...

struct	unique_violation

struct	usage_error
	Error in usage of libpqxx library, similar to std::logic_error. More...

struct	variable_set_to_null
	The caller attempted to set a variable to null, which is not allowed. More...

class	zview
	Marker-type wrapper: zero-terminated `std::string_view`. More...

Typedefs
using	table_path = std::initializer_list< std::string_view >
	Representation of a PostgreSQL table path. More...

using	connection_base = connection

using	fieldstream = basic_fieldstream< char >

using	oid = unsigned int
	PostgreSQL database row identifier. More...

using	ilostream = basic_ilostream< char >

using	olostream = basic_olostream< char >

using	lostream = basic_lostream< char >

using	work = transaction< isolation_level::read_committed, write_policy::read_write >
	The default transaction type. More...

using	read_transaction = transaction< isolation_level::read_committed, write_policy::read_only >
	Read-only transaction. More...

using	result_size_type = int
	Number of rows in a result set. More...

using	result_difference_type = int
	Difference between result sizes. More...

using	row_size_type = int
	Number of fields in a row of database data. More...

using	row_difference_type = int
	Difference between row sizes. More...

using	field_size_type = std::size_t
	Number of bytes in a field of database data. More...

using	large_object_size_type = int64_t
	Number of bytes in a large object. More...

template<typename TYPE >
using	strip_t = std::remove_cv_t< std::remove_reference_t< TYPE >>
	Remove any constness, volatile, and reference-ness from a type. More...

template<typename CONTAINER >
using	value_type = strip_t< decltype(*std::begin(std::declval< CONTAINER >()))>
	The type of a container's elements. More...

using	bytes = std::conditional< has_generic_bytes_char_traits, std::basic_string< std::byte >, std::basic_string< std::byte, byte_char_traits >>::type
	Type alias for a container containing bytes. More...

using	bytes_view = std::conditional< has_generic_bytes_char_traits, std::basic_string_view< std::byte >, std::basic_string_view< std::byte, byte_char_traits >>::type
	Type alias for a view of bytes. More...

Enumerations
enum	skip_init : int { nothing, openssl, crypto }
	Flags for skipping initialisation of SSL-related libraries. More...

enum	error_verbosity : int { error_verbosity::terse = 0, error_verbosity::normal = 1, error_verbosity::verbose = 2 }
	Error verbosity levels. More...

enum	write_policy { write_policy::read_only, write_policy::read_write }
	Should a transaction be read-only, or read-write? More...

enum	isolation_level { read_committed, repeatable_read, serializable }
	Transaction isolation levels. More...

enum	format : int { format::text = 0, format::binary = 1 }
	Format code: is data text or binary? More...

Functions
template<>
constexpr	__attribute__ ((pure)) std

template<typename... T>
void	parse_composite (pqxx::internal::encoding_group enc, std::string_view text, T &...fields)
	Parse a string representation of a value of a composite type. More...

template<typename... T>
void	parse_composite (std::string_view text, T &...fields)
	Parse a string representation of a value of a composite type. More...

template<typename... T>
std::size_t	composite_size_buffer (T const &...fields) noexcept
	Estimate the buffer size needed to represent a value of a composite type. More...

template<typename... T>
char *	composite_into_buf (char begin, char end, T const &...fields)
	Render a series of values as a single composite SQL value. More...

template<skip_init... SKIP>
void	skip_init_ssl () noexcept
	Control initialisation of OpenSSL and libcrypto libraries. More...

std::string PQXX_LIBEXPORT	encrypt_password (char const user[], char const password[])
	Encrypt a password. More...

std::string	encrypt_password (zview user, zview password)
	Encrypt password. More...

template<>
bool	field::to< std::string > (std::string &obj) const

template<>
bool	field::to< std::string > (std::string &obj, std::string const &default_value) const

template<>
bool	field::to< std::string_view > (std::string_view &obj) const

template<>
bool	field::to< std::string_view > (std::string_view &obj, std::string_view const &default_value) const

template<>
std::string_view	field::as< std::string_view > () const

template<>
std::string_view	field::as< std::string_view > (std::string_view const &default_value) const

template<typename CHAR >
std::basic_ostream< CHAR > &	operator<< (std::basic_ostream< CHAR > &s, field const &value)
	Write a result field to any type of stream. More...

template<typename T >
T	from_string (field const &value)
	Convert a field's value to type `T`. More...

template<>
std::nullptr_t	from_string< std::nullptr_t > (field const &value)
	Convert a field's value to `nullptr_t`. More...

template<>
PQXX_LIBEXPORT std::string	to_string (field const &value)
	Convert a field to a string. More...

template<typename T >
constexpr format	param_format (std::optional< T > const &value)

template<typename... Args>
constexpr format	param_format (std::variant< Args... > const &value)

template<typename T >
T	from_string (std::stringstream const &text)

template<typename T , typename... Args>
format	param_format (std::unique_ptr< T, Args... > const &value)

template<typename T >
format	param_format (std::shared_ptr< T > const &value)

template<>
constexpr format	param_format (bytes const &)

template<>
constexpr format	param_format (bytes_view const &)

template<typename T , typename... Args>
constexpr format	param_format (std::vector< T, Args... > const &)
	We don't know how to pass array params in binary format, so pass as text. More...

template<typename... Args>
constexpr format	param_format (std::vector< std::byte, Args... > const &)
	A `std::vector<std::byte>` is a binary string. Other vectors are not. More...

template<typename T , typename... Args, Args... args>
constexpr format	param_format (std::array< T, args... > const &)
	We don't know how to pass array params in binary format, so pass as text. More...

template<typename... Args, Args... args>
constexpr format	param_format (std::array< std::byte, args... > const &)
	An array of `std::byte` is a binary string. More...

template<typename T >
std::string	to_string (T const &value)

template<>
std::string	to_string (float const &value)

template<>
std::string	to_string (double const &value)

template<>
std::string	to_string (long double const &value)

template<>
std::string	to_string (std::stringstream const &value)

template<typename T >
void	into_string (T const &value, std::string &out)

const_result_iterator	operator+ (result::difference_type o, const_result_iterator const &i)

const_reverse_result_iterator	operator+ (result::difference_type n, const_reverse_result_iterator const &i)

const_row_iterator	operator+ (const_row_iterator::difference_type o, const_row_iterator const &i) noexcept

template<typename ITER , typename ACCESS >
std::string	separated_list (std::string_view sep, ITER begin, ITER end, ACCESS access)
	Represent sequence of values as a string, joined by a given separator. More...

template<typename ITER >
std::string	separated_list (std::string_view sep, ITER begin, ITER end)
	Render sequence as a string, using given separator between items. More...

template<typename CONTAINER >
auto	separated_list (std::string_view sep, CONTAINER const &c) -> typename std::enable_if< (not std::is_void< decltype(std::begin(c))>::value and not std::is_void< decltype(std::end(c))>::value), std::string >::type
	Render items in a container as a string, using given separator. More...

template<typename TUPLE , std::size_t INDEX = 0, typename ACCESS , typename std::enable_if< (INDEX==std::tuple_size< TUPLE >::value-1), int >::type = 0>
std::string	separated_list (std::string_view, TUPLE const &t, ACCESS const &access)
	Render items in a tuple as a string, using given separator. More...

template<typename TUPLE , std::size_t INDEX = 0, typename ACCESS >
std::string	separated_list (std::string_view sep, TUPLE const &t, ACCESS const &access)

template<typename TUPLE , std::size_t INDEX = 0>
std::string	separated_list (std::string_view sep, TUPLE const &t)

template<typename TYPE >
void	oops_forbidden_conversion () noexcept
	Nonexistent function to indicate a disallowed type conversion. More...

template<typename TYPE >
TYPE	from_string (std::string_view text)
	Parse a value in postgres' text format as a TYPE. More...

template<>
std::string_view	from_string (std::string_view text)
	"Convert" a std::string_view to a std::string_view. More...

template<typename T >
void	from_string (std::string_view text, T &value)
	Attempt to convert postgres-generated string to given built-in object. More...

template<typename TYPE >
std::string	to_string (TYPE const &value)
	Convert a value to a readable string that PostgreSQL will understand. More...

template<typename... TYPE>
std::vector< std::string_view >	to_buf (char here, char const end, TYPE...value)
	Convert multiple values to strings inside a single buffer. More...

template<typename TYPE >
void	into_string (TYPE const &value, std::string &out)
	Convert a value to a readable string that PostgreSQL will understand. More...

template<typename TYPE >
constexpr bool	is_null (TYPE const &value) noexcept
	Is `value` null? More...

template<typename... TYPE>
std::size_t	size_buffer (TYPE const &...value) noexcept
	Estimate how much buffer space is needed to represent values as a string. More...

template<typename TYPE >
constexpr format	param_format (TYPE const &)
	What's the preferred format for passing non-null parameters of this type? More...

template<typename TYPE >
zview	generic_to_buf (char begin, char end, TYPE const &value)
	Implement `string_traits<TYPE>::to_buf` by calling `into_buf`. More...

template<>
std::string_view	transaction_base::query_value< std::string_view > (zview query, std::string_view desc)=delete
	Forbidden specialisation: underlying buffer immediately goes out of scope. More...

template<typename TRANSACTION_CALLBACK >
auto	perform (TRANSACTION_CALLBACK &&callback, int attempts=3) -> std::invoke_result_t< TRANSACTION_CALLBACK >
	Simple way to execute a transaction with automatic retry. More...

template<typename TYPE >
constexpr std::string_view	name_type () noexcept
	Return human-readable name for `TYPE`. More...

template<>
PQXX_PURE constexpr std::string_view	name_type< std::string > () noexcept

template<>
PQXX_PURE constexpr std::string_view	name_type< std::string_view > () noexcept

template<>
PQXX_PURE constexpr std::string_view	name_type< char const * > () noexcept

template<>
PQXX_PURE constexpr std::string_view	name_type< bool > () noexcept

template<>
PQXX_PURE constexpr std::string_view	name_type< short > () noexcept

template<>
PQXX_PURE constexpr std::string_view	name_type< int > () noexcept

template<>
PQXX_PURE constexpr std::string_view	name_type< long > () noexcept

template<>
PQXX_PURE constexpr std::string_view	name_type< long long > () noexcept

template<>
PQXX_PURE constexpr std::string_view	name_type< unsigned short > () noexcept

template<>
PQXX_PURE constexpr std::string_view	name_type< unsigned > () noexcept

template<>
PQXX_PURE constexpr std::string_view	name_type< unsigned long > () noexcept

template<>
PQXX_PURE constexpr std::string_view	name_type< unsigned long long > () noexcept

template<>
PQXX_PURE constexpr std::string_view	name_type< float > () noexcept

template<>
PQXX_PURE constexpr std::string_view	name_type< double > () noexcept

template<>
PQXX_PURE constexpr std::string_view	name_type< long double > () noexcept

template<>
PQXX_PURE constexpr std::string_view	name_type< std::nullptr_t > () noexcept

template<typename... T>
constexpr void	ignore_unused (T &&...) noexcept
	Suppress compiler warning about an unused item. More...

template<typename TO , typename FROM >
TO	check_cast (FROM value, std::string_view description)
	Cast a numeric value to another type, or throw if it underflows/overflows. More...

PQXX_PRIVATE void	check_version () noexcept

PQXX_LIBEXPORT thread_safety_model	describe_thread_safety ()
	Describe thread safety available in this build. More...

template<typename TYPE >
bytes_view	binary_cast (TYPE const &data)
	End a code block started by "ignore-deprecated-pre.hxx". More...

template<typename CHAR , typename SIZE >
bytes_view	binary_cast (CHAR const *data, SIZE size)
	Construct a type that libpqxx will recognise as binary. More...

constexpr zview	operator""_zv (char const str[], std::size_t len) noexcept
	Support zview literals. More...

template<>
PQXX_PURE constexpr std::string_view	name_type< zview > () noexcept

Variables
template<>
constexpr bool	is_unquoted_safe< short > {true}

template<>
constexpr bool	is_unquoted_safe< unsigned short > {true}

template<>
constexpr bool	is_unquoted_safe< int > {true}

template<>
constexpr bool	is_unquoted_safe< unsigned > {true}

template<>
constexpr bool	is_unquoted_safe< long > {true}

template<>
constexpr bool	is_unquoted_safe< unsigned long > {true}

template<>
constexpr bool	is_unquoted_safe< long long > {true}

template<>
constexpr bool	is_unquoted_safe< unsigned long long > {true}

template<>
constexpr bool	is_unquoted_safe< float > {true}

template<>
constexpr bool	is_unquoted_safe< double > {true}

template<>
constexpr bool	is_unquoted_safe< long double > {true}

template<>
constexpr bool	is_unquoted_safe< bool > {true}

template<typename TYPE >
constexpr bool	is_sql_array {false}
	Does this type translate to an SQL array? More...

template<typename TYPE >
constexpr bool	is_unquoted_safe {false}
	Can we use this type in arrays and composite types without quoting them? More...

template<typename T >
constexpr char	array_separator {','}
	Element separator between SQL array elements of this type. More...

constexpr from_table_t	from_table
	Pass this to a `stream_from` constructor to stream table contents. More...

constexpr from_query_t	from_query
	Pass this to a `stream_from` constructor to stream query results. More...

template<typename TYPE >
std::string const	type_name {internal::demangle_type_name(typeid(TYPE).name())}
	A human-readable name for a type, used in error messages and such. More...

constexpr bool	has_generic_bytes_char_traits

constexpr oid	oid_none {0}
	The "null" oid. More...