QxOrm 1.4.9
C++ Object Relational Mapping library
Loading...
Searching...
No Matches
QxRepository.h
Go to the documentation of this file.
1/****************************************************************************
2**
3** https://www.qxorm.com/
4** Copyright (C) 2013 Lionel Marty (contact@qxorm.com)
5**
6** This file is part of the QxOrm library
7**
8** This software is provided 'as-is', without any express or implied
9** warranty. In no event will the authors be held liable for any
10** damages arising from the use of this software
11**
12** Commercial Usage
13** Licensees holding valid commercial QxOrm licenses may use this file in
14** accordance with the commercial license agreement provided with the
15** Software or, alternatively, in accordance with the terms contained in
16** a written agreement between you and Lionel Marty
17**
18** GNU General Public License Usage
19** Alternatively, this file may be used under the terms of the GNU
20** General Public License version 3.0 as published by the Free Software
21** Foundation and appearing in the file 'license.gpl3.txt' included in the
22** packaging of this file. Please review the following information to
23** ensure the GNU General Public License version 3.0 requirements will be
24** met : http://www.gnu.org/copyleft/gpl.html
25**
26** If you are unsure which license is appropriate for your use, or
27** if you have questions regarding the use of this file, please contact :
28** contact@qxorm.com
29**
30****************************************************************************/
31
32#ifndef _QX_REPOSITORY_H_
33#define _QX_REPOSITORY_H_
34
35#ifdef _MSC_VER
36#pragma once
37#endif
38
48
49#include <QxDao/QxDao.h>
50#include <QxDao/QxSession.h>
51#include <QxDao/QxSqlError.h>
52
53#include <QxRegister/QxClass.h>
54
56
58
59#define QX_REPOSITORY_COLLECTION_DYNAMIC_CAST_ERROR QSqlError("[QxOrm] qx::QxRepository<T> : 'invalid collection pointer, dynamic_cast failed'", "", QSqlError::UnknownError)
60#define QX_REPOSITORY_POINTER_DYNAMIC_CAST_ERROR QSqlError("[QxOrm] qx::QxRepository<T> : 'invalid pointer, dynamic_cast failed'", "", QSqlError::UnknownError)
61#define QX_REPOSITORY_QOBJECT_BASE_CLASS_ERROR QSqlError("[QxOrm] qx::QxRepository<T> : 'invalid pointer, need to inherit from QObject class to use qx::IxRepository interface'", "", QSqlError::UnknownError)
62
63#ifndef _QX_NO_RTTI
64#define QX_REPOSITORY_CAST_COLLECTION \
65type_collection_qt * x = dynamic_cast<type_collection_qt *>(p); \
66type_collection_boost * y = (x ? NULL : dynamic_cast<type_collection_boost *>(p)); \
67if (! x && ! y) { throw qx::dao::sql_error(QX_REPOSITORY_COLLECTION_DYNAMIC_CAST_ERROR); }
68#else // _QX_NO_RTTI
69#define QX_REPOSITORY_CAST_COLLECTION \
70type_collection_qt * x = NULL; \
71type_collection_boost * y = static_cast<type_collection_boost *>(p);
72#endif // _QX_NO_RTTI
73
74namespace qx {
75
76template <class T>
77inline void register_repository(const QString & sKey);
78
83template <class T>
85{
86
87 template <class U>
88 friend inline void register_repository(const QString & sKey);
89
90private:
91
92 QxRepository(const QString & sKey) : IxRepository(true, sKey) { ; }
93
94public:
95
96 QxRepository() : IxRepository(false, QString("")) { ; }
97 QxRepository(const QSqlDatabase & database) : IxRepository(false, QString(""), database) { ; }
98 QxRepository(QxSession * pSession) : IxRepository(false, QString(""), pSession) { ; }
99 virtual ~QxRepository() { ; }
100
101 long count(const qx::QxSqlQuery & query = qx::QxSqlQuery())
102 { return qx::dao::count<T>(query, this->database()); }
103
104 T * fetchById(const QVariant & id, const QStringList & columns = QStringList(), const QStringList & relation = QStringList())
105 {
106 IxDataMemberX * pDataMemberX = QxClass<T>::getSingleton()->getDataMemberX();
107 IxDataMember * pDataMemberId = (pDataMemberX ? pDataMemberX->getId_WithDaoStrategy() : NULL);
108 if (! pDataMemberId) { qAssert(false); return NULL; }
109 T * t = new T(); QSqlError err;
110 pDataMemberId->fromVariant(t, id, -1, qx::cvt::context::e_database);
111 if (relation.count() == 0) { err = qx::dao::fetch_by_id((* t), this->database(), columns); }
112 else { err = qx::dao::fetch_by_id_with_relation(relation, (* t), this->database()); }
113 if (err.isValid() && m_pSession) { delete t; t = NULL; (* m_pSession) += err; }
114 else if (err.isValid()) { delete t; t = NULL; }
115 return t;
116 }
117
118 template <class U>
119 QSqlError fetchById(U & u, const QStringList & columns = QStringList(), const QStringList & relation = QStringList())
120 {
121 QSqlError err;
122 if (relation.count() == 0) { err = qx::dao::fetch_by_id(u, this->database(), columns); }
123 else { err = qx::dao::fetch_by_id_with_relation(relation, u, this->database()); }
124 if (err.isValid() && m_pSession) { (* m_pSession) += err; }
125 return err;
126 }
127
128 template <class U>
129 QSqlError fetchAll(U & u, const QStringList & columns = QStringList(), const QStringList & relation = QStringList())
130 {
131 QSqlError err;
132 if (relation.count() == 0) { err = qx::dao::fetch_all(u, this->database(), columns); }
133 else { err = qx::dao::fetch_all_with_relation(relation, u, this->database()); }
134 if (err.isValid() && m_pSession) { (* m_pSession) += err; }
135 return err;
136 }
137
138 template <class U>
139 QSqlError fetchByQuery(const qx::QxSqlQuery & query, U & u, const QStringList & columns = QStringList(), const QStringList & relation = QStringList())
140 {
141 QSqlError err;
142 if (relation.count() == 0) { err = qx::dao::fetch_by_query(query, u, this->database(), columns); }
143 else { err = qx::dao::fetch_by_query_with_relation(relation, query, u, this->database()); }
144 if (err.isValid() && m_pSession) { (* m_pSession) += err; }
145 return err;
146 }
147
148 template <class U>
149 QSqlError insert(U & u, const QStringList & relation = QStringList(), bool bUseExecBatch = false)
150 {
151 QSqlError err;
152 if (relation.count() == 0) { err = qx::dao::insert(u, this->database(), bUseExecBatch); }
153 else { err = qx::dao::insert_with_relation(relation, u, this->database()); }
154 if (err.isValid() && m_pSession) { (* m_pSession) += err; }
155 return err;
156 }
157
158 template <class U>
159 QSqlError update(U & u, const qx::QxSqlQuery & query = qx::QxSqlQuery(), const QStringList & columns = QStringList(), const QStringList & relation = QStringList(), bool bUseExecBatch = false)
160 {
161 QSqlError err;
162 if (relation.count() == 0) { err = qx::dao::update_by_query(query, u, this->database(), columns, bUseExecBatch); }
163 else { err = qx::dao::update_by_query_with_relation(relation, query, u, this->database()); }
164 if (err.isValid() && m_pSession) { (* m_pSession) += err; }
165 return err;
166 }
167
168 template <class U>
169 QSqlError save(U & u, const QStringList & relation = QStringList())
170 {
171 QSqlError err;
172 if (relation.count() == 0) { err = qx::dao::save(u, this->database()); }
173 else { err = qx::dao::save_with_relation(relation, u, this->database()); }
174 if (err.isValid() && m_pSession) { (* m_pSession) += err; }
175 return err;
176 }
177
178 QSqlError deleteById(const QVariant & id)
179 {
180 IxDataMemberX * pDataMemberX = QxClass<T>::getSingleton()->getDataMemberX();
181 IxDataMember * pDataMemberId = (pDataMemberX ? pDataMemberX->getId_WithDaoStrategy() : NULL);
182 if (! pDataMemberId) { qAssert(false); return QSqlError(); }
183 std::shared_ptr<T> t = std::make_shared<T>();
184 pDataMemberId->fromVariant(t.get(), id, -1, qx::cvt::context::e_database);
185 QSqlError err = qx::dao::delete_by_id((* t), this->database());
186 if (err.isValid() && m_pSession) { (* m_pSession) += err; }
187 return err;
188 }
189
190 template <class U>
191 QSqlError deleteById(U & u, bool bUseExecBatch = false)
192 {
193 QSqlError err = qx::dao::delete_by_id(u, this->database(), bUseExecBatch);
194 if (err.isValid() && m_pSession) { (* m_pSession) += err; }
195 return err;
196 }
197
198 QSqlError deleteAll()
199 {
200 QSqlError err = qx::dao::delete_all<T>(this->database());
201 if (err.isValid() && m_pSession) { (* m_pSession) += err; }
202 return err;
203 }
204
205 QSqlError deleteByQuery(const qx::QxSqlQuery & query)
206 {
207 QSqlError err = qx::dao::delete_by_query<T>(query, this->database());
208 if (err.isValid() && m_pSession) { (* m_pSession) += err; }
209 return err;
210 }
211
212 QSqlError destroyById(const QVariant & id)
213 {
214 IxDataMemberX * pDataMemberX = QxClass<T>::getSingleton()->getDataMemberX();
215 IxDataMember * pDataMemberId = (pDataMemberX ? pDataMemberX->getId_WithDaoStrategy() : NULL);
216 if (! pDataMemberId) { qAssert(false); return QSqlError(); }
217 std::shared_ptr<T> t = std::make_shared<T>();
218 pDataMemberId->fromVariant(t.get(), id, -1, qx::cvt::context::e_database);
219 QSqlError err = qx::dao::destroy_by_id((* t), this->database());
220 if (err.isValid() && m_pSession) { (* m_pSession) += err; }
221 return err;
222 }
223
224 template <class U>
225 QSqlError destroyById(U & u, bool bUseExecBatch = false)
226 {
227 QSqlError err = qx::dao::destroy_by_id(u, this->database(), bUseExecBatch);
228 if (err.isValid() && m_pSession) { (* m_pSession) += err; }
229 return err;
230 }
231
232 QSqlError destroyAll()
233 {
234 QSqlError err = qx::dao::destroy_all<T>(this->database());
235 if (err.isValid() && m_pSession) { (* m_pSession) += err; }
236 return err;
237 }
238
239 QSqlError destroyByQuery(const qx::QxSqlQuery & query)
240 {
241 QSqlError err = qx::dao::destroy_by_query<T>(query, this->database());
242 if (err.isValid() && m_pSession) { (* m_pSession) += err; }
243 return err;
244 }
245
246 template <class U>
248 { return qx::dao::exist(u, this->database()); }
249
250private:
251
255
256 template <bool bIsQObject /* = false */, int dummy>
258 { static inline T * get(QObject * p) { Q_UNUSED(p); throw qx::dao::sql_error(QX_REPOSITORY_QOBJECT_BASE_CLASS_ERROR); return NULL; } };
259
260 template <int dummy>
261 struct qxVerifyPointer<true, dummy>
262#ifdef _QX_NO_RTTI
263 { static inline T * get(QObject * p) { T * t = qobject_cast<T *>(p); if (! t) { throw qx::dao::sql_error(QX_REPOSITORY_POINTER_DYNAMIC_CAST_ERROR); }; return t; } };
264#else // _QX_NO_RTTI
265 { static inline T * get(QObject * p) { T * t = dynamic_cast<T *>(p); if (! t) { throw qx::dao::sql_error(QX_REPOSITORY_POINTER_DYNAMIC_CAST_ERROR); }; return t; } };
266#endif // _QX_NO_RTTI
267
268public:
269
270 virtual long _count(const qx::QxSqlQuery & query = qx::QxSqlQuery())
271 { return this->count(query); }
272
273 virtual void * _fetchById(const QVariant & id, const QStringList & columns = QStringList(), const QStringList & relation = QStringList())
274 { return static_cast<void *>(this->fetchById(id, columns, relation)); }
275
276 virtual QSqlError _fetchById(QObject * p, const QStringList & columns = QStringList(), const QStringList & relation = QStringList())
277 {
279 return this->fetchById((* t), columns, relation);
280 }
281
282 virtual QSqlError _fetchById(qx::IxCollection * p, const QStringList & columns = QStringList(), const QStringList & relation = QStringList())
283 {
285 return (x ? this->fetchById((* x), columns, relation) : this->fetchById((* y), columns, relation));
286 }
287
288 virtual QSqlError _fetchAll(QObject * p, const QStringList & columns = QStringList(), const QStringList & relation = QStringList())
289 {
291 return this->fetchAll((* t), columns, relation);
292 }
293
294 virtual QSqlError _fetchAll(qx::IxCollection * p, const QStringList & columns = QStringList(), const QStringList & relation = QStringList())
295 {
297 return (x ? this->fetchAll((* x), columns, relation) : this->fetchAll((* y), columns, relation));
298 }
299
300 virtual QSqlError _fetchByQuery(const qx::QxSqlQuery & query, QObject * p, const QStringList & columns = QStringList(), const QStringList & relation = QStringList())
301 {
303 return this->fetchByQuery(query, (* t), columns, relation);
304 }
305
306 virtual QSqlError _fetchByQuery(const qx::QxSqlQuery & query, qx::IxCollection * p, const QStringList & columns = QStringList(), const QStringList & relation = QStringList())
307 {
309 return (x ? this->fetchByQuery(query, (* x), columns, relation) : this->fetchByQuery(query, (* y), columns, relation));
310 }
311
312 virtual QSqlError _insert(QObject * p, const QStringList & relation = QStringList())
313 {
315 return this->insert((* t), relation);
316 }
317
318 virtual QSqlError _insert(qx::IxCollection * p, const QStringList & relation = QStringList())
319 {
321 return (x ? this->insert((* x), relation) : this->insert((* y), relation));
322 }
323
324 virtual QSqlError _update(QObject * p, const qx::QxSqlQuery & query = qx::QxSqlQuery(), const QStringList & columns = QStringList(), const QStringList & relation = QStringList())
325 {
327 return this->update((* t), query, columns, relation);
328 }
329
330 virtual QSqlError _update(qx::IxCollection * p, const qx::QxSqlQuery & query = qx::QxSqlQuery(), const QStringList & columns = QStringList(), const QStringList & relation = QStringList())
331 {
333 return (x ? this->update((* x), query, columns, relation) : this->update((* y), query, columns, relation));
334 }
335
336 virtual QSqlError _save(QObject * p, const QStringList & relation = QStringList())
337 {
339 return this->save((* t), relation);
340 }
341
342 virtual QSqlError _save(qx::IxCollection * p, const QStringList & relation = QStringList())
343 {
345 return (x ? this->save((* x), relation) : this->save((* y), relation));
346 }
347
348 virtual QSqlError _deleteById(const QVariant & id)
349 { return this->deleteById(id); }
350
351 virtual QSqlError _deleteById(QObject * p)
352 {
354 return this->deleteById(* t);
355 }
356
357 virtual QSqlError _deleteById(qx::IxCollection * p)
358 {
360 return (x ? this->deleteById(* x) : this->deleteById(* y));
361 }
362
363 virtual QSqlError _deleteAll()
364 { return this->deleteAll(); }
365
366 virtual QSqlError _deleteByQuery(const qx::QxSqlQuery & query)
367 { return this->deleteByQuery(query); }
368
369 virtual QSqlError _destroyById(const QVariant & id)
370 { return this->destroyById(id); }
371
372 virtual QSqlError _destroyById(QObject * p)
373 {
375 return this->destroyById(* t);
376 }
377
378 virtual QSqlError _destroyById(qx::IxCollection * p)
379 {
381 return (x ? this->destroyById(* x) : this->destroyById(* y));
382 }
383
384 virtual QSqlError _destroyAll()
385 { return this->destroyAll(); }
386
387 virtual QSqlError _destroyByQuery(const qx::QxSqlQuery & query)
388 { return this->destroyByQuery(query); }
389
390 virtual qx_bool _exist(QObject * p)
391 {
393 return this->exist(* t);
394 }
395
397 {
399 return (x ? this->exist(* x) : this->exist(* y));
400 }
401
403 {
404 qx::IxCollection_ptr lst = std::make_shared<type_collection_boost>();
405 return lst;
406 }
407
408 virtual qx::IxClass * _getClass() const
409 { return qx::QxClass<T>::getSingleton(); }
410
411public:
412
413 static T * getById(const QVariant & id, const QStringList & columns = QStringList(), const QStringList & relation = QStringList())
414 {
415 IxDataMemberX * pDataMemberX = QxClass<T>::getSingleton()->getDataMemberX();
416 IxDataMember * pDataMemberId = (pDataMemberX ? pDataMemberX->getId_WithDaoStrategy() : NULL);
417 if (! pDataMemberId) { qAssert(false); return NULL; }
418 T * t = new T(); QSqlError err;
419 pDataMemberId->fromVariant(t, id, -1, qx::cvt::context::e_database);
420 if (relation.count() == 0) { err = qx::dao::fetch_by_id((* t), NULL, columns); }
421 else { err = qx::dao::fetch_by_id_with_relation(relation, (* t), NULL); }
422 if (err.isValid()) { delete t; t = NULL; }
423 return t;
424 }
425
426};
427
428template <class T>
429inline void register_repository(const QString & sKey)
430{
431 // 'pNewRepository' instance will be destroyed by 'qx::QxRepositoryX::unregisterRepository()' method
432 qx::QxRepository<T> * pNewRepository = new qx::QxRepository<T>(sKey);
433 Q_UNUSED(pNewRepository);
434}
435
436} // namespace qx
437
438#endif // _QX_REPOSITORY_H_
Common interface for all repositories to provide access to database by introspection using QObject cl...
Concrete class registered into QxOrm context.
QxOrm thread-safe container (keep insertion order + quick access by index + quick access by key)
Provide template functions to map C++ class registered into QxOrm context with table database (ORM - ...
#define qAssert(x)
Definition QxMacro.h:52
#define QX_REPOSITORY_CAST_COLLECTION
#define QX_REPOSITORY_QOBJECT_BASE_CLASS_ERROR
#define QX_REPOSITORY_POINTER_DYNAMIC_CAST_ERROR
List of all repositories registered using qx::register_repository<T> function.
Define a session to manage automatically database transactions (using C++ RAII)
Define a SQL error exception and retrieve QSqlError type of Qt library.
qx::IxClass : common interface for all classes registered into QxOrm context
Definition IxClass.h:69
qx::IxCollection : common interface for all QxOrm containers qx::QxCollection<Key,...
qx::IxDataMember : common interface for all class properties registered into QxOrm context
virtual qx_bool fromVariant(void *pOwner, const QVariant &v, const QString &sFormat, int iIndexName=-1, qx::cvt::context::ctx_type ctx=qx::cvt::context::e_no_context)=0
qx::IxDataMemberX : common interface for a list of IxDataMember class properties registered into QxOr...
virtual IxDataMember * getId_WithDaoStrategy() const =0
qx::IxRepository : common interface for all repositories to provide access to database by introspecti...
QSqlDatabase * database()
QxSession * m_pSession
Session associated to the repository.
qx_bool : boolean type with code and description message when an error occured
Definition QxBool.h:71
qx::QxCollection<Key, Value> : QxOrm thread-safe container (keep insertion order + quick access by in...
qx::QxRepository<T> : repository to provide a common interface to communicate with database
virtual qx_bool _exist(QObject *p)
virtual QSqlError _deleteByQuery(const qx::QxSqlQuery &query)
virtual QSqlError _fetchByQuery(const qx::QxSqlQuery &query, qx::IxCollection *p, const QStringList &columns=QStringList(), const QStringList &relation=QStringList())
QxRepository(const QString &sKey)
qx::QxCollection< type_primary_key, std::shared_ptr< T > > type_collection_boost
qx_bool exist(U &u)
virtual long _count(const qx::QxSqlQuery &query=qx::QxSqlQuery())
virtual QSqlError _fetchById(QObject *p, const QStringList &columns=QStringList(), const QStringList &relation=QStringList())
virtual qx::IxClass * _getClass() const
virtual QSqlError _update(QObject *p, const qx::QxSqlQuery &query=qx::QxSqlQuery(), const QStringList &columns=QStringList(), const QStringList &relation=QStringList())
T * fetchById(const QVariant &id, const QStringList &columns=QStringList(), const QStringList &relation=QStringList())
static T * getById(const QVariant &id, const QStringList &columns=QStringList(), const QStringList &relation=QStringList())
QSqlError deleteById(const QVariant &id)
virtual QSqlError _insert(QObject *p, const QStringList &relation=QStringList())
virtual QSqlError _update(qx::IxCollection *p, const qx::QxSqlQuery &query=qx::QxSqlQuery(), const QStringList &columns=QStringList(), const QStringList &relation=QStringList())
virtual QSqlError _fetchByQuery(const qx::QxSqlQuery &query, QObject *p, const QStringList &columns=QStringList(), const QStringList &relation=QStringList())
virtual qx::IxCollection_ptr _newCollection() const
virtual QSqlError _destroyAll()
virtual QSqlError _save(QObject *p, const QStringList &relation=QStringList())
friend void register_repository(const QString &sKey)
qx::trait::get_primary_key< T >::type type_primary_key
virtual QSqlError _destroyById(const QVariant &id)
QSqlError deleteByQuery(const qx::QxSqlQuery &query)
QxRepository(QxSession *pSession)
QSqlError insert(U &u, const QStringList &relation=QStringList(), bool bUseExecBatch=false)
QSqlError destroyAll()
virtual QSqlError _deleteById(qx::IxCollection *p)
virtual void * _fetchById(const QVariant &id, const QStringList &columns=QStringList(), const QStringList &relation=QStringList())
QSqlError save(U &u, const QStringList &relation=QStringList())
QSqlError fetchByQuery(const qx::QxSqlQuery &query, U &u, const QStringList &columns=QStringList(), const QStringList &relation=QStringList())
qx::QxCollection< type_primary_key, QSharedPointer< T > > type_collection_qt
virtual QSqlError _destroyById(QObject *p)
QxRepository(const QSqlDatabase &database)
QSqlError update(U &u, const qx::QxSqlQuery &query=qx::QxSqlQuery(), const QStringList &columns=QStringList(), const QStringList &relation=QStringList(), bool bUseExecBatch=false)
QSqlError destroyById(const QVariant &id)
virtual QSqlError _fetchAll(qx::IxCollection *p, const QStringList &columns=QStringList(), const QStringList &relation=QStringList())
virtual ~QxRepository()
virtual QSqlError _insert(qx::IxCollection *p, const QStringList &relation=QStringList())
long count(const qx::QxSqlQuery &query=qx::QxSqlQuery())
virtual QSqlError _save(qx::IxCollection *p, const QStringList &relation=QStringList())
virtual QSqlError _deleteById(QObject *p)
QSqlError deleteById(U &u, bool bUseExecBatch=false)
QSqlError fetchById(U &u, const QStringList &columns=QStringList(), const QStringList &relation=QStringList())
virtual QSqlError _fetchById(qx::IxCollection *p, const QStringList &columns=QStringList(), const QStringList &relation=QStringList())
QSqlError destroyByQuery(const qx::QxSqlQuery &query)
QSqlError destroyById(U &u, bool bUseExecBatch=false)
virtual qx_bool _exist(qx::IxCollection *p)
virtual QSqlError _deleteAll()
virtual QSqlError _destroyById(qx::IxCollection *p)
QSqlError fetchAll(U &u, const QStringList &columns=QStringList(), const QStringList &relation=QStringList())
QSqlError deleteAll()
virtual QSqlError _fetchAll(QObject *p, const QStringList &columns=QStringList(), const QStringList &relation=QStringList())
virtual QSqlError _destroyByQuery(const qx::QxSqlQuery &query)
virtual QSqlError _deleteById(const QVariant &id)
qx::QxSession : define a session to manage automatically database transactions (using C++ RAII)
Definition QxSession.h:119
qx::QxSqlQuery : define a user SQL query added to default SQL query builded by QxOrm library,...
Definition QxSqlQuery.h:245
qx::dao::sql_error : define a SQL error exception and retrieve QSqlError type of Qt library
Definition QxSqlError.h:61
qx::trait::get_primary_key<T>::type : return primary key type of T, by default primary key is long ty...
QSqlError destroy_all(QSqlDatabase *pDatabase=NULL)
Destroy all lines of a table (database) mapped to a C++ class T (registered into QxOrm context),...
Definition QxDao.h:220
QSqlError save(T &t, QSqlDatabase *pDatabase=NULL)
Insert (if no exist) or update (if already exist) an element or a list of elements into database.
Definition QxDao.h:158
QSqlError fetch_by_id(T &t, QSqlDatabase *pDatabase=NULL, const QStringList &columns=QStringList())
Fetch an object t (retrieve all its properties) of type T (registered into QxOrm context) mapped to a...
Definition QxDao.h:636
QSqlError fetch_by_query_with_relation(const QString &relation, const qx::QxSqlQuery &query, T &t, QSqlDatabase *pDatabase=NULL)
Fetch a list of objects (retrieve all elements and properties associated) of type T (container regist...
Definition QxDao.h:382
QSqlError fetch_by_id_with_relation(const QString &relation, T &t, QSqlDatabase *pDatabase=NULL)
Fetch an object t (retrieve all its properties) of type T (registered into QxOrm context) mapped to a...
Definition QxDao.h:293
QSqlError delete_by_id(T &t, QSqlDatabase *pDatabase=NULL, bool bUseExecBatch=false)
Delete a line (or list of lines) of a table (database) mapped to a C++ object of type T (registered i...
Definition QxDao.h:176
qx_bool exist(T &t, QSqlDatabase *pDatabase=NULL)
Search if an element (or list of elements) already exists into database.
Definition QxDao.h:278
QSqlError save_with_relation(const QString &relation, T &t, QSqlDatabase *pDatabase=NULL)
Insert (if no exist) or update (if already exist) an element and its relationships (or a list of elem...
Definition QxDao.h:565
QSqlError insert_with_relation(const QString &relation, T &t, QSqlDatabase *pDatabase=NULL)
Insert an element and its relationships (or a list of elements + relationships) into database.
Definition QxDao.h:428
QSqlError insert(T &t, QSqlDatabase *pDatabase=NULL, bool bUseExecBatch=false)
Insert an element or a list of elements into database.
Definition QxDao.h:142
QSqlError destroy_by_query(const qx::QxSqlQuery &query, QSqlDatabase *pDatabase=NULL)
Destroy all lines of a table (database) mapped to a C++ class T (registered into QxOrm context) and f...
Definition QxDao.h:251
QSqlError delete_all(QSqlDatabase *pDatabase=NULL)
Delete all lines of a table (database) mapped to a C++ class T (registered into QxOrm context)
Definition QxDao.h:207
QSqlError update_by_query(const qx::QxSqlQuery &query, T &t, QSqlDatabase *pDatabase=NULL, const QStringList &columns=QStringList(), bool bUseExecBatch=false)
Update an element or a list of elements into database (adding a user SQL query to the default SQL que...
Definition QxDao.h:700
QSqlError fetch_by_query(const qx::QxSqlQuery &query, T &t, QSqlDatabase *pDatabase=NULL, const QStringList &columns=QStringList())
Fetch a list of objects (retrieve all elements and properties associated) of type T (container regist...
Definition QxDao.h:667
QSqlError update_by_query_with_relation(const QString &relation, const qx::QxSqlQuery &query, T &t, QSqlDatabase *pDatabase=NULL)
Update an element and its relationships (or a list of elements + relationships) into database (adding...
Definition QxDao.h:488
QSqlError fetch_all(T &t, QSqlDatabase *pDatabase=NULL, const QStringList &columns=QStringList())
Fetch a list of objects (retrieve all elements and properties associated) of type T (container regist...
Definition QxDao.h:651
QSqlError delete_by_query(const qx::QxSqlQuery &query, QSqlDatabase *pDatabase=NULL)
Delete all lines of a table (database) mapped to a C++ class T (registered into QxOrm context) and fi...
Definition QxDao.h:237
QSqlError fetch_all_with_relation(const QString &relation, T &t, QSqlDatabase *pDatabase=NULL)
Fetch a list of objects (retrieve all elements and properties associated) of type T (container regist...
Definition QxDao.h:337
long count(const qx::QxSqlQuery &query=qx::QxSqlQuery(), QSqlDatabase *pDatabase=NULL)
Return the number of lines in the table (database) mapped to the C++ class T (registered into QxOrm c...
Definition QxDao.h:98
QSqlError destroy_by_id(T &t, QSqlDatabase *pDatabase=NULL, bool bUseExecBatch=false)
Destroy a line (or list of lines) of a table (database) mapped to a C++ object of type T (registered ...
Definition QxDao.h:191
Root namespace for all QxOrm library features.
void register_repository(const QString &sKey)
std::shared_ptr< qx::IxCollection > IxCollection_ptr