Pour de grosses extraction de données complexes sur une BD
 
Etes-vous plutot du genre : "Je genere dynamiquement ma MEGA requete SQL et je l'execute pour traiter les resultats, vive les left join, union, count, group by, etc ..."
 
Ou : "Je prefere faire plein de petites requetes très simple pour construire mes objets et ainsi de retrouver par moi même les resultats"
 
et quel est selon vous la plus rapide en terme d'execution ?

Perso, je pense que l plus rapide en execution sera certainement la première solution car pour obtenir un meme resultat, tu sera d'une façon ou d'une autre ammenée a faire les memes opérations, de plus avec la seconde solution, a chaque requette, tu prend du temps pour connect, deconnect, transfert de data,...

Je suggere la deuxieme solution en utilisant des PreparedStatement enfin je pense aussi que ca depend du temps que ta base aura à traiter cette requete.

 
Mais en utilisant un pool de connexions, ça reduit deja enormement les temps de connexions.
 
Je sais que ça peut paraitre bete la question qui suit mais en terme de calcul complexe et elevé, une BD est plus rapide que la JVM ?

 
Ca depend les temps pour connect/deconnect peuvent etre paliées via un un pool de connexion en base et l'objet preparedstatement prepare la connexion avant meme l'envoi de la requete ce qui te permet de gagner du temps a l'execution et surtt de pouvoir rejouer la requete autant de fois que necessaire ...

lol mazda m'a devancé

Pourquoi ne pas tester sur 100 puis 1000 lignes.
Tu feras vite la différence.
 
Mais même chose que Savory, la deuxieme solution est mieux, surtout si la base doit rester accessible et performante.
Là au moins les calculs seront sur la machine où le prog java tourne.

Pour moi il est mega évident que ta première solution sera la meilleure. Tout les bases de données sont optimisé au maximum pour traiter le SQL.  
Faire un premier SELECT en java puis récuperer le resultat que tu stockeras en memoire, traiteras puis tu enchaineras d'autres requete en fonction des résultats précedents et de d'autres parametres sera très vraisemblablement moins rapide qu'une bonne grosse vielle requete SQL.
Les bases de données comme Oracle utilisent des plan d'execution permettant de manière implicite d'optimiser la requete SQL.
Cela ne te soustrait pas d'utiliser en plus un pool de connexion et un preparedStatement pour ta/tes requetes.  
Attention tout de même à ta méga requete à bien faire des jointures sur des clefs des index etc ...

Cela n'a pas vraiment de sens de comparer la vitesse de la BD et de la JVM mais pour exemple :
Select a,b,c from ta_table where condtions
puis traitement en java du résultat puis  
Select a,b,c from ta_table where d_autres_condtions
puis traitement et concaténation en java du résultat sera moins rapide
que  
Select a,b,c from ta_table where condtions
UNION
Select a,b,c from ta_table where d_autres_condtions
puis traitement en java.
 
Evidemment un preparedStatement reduira l'ecart entre les 2 mais le 1er cas sera toujours plus rapide.
 
Il existe tout de même des exceptions lié à la cardinalité des tables si la requete est horrible en terme de complexité
ex : select a.a1, b.b1 from a,b
Dans ce cas mieux vaut  
select a1 from a
suivi de  
select b1 from b

je choisirait plutôt ma 1° soluce, par expérience :
j'ai une requête un peu maousse a faire, et je suis obligé de passer par des petites requêtes de rien (bicause join impossible entre clusters DB2), et du coup, je génère la bagatelle de 1300 requêtes (ce qui est bien mais pas top), et du coup, 7 minutes de traitement, BAD !
Alors qu'une big requête serai traitée bien plus rapidement par le serveur SQL, c'est son taf.
 
m'enfin ça n'est que mon avis.