Namespaces
	common

	core

	details

	tr1

Classes
struct	abstract_class

class	access

struct	alias_traits

struct	already_in_session

struct	already_in_transaction

struct	callback_event

struct	class_traits

struct	class_traits< const T >

struct	composite_value_traits

class	connection

struct	connection_lost

struct	data_migration_entry

class	database

struct	database_exception

struct	deadlock

struct	decay_traits

struct	decay_traits< T[N]>

struct	dispatch_load

struct	dispatch_load< R, DB, R >

struct	dispatch_persist

struct	dispatch_persist< T, DB, true >

struct	exception

class	lazy_auto_ptr

struct	lazy_auto_ptr_ref

class	lazy_ptr

class	lazy_ptr_base

class	lazy_ptr_impl

struct	lazy_ptr_impl_ref

struct	map_functions

struct	native_column_info

class	no_id_object_result_impl

struct	no_id_pointer_cache_traits

struct	no_id_reference_cache_traits

struct	no_op_pointer_cache_traits

struct	no_op_reference_cache_traits

struct	no_type_info

struct	not_in_session

struct	not_in_transaction

struct	null_pointer

class	nullable

struct	object_already_persistent

struct	object_changed

struct	object_function_table_entry

struct	object_not_persistent

class	object_result_impl

struct	object_result_impl_selector

struct	object_result_impl_selector< T, ID, false >

struct	object_result_impl_selector< T, ID, true >

struct	object_result_impl_selector< T, void, false >

class	object_result_iterator

class	object_result_iterator< T, ID, false >

class	object_result_iterator< T, ID, true >

class	object_result_iterator< T, void, false >

struct	object_traits

struct	object_traits< const P< T > >

struct	object_traits< const P< T, A1 > >

struct	object_traits< const T >

struct	object_traits< P< T > >

struct	object_traits< P< T, A1 > >

struct	object_traits< section >

struct	object_traits< T * >

struct	object_traits< T *const >

struct	object_traits_impl

struct	ordered_functions

struct	pointer_cache_traits

struct	pointer_cache_traits_impl

struct	pointer_cache_traits_impl< P, S, pk_unique >

struct	pointer_cache_type

struct	pointer_cache_type< P, E, O, pk_unique >

struct	pointer_cache_type< P, T, T, pk >

struct	pointer_cache_type< P, T, T, pk_unique >

struct	pointer_query_columns

class	pointer_traits

class	pointer_traits< lazy_auto_ptr< T > >

class	pointer_traits< lazy_ptr< T > >

class	pointer_traits< std::auto_ptr< T > >

class	pointer_traits< std::tr1::shared_ptr< T > >

class	pointer_traits< std::tr1::weak_ptr< T > >

class	pointer_traits< T * >

class	pointer_traits< tr1::lazy_shared_ptr< T > >

class	pointer_traits< tr1::lazy_weak_ptr< T > >

struct	polymorphic_abstract_info

struct	polymorphic_concrete_info

struct	polymorphic_entry

struct	polymorphic_entry_impl

struct	polymorphic_map

class	polymorphic_object_result_impl

struct	prepared_already_cached

struct	prepared_query

class	prepared_query_impl

struct	prepared_type_mismatch

class	query

class	query< T, query_base >

class	query_base

struct	query_column

struct	query_columns

struct	query_columns_base

struct	query_param

struct	query_pointer

struct	query_selector

struct	query_selector_impl

struct	query_selector_impl< T, DB, class_object >

struct	query_selector_impl< T, DB, class_view >

class	raw_ptr_guard

struct	recoverable

struct	ref_bind

struct	ref_bind< T[N]>

struct	reference_cache_traits

struct	reference_cache_traits_impl

struct	reference_cache_traits_impl< T, S, pk_raw >

struct	reference_cache_type

struct	reference_cache_type< T, T >

class	result

class	result_base

class	result_base< T, class_object >

class	result_base< T, class_view >

class	result_impl

class	result_iterator

class	result_iterator< T, class_object >

class	result_iterator< T, class_view >

struct	result_not_cached

struct	root_image

struct	root_image< T, false >

struct	root_image_impl

struct	root_image_impl< T, 1 >

class	schema_catalog

struct	schema_catalog_create_entry

struct	schema_catalog_init

struct	schema_catalog_migrate_entry

struct	schema_version_migration

class	section

struct	section_not_in_object

struct	section_not_loaded

class	session

struct	session_required

struct	set_functions

struct	smart_ordered_functions

class	smart_ptr_guard

class	statement

struct	timeout

class	tracer

class	transaction

struct	transaction_already_finalized

class	transaction_impl

struct	unknown_schema

struct	unknown_schema_version

struct	val_bind

struct	val_query_param

class	vector

class	vector_base

class	vector_impl

class	vector_iterator

class	vector_iterator< V, std::reverse_iterator< J > >

struct	view_function_table_entry

class	view_result_impl

struct	view_traits

struct	view_traits< const T >

struct	view_traits_impl

class	wrapper_traits

class	wrapper_traits< nullable< T > >

class	wrapper_traits< std::auto_ptr< T > >

class	wrapper_traits< std::tr1::shared_ptr< T > >

Typedefs
typedef details::shared_ptr < connection >	connection_ptr

typedef unsigned long long	schema_version

typedef std::char_traits< char >	traits

Enumerations
enum	container_kind { ck_ordered, ck_set, ck_multiset, ck_map, ck_multimap }

enum	database_id { id_mysql, id_sqlite, id_pgsql, id_oracle, id_mssql, id_common }

enum	pointer_kind { pk_raw, pk_unique, pk_shared, pk_weak }

enum	class_kind { class_object, class_view, class_other }

Functions
template<class T , class Y >
bool	operator== (const lazy_ptr< T > &, const lazy_ptr< Y > &)

template<class T , class Y >
bool	operator!= (const lazy_ptr< T > &, const lazy_ptr< Y > &)

template<class T >
void	swap (lazy_ptr< T > &, lazy_ptr< T > &)

template<typename R >
const polymorphic_concrete_info< R > *	polymorphic_info (const polymorphic_concrete_info< R > &i)

template<typename R >
const polymorphic_concrete_info< R > *	polymorphic_info (const polymorphic_abstract_info< R > &)

template<typename T >
object_traits< typename object_traits< T >::root_type > ::pointer_type	create_impl ()

template<typename T , database_id DB>
bool	dispatch_impl (typename polymorphic_concrete_info< typename object_traits< T >::root_type >::call_type c, database &db, const typename object_traits< T >::root_type pobj, const void arg)

template<typename T , database_id DB, typename ST >
void	section_load_impl (odb::connection &conn, typename object_traits< T >::root_type &obj, bool top)

template<typename T , database_id DB, typename ST >
void	section_update_impl (odb::connection &conn, const typename object_traits< T >::root_type &obj)

query_base	operator+ (const query_base &x, const query_base &y)

query_base	operator+ (const query_base &q, const std::string &s)

query_base	operator+ (const std::string &s, const query_base &q)

LIBODB_EXPORT query_base	operator&& (const query_base &, const query_base &)

LIBODB_EXPORT query_base	operator\|\| (const query_base &, const query_base &)

LIBODB_EXPORT query_base	operator! (const query_base &)

template<typename T >
const T &	type_instance ()

template<typename T >
query_base	operator+ (const query_column< T > &c, const std::string &s)

template<typename T >
query_base	operator+ (const std::string &s, const query_column< T > &c)

template<typename T >
query_base	operator+ (const query_column< T > &c, const query_base &q)

template<typename T >
query_base	operator+ (const query_base &q, const query_column< T > &c)

template<typename T , class_kind kind>
bool	operator== (result_iterator< T, kind > i, result_iterator< T, kind > j)

template<typename T , class_kind kind>
bool	operator!= (result_iterator< T, kind > i, result_iterator< T, kind > j)

bool	operator== (const schema_version_migration &x, const schema_version_migration &y)

bool	operator!= (const schema_version_migration &x, const schema_version_migration &y)

bool	operator< (const schema_version_migration &x, const schema_version_migration &y)

bool	operator> (const schema_version_migration &x, const schema_version_migration &y)

bool	operator<= (const schema_version_migration &x, const schema_version_migration &y)

bool	operator>= (const schema_version_migration &x, const schema_version_migration &y)

template<class T , class A LIBODB_VECTOR_ARG_DECL>
bool	operator== (const vector< T, A LIBODB_VECTOR_ARG_USE > &x, const vector< T, A LIBODB_VECTOR_ARG_USE > &y)

template<class T , class A LIBODB_VECTOR_ARG_DECL>
bool	operator== (const vector< T, A LIBODB_VECTOR_ARG_USE > &x, const std::vector< T, A > &y)

template<class T , class A LIBODB_VECTOR_ARG_DECL>
bool	operator== (const std::vector< T, A > &x, const vector< T, A LIBODB_VECTOR_ARG_USE > &y)

template<class T , class A LIBODB_VECTOR_ARG_DECL>
bool	operator< (const vector< T, A LIBODB_VECTOR_ARG_USE > &x, const vector< T, A LIBODB_VECTOR_ARG_USE > &y)

template<class T , class A LIBODB_VECTOR_ARG_DECL>
bool	operator< (const vector< T, A LIBODB_VECTOR_ARG_USE > &x, const std::vector< T, A > &y)

template<class T , class A LIBODB_VECTOR_ARG_DECL>
bool	operator< (const std::vector< T, A > &x, const vector< T, A LIBODB_VECTOR_ARG_USE > &y)

template<class T , class A LIBODB_VECTOR_ARG_DECL>
bool	operator!= (const vector< T, A LIBODB_VECTOR_ARG_USE > &x, const vector< T, A LIBODB_VECTOR_ARG_USE > &y)

template<class T , class A LIBODB_VECTOR_ARG_DECL>
bool	operator!= (const vector< T, A LIBODB_VECTOR_ARG_USE > &x, const std::vector< T, A > &y)

template<class T , class A LIBODB_VECTOR_ARG_DECL>
bool	operator!= (const std::vector< T, A > &x, const vector< T, A LIBODB_VECTOR_ARG_USE > &y)

template<class T , class A LIBODB_VECTOR_ARG_DECL>
bool	operator> (const vector< T, A LIBODB_VECTOR_ARG_USE > &x, const vector< T, A LIBODB_VECTOR_ARG_USE > &y)

template<class T , class A LIBODB_VECTOR_ARG_DECL>
bool	operator>= (const vector< T, A LIBODB_VECTOR_ARG_USE > &x, const vector< T, A LIBODB_VECTOR_ARG_USE > &y)

template<class T , class A LIBODB_VECTOR_ARG_DECL>
bool	operator>= (const vector< T, A LIBODB_VECTOR_ARG_USE > &x, const std::vector< T, A > &y)

template<class T , class A LIBODB_VECTOR_ARG_DECL>
bool	operator>= (const std::vector< T, A > &x, const vector< T, A LIBODB_VECTOR_ARG_USE > &y)

template<class T , class A LIBODB_VECTOR_ARG_DECL>
bool	operator<= (const vector< T, A LIBODB_VECTOR_ARG_USE > &x, const vector< T, A LIBODB_VECTOR_ARG_USE > &y)

template<class T , class A LIBODB_VECTOR_ARG_DECL>
bool	operator<= (const vector< T, A LIBODB_VECTOR_ARG_USE > &x, const std::vector< T, A > &y)

template<class T , class A LIBODB_VECTOR_ARG_DECL>
bool	operator<= (const std::vector< T, A > &x, const vector< T, A LIBODB_VECTOR_ARG_USE > &y)

template<class V , class I >
bool	operator== (const vector_iterator< V, I > &x, const vector_iterator< V, I > &y)

template<class V , class I >
bool	operator== (const vector_iterator< V, I > &x, const typename vector_iterator< V, I >::const_iterator_type &y)

template<class V , class I >
bool	operator== (const typename vector_iterator< V, I >::const_iterator_type &x, const vector_iterator< V, I > &y)

template<class V , class I >
bool	operator< (const vector_iterator< V, I > &x, const vector_iterator< V, I > &y)

template<class V , class I >
bool	operator< (const vector_iterator< V, I > &x, const typename vector_iterator< V, I >::const_iterator_type &y)

template<class V , class I >
bool	operator< (const typename vector_iterator< V, I >::const_iterator_type &x, const vector_iterator< V, I > &y)

template<class V , class I >
bool	operator!= (const vector_iterator< V, I > &x, const vector_iterator< V, I > &y)

template<class V , class I >
bool	operator!= (const vector_iterator< V, I > &x, const typename vector_iterator< V, I >::const_iterator_type &y)

template<class V , class I >
bool	operator!= (const typename vector_iterator< V, I >::const_iterator_type &x, const vector_iterator< V, I > &y)

template<class V , class I >
bool	operator> (const vector_iterator< V, I > &x, const vector_iterator< V, I > &y)

template<class V , class I >
bool	operator> (const vector_iterator< V, I > &x, const typename vector_iterator< V, I >::const_iterator_type &y)

template<class V , class I >
bool	operator> (const typename vector_iterator< V, I >::const_iterator_type &x, const vector_iterator< V, I > &y)

template<class V , class I >
bool	operator>= (const vector_iterator< V, I > &x, const vector_iterator< V, I > &y)

template<class V , class I >
bool	operator>= (const vector_iterator< V, I > &x, const typename vector_iterator< V, I >::const_iterator_type &y)

template<class V , class I >
bool	operator>= (const typename vector_iterator< V, I >::const_iterator_type &x, const vector_iterator< V, I > &y)

template<class V , class I >
bool	operator<= (const vector_iterator< V, I > &x, const vector_iterator< V, I > &y)

template<class V , class I >
bool	operator<= (const vector_iterator< V, I > &x, const typename vector_iterator< V, I >::const_iterator_type &y)

template<class V , class I >
bool	operator<= (const typename vector_iterator< V, I >::const_iterator_type &x, const vector_iterator< V, I > &y)

template<class V , class I >
vector_iterator< V, I > ::difference_type	operator- (const vector_iterator< V, I > &x, const vector_iterator< V, I > &y)

template<class V , class I >
vector_iterator< V, I > ::difference_type	operator- (const vector_iterator< V, I > &x, const typename vector_iterator< V, I >::const_iterator_type &y)

template<class V , class I >
vector_iterator< V, I > ::difference_type	operator- (const typename vector_iterator< V, I >::const_iterator_type &x, const vector_iterator< V, I > &y)

template<class V , class I >
vector_iterator< V, I >	operator+ (typename vector_iterator< V, I >::difference_type n, const vector_iterator< V, I > &x)

Variables
LIBODB_EXPORT tracer &	stderr_tracer

const std::size_t	database_count = id_common

Typedef Documentation

typedef details::shared_ptr< connection > odb::connection_ptr

typedef unsigned long long odb::schema_version

typedef std::char_traits<char> odb::traits

Enumeration Type Documentation

enum odb::container_kind

Enumerator
ck_ordered
ck_set
ck_multiset
ck_map
ck_multimap

enum odb::database_id

Enumerator
id_mysql
id_sqlite
id_pgsql
id_oracle
id_mssql
id_common

enum odb::pointer_kind

Enumerator
pk_raw
pk_unique
pk_shared
pk_weak

enum odb::class_kind

Enumerator
class_object
class_view
class_other

Function Documentation

template<class T , class Y >

bool odb::operator==	(	const lazy_ptr< T > &	,
		const lazy_ptr< Y > &
	)

template<class T , class Y >

bool odb::operator!=	(	const lazy_ptr< T > &	,
		const lazy_ptr< Y > &
	)

template<class T >

void odb::swap	(	lazy_ptr< T > &	,
		lazy_ptr< T > &
	)

template<typename R >

const polymorphic_concrete_info<R>* odb::polymorphic_info ( const polymorphic_concrete_info< R > & i )

inline

template<typename R >

const polymorphic_concrete_info<R>* odb::polymorphic_info ( const polymorphic_abstract_info< R > & )

inline

template<typename T >

object_traits<typename object_traits<T>::root_type>::pointer_type odb::create_impl ( )

template<typename T , database_id DB>

bool odb::dispatch_impl	(	typename polymorphic_concrete_info< typename object_traits< T >::root_type >::call_type	c,
		database &	db,
		const typename object_traits< T >::root_type *	pobj,
		const void *	arg
	)

template<typename T , database_id DB, typename ST >

void odb::section_load_impl	(	odb::connection &	conn,
		typename object_traits< T >::root_type &	obj,
		bool	top
	)

template<typename T , database_id DB, typename ST >

void odb::section_update_impl	(	odb::connection &	conn,
		const typename object_traits< T >::root_type &	obj
	)

query_base odb::operator+	(	const query_base &	x,
		const query_base &	y
	)

inline

query_base odb::operator+	(	const query_base &	q,
		const std::string &	s
	)

inline

query_base odb::operator+	(	const std::string &	s,
		const query_base &	q
	)

inline

LIBODB_EXPORT query_base odb::operator&&	(	const query_base &	,
		const query_base &
	)

LIBODB_EXPORT query_base odb::operator\|\|	(	const query_base &	,
		const query_base &
	)

LIBODB_EXPORT query_base odb::operator! ( const query_base & )

template<typename T >

const T& odb::type_instance ( )

template<typename T >

query_base odb::operator+	(	const query_column< T > &	c,
		const std::string &	s
	)

inline

template<typename T >

query_base odb::operator+	(	const std::string &	s,
		const query_column< T > &	c
	)

inline

template<typename T >

query_base odb::operator+	(	const query_column< T > &	c,
		const query_base &	q
	)

inline

template<typename T >

query_base odb::operator+	(	const query_base &	q,
		const query_column< T > &	c
	)

inline

template<typename T , class_kind kind>

bool odb::operator==	(	result_iterator< T, kind >	i,
		result_iterator< T, kind >	j
	)

inline

template<typename T , class_kind kind>

bool odb::operator!=	(	result_iterator< T, kind >	i,
		result_iterator< T, kind >	j
	)

inline

bool odb::operator==	(	const schema_version_migration &	x,
		const schema_version_migration &	y
	)

inline

bool odb::operator!=	(	const schema_version_migration &	x,
		const schema_version_migration &	y
	)

inline

bool odb::operator<	(	const schema_version_migration &	x,
		const schema_version_migration &	y
	)

inline

bool odb::operator>	(	const schema_version_migration &	x,
		const schema_version_migration &	y
	)

inline

bool odb::operator<=	(	const schema_version_migration &	x,
		const schema_version_migration &	y
	)

inline

bool odb::operator>=	(	const schema_version_migration &	x,
		const schema_version_migration &	y
	)

inline