![]() |
QxOrm 1.1.9
C++ Object Relational Mapping library
|
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::QxDateNeutral |
qx::QxDateNeutral : helper class to store a date value into database under neutral format (YYYYMMDD) => cross database compatibility More... | |
class | qx::QxDateTimeNeutral |
qx::QxDateTimeNeutral : helper class to store a date-time value into database under neutral format (YYYYMMDDHHMMSS) => cross database compatibility More... | |
class | qx::QxSession |
qx::QxSession : define a session to manage automatically database transactions (using C++ RAII) More... | |
class | qx::QxSoftDelete |
qx::QxSoftDelete : soft delete (or logical delete) behavior to update a row into database (flag it as deleted) instead of delete it from database 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::dao::sql_error |
qx::dao::sql_error : define a SQL error exception and retrieve QSqlError type of Qt library 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... | |
class | qx::QxTimeNeutral |
qx::QxTimeNeutral : helper class to store a time value into database under neutral format (HHMMSS) => cross database compatibility 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 | QxDateNeutral.h |
Helper class to store a date value into database under neutral format (YYYYMMDD) => cross database compatibility. | |
file | QxDateTimeNeutral.h |
Helper class to store a date-time value into database under neutral format (YYYYMMDDHHMMSS) => cross database compatibility. | |
file | QxSession.h |
Define a session to manage automatically database transactions (using C++ RAII) | |
file | QxSoftDelete.h |
Soft delete (or logical delete) behavior to update a row into database (flag it as deleted) instead of delete it from database. | |
file | QxSqlDatabase.h |
Define all parameters to connect to database and retrieve a valid connection by thread. | |
file | QxSqlError.h |
Define a SQL error exception and retrieve QSqlError type of Qt library. | |
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. | |
file | QxTimeNeutral.h |
Helper class to store a time value into database under neutral format (HHMMSS) => cross database compatibility. | |
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::update_by_query (const qx::QxSqlQuery &query, T &t, QSqlDatabase *pDatabase) |
Update an element or a list of elements into database (adding a user SQL query to the default SQL query builded by QxOrm library) | |
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::destroy_by_id (T &t, QSqlDatabase *pDatabase) |
Destroy a line (or list of lines) of a table (database) mapped to a C++ object of type T (registered into QxOrm context), even if a soft delete behavior is defined for class T. | |
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::destroy_all (QSqlDatabase *pDatabase) |
Destroy all lines of a table (database) mapped to a C++ class T (registered into QxOrm context), even if a soft delete behavior is defined for class T. | |
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::destroy_by_query (const qx::QxSqlQuery &query, QSqlDatabase *pDatabase) |
Destroy all lines of a table (database) mapped to a C++ class T (registered into QxOrm context) and filtered by a user SQL query, even if a soft delete behavior is defined for class T. | |
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_by_query_with_relation (const QString &relation, const qx::QxSqlQuery &query, T &t, QSqlDatabase *pDatabase) |
Update an element and its relationships (or a list of elements + relationships) into database (adding a user SQL query to the default SQL query builded by QxOrm library) | |
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_by_query_with_relation (const QStringList &relation, const qx::QxSqlQuery &query, T &t, QSqlDatabase *pDatabase) |
Update an element and its relationships (or a list of elements + relationships) into database (adding a user SQL query to the default SQL query builded by QxOrm library) | |
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::update_by_query_with_all_relation (const qx::QxSqlQuery &query, T &t, QSqlDatabase *pDatabase) |
Update an element and all its relationships (or a list of elements + all relationships) into database (adding a user SQL query to the default SQL query builded by QxOrm library) | |
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::update_by_query (const qx::QxSqlQuery &query, T &t) |
Update an element or a list of elements into database (adding a user SQL query to the default SQL query builded by QxOrm library) | |
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::destroy_by_id (T &t) |
Destroy a line (or list of lines) of a table (database) mapped to a C++ object of type T (registered into QxOrm context), even if a soft delete behavior is defined for class T. | |
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::destroy_all () |
Destroy all lines of a table (database) mapped to a C++ class T (registered into QxOrm context), even if a soft delete behavior is defined for class T. | |
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::destroy_by_query (const qx::QxSqlQuery &query) |
Destroy all lines of a table (database) mapped to a C++ class T (registered into QxOrm context) and filtered by a user SQL query, even if a soft delete behavior is defined for class T. | |
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_by_query (const qx::QxSqlQuery &query, T &t, QSqlDatabase *pDatabase, const QStringList &columns) |
Update an element or a list of elements into database (adding a user SQL query to the default SQL query builded by QxOrm library) | |
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_by_query (const qx::QxSqlQuery &query, 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), adding a user SQL query to the default SQL query builded by QxOrm library. | |
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::update_optimized_by_query (const qx::QxSqlQuery &query, 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), adding a user SQL query to the default SQL query builded by QxOrm library. | |
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_by_query_with_relation (const QString &relation, const qx::QxSqlQuery &query, T &t) |
Update an element and its relationships (or a list of elements + relationships) into database (adding a user SQL query to the default SQL query builded by QxOrm library) | |
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_by_query_with_relation (const QStringList &relation, const qx::QxSqlQuery &query, T &t) |
Update an element and its relationships (or a list of elements + relationships) into database (adding a user SQL query to the default SQL query builded by QxOrm library) | |
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::update_by_query_with_all_relation (const qx::QxSqlQuery &query, T &t) |
Update an element and all its relationships (or a list of elements + all relationships) into database (adding a user SQL query to the default SQL query builded by QxOrm library) | |
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) |
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)
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
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.
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...
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
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.
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...
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)
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::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.)
QSqlError qx::dao::create_table | ( | ) | [inline] |
Create a table into database (with all columns) mapped to a C++ class T (registered into QxOrm context)
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.)
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)
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::delete_all<T>() execute following SQL query :
DELETE FROM my_table
If a soft delete behavior is defined for class T, qx::dao::delete_all<T>() execute following SQL query :
UPDATE my_table SET is_deleted='1'
QSqlError qx::dao::delete_all | ( | ) | [inline] |
Delete all lines of a table (database) mapped to a C++ class T (registered into QxOrm context)
qx::dao::delete_all<T>() execute following SQL query :
DELETE FROM my_table
If a soft delete behavior is defined for class T, qx::dao::delete_all<T>() execute following SQL query :
UPDATE my_table SET is_deleted='1'
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)
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 |
qx::dao::delete_by_id<T>() execute following SQL query :
DELETE FROM my_table WHERE my_id = ?
If a soft delete behavior is defined for class T, qx::dao::delete_by_id<T>() execute following SQL query :
UPDATE my_table SET is_deleted='1' WHERE my_id = ?
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)
t | Element (or list of elements) to be deleted into database |
qx::dao::delete_by_id<T>() execute following SQL query :
DELETE FROM my_table WHERE my_id = ?
If a soft delete behavior is defined for class T, qx::dao::delete_by_id<T>() execute following SQL query :
UPDATE my_table SET is_deleted='1' WHERE my_id = ?
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.
query | Define a user SQL query added to default SQL query builded by QxOrm library |
qx::dao::delete_by_query<T>() execute following SQL query :
DELETE FROM my_table + WHERE my_query...
If a soft delete behavior is defined for class T, qx::dao::delete_by_query<T>() execute following SQL query :
UPDATE my_table SET is_deleted='1' + WHERE my_query...
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.
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::delete_by_query<T>() execute following SQL query :
DELETE FROM my_table + WHERE my_query...
If a soft delete behavior is defined for class T, qx::dao::delete_by_query<T>() execute following SQL query :
UPDATE my_table SET is_deleted='1' + WHERE my_query...
QSqlError qx::dao::destroy_all | ( | QSqlDatabase * | pDatabase | ) | [inline] |
Destroy all lines of a table (database) mapped to a C++ class T (registered into QxOrm context), even if a soft delete behavior is defined for class T.
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::destroy_all<T>() execute following SQL query :
DELETE FROM my_table
QSqlError qx::dao::destroy_all | ( | ) | [inline] |
Destroy all lines of a table (database) mapped to a C++ class T (registered into QxOrm context), even if a soft delete behavior is defined for class T.
qx::dao::destroy_all<T>() execute following SQL query :
DELETE FROM my_table
QSqlError qx::dao::destroy_by_id | ( | T & | t, |
QSqlDatabase * | pDatabase | ||
) | [inline] |
Destroy a line (or list of lines) of a table (database) mapped to a C++ object of type T (registered into QxOrm context), even if a soft delete behavior is defined for class T.
t | Element (or list of elements) to be destroyed 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 |
qx::dao::destroy_by_id<T>() execute following SQL query :
DELETE FROM my_table WHERE my_id = ?
QSqlError qx::dao::destroy_by_id | ( | T & | t | ) | [inline] |
Destroy a line (or list of lines) of a table (database) mapped to a C++ object of type T (registered into QxOrm context), even if a soft delete behavior is defined for class T.
t | Element (or list of elements) to be destroyed into database |
qx::dao::destroy_by_id<T>() execute following SQL query :
DELETE FROM my_table WHERE my_id = ?
QSqlError qx::dao::destroy_by_query | ( | const qx::QxSqlQuery & | query | ) | [inline] |
Destroy all lines of a table (database) mapped to a C++ class T (registered into QxOrm context) and filtered by a user SQL query, even if a soft delete behavior is defined for class T.
query | Define a user SQL query added to default SQL query builded by QxOrm library |
qx::dao::destroy_by_query<T>() execute following SQL query :
DELETE FROM my_table + WHERE my_query...
QSqlError qx::dao::destroy_by_query | ( | const qx::QxSqlQuery & | query, |
QSqlDatabase * | pDatabase | ||
) | [inline] |
Destroy all lines of a table (database) mapped to a C++ class T (registered into QxOrm context) and filtered by a user SQL query, even if a soft delete behavior is defined for class T.
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::destroy_by_query<T>() execute following SQL query :
DELETE FROM my_table + WHERE my_query...
qx_bool qx::dao::exist | ( | T & | t, |
QSqlDatabase * | pDatabase | ||
) | [inline] |
Search if an element (or list of elements) already exists into database.
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 |
qx::dao::exist<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?
qx_bool qx::dao::exist | ( | T & | t | ) | [inline] |
Search if an element (or list of elements) already exists into database.
t | Element (or list of elements) to be searched into database |
qx::dao::exist<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?
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.
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 |
qx::dao::fetch_all<T>() execute following SQL query :
SELECT * FROM my_table
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.
t | Container to be fetched (retrieve all elements and properties associated); t is cleared before executing SQL query |
qx::dao::fetch_all<T>() execute following SQL query :
SELECT * FROM my_table
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.
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 |
qx::dao::fetch_all<T>() execute following SQL query :
SELECT * FROM my_table
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.
t | Container to be fetched (retrieve all elements and properties + all relationships associated); t is cleared before executing SQL query |
qx::dao::fetch_all_with_all_relation<T>() execute following SQL query :
SELECT * FROM my_table
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.
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 |
qx::dao::fetch_all_with_all_relation<T>() execute following SQL query :
SELECT * FROM my_table
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.
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 |
qx::dao::fetch_all_with_relation<T>() execute following SQL query :
SELECT * FROM my_table
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.
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 |
qx::dao::fetch_all_with_relation<T>() execute following SQL query :
SELECT * FROM my_table
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.
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 |
qx::dao::fetch_all_with_relation<T>() execute following SQL query :
SELECT * FROM my_table
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.
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 |
qx::dao::fetch_all_with_relation<T>() execute following SQL query :
SELECT * FROM my_table
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)
t | Instance (with a valid id) to be fetched (retrieve all properties from database) |
qx::dao::fetch_by_id<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?
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)
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 |
qx::dao::fetch_by_id<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?
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)
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 |
qx::dao::fetch_by_id<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?
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)
t | Instance (with a valid id) to be fetched (retrieve all properties and relationships from database) |
qx::dao::fetch_by_id_with_all_relation<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?
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)
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 |
qx::dao::fetch_by_id_with_all_relation<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?
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)
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) |
qx::dao::fetch_by_id_with_relation<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?
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)
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) |
qx::dao::fetch_by_id_with_relation<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?
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)
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 |
qx::dao::fetch_by_id_with_relation<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?
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)
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 |
qx::dao::fetch_by_id_with_relation<T>() execute following SQL query :
SELECT * FROM my_table WHERE my_id = ?
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.
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 |
qx::dao::fetch_by_query<T>() execute following SQL query :
SELECT * FROM my_table + WHERE my_query...
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.
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 |
qx::dao::fetch_by_query<T>() execute following SQL query :
SELECT * FROM my_table + WHERE my_query...
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.
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 |
qx::dao::fetch_by_query<T>() execute following SQL query :
SELECT * FROM my_table + WHERE my_query...
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.
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 |
qx::dao::fetch_by_query_with_all_relation<T>() execute following SQL query :
SELECT * FROM my_table + WHERE my_query...
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.
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 |
qx::dao::fetch_by_query_with_all_relation<T>() execute following SQL query :
SELECT * FROM my_table + WHERE my_query...
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.
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 |
qx::dao::fetch_by_query_with_relation<T>() execute following SQL query :
SELECT * FROM my_table + WHERE my_query...
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.
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 |
qx::dao::fetch_by_query_with_relation<T>() execute following SQL query :
SELECT * FROM my_table + WHERE my_query...
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.
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 |
qx::dao::fetch_by_query_with_relation<T>() execute following SQL query :
SELECT * FROM my_table + WHERE my_query...
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.
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 |
qx::dao::fetch_by_query_with_relation<T>() execute following SQL query :
SELECT * FROM my_table + WHERE my_query...
QSqlError qx::dao::insert | ( | T & | t | ) | [inline] |
Insert an element or a list of elements into database.
t | Element (or list of elements) to be inserted into database |
qx::dao::insert<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)
QSqlError qx::dao::insert | ( | T & | t, |
QSqlDatabase * | pDatabase | ||
) | [inline] |
Insert an element or a list of elements into 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 |
qx::dao::insert<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)
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.
t | Element (or list of elements) to be inserted into database |
qx::dao::insert_with_all_relation<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)
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.
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 |
qx::dao::insert_with_all_relation<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)
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.
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 |
qx::dao::insert_with_relation<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)
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.
relation | List of relationships keys to be inserted in others tables of database |
t | Element (or list of elements) to be inserted into database |
qx::dao::insert_with_relation<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)
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.
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 |
qx::dao::insert_with_relation<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)
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.
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 |
qx::dao::insert_with_relation<T>() execute following SQL query :
INSERT INTO my_table (my_column_1, my_column_2, etc.) VALUES (?, ?, etc.)
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)
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)
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)
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)
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)
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)
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.
t | Element (or list of elements) to be inserted (if no exist) or updated (if already exist) into database |
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.
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.
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 |
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.
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.
t | Element (or list of elements) to be inserted (if no exist) or updated (if already exist) into database |
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.
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.
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 |
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.
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.
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 |
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.
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.
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 |
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.
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.
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 |
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.
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.
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 |
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.
QSqlError qx::dao::update | ( | T & | t, |
QSqlDatabase * | pDatabase, | ||
const QStringList & | columns | ||
) | [inline] |
Update an element or a list of elements into 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 |
columns | List of database table columns (mapped to properties of C++ class T) to be updated |
qx::dao::update<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.
QSqlError qx::dao::update | ( | T & | t, |
QSqlDatabase * | pDatabase | ||
) | [inline] |
Update an element or a list of elements into 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 |
qx::dao::update<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.
QSqlError qx::dao::update | ( | T & | t | ) | [inline] |
Update an element or a list of elements into database.
t | Element (or list of elements) to be updated into database |
qx::dao::update<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.
QSqlError qx::dao::update_by_query | ( | const qx::QxSqlQuery & | query, |
T & | t, | ||
QSqlDatabase * | pDatabase | ||
) | [inline] |
Update an element or a list of elements into database (adding a user SQL query to the default SQL query builded by QxOrm library)
query | Define a user SQL query added to default SQL query builded by QxOrm library |
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 |
qx::dao::update_by_query<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc. + WHERE my_query...
QSqlError qx::dao::update_by_query | ( | const qx::QxSqlQuery & | query, |
T & | t | ||
) | [inline] |
Update an element or a list of elements into database (adding a user SQL query to the default SQL query builded by QxOrm library)
query | Define a user SQL query added to default SQL query builded by QxOrm library |
t | Element (or list of elements) to be updated into database |
qx::dao::update_by_query<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc. + WHERE my_query...
QSqlError qx::dao::update_by_query | ( | const qx::QxSqlQuery & | query, |
T & | t, | ||
QSqlDatabase * | pDatabase, | ||
const QStringList & | columns | ||
) | [inline] |
Update an element or a list of elements into database (adding a user SQL query to the default SQL query builded by QxOrm library)
query | Define a user SQL query added to default SQL query builded by QxOrm library |
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 |
qx::dao::update_by_query<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc. + WHERE my_query...
QSqlError qx::dao::update_by_query_with_all_relation | ( | const qx::QxSqlQuery & | query, |
T & | t, | ||
QSqlDatabase * | pDatabase | ||
) | [inline] |
Update an element and all its relationships (or a list of elements + all relationships) into database (adding a user SQL query to the default SQL query builded by QxOrm library)
query | Define a user SQL query added to default SQL query builded by QxOrm library |
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 |
qx::dao::update_by_query_with_all_relation<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc. + WHERE my_query...
QSqlError qx::dao::update_by_query_with_all_relation | ( | const qx::QxSqlQuery & | query, |
T & | t | ||
) | [inline] |
Update an element and all its relationships (or a list of elements + all relationships) into database (adding a user SQL query to the default SQL query builded by QxOrm library)
query | Define a user SQL query added to default SQL query builded by QxOrm library |
t | Element (or list of elements) to be updated into database |
qx::dao::update_by_query_with_all_relation<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc. + WHERE my_query...
QSqlError qx::dao::update_by_query_with_relation | ( | const QStringList & | relation, |
const qx::QxSqlQuery & | query, | ||
T & | t | ||
) | [inline] |
Update an element and its relationships (or a list of elements + relationships) into database (adding a user SQL query to the default SQL query builded by QxOrm library)
relation | List of relationships keys to be updated in others tables of database |
query | Define a user SQL query added to default SQL query builded by QxOrm library |
t | Element (or list of elements) to be updated into database |
qx::dao::update_by_query_with_relation<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc. + WHERE my_query...
QSqlError qx::dao::update_by_query_with_relation | ( | const QString & | relation, |
const qx::QxSqlQuery & | query, | ||
T & | t, | ||
QSqlDatabase * | pDatabase | ||
) | [inline] |
Update an element and its relationships (or a list of elements + relationships) into database (adding a user SQL query to the default SQL query builded by QxOrm library)
relation | List of relationships keys to be updated in others tables of database : 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 | 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 |
qx::dao::update_by_query_with_relation<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc. + WHERE my_query...
QSqlError qx::dao::update_by_query_with_relation | ( | const QString & | relation, |
const qx::QxSqlQuery & | query, | ||
T & | t | ||
) | [inline] |
Update an element and its relationships (or a list of elements + relationships) into database (adding a user SQL query to the default SQL query builded by QxOrm library)
relation | List of relationships keys to be updated in others tables of database : 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 | Element (or list of elements) to be updated into database |
qx::dao::update_by_query_with_relation<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc. + WHERE my_query...
QSqlError qx::dao::update_by_query_with_relation | ( | const QStringList & | relation, |
const qx::QxSqlQuery & | query, | ||
T & | t, | ||
QSqlDatabase * | pDatabase | ||
) | [inline] |
Update an element and its relationships (or a list of elements + relationships) into database (adding a user SQL query to the default SQL query builded by QxOrm library)
relation | List of relationships keys to be updated in others tables of database |
query | Define a user SQL query added to default SQL query builded by QxOrm library |
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 |
qx::dao::update_by_query_with_relation<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc. + WHERE my_query...
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)
ptr | Element (or list of elements) to be updated into database |
qx::dao::update_optimized<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.
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)
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 |
qx::dao::update_optimized<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.
QSqlError qx::dao::update_optimized_by_query | ( | const qx::QxSqlQuery & | query, |
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), adding a user SQL query to the default SQL query builded by QxOrm library.
query | Define a user SQL query added to default SQL query builded by QxOrm library |
ptr | Element (or list of elements) to be updated into database |
qx::dao::update_optimized_by_query<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc. + WHERE my_query...
QSqlError qx::dao::update_optimized_by_query | ( | const qx::QxSqlQuery & | query, |
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), adding a user SQL query to the default SQL query builded by QxOrm library.
query | Define a user SQL query added to default SQL query builded by QxOrm library |
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 |
qx::dao::update_optimized_by_query<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc. + WHERE my_query...
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.
t | Element (or list of elements) to be updated into database |
qx::dao::update_with_all_relation<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.
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.
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 |
qx::dao::update_with_all_relation<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.
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.
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 |
qx::dao::update_with_relation<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.
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.
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 |
qx::dao::update_with_relation<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.
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.
relation | List of relationships keys to be updated in others tables of database |
t | Element (or list of elements) to be updated into database |
qx::dao::update_with_relation<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.
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.
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 |
qx::dao::update_with_relation<T>() execute following SQL query :
UPDATE my_table SET my_column_1 = ?, my_column_2 = ?, etc.