Beta-test de la prochaine version : QxOrm 1.2.1

Version imprimable

07/10/2011, 19h01
QxOrm

Beta-test de la prochaine version : QxOrm 1.2.1
Bonjour à tous,

Je vous propose de beta-tester la prochaine version de QxOrm (nommée 1.2.1) :
http://www.qxorm.com/version/QxOrm_1.2.1_BETA_09.zip

Au programme de cette future version et déjà implémenté dans cette beta :
- amélioration de la classe qx::QxSqlQuery : nouveau moteur pour générer des requêtes sans écrire de SQL à partir de la classe qx::QxSqlQuery (inspiré de l'excellent Subsonic pour .Net, par exemple : query.where("my_column").isEqualTo(3).and_("my_column2").isGreaterThan(4) ===> le gros intérêt est de ne plus avoir à binder ses paramètres et la syntaxe est très proche du SQL) ;
- amélioration de la classe qx::QxSession : toutes les opérations de persistance (CRUD) peuvent être appelées plus facilement depuis une session, comme par exemple : session.fetchById<MonType>(3) pour récupérer une instance de MonType ayant pour identifiant 3 dans la base de données ;
- implémentation du pattern Repository avec les 3 classes suivantes : qx::IxRepository, qx::QxRepository<T>, et qx::QxRepositoryX ;
- nouvelle fonction void * qx::create_void_ptr(...) (cf. problématique de dodobibi sur ce thread), qui permet de passer par le type void * pour utiliser le moteur d'instrospection et valoriser les propriétés.
Voilà, il n'y a aucune doc encore ni de test unitaire mais ça compile correctement (donc ça marche :D ).

Concernant la classe qx::QxRepositoryX, j'ai mis une option de compilation (_QX_AUTO_REGISTER_REPOSITORY) pour remplir la collection automatiquement. Je pense que par défaut, ce ne sera pas activé car ça répond quand même à une problématique bien particulière. Même sans l'option de compilation, il est possible de remplir la collection en utilisant qx::register_repository<T>(sKey).

Merci d'avance à tous ceux qui pourront tester cette version, faire des critiques et demandes d'évolution, etc.
12/10/2011, 20h41
QxOrm

Nouvelle version BETA disponible au téléchargement (QxOrm_1.2.1_BETA_14) :
http://www.qxorm.com/version/QxOrm_1.2.1_BETA_14.zip

La pattern repository a évolué pour pouvoir faire une vérification du type à l'exécution du programme (ça ne fonctionnait pas avec void *, et boost::any n'était pas satisfaisant). Pour utiliser l'interface qx::IxRepository, il faut soit passer par un type QObject * ou bien qx::IxCollection *.
Par contre, il n'y a aucune contrainte avec l'utilisation de qx::QxRepository<T>.

Sinon, j'ai ajouté la méthode qx::QxSqlQuery::distinct() pour faire un SELECT DISTINCT dans une requête SQL.
Je pense qu'à présent, la classe qx::QxSqlQuery doit gérer la plupart des expressions SQL.

La méthode qx::QxSqlQuery::limit() permettant de limiter le nombre d'éléments d'une requête SQL devrait fonctionner avec les bases suivantes :
SQLite, PostgreSQL, MySQL, Oracle et SQLServer.

Enfin, il est à présent possible de sérialiser un QVariant contenant un type non gérer par défaut par la bibliothèque Qt (cf. fichier QxSerialize_QVariant.cpp, case default...).

Merci à tous ceux qui pourront tester cette version ;)

:salut:

J'ai une question sur l'utilisation des qx::dao::ptr avec les repository

avec le code suivant :
Code:

1 2 3 m_commune = commune_ptr(new domain::Collectivites::Commune); m_commune->setCommune(Commune); qx::dao::fetch_by_id(m_commune);
l'objet est bien instancié et cloné dans pOriginal.

avec le code suivant :

Code:

m_commune = commune_ptr(m_repo.getById(Commune));

pOriginal est NULL. C'est normal vu que le repository renvoie un pointeur simple et non un qx::dao::ptr.

pour cloner l'objet dans pOriginal et ainsi bénéficier de toutes les fonctions de qx::dao::ptr (isDirty, etc...), j'utilise la fonction suivante :

Code:

m_commune.resetOriginal(qx::clone_to_qt_shared_ptr(*m_commune));

Cela fonctionne, mais je me demande s'il ne serait pas intéressant d'intégrer une fonction à qx::dao::ptr pour sauvegarder dans pOriginal, et restaurer depuis pOriginal, sans avoir a appeler qx::clone_to_qt_shared_ptr.
QxDaoPointer.h :
Code:

1 2 inline void saveToOriginal() { m_pOriginal.clear(); resetOriginal(qx::clone_to_qt_shared_ptr(* m_pWork)); } inline void restoreFromOriginal() { m_pWork.clear(); reset(qx::clone_to_qt_shared_ptr(* m_pOriginal)); };
ainsi, mon code devient :
Code:

1 2 3 m_commune = commune_ptr(m_repo.getById(Commune)); m_commune.saveToOriginal(); ......

27/10/2011, 10h34
QxOrm

Citation:

je me demande s'il ne serait pas intéssant d'intégrer une fonction à qx::dao::ptr pour sauvegarder dans pOriginal

En effet, ton code va fonctionner correctement en utilisant qx::clone_to_qt_shared_ptr, mais c'est vrai que l'idée d'ajouter les 2 méthodes saveToOriginal() et restoreFromOriginal() peut simplifier l'écriture du code (peut-être ajouter un nouveau constructeur pour faire ça également).

Ça sera fait dans la prochaine version, mais pas la 1.2.1 car j'ai finalisé la version.
Je peaufine un peu la documentation mais le code source de la bibliothèque ne bougera plus en 1.2.1 (sauf bugs bloquants) => je passe donc ce post en résolu.
Ce sera donc pour la 1.2.2... Merci pour tes tests ;)
27/10/2011, 12h06
dodobibi
Merci pour ta réponse.

Concernant l'implémentation des Repositories, je me pose une question :

A l'instar de

Code:

QSqlError QxRepository<T>::fetchAll(...)

où l'on passe le container de T par référence (qui peut être QxCollection<...,T>), pourquoi avoir implémenté

Code:

T* QxRepository<T>::fetchById(id)

et non

Code:

QSqlError QxRepository<T>::fetchById(..., id)

ainsi, en fonction du type passé en paramètre (qx::dao::ptr<T> ou QSharedPointer<T> ou T*), le repository permettrait de faire le backup vers pOriginal (comme le fait qx::dao::fetchById) dans le cas où l'on passe un qx::dao::ptr<T>, ainsi que de récupérer un QSqlError.

ex :
Code:

1 2 3 4 m_commune = new commune_ptr(); QSqlError err = m_repo.getById(m_commune, "Commune"); // m_commune étant un qx::dao::ptr<Commune>, pWork est cloné dans pOrignal... ......
Désolé si je suis pas très clair (je ne suis pas sur mon poste de dev et n'ai pas la code source de QxOrm sous les yeux)

Ça existe déjà dans l'implémentation de qx::QxRepository<T>, tu as les méthodes suivantes :
Code:

1 2 3 4 5 6 T * fetchById(const QVariant & id, const QStringList & columns = QStringList(), const QStringList & relation = QStringList()); template <class U> QSqlError fetchById(U & u, const QStringList & columns = QStringList(), const QStringList & relation = QStringList()); static T * getById(const QVariant & id, const QStringList & columns = QStringList(), const QStringList & relation = QStringList());
getById() est static => tu peux donc l'utiliser sans instancier un repository (c'est la seule pour le moment dans ce cas).

Sinon, toutes les fonctions que tu as dans le namespace qx::dao ont leur équivalent dans qx::QxRepository<T>.
Tu peux donc sans problème utiliser qx::dao::ptr<T> et avoir le même comportement (à savoir sauvegarder automatiquement pOriginal) avec les repository (cf. la 2ème méthode).