Frameworks : optimisation de chargement de données

[Ter Rowan]

Bonjour

Après quelques difficultés apparues hier (erf) sur mes devs, je me suis demandé comment les différents frameworks (et peu importe le langage derrière) géraient les chargements de données complémentaires
- bon je crois que ça ne veut rien dire, je vais illustrer pour clarifier ^^ -

Prenons un cas simplifié sur les personnages.
Les personnages ont des compétences.

j'ai de fait deux tables qui concernent les personnages :

la table personnage ( id perso / nom / prénom / ...)
la table perso_comp ( id perso / id comp / valeur )

maintenant je n'ai besoin de connaitre les compétences d'un personnage que pour traiter la résolution d'action et pour afficher la fiche de personnage.

Dans les autres cas, comme afficher une carte avec les différents personnages présents, je n'ai pas besoin de ces informations de compétence

maintenant dans le cadre de la résolution d'action, on peut avoir à "monter en mémoire" plusieurs personnages (tous les participants)

de fait, si j'ai besoin des compétences d'un personnage, je sais d'avance que je vais avoir besoin des compétences de tous les personnages en mémoire (si il y a une action, tous les participants font un test sur leur compétences)

ça c'est la problématique que j'espère claire ^^

maintenant la question associée : comment traiter ceci ?

n'utilisant pas de FW je suis passé par deux états :

1) je charge les données d'un personnage la première fois qu'un script demande les valeurs du personnage.

Conclusion si 10 personnages en mémoire, je fais 10 fois (pour chaque personnage) select * from perso_comp where id perso = $id perso

2) je charge les données de tous les personnages en mémoire la première fois qu'un script demande les valeurs d'un personnage en mémoire

Conclusion si 10 personnages en mémoire, je fais 1 fois select * from perso_comp where id perso in ($i1, $i2, .... $i10)

aujourd'hui j'en suis à l'état 2 et ça marche pas trop mal (bon jusqu'au refactoring d'hier soir qui m'a mis un petit trouble alors que ça marchait depuis 6 mois)

Certains me diront que cette "optimisation" (quoique je n'en ai pas la preuve, ce n'est que théorique 1 requête meilleure que n )n'est pas forcément utile, et c'est possible mais je crains qu'une fois toutes les informations collectées (compétence, caractéristique, stratégie etc...) je me retrouve avec 60 requêtes au lieu de 6


donc voilo, j'aurais bien aimé savoir comment fonctionnait les FW sur ce sujet (ou comment vous, vous l'auriez résolu) parce que ça doit arriver assez souvent

[srm]

Et bien il y a un peu de tout.

Par exemple en eager loading si tu fais une jointure entre les deux tables, il va effectuer la jointure et rapatrier 100% des enregistrements.

En lazy loading si tu fais la jointure entre les deux tables il ne va récupérer les données de la jointure que lorsque tu en as besoin, donc avec autant de select perso_comp que nécessaire.

Où encore des lazy loading intelligent comme le fait par exemple DataMapper, ou il va voir ce dont tu as besoin et faire un select comp id_perso in (bla bla blabla)

Et donc à toi de voir ce que tu utilises selon le contexte

[Ter Rowan]

merci oxman,

j'ai commencé à regarder ces notions mais je n'ai pas trouvé grand chose de poussé via google (bon je n'ai pas cliqué sur tous les liens non plus, je ne suis peut être pas tombé sur les bons)

par contre j'ai trouvé assez "abusé" le nombre de lignes de paramétrage pour JBoss (un des liens sur lequel j'ai cliqué)

c'est beaucoup plus volumineux que ce que je fais comme paramétrage (bon je suis sûr d'avoir bcp moins de possibilité, mais quand même)

Sinon pas d'autres expériences (zend, cakephp, ror, etc...) ?

[srm]

Pour DataMapper je t'invite à lire http://datamapper.org/why qui explique en gros tout leur système de lazy/eager qui est top je trouve.

Concernant Hibernate/Java/PlayFramework/Scala je ne m'y suis encore jamais intéressé, je te fais un retour quand ça sera le cas

[Sephi-Chan]

Dans Rails, le comportement par défaut est de faire du lazy loading et tu peux forcer le eager loading :

# Je charge l'article avec ses commentaires.

@article = Article.find(params[:id]).includes(:comments)



# Mais tu peux faire un truc plus poilu :

# Ici je charge l'article, son auteur, ainsi que les commentaires de l'article et leur auteur, ainsi que

# les utilisateurs qui aiment le commentaires (en supposant qu'on puisse dire "J'aime ce commentaire").

@article = Article.find(params[:id]).includes([ :author, { :comments => { :author, :likers } } ])

Guides Ruby on Rails — Active Record Query Interface : Eager Loading Associations

Tu peux voir ça en action sur mon draft Spherium, je montre des exemples pour afficher la carte (à 50% de la page environ).

Je vais éditer pour te montrer quelques exemples de requêtes que ça donne (certaines sont vraiment flippantes).