Blog RIA

Bonjour à tous,

Le blog de Kap IT est ouvert à la partie « serveur ». Cette partie les développeurs Flex n’osent pas y aller, ils se disent qu’il y a des toiles d’araignées, que tout est un peu vétuste, et qu’en soulevant un tapis ils vont trouver une base de données VSAM. En fait ça, ils ne se le disent pas car ils ne savent ce que c’est (celui qui trouve ce que c’est, gagne… mon estime). Et bien il est grand temps de dépoussiérer tout ça. Tout au moins de montrer que les fondations sont solides, robustes mais aussi innovantes.

Pour bien commencer, je vais vous parler d’une des briques principales d’ORM (Object Relational Mapping) entre une base de données relationnelle et des objets Java : Hibernate 4.0.1.

La plupart des clients ou grands comptes disposent de base de données DB2. Pour ceux qui connaissent, ils savent que l’intégration avec Hibernate est tricky. Et que bien souvent on est obligé de passer par du JDBC pour écrire nous même les requêtes. C’était vrai avec Hibernate 3. Et… c’est encore vrai avec Hibernate 4, mais, mais, …, voici quelques améliorations.

L’avantage d’Hibernate 4 est que la classe DB2Dialect a été un peu réécrite. Et notamment la fonction pour la pagination, il s’agit de la méthode : org.hibernate.dialect.DB2Dialect.getLimitString(String, int, int).

Par exemple,  si je veux afficher les enregistrements de la table des utilisateurs depuis l’index 100 et avoir en retour 200 enregistrements maximum, j’écris le code suivant :

Session session = sessionFactory.getCurrentSession();
Criteria criteria = session.createCriteria(User.class);
criteria.setFirstResult(100);
criteria.setMaxResults(200);

Le paramètre FirstResult représente l’index de début et MaxResults le maximum d’enregistrement.

Hibernate 3.6 imbrique 2 requêtes. Il sélectionne d’abord l’intégralité des lignes de la table USER dans une table TEMP, et numérote chaque ligne (fonction rownumber()), puis il restreint le nombre de résultats avec la clause  where rownumber_ between 101 and 300

SELECT * FROM (
	SELECT rownumber() OVER() AS rownumber_,
		this_.ID AS ID26_0_,
		...
		FROM USER this_
		ORDER BY this_.ID ASC ) AS temp_  WHERE rownumber_ BETWEEN 101 AND 300

Si l’index de début (FirstResult) est = 0, alors il restreindra les résultats avec la clause where rownumber_ <= MaxResult

Hibernate 4 tire avantage de l’instruction DB2 fetch first x rows only. Au lieu de sélectionner la totalité des résultats de la table, il sélectionne seulement les éléments qui vont lui servir pour la clause de restriction soit : FirstResult+MaxResult premiers éléments (ici 100 + 200 = 300), en utilisant la clause fetch first 300 rows only :

SELECT * FROM (
           SELECT inner2_.*, rownumber() OVER(ORDER BY ORDER OF inner2_) AS rownumber_
           FROM (
              SELECT this_.ID AS ID26_0_,
              ...
              FROM USER this_
              ORDER BY this_.ID ASC
              fetch FIRST 300 ROWS ONLY
           ) AS inner2_
      ) AS inner1_
      WHERE rownumber_ > 100 ORDER BY rownumber_

Par ailleurs si le paramètre FirstResult est = 0, il ne crée pas de requête de numérotation et utilise directement l’instruction fetch first 200 rows only.

En terme de comparatif, sur des requêtes complexes (10aines de jointures), avec 100 enregistrements je note des gains de 350 ms par requête (soit 20% plus rapide) !

Pas mal Hibernate 4 non ? Merci Gavin King.

Bon il n’y a toujours pas moyen de rajouter simplement l’instruction WITH UR (UNCOMMITED READ). Mais on peut utiliser simplement la Transaction API de Spring .

Vous avez utilisé Hibernate 4, quels sont vos retours d’expérience ?