Classes
class	qx::IxSqlQueryBuilder
	qx::IxSqlQueryBuilder : common interface to build SQL queries to communicate with database More...
class	qx::IxSqlRelation
	qx::IxSqlRelation : common interface for all relationships defined between 2 classes (or between 2 tables in database) More...
class	qx::dao::ptr< T >
	qx::dao::ptr<T> : provide a classic smart-pointer (like boost::shared_ptr<T> or QSharedPointer<T>) with some features associated with QxDao module of QxOrm library More...
struct	qx::dao::strategy
	Class inheritance strategy and database (Concrete Table Inheritance is the default strategy used by QxOrm library) More...
class	qx::QxSqlDatabase
	qx::QxSqlDatabase : define all parameters to connect to database and retrieve a valid connection by thread (this class is a singleton and is thread-safe) More...
class	qx::QxSqlQuery
	qx::QxSqlQuery : define a user SQL query added to default SQL query builded by QxOrm library, and used by qx::dao::xxx functions to filter elements fetched from database More...
class	qx::QxSqlQueryBuilder< T >
	qx::QxSqlQueryBuilder<T> : concrete SQL query builder for the class T with a cache mechanism to backup and restore queries already builded by the program More...
class	qx::QxSqlRelation< DataType, Owner >
	qx::QxSqlRelation<DataType, Owner> : base class for all relationships defined between 2 classes (or between 2 tables in database) More...
class	qx::QxSqlRelation_ManyToMany< DataType, Owner >
	qx::QxSqlRelation_ManyToMany<DataType, Owner> : manage a relationship many-to-many defined between 2 classes (or between 2 tables in database) More...
class	qx::QxSqlRelation_ManyToOne< DataType, Owner >
	qx::QxSqlRelation_ManyToOne<DataType, Owner> : manage a relationship many-to-one defined between 2 classes (or between 2 tables in database) More...
class	qx::QxSqlRelation_OneToMany< DataType, Owner >
	qx::QxSqlRelation_OneToMany<DataType, Owner> : manage a relationship one-to-many defined between 2 classes (or between 2 tables in database) More...
class	qx::QxSqlRelation_OneToOne< DataType, Owner >
	qx::QxSqlRelation_OneToOne<DataType, Owner> : manage a relationship one-to-one defined between 2 classes (or between 2 tables in database) More...
class	qx::QxSqlRelationParams
	qx::QxSqlRelationParams : define list of parameters to transfer to relationships to manage SQL queries builded by QxOrm library More...
Namespaces
namespace	qx::dao
	Database communication used by persistence engine (ORM - Object Relational Mapping)
namespace	qx::dao::detail
	Internal helper tools for qx::dao namespace.
Files
file	IxSqlQueryBuilder.h
	Common interface to build SQL queries to communicate with database.
file	IxSqlRelation.h
	Common interface for all relationships defined between 2 classes (or between 2 tables in database)
file	QxDao.h
	Provide template functions to map C++ class registered into QxOrm context with table database (ORM - Object Relational Mapping)
file	QxDaoPointer.h
	qx::dao::ptr<T> : provide a classic smart-pointer (like boost::shared_ptr<T> or QSharedPointer<T>) with some features associated with QxDao module of QxOrm library
file	QxDaoStrategy.h
	Class inheritance strategy and database (Concrete Table Inheritance is the default strategy used by QxOrm library)
file	QxSqlDatabase.h
	Define all parameters to connect to database and retrieve a valid connection by thread.
file	QxSqlQuery.h
	Define a user SQL query added to default SQL query builded by QxOrm library, and used by qx::dao::xxx functions to filter elements fetched from database.
file	QxSqlQueryBuilder.h
	Concrete SQL query builder by class with a cache mechanism to backup and restore queries already builded by the program.
file	QxSqlRelation.h
	Base class for all relationships defined between 2 classes (or between 2 tables in database)
file	QxSqlRelation_ManyToMany.h
	Manage a relationship many-to-many defined between 2 classes (or between 2 tables in database)
file	QxSqlRelation_ManyToOne.h
	Manage a relationship many-to-one defined between 2 classes (or between 2 tables in database)
file	QxSqlRelation_OneToMany.h
	Manage a relationship one-to-many defined between 2 classes (or between 2 tables in database)
file	QxSqlRelation_OneToOne.h
	Manage a relationship one-to-one defined between 2 classes (or between 2 tables in database)
file	QxSqlRelationParams.h
	Define list of parameters to transfer to relationships to manage SQL queries builded by QxOrm library.
Functions
template<class T >
long	qx::dao::count (QSqlDatabase *pDatabase)
	Return the number of lines in the table (database) mapped to the C++ class T (registered into QxOrm context)
template<class T >
long	qx::dao::count (const qx::QxSqlQuery &query, QSqlDatabase *pDatabase)
	Return the number of lines in the table (database) mapped to the C++ class T (registered into QxOrm context) and filtered by a user SQL query.
template<class T >
QSqlError	qx::dao::fetch_by_id (T &t, QSqlDatabase *pDatabase)
	Fetch an object t (retrieve all its properties) of type T (registered into QxOrm context) mapped to a table in the database (t must have a valid id before to be fetched without error)
template<class T >
QSqlError	qx::dao::fetch_all (T &t, QSqlDatabase *pDatabase)
	Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database.
template<class T >
QSqlError	qx::dao::fetch_by_query (const qx::QxSqlQuery &query, T &t, QSqlDatabase *pDatabase)
	Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database and filtered by a user SQL query.
template<class T >
QSqlError	qx::dao::insert (T &t, QSqlDatabase *pDatabase)
	Insert an element or a list of elements into database.
template<class T >
QSqlError	qx::dao::update (T &t, QSqlDatabase *pDatabase)
	Update an element or a list of elements into database.
template<class T >
QSqlError	qx::dao::save (T &t, QSqlDatabase *pDatabase)
	Insert (if no exist) or update (if already exist) an element or a list of elements into database.
template<class T >
QSqlError	qx::dao::delete_by_id (T &t, QSqlDatabase *pDatabase)
	Delete a line (or list of lines) of a table (database) mapped to a C++ object of type T (registered into QxOrm context)
template<class T >
QSqlError	qx::dao::delete_all (QSqlDatabase *pDatabase)
	Delete all lines of a table (database) mapped to a C++ class T (registered into QxOrm context)
template<class T >
QSqlError	qx::dao::delete_by_query (const qx::QxSqlQuery &query, QSqlDatabase *pDatabase)
	Delete all lines of a table (database) mapped to a C++ class T (registered into QxOrm context) and filtered by a user SQL query.
template<class T >
QSqlError	qx::dao::create_table (QSqlDatabase *pDatabase)
	Create a table into database (with all columns) mapped to a C++ class T (registered into QxOrm context)
template<class T >
qx_bool	qx::dao::exist (T &t, QSqlDatabase *pDatabase)
	Search if an element (or list of elements) already exists into database.
template<class T >
QSqlError	qx::dao::fetch_by_id_with_relation (const QString &relation, T &t, QSqlDatabase *pDatabase)
	Fetch an object t (retrieve all its properties) of type T (registered into QxOrm context) mapped to a table in the database (t must have a valid id before to be fetched without error)
template<class T >
QSqlError	qx::dao::fetch_by_id_with_relation (const QStringList &relation, T &t, QSqlDatabase *pDatabase)
	Fetch an object t (retrieve all its properties) of type T (registered into QxOrm context) mapped to a table in the database (t must have a valid id before to be fetched without error)
template<class T >
QSqlError	qx::dao::fetch_by_id_with_all_relation (T &t, QSqlDatabase *pDatabase)
	Fetch an object t (retrieve all its properties and relationships) of type T (registered into QxOrm context) mapped to a table in the database (t must have a valid id before to be fetched without error)
template<class T >
QSqlError	qx::dao::fetch_all_with_relation (const QString &relation, T &t, QSqlDatabase *pDatabase)
	Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database.
template<class T >
QSqlError	qx::dao::fetch_all_with_relation (const QStringList &relation, T &t, QSqlDatabase *pDatabase)
	Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database.
template<class T >
QSqlError	qx::dao::fetch_all_with_all_relation (T &t, QSqlDatabase *pDatabase)
	Fetch a list of objects (retrieve all elements and properties + all relationships associated) of type T (container registered into QxOrm context) mapped to a table in the database.
template<class T >
QSqlError	qx::dao::fetch_by_query_with_relation (const QString &relation, const qx::QxSqlQuery &query, T &t, QSqlDatabase *pDatabase)
	Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database and filtered by a user SQL query.
template<class T >
QSqlError	qx::dao::fetch_by_query_with_relation (const QStringList &relation, const qx::QxSqlQuery &query, T &t, QSqlDatabase *pDatabase)
	Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database and filtered by a user SQL query.
template<class T >
QSqlError	qx::dao::fetch_by_query_with_all_relation (const qx::QxSqlQuery &query, T &t, QSqlDatabase *pDatabase)
	Fetch a list of objects (retrieve all elements and properties + all relationships associated) of type T (container registered into QxOrm context) mapped to a table in the database and filtered by a user SQL query.
template<class T >
QSqlError	qx::dao::insert_with_relation (const QString &relation, T &t, QSqlDatabase *pDatabase)
	Insert an element and its relationships (or a list of elements + relationships) into database.
template<class T >
QSqlError	qx::dao::insert_with_relation (const QStringList &relation, T &t, QSqlDatabase *pDatabase)
	Insert an element and its relationships (or a list of elements + relationships) into database.
template<class T >
QSqlError	qx::dao::insert_with_all_relation (T &t, QSqlDatabase *pDatabase)
	Insert an element and all its relationships (or a list of elements + all relationships) into database.
template<class T >
QSqlError	qx::dao::update_with_relation (const QString &relation, T &t, QSqlDatabase *pDatabase)
	Update an element and its relationships (or a list of elements + relationships) into database.
template<class T >
QSqlError	qx::dao::update_with_relation (const QStringList &relation, T &t, QSqlDatabase *pDatabase)
	Update an element and its relationships (or a list of elements + relationships) into database.
template<class T >
QSqlError	qx::dao::update_with_all_relation (T &t, QSqlDatabase *pDatabase)
	Update an element and all its relationships (or a list of elements + all relationships) into database.
template<class T >
QSqlError	qx::dao::save_with_relation (const QString &relation, T &t, QSqlDatabase *pDatabase)
	Insert (if no exist) or update (if already exist) an element and its relationships (or a list of elements + relationships) into database.
template<class T >
QSqlError	qx::dao::save_with_relation (const QStringList &relation, T &t, QSqlDatabase *pDatabase)
	Insert (if no exist) or update (if already exist) an element and its relationships (or a list of elements + relationships) into database.
template<class T >
QSqlError	qx::dao::save_with_all_relation (T &t, QSqlDatabase *pDatabase)
	Insert (if no exist) or update (if already exist) an element and all its relationships (or a list of elements + all relationships) into database.
template<class T >
long	qx::dao::count ()
	Return the number of lines in the table (database) mapped to the C++ class T (registered into QxOrm context)
template<class T >
long	qx::dao::count (const qx::QxSqlQuery &query)
	Return the number of lines in the table (database) mapped to the C++ class T (registered into QxOrm context) and filtered by a user SQL query.
template<class T >
QSqlError	qx::dao::fetch_by_id (T &t)
	Fetch an object t (retrieve all its properties) of type T (registered into QxOrm context) mapped to a table in the database (t must have a valid id before to be fetched without error)
template<class T >
QSqlError	qx::dao::fetch_all (T &t)
	Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database.
template<class T >
QSqlError	qx::dao::fetch_by_query (const qx::QxSqlQuery &query, T &t)
	Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database and filtered by a user SQL query.
template<class T >
QSqlError	qx::dao::insert (T &t)
	Insert an element or a list of elements into database.
template<class T >
QSqlError	qx::dao::update (T &t)
	Update an element or a list of elements into database.
template<class T >
QSqlError	qx::dao::save (T &t)
	Insert (if no exist) or update (if already exist) an element or a list of elements into database.
template<class T >
QSqlError	qx::dao::delete_by_id (T &t)
	Delete a line (or list of lines) of a table (database) mapped to a C++ object of type T (registered into QxOrm context)
template<class T >
QSqlError	qx::dao::delete_all ()
	Delete all lines of a table (database) mapped to a C++ class T (registered into QxOrm context)
template<class T >
QSqlError	qx::dao::delete_by_query (const qx::QxSqlQuery &query)
	Delete all lines of a table (database) mapped to a C++ class T (registered into QxOrm context) and filtered by a user SQL query.
template<class T >
QSqlError	qx::dao::create_table ()
	Create a table into database (with all columns) mapped to a C++ class T (registered into QxOrm context)
template<class T >
qx_bool	qx::dao::exist (T &t)
	Search if an element (or list of elements) already exists into database.
template<class T >
QSqlError	qx::dao::fetch_by_id (T &t, QSqlDatabase *pDatabase, const QStringList &columns)
	Fetch an object t (retrieve all its properties) of type T (registered into QxOrm context) mapped to a table in the database (t must have a valid id before to be fetched without error)
template<class T >
QSqlError	qx::dao::fetch_all (T &t, QSqlDatabase *pDatabase, const QStringList &columns)
	Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database.
template<class T >
QSqlError	qx::dao::fetch_by_query (const qx::QxSqlQuery &query, T &t, QSqlDatabase *pDatabase, const QStringList &columns)
	Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database and filtered by a user SQL query.
template<class T >
QSqlError	qx::dao::update (T &t, QSqlDatabase *pDatabase, const QStringList &columns)
	Update an element or a list of elements into database.
template<class T >
QSqlError	qx::dao::update_optimized (qx::dao::ptr< T > &ptr)
	Update only modified fields/properties of an element or a list of elements into database (using is dirty pattern and qx::dao::ptr<T> smart-pointer)
template<class T >
QSqlError	qx::dao::update_optimized (qx::dao::ptr< T > &ptr, QSqlDatabase *pDatabase)
	Update only modified fields/properties of an element or a list of elements into database (using is dirty pattern and qx::dao::ptr<T> smart-pointer)
template<class T >
QSqlError	qx::dao::fetch_by_id_with_relation (const QString &relation, T &t)
	Fetch an object t (retrieve all its properties) of type T (registered into QxOrm context) mapped to a table in the database (t must have a valid id before to be fetched without error)
template<class T >
QSqlError	qx::dao::fetch_by_id_with_relation (const QStringList &relation, T &t)
	Fetch an object t (retrieve all its properties) of type T (registered into QxOrm context) mapped to a table in the database (t must have a valid id before to be fetched without error)
template<class T >
QSqlError	qx::dao::fetch_by_id_with_all_relation (T &t)
	Fetch an object t (retrieve all its properties and relationships) of type T (registered into QxOrm context) mapped to a table in the database (t must have a valid id before to be fetched without error)
template<class T >
QSqlError	qx::dao::fetch_all_with_relation (const QString &relation, T &t)
	Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database.
template<class T >
QSqlError	qx::dao::fetch_all_with_relation (const QStringList &relation, T &t)
	Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database.
template<class T >
QSqlError	qx::dao::fetch_all_with_all_relation (T &t)
	Fetch a list of objects (retrieve all elements and properties + all relationships associated) of type T (container registered into QxOrm context) mapped to a table in the database.
template<class T >
QSqlError	qx::dao::fetch_by_query_with_relation (const QString &relation, const qx::QxSqlQuery &query, T &t)
	Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database and filtered by a user SQL query.
template<class T >
QSqlError	qx::dao::fetch_by_query_with_relation (const QStringList &relation, const qx::QxSqlQuery &query, T &t)
	Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database and filtered by a user SQL query.
template<class T >
QSqlError	qx::dao::fetch_by_query_with_all_relation (const qx::QxSqlQuery &query, T &t)
	Fetch a list of objects (retrieve all elements and properties + all relationships associated) of type T (container registered into QxOrm context) mapped to a table in the database and filtered by a user SQL query.
template<class T >
QSqlError	qx::dao::insert_with_relation (const QString &relation, T &t)
	Insert an element and its relationships (or a list of elements + relationships) into database.
template<class T >
QSqlError	qx::dao::insert_with_relation (const QStringList &relation, T &t)
	Insert an element and its relationships (or a list of elements + relationships) into database.
template<class T >
QSqlError	qx::dao::insert_with_all_relation (T &t)
	Insert an element and all its relationships (or a list of elements + all relationships) into database.
template<class T >
QSqlError	qx::dao::update_with_relation (const QString &relation, T &t)
	Update an element and its relationships (or a list of elements + relationships) into database.
template<class T >
QSqlError	qx::dao::update_with_relation (const QStringList &relation, T &t)
	Update an element and its relationships (or a list of elements + relationships) into database.
template<class T >
QSqlError	qx::dao::update_with_all_relation (T &t)
	Update an element and all its relationships (or a list of elements + all relationships) into database.
template<class T >
QSqlError	qx::dao::save_with_relation (const QString &relation, T &t)
	Insert (if no exist) or update (if already exist) an element and its relationships (or a list of elements + relationships) into database.
template<class T >
QSqlError	qx::dao::save_with_relation (const QStringList &relation, T &t)
	Insert (if no exist) or update (if already exist) an element and its relationships (or a list of elements + relationships) into database.
template<class T >
QSqlError	qx::dao::save_with_all_relation (T &t)
	Insert (if no exist) or update (if already exist) an element and all its relationships (or a list of elements + all relationships) into database.
template<class T >
void	qx::dao::on_before_insert (T t, qx::dao::detail::IxDao_Helper dao)
	Callback before inserting an object into database (here is an example using QxOrm Trigger)
template<class T >
void	qx::dao::on_before_update (T t, qx::dao::detail::IxDao_Helper dao)
	Callback before updating an object into database (here is an example using QxOrm Trigger)
template<class T >
void	qx::dao::on_before_delete (T t, qx::dao::detail::IxDao_Helper dao)
	Callback before deleting an object into database (here is an example using QxOrm Trigger)
template<class T >
void	qx::dao::on_after_insert (T t, qx::dao::detail::IxDao_Helper dao)
	Callback after inserting an object into database (here is an example using QxOrm Trigger)
template<class T >
void	qx::dao::on_after_update (T t, qx::dao::detail::IxDao_Helper dao)
	Callback after updating an object into database (here is an example using QxOrm Trigger)
template<class T >
void	qx::dao::on_after_delete (T t, qx::dao::detail::IxDao_Helper dao)
	Callback after deleting an object into database (here is an example using QxOrm trigger)

Function Documentation

template<class T >

long qx::dao::count ( QSqlDatabase * pDatabase ) [inline]

Return the number of lines in the table (database) mapped to the C++ class T (registered into QxOrm context)

Parameters:

pDatabase Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

qx::dao::count<T>() execute following SQL query :
SELECT COUNT(*) FROM my_table

Definition at line 85 of file QxDao.h.

template<class T >

long qx::dao::count	(	const qx::QxSqlQuery &	query,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Return the number of lines in the table (database) mapped to the C++ class T (registered into QxOrm context) and filtered by a user SQL query.

Parameters:

query	Define a user SQL query added to default SQL query builded by QxOrm library
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

qx::dao::count<T>() execute following SQL query :
SELECT COUNT(*) FROM my_table + WHERE my_query...

Definition at line 98 of file QxDao.h.

template<class T >

long qx::dao::count ( ) [inline]

Return the number of lines in the table (database) mapped to the C++ class T (registered into QxOrm context)

qx::dao::count<T>() execute following SQL query :
SELECT COUNT(*) FROM my_table

Definition at line 537 of file QxDao.h.

template<class T >

long qx::dao::count ( const qx::QxSqlQuery & query ) [inline]

Return the number of lines in the table (database) mapped to the C++ class T (registered into QxOrm context) and filtered by a user SQL query.

Parameters:

query Define a user SQL query added to default SQL query builded by QxOrm library

qx::dao::count<T>() execute following SQL query :
SELECT COUNT(*) FROM my_table + WHERE my_query...

Definition at line 549 of file QxDao.h.

template<class T >

QSqlError qx::dao::create_table ( ) [inline]

Create a table into database (with all columns) mapped to a C++ class T (registered into QxOrm context)

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::create_table<T>() execute following SQL query :
CREATE TABLE my_table (my_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, my_column_1 TEXT, my_column_2 TEXT, etc.)

Definition at line 680 of file QxDao.h.

template<class T >

QSqlError qx::dao::create_table ( QSqlDatabase * pDatabase ) [inline]

Create a table into database (with all columns) mapped to a C++ class T (registered into QxOrm context)

Parameters:

pDatabase Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::create_table<T>() execute following SQL query :
CREATE TABLE my_table (my_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, my_column_1 TEXT, my_column_2 TEXT, etc.)

Definition at line 239 of file QxDao.h.

template<class T >

QSqlError qx::dao::delete_all ( QSqlDatabase * pDatabase ) [inline]

Delete all lines of a table (database) mapped to a C++ class T (registered into QxOrm context)

Parameters:

pDatabase Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::delete_all<T>() execute following SQL query :
DELETE FROM my_table

Definition at line 212 of file QxDao.h.

template<class T >

QSqlError qx::dao::delete_all ( ) [inline]

Delete all lines of a table (database) mapped to a C++ class T (registered into QxOrm context)

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::delete_all<T>() execute following SQL query :
DELETE FROM my_table

Definition at line 655 of file QxDao.h.

template<class T >

QSqlError qx::dao::delete_by_id	(	T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Delete a line (or list of lines) of a table (database) mapped to a C++ object of type T (registered into QxOrm context)

Parameters:

t	Element (or list of elements) to be deleted into database
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::delete_by_id<T>() execute following SQL query :
DELETE FROM my_table WHERE my_id = ?

Definition at line 199 of file QxDao.h.

template<class T >

QSqlError qx::dao::delete_by_id ( T & t ) [inline]

Delete a line (or list of lines) of a table (database) mapped to a C++ object of type T (registered into QxOrm context)

Parameters:

t	Element (or list of elements) to be deleted into database

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::delete_by_id<T>() execute following SQL query :
DELETE FROM my_table WHERE my_id = ?

Definition at line 643 of file QxDao.h.

template<class T >

QSqlError qx::dao::delete_by_query ( const qx::QxSqlQuery & query ) [inline]

Delete all lines of a table (database) mapped to a C++ class T (registered into QxOrm context) and filtered by a user SQL query.

Parameters:

query Define a user SQL query added to default SQL query builded by QxOrm library

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::delete_by_query<T>() execute following SQL query :
DELETE FROM my_table + WHERE my_query...

Definition at line 668 of file QxDao.h.

template<class T >

QSqlError qx::dao::delete_by_query	(	const qx::QxSqlQuery &	query,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Delete all lines of a table (database) mapped to a C++ class T (registered into QxOrm context) and filtered by a user SQL query.

Parameters:

query	Define a user SQL query added to default SQL query builded by QxOrm library
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::delete_by_query<T>() execute following SQL query :
DELETE FROM my_table + WHERE my_query...

Definition at line 226 of file QxDao.h.

template<class T >

qx_bool qx::dao::exist ( T & t ) [inline]

Search if an element (or list of elements) already exists into database.

Parameters:

t	Element (or list of elements) to be searched into database

Returns:: Return true if element already exists into database; otherwise return false; if an error occurred, qx_bool object contains a description of database error executing SQL query

qx::dao::exist<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?

Definition at line 693 of file QxDao.h.

template<class T >

qx_bool qx::dao::exist	(	T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Search if an element (or list of elements) already exists into database.

Parameters:

t	Element (or list of elements) to be searched into database
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Return true if element already exists into database; otherwise return false; if an error occurred, qx_bool object contains a description of database error executing SQL query

qx::dao::exist<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?

Definition at line 253 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_all ( T & t ) [inline]

Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database.

Parameters:

t	Container to be fetched (retrieve all elements and properties associated); t is cleared before executing SQL query

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_all<T>() execute following SQL query :
SELECT * FROM my_table

Definition at line 575 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_all	(	T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database.

Parameters:

t	Container to be fetched (retrieve all elements and properties associated); t is cleared before executing SQL query
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_all<T>() execute following SQL query :
SELECT * FROM my_table

Definition at line 126 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_all	(	T &	t,
		QSqlDatabase *	pDatabase,
		const QStringList &	columns
	)		`[inline]`

Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database.

Parameters:

t	Container to be fetched (retrieve all elements and properties associated); t is cleared before executing SQL query
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class
columns	List of database table columns (mapped to properties of C++ class T) to be fetched

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_all<T>() execute following SQL query :
SELECT * FROM my_table

Definition at line 723 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_all_with_all_relation	(	T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Fetch a list of objects (retrieve all elements and properties + all relationships associated) of type T (container registered into QxOrm context) mapped to a table in the database.

Parameters:

t	Container to be fetched (retrieve all elements and properties + all relationships associated); t is cleared before executing SQL query
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_all_with_all_relation<T>() execute following SQL query :
SELECT * FROM my_table

Definition at line 341 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_all_with_all_relation ( T & t ) [inline]

Fetch a list of objects (retrieve all elements and properties + all relationships associated) of type T (container registered into QxOrm context) mapped to a table in the database.

Parameters:

t	Container to be fetched (retrieve all elements and properties + all relationships associated); t is cleared before executing SQL query

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_all_with_all_relation<T>() execute following SQL query :
SELECT * FROM my_table

Definition at line 863 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_all_with_relation	(	const QString &	relation,
		T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database.

Parameters:

relation	List of relationships keys to be fetched (eager fetch instead of default lazy fetch for a relation) : use "\|" separator to put many relationships keys into this parameter
t	Container to be fetched (retrieve all elements and properties associated); t is cleared before executing SQL query
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_all_with_relation<T>() execute following SQL query :
SELECT * FROM my_table

Definition at line 312 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_all_with_relation	(	const QStringList &	relation,
		T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database.

Parameters:

relation	List of relationships keys to be fetched (eager fetch instead of default lazy fetch for a relation)
t	Container to be fetched (retrieve all elements and properties associated); t is cleared before executing SQL query
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_all_with_relation<T>() execute following SQL query :
SELECT * FROM my_table

Definition at line 327 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_all_with_relation	(	const QString &	relation,
		T &	t
	)		`[inline]`

Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database.

Parameters:

relation	List of relationships keys to be fetched (eager fetch instead of default lazy fetch for a relation) : use "\|" separator to put many relationships keys into this parameter
t	Container to be fetched (retrieve all elements and properties associated); t is cleared before executing SQL query

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_all_with_relation<T>() execute following SQL query :
SELECT * FROM my_table

Definition at line 836 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_all_with_relation	(	const QStringList &	relation,
		T &	t
	)		`[inline]`

Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database.

Parameters:

relation	List of relationships keys to be fetched (eager fetch instead of default lazy fetch for a relation)
t	Container to be fetched (retrieve all elements and properties associated); t is cleared before executing SQL query

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_all_with_relation<T>() execute following SQL query :
SELECT * FROM my_table

Definition at line 850 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_by_id ( T & t ) [inline]

Fetch an object t (retrieve all its properties) of type T (registered into QxOrm context) mapped to a table in the database (t must have a valid id before to be fetched without error)

Parameters:

t	Instance (with a valid id) to be fetched (retrieve all properties from database)

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_by_id<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?

Definition at line 562 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_by_id	(	T &	t,
		QSqlDatabase *	pDatabase,
		const QStringList &	columns
	)		`[inline]`

Fetch an object t (retrieve all its properties) of type T (registered into QxOrm context) mapped to a table in the database (t must have a valid id before to be fetched without error)

Parameters:

t	Instance (with a valid id) to be fetched (retrieve all properties from database)
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class
columns	List of database table columns (mapped to properties of C++ class T) to be fetched

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_by_id<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?

Definition at line 708 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_by_id	(	T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Fetch an object t (retrieve all its properties) of type T (registered into QxOrm context) mapped to a table in the database (t must have a valid id before to be fetched without error)

Parameters:

t	Instance (with a valid id) to be fetched (retrieve all properties from database)
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_by_id<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?

Definition at line 112 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_by_id_with_all_relation	(	T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Fetch an object t (retrieve all its properties and relationships) of type T (registered into QxOrm context) mapped to a table in the database (t must have a valid id before to be fetched without error)

Parameters:

t	Instance (with a valid id) to be fetched (retrieve all properties and relationships from database)
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_by_id_with_all_relation<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?

Definition at line 297 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_by_id_with_all_relation ( T & t ) [inline]

Fetch an object t (retrieve all its properties and relationships) of type T (registered into QxOrm context) mapped to a table in the database (t must have a valid id before to be fetched without error)

Parameters:

t	Instance (with a valid id) to be fetched (retrieve all properties and relationships from database)

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_by_id_with_all_relation<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?

Definition at line 822 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_by_id_with_relation	(	const QString &	relation,
		T &	t
	)		`[inline]`

Fetch an object t (retrieve all its properties) of type T (registered into QxOrm context) mapped to a table in the database (t must have a valid id before to be fetched without error)

Parameters:

relation	List of relationships keys to be fetched (eager fetch instead of default lazy fetch for a relation) : use "\|" separator to put many relationships keys into this parameter
t	Instance (with a valid id) to be fetched (retrieve all properties from database)

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_by_id_with_relation<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?

Definition at line 795 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_by_id_with_relation	(	const QStringList &	relation,
		T &	t
	)		`[inline]`

Fetch an object t (retrieve all its properties) of type T (registered into QxOrm context) mapped to a table in the database (t must have a valid id before to be fetched without error)

Parameters:

relation	List of relationships keys to be fetched (eager fetch instead of default lazy fetch for a relation)
t	Instance (with a valid id) to be fetched (retrieve all properties from database)

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_by_id_with_relation<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?

Definition at line 809 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_by_id_with_relation	(	const QString &	relation,
		T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Fetch an object t (retrieve all its properties) of type T (registered into QxOrm context) mapped to a table in the database (t must have a valid id before to be fetched without error)

Parameters:

relation	List of relationships keys to be fetched (eager fetch instead of default lazy fetch for a relation) : use "\|" separator to put many relationships keys into this parameter
t	Instance (with a valid id) to be fetched (retrieve all properties from database)
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_by_id_with_relation<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?

Definition at line 268 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_by_id_with_relation	(	const QStringList &	relation,
		T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Fetch an object t (retrieve all its properties) of type T (registered into QxOrm context) mapped to a table in the database (t must have a valid id before to be fetched without error)

Parameters:

relation	List of relationships keys to be fetched (eager fetch instead of default lazy fetch for a relation)
t	Instance (with a valid id) to be fetched (retrieve all properties from database)
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_by_id_with_relation<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?

Definition at line 283 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_by_query	(	const qx::QxSqlQuery &	query,
		T &	t
	)		`[inline]`

Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database and filtered by a user SQL query.

Parameters:

query	Define a user SQL query added to default SQL query builded by QxOrm library
t	Container to be fetched (retrieve all elements and properties associated); t is cleared before executing SQL query

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_by_query<T>() execute following SQL query :
SELECT * FROM my_table + WHERE my_query...

Definition at line 589 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_by_query	(	const qx::QxSqlQuery &	query,
		T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database and filtered by a user SQL query.

Parameters:

query	Define a user SQL query added to default SQL query builded by QxOrm library
t	Container to be fetched (retrieve all elements and properties associated); t is cleared before executing SQL query
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_by_query<T>() execute following SQL query :
SELECT * FROM my_table + WHERE my_query...

Definition at line 141 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_by_query	(	const qx::QxSqlQuery &	query,
		T &	t,
		QSqlDatabase *	pDatabase,
		const QStringList &	columns
	)		`[inline]`

Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database and filtered by a user SQL query.

Parameters:

query	Define a user SQL query added to default SQL query builded by QxOrm library
t	Container to be fetched (retrieve all elements and properties associated); t is cleared before executing SQL query
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class
columns	List of database table columns (mapped to properties of C++ class T) to be fetched

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_by_query<T>() execute following SQL query :
SELECT * FROM my_table + WHERE my_query...

Definition at line 739 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_by_query_with_all_relation	(	const qx::QxSqlQuery &	query,
		T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Fetch a list of objects (retrieve all elements and properties + all relationships associated) of type T (container registered into QxOrm context) mapped to a table in the database and filtered by a user SQL query.

Parameters:

query	Define a user SQL query added to default SQL query builded by QxOrm library
t	Container to be fetched (retrieve all elements and properties + all relationships associated); t is cleared before executing SQL query
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_by_query_with_all_relation<T>() execute following SQL query :
SELECT * FROM my_table + WHERE my_query...

Definition at line 388 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_by_query_with_all_relation	(	const qx::QxSqlQuery &	query,
		T &	t
	)		`[inline]`

Fetch a list of objects (retrieve all elements and properties + all relationships associated) of type T (container registered into QxOrm context) mapped to a table in the database and filtered by a user SQL query.

Parameters:

query	Define a user SQL query added to default SQL query builded by QxOrm library
t	Container to be fetched (retrieve all elements and properties + all relationships associated); t is cleared before executing SQL query

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_by_query_with_all_relation<T>() execute following SQL query :
SELECT * FROM my_table + WHERE my_query...

Definition at line 907 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_by_query_with_relation	(	const QString &	relation,
		const qx::QxSqlQuery &	query,
		T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database and filtered by a user SQL query.

Parameters:

relation	List of relationships keys to be fetched (eager fetch instead of default lazy fetch for a relation) : use "\|" separator to put many relationships keys into this parameter
query	Define a user SQL query added to default SQL query builded by QxOrm library
t	Container to be fetched (retrieve all elements and properties associated); t is cleared before executing SQL query
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_by_query_with_relation<T>() execute following SQL query :
SELECT * FROM my_table + WHERE my_query...

Definition at line 357 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_by_query_with_relation	(	const QStringList &	relation,
		const qx::QxSqlQuery &	query,
		T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database and filtered by a user SQL query.

Parameters:

relation	List of relationships keys to be fetched (eager fetch instead of default lazy fetch for a relation)
query	Define a user SQL query added to default SQL query builded by QxOrm library
t	Container to be fetched (retrieve all elements and properties associated); t is cleared before executing SQL query
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_by_query_with_relation<T>() execute following SQL query :
SELECT * FROM my_table + WHERE my_query...

Definition at line 373 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_by_query_with_relation	(	const QString &	relation,
		const qx::QxSqlQuery &	query,
		T &	t
	)		`[inline]`

Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database and filtered by a user SQL query.

Parameters:

relation	List of relationships keys to be fetched (eager fetch instead of default lazy fetch for a relation) : use "\|" separator to put many relationships keys into this parameter
query	Define a user SQL query added to default SQL query builded by QxOrm library
t	Container to be fetched (retrieve all elements and properties associated); t is cleared before executing SQL query

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_by_query_with_relation<T>() execute following SQL query :
SELECT * FROM my_table + WHERE my_query...

Definition at line 878 of file QxDao.h.

template<class T >

QSqlError qx::dao::fetch_by_query_with_relation	(	const QStringList &	relation,
		const qx::QxSqlQuery &	query,
		T &	t
	)		`[inline]`

Fetch a list of objects (retrieve all elements and properties associated) of type T (container registered into QxOrm context) mapped to a table in the database and filtered by a user SQL query.

Parameters:

relation	List of relationships keys to be fetched (eager fetch instead of default lazy fetch for a relation)
query	Define a user SQL query added to default SQL query builded by QxOrm library
t	Container to be fetched (retrieve all elements and properties associated); t is cleared before executing SQL query

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::fetch_by_query_with_relation<T>() execute following SQL query :
SELECT * FROM my_table + WHERE my_query...

Definition at line 893 of file QxDao.h.

template<class T >

QSqlError qx::dao::insert ( T & t ) [inline]

Insert an element or a list of elements into database.

Parameters:

t	Element (or list of elements) to be inserted into database

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::insert<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)

Definition at line 602 of file QxDao.h.

template<class T >

QSqlError qx::dao::insert	(	T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Insert an element or a list of elements into database.

Parameters:

t	Element (or list of elements) to be inserted into database
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::insert<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)

Definition at line 155 of file QxDao.h.

template<class T >

QSqlError qx::dao::insert_with_all_relation	(	T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Insert an element and all its relationships (or a list of elements + all relationships) into database.

Parameters:

t	Element (or list of elements) to be inserted into database
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::insert_with_all_relation<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)

Definition at line 432 of file QxDao.h.

template<class T >

QSqlError qx::dao::insert_with_all_relation ( T & t ) [inline]

Insert an element and all its relationships (or a list of elements + all relationships) into database.

Parameters:

t	Element (or list of elements) to be inserted into database

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::insert_with_all_relation<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)

Definition at line 948 of file QxDao.h.

template<class T >

QSqlError qx::dao::insert_with_relation	(	const QStringList &	relation,
		T &	t
	)		`[inline]`

Insert an element and its relationships (or a list of elements + relationships) into database.

Parameters:

relation	List of relationships keys to be inserted in others tables of database
t	Element (or list of elements) to be inserted into database

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::insert_with_relation<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)

Definition at line 935 of file QxDao.h.

template<class T >

QSqlError qx::dao::insert_with_relation	(	const QString &	relation,
		T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Insert an element and its relationships (or a list of elements + relationships) into database.

Parameters:

relation	List of relationships keys to be inserted in others tables of database : use "\|" separator to put many relationships keys into this parameter
t	Element (or list of elements) to be inserted into database
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::insert_with_relation<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)

Definition at line 403 of file QxDao.h.

template<class T >

QSqlError qx::dao::insert_with_relation	(	const QStringList &	relation,
		T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Insert an element and its relationships (or a list of elements + relationships) into database.

Parameters:

relation	List of relationships keys to be inserted in others tables of database
t	Element (or list of elements) to be inserted into database
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::insert_with_relation<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)

Definition at line 418 of file QxDao.h.

template<class T >

QSqlError qx::dao::insert_with_relation	(	const QString &	relation,
		T &	t
	)		`[inline]`

Insert an element and its relationships (or a list of elements + relationships) into database.

Parameters:

relation	List of relationships keys to be inserted in others tables of database : use "\|" separator to put many relationships keys into this parameter
t	Element (or list of elements) to be inserted into database

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::insert_with_relation<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)

Definition at line 921 of file QxDao.h.

template<class T >

void qx::dao::on_after_delete	(	T *	t,
		qx::dao::detail::IxDao_Helper *	dao
	)		`[inline]`

Callback after deleting an object into database (here is an example using QxOrm trigger)

Definition at line 1084 of file QxDao.h.

template<class T >

void qx::dao::on_after_insert	(	T *	t,
		qx::dao::detail::IxDao_Helper *	dao
	)		`[inline]`

Callback after inserting an object into database (here is an example using QxOrm Trigger)

Definition at line 1068 of file QxDao.h.

template<class T >

void qx::dao::on_after_update	(	T *	t,
		qx::dao::detail::IxDao_Helper *	dao
	)		`[inline]`

Callback after updating an object into database (here is an example using QxOrm Trigger)

Definition at line 1076 of file QxDao.h.

template<class T >

void qx::dao::on_before_delete	(	T *	t,
		qx::dao::detail::IxDao_Helper *	dao
	)		`[inline]`

Callback before deleting an object into database (here is an example using QxOrm Trigger)

Definition at line 1060 of file QxDao.h.

template<class T >

void qx::dao::on_before_insert	(	T *	t,
		qx::dao::detail::IxDao_Helper *	dao
	)		`[inline]`

Callback before inserting an object into database (here is an example using QxOrm Trigger)

Definition at line 1044 of file QxDao.h.

template<class T >

void qx::dao::on_before_update	(	T *	t,
		qx::dao::detail::IxDao_Helper *	dao
	)		`[inline]`

Callback before updating an object into database (here is an example using QxOrm Trigger)

Definition at line 1052 of file QxDao.h.

template<class T >

QSqlError qx::dao::save	(	T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Insert (if no exist) or update (if already exist) an element or a list of elements into database.

Parameters:

t	Element (or list of elements) to be inserted (if no exist) or updated (if already exist) into database
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::save<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)
or (if already exist into database) :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.

Definition at line 185 of file QxDao.h.

template<class T >

QSqlError qx::dao::save ( T & t ) [inline]

Insert (if no exist) or update (if already exist) an element or a list of elements into database.

Parameters:

t	Element (or list of elements) to be inserted (if no exist) or updated (if already exist) into database

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::save<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)
or (if already exist into database) :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.

Definition at line 630 of file QxDao.h.

template<class T >

QSqlError qx::dao::save_with_all_relation	(	T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Insert (if no exist) or update (if already exist) an element and all its relationships (or a list of elements + all relationships) into database.

Parameters:

t	Element (or list of elements) to be inserted (if no exist) or updated (if already exist) into database
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::save_with_all_relation<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)
or (if already exist into database) :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.

Definition at line 526 of file QxDao.h.

template<class T >

QSqlError qx::dao::save_with_all_relation ( T & t ) [inline]

Insert (if no exist) or update (if already exist) an element and all its relationships (or a list of elements + all relationships) into database.

Parameters:

t	Element (or list of elements) to be inserted (if no exist) or updated (if already exist) into database

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::save_with_all_relation<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)
or (if already exist into database) :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.

Definition at line 1036 of file QxDao.h.

template<class T >

QSqlError qx::dao::save_with_relation	(	const QString &	relation,
		T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Insert (if no exist) or update (if already exist) an element and its relationships (or a list of elements + relationships) into database.

Parameters:

relation	List of relationships keys to be inserted or updated in others tables of database : use "\|" separator to put many relationships keys into this parameter
t	Element (or list of elements) to be inserted (if no exist) or updated (if already exist) into database
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::save_with_relation<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)
or (if already exist into database) :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.

Definition at line 493 of file QxDao.h.

template<class T >

QSqlError qx::dao::save_with_relation	(	const QStringList &	relation,
		T &	t
	)		`[inline]`

Insert (if no exist) or update (if already exist) an element and its relationships (or a list of elements + relationships) into database.

Parameters:

relation	List of relationships keys to be inserted or updated in others tables of database
t	Element (or list of elements) to be inserted (if no exist) or updated (if already exist) into database

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::save_with_relation<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)
or (if already exist into database) :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.

Definition at line 1021 of file QxDao.h.

template<class T >

QSqlError qx::dao::save_with_relation	(	const QStringList &	relation,
		T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Insert (if no exist) or update (if already exist) an element and its relationships (or a list of elements + relationships) into database.

Parameters:

relation	List of relationships keys to be inserted or updated in others tables of database
t	Element (or list of elements) to be inserted (if no exist) or updated (if already exist) into database
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::save_with_relation<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)
or (if already exist into database) :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.

Definition at line 510 of file QxDao.h.

template<class T >

QSqlError qx::dao::save_with_relation	(	const QString &	relation,
		T &	t
	)		`[inline]`

Insert (if no exist) or update (if already exist) an element and its relationships (or a list of elements + relationships) into database.

Parameters:

relation	List of relationships keys to be inserted or updated in others tables of database : use "\|" separator to put many relationships keys into this parameter
t	Element (or list of elements) to be inserted (if no exist) or updated (if already exist) into database

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::save_with_relation<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)
or (if already exist into database) :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.

Definition at line 1005 of file QxDao.h.

template<class T >

QSqlError qx::dao::update	(	T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Update an element or a list of elements into database.

Parameters:

t	Element (or list of elements) to be updated into database
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::update<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.

Definition at line 169 of file QxDao.h.

template<class T >

QSqlError qx::dao::update ( T & t ) [inline]

Update an element or a list of elements into database.

Parameters:

t	Element (or list of elements) to be updated into database

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::update<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.

Definition at line 615 of file QxDao.h.

template<class T >

QSqlError qx::dao::update	(	T &	t,
		QSqlDatabase *	pDatabase,
		const QStringList &	columns
	)		`[inline]`

Update an element or a list of elements into database.

Parameters:

t	Element (or list of elements) to be updated into database
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class
columns	List of database table columns (mapped to properties of C++ class T) to be updated

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::update<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.

Definition at line 754 of file QxDao.h.

template<class T >

QSqlError qx::dao::update_optimized ( qx::dao::ptr< T > & ptr ) [inline]

Update only modified fields/properties of an element or a list of elements into database (using is dirty pattern and qx::dao::ptr<T> smart-pointer)

Parameters:

ptr	Element (or list of elements) to be updated into database

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::update_optimized<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.

Definition at line 767 of file QxDao.h.

template<class T >

QSqlError qx::dao::update_optimized	(	qx::dao::ptr< T > &	ptr,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Update only modified fields/properties of an element or a list of elements into database (using is dirty pattern and qx::dao::ptr<T> smart-pointer)

Parameters:

ptr	Element (or list of elements) to be updated into database
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::update_optimized<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.

Definition at line 781 of file QxDao.h.

template<class T >

QSqlError qx::dao::update_with_all_relation ( T & t ) [inline]

Update an element and all its relationships (or a list of elements + all relationships) into database.

Parameters:

t	Element (or list of elements) to be updated into database

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::update_with_all_relation<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.

Definition at line 989 of file QxDao.h.

template<class T >

QSqlError qx::dao::update_with_all_relation	(	T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Update an element and all its relationships (or a list of elements + all relationships) into database.

Parameters:

t	Element (or list of elements) to be updated into database
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::update_with_all_relation<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.

Definition at line 476 of file QxDao.h.

template<class T >

QSqlError qx::dao::update_with_relation	(	const QString &	relation,
		T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Update an element and its relationships (or a list of elements + relationships) into database.

Parameters:

relation	List of relationships keys to be updated in others tables of database : use "\|" separator to put many relationships keys into this parameter
t	Element (or list of elements) to be updated into database
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::update_with_relation<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.

Definition at line 447 of file QxDao.h.

template<class T >

QSqlError qx::dao::update_with_relation	(	const QStringList &	relation,
		T &	t,
		QSqlDatabase *	pDatabase
	)		`[inline]`

Update an element and its relationships (or a list of elements + relationships) into database.

Parameters:

relation	List of relationships keys to be updated in others tables of database
t	Element (or list of elements) to be updated into database
pDatabase	Connection to database (you can manage your own connection pool for example, you can also define a transaction, etc.); if NULL, a valid connection for the current thread is provided by qx::QxSqlDatabase singleton class

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::update_with_relation<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.

Definition at line 462 of file QxDao.h.

template<class T >

QSqlError qx::dao::update_with_relation	(	const QString &	relation,
		T &	t
	)		`[inline]`

Update an element and its relationships (or a list of elements + relationships) into database.

Parameters:

relation	List of relationships keys to be updated in others tables of database : use "\|" separator to put many relationships keys into this parameter
t	Element (or list of elements) to be updated into database

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::update_with_relation<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.

Definition at line 962 of file QxDao.h.

template<class T >

QSqlError qx::dao::update_with_relation	(	const QStringList &	relation,
		T &	t
	)		`[inline]`

Update an element and its relationships (or a list of elements + relationships) into database.

Parameters:

relation	List of relationships keys to be updated in others tables of database
t	Element (or list of elements) to be updated into database

Returns:: Empty QSqlError object (from Qt library) if no error occurred; otherwise QSqlError contains a description of database error executing SQL query

qx::dao::update_with_relation<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.

Definition at line 976 of file QxDao.h.

Classes

Namespaces

Files

Functions

Function Documentation