Synopsis of: http://www.codesynthesis.com/products/odb/doc/manual.xhtml

ODB_cheatsheet.cpp

//
// Общие заметки:
//  * все возвращаемые сырые указатели нужно освобождать самим (т.е оборачивать их в умные)

//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
//
// Querying
//
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////

//
// _val, _ref
//

query q1 (query::age < age);                // By value.
query q2 (query::age < query::_val (age));  // By value.
query q3 (query::age < query::_ref (age));  // By reference.

query q4 ("age < " + age);                  // Error.
query q5 ("age < " + query::_val (age));    // By value.
query q6 ("age < " + query::_ref (age));    // By reference.

//
// Executing
//

template <typename T>
result<T>
query (bool cache = true);

template <typename T>
result<T>
query (const odb::query<T>&, bool cache = true);

//
// query_one
//

// The query_one() function allows us to determine if the query 
// result contains zero or one element. If no objects matching 
// the query criteria were found in the database, the first 
// version of query_one() returns the NULL pointer while 
// the second — false. If the second version returns false, 
// then the passed object remains unchanged. For example:

// If the query executed using query_one() or query_value() returns 
// more than one element, then these functions fail with an 
// assertion. Additionally, query_value() also fails with an 
// assertion if the query returned no elements.

template <typename T>
typename object_traits<T>::pointer_type
query_one ();

template <typename T>
bool
query_one (T&);

template <typename T>
T
query_value ();

template <typename T>
typename object_traits<T>::pointer_type
query_one (const odb::query<T>&);

template <typename T>
bool
query_one (const odb::query<T>&, T&);

template <typename T>
T
query_value (const odb::query<T>&);

//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
//
// Objects
//
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////
// Persisting
//////////////////////////////////////////////////////////////////////

//
// Persist (сохранение transient объекта, id инициализируется во время сохранения, предыдущее значение игнорируется)
//

template <typename T>
typename object_traits<T>::id_type
persist (const T& object);

template <typename T>
typename object_traits<T>::id_type
persist (const object_traits<T>::const_pointer_type& object);

template <typename T>
typename object_traits<T>::id_type
persist (T& object);

template <typename T>
typename object_traits<T>::id_type
persist (const object_traits<T>::pointer_type& object);

//////////////////////////////////////////////////////////////////////
// Loading
//////////////////////////////////////////////////////////////////////

//
// Load (загрузка объекта по известному id)
//

template <typename T>
typename object_traits<T>::pointer_type
load (const typename object_traits<T>::id_type& id);

template <typename T>
void
load (const typename object_traits<T>::id_type& id, T& object);

//
// Reload (перезагрузить объект по уже имеющемуся в нем id)
//  * не работает с session cache
//  * делает optimistic concurence
//

template <typename T>
void
reload (T& object);

template <typename T>
void
reload (const object_traits<T>::pointer_type& object);

//
// Find (когда не знаем есть ли объект в БД или нет)
//

template <typename T>
typename object_traits<T>::pointer_type
find (const typename object_traits<T>::id_type& id);

template <typename T>
bool
find (const typename object_traits<T>::id_type& id, T& object);

//////////////////////////////////////////////////////////////////////
// Updating
//////////////////////////////////////////////////////////////////////

template <typename T>
void
update (const T& object);

template <typename T>
void
update (const object_traits<T>::const_pointer_type& object);

template <typename T>
void
update (const object_traits<T>::pointer_type& object);

//////////////////////////////////////////////////////////////////////
// Deleting
//////////////////////////////////////////////////////////////////////

//
// Erase
//

template <typename T>
void
erase (const T& object);

template <typename T>
void
erase (const object_traits<T>::const_pointer_type& object);

template <typename T>
void
erase (const object_traits<T>::pointer_type& object);

template <typename T>
void
erase (const typename object_traits<T>::id_type& id);

//
// Erase query
//

template <typename T>
unsigned long long
erase_query ();

template <typename T>
unsigned long long
erase_query (const odb::query<T>&);

unsigned long long
execute (const char* statement);

//////////////////////////////////////////////////////////////////////
// Executing Native SQL Statements
//////////////////////////////////////////////////////////////////////

unsigned long long
execute (const std::string& statement);

unsigned long long
execute (const char* statement, std::size_t length)