optimisation de traitement (requete contre mémoire)
4 réponses
f.lhermitte
Bonjour,
Voici ma petite question:
- J'ai un traitement de nuit qui récupère des informations dans une
base, les traites et les inscrient dans un fichier.
- Le traitement actuel est fait comme suit:
1) je récupère les informations grâce à une grosse requête.
2) je stock chaque lignes dans un objets (un objet par ligne)
3) je fait mais différents traitements sur ces objets et stock les
résultats dans d'autres objets.
4) je me décide enfin à écrire les objets résultats dans un fichier
texte.
- Le problème est que je constate un grand ralentissement du
traitement quand le nombre de ligne retournée par la requête est
conséquent. (ce rallentissement n'est pas proportionnel au nombre de
ligne : s'il faut 1s pour une ligne il me faut 100s pour 100lignes
mais le constat est plutôt 400s pour 100 lignes)
- bref j'arrive même parfois à dépassé la capacité mémoire
(exception).
tout ça est assez logique et s'explique.
Question:
Serait il plus rapide de faire une requête par ligne (ou groupe de
lignes liées), traiter ce groupe e ligne et écrire direcetement dans
le fichier le résultat et répété ce process autant de fois que j'ai de
groupe de ligne à traiter. bref privilégier plus d'acces à la base et
moins de stockage en mémoire?
Pour cette méthode je m'attend bien sur que le traitement sur un petit
nombre de ligne soit plus lent que le premier mais pour un trés gros
volume au moins je n'aurais pas de dépassement de capacité mémoire au
moins ça c'est sûr.
mais vais-je gagner du temps sur les gros volumes????
(dit autrement de l'accés en base peutil être plus rapide que des
traitements en mémoire saturée?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Marc Collin
wrote:
Bonjour,
Voici ma petite question:
- J'ai un traitement de nuit qui récupère des informations dans une base, les traites et les inscrient dans un fichier.
- Le traitement actuel est fait comme suit: 1) je récupère les informations grâce à une grosse requête. 2) je stock chaque lignes dans un objets (un objet par ligne) 3) je fait mais différents traitements sur ces objets et stock les résultats dans d'autres objets. 4) je me décide enfin à écrire les objets résultats dans un fichier texte.
- Le problème est que je constate un grand ralentissement du traitement quand le nombre de ligne retournée par la requête est conséquent. (ce rallentissement n'est pas proportionnel au nombre de ligne : s'il faut 1s pour une ligne il me faut 100s pour 100lignes mais le constat est plutôt 400s pour 100 lignes)
- bref j'arrive même parfois à dépassé la capacité mémoire (exception).
tout ça est assez logique et s'explique.
Question: Serait il plus rapide de faire une requête par ligne (ou groupe de lignes liées), traiter ce groupe e ligne et écrire direcetement dans le fichier le résultat et répété ce process autant de fois que j'ai de groupe de ligne à traiter. bref privilégier plus d'acces à la base et moins de stockage en mémoire?
la meilleur solution est de testé...
tu verras... peut-être que la première solution est mieux pour un nombre x de ligne et que la deuxième est mieux pour y de ligne
Pour cette méthode je m'attend bien sur que le traitement sur un petit nombre de ligne soit plus lent que le premier mais pour un trés gros volume au moins je n'aurais pas de dépassement de capacité mémoire au moins ça c'est sûr.
mais vais-je gagner du temps sur les gros volumes????
encore là teste
(dit autrement de l'accés en base peutil être plus rapide que des traitements en mémoire saturée?
merci beaucoup pour votre réponse...
-- La boîte à prog http://www.laboiteaprog.com
f.lhermitte@free.fr wrote:
Bonjour,
Voici ma petite question:
- J'ai un traitement de nuit qui récupère des informations dans une
base, les traites et les inscrient dans un fichier.
- Le traitement actuel est fait comme suit:
1) je récupère les informations grâce à une grosse requête.
2) je stock chaque lignes dans un objets (un objet par ligne)
3) je fait mais différents traitements sur ces objets et stock les
résultats dans d'autres objets.
4) je me décide enfin à écrire les objets résultats dans un fichier
texte.
- Le problème est que je constate un grand ralentissement du
traitement quand le nombre de ligne retournée par la requête est
conséquent. (ce rallentissement n'est pas proportionnel au nombre de
ligne : s'il faut 1s pour une ligne il me faut 100s pour 100lignes
mais le constat est plutôt 400s pour 100 lignes)
- bref j'arrive même parfois à dépassé la capacité mémoire
(exception).
tout ça est assez logique et s'explique.
Question:
Serait il plus rapide de faire une requête par ligne (ou groupe de
lignes liées), traiter ce groupe e ligne et écrire direcetement dans
le fichier le résultat et répété ce process autant de fois que j'ai de
groupe de ligne à traiter. bref privilégier plus d'acces à la base et
moins de stockage en mémoire?
la meilleur solution est de testé...
tu verras... peut-être que la première solution est mieux pour un nombre
x de ligne et que la deuxième est mieux pour y de ligne
Pour cette méthode je m'attend bien sur que le traitement sur un petit
nombre de ligne soit plus lent que le premier mais pour un trés gros
volume au moins je n'aurais pas de dépassement de capacité mémoire au
moins ça c'est sûr.
mais vais-je gagner du temps sur les gros volumes????
encore là teste
(dit autrement de l'accés en base peutil être plus rapide que des
traitements en mémoire saturée?
- J'ai un traitement de nuit qui récupère des informations dans une base, les traites et les inscrient dans un fichier.
- Le traitement actuel est fait comme suit: 1) je récupère les informations grâce à une grosse requête. 2) je stock chaque lignes dans un objets (un objet par ligne) 3) je fait mais différents traitements sur ces objets et stock les résultats dans d'autres objets. 4) je me décide enfin à écrire les objets résultats dans un fichier texte.
- Le problème est que je constate un grand ralentissement du traitement quand le nombre de ligne retournée par la requête est conséquent. (ce rallentissement n'est pas proportionnel au nombre de ligne : s'il faut 1s pour une ligne il me faut 100s pour 100lignes mais le constat est plutôt 400s pour 100 lignes)
- bref j'arrive même parfois à dépassé la capacité mémoire (exception).
tout ça est assez logique et s'explique.
Question: Serait il plus rapide de faire une requête par ligne (ou groupe de lignes liées), traiter ce groupe e ligne et écrire direcetement dans le fichier le résultat et répété ce process autant de fois que j'ai de groupe de ligne à traiter. bref privilégier plus d'acces à la base et moins de stockage en mémoire?
la meilleur solution est de testé...
tu verras... peut-être que la première solution est mieux pour un nombre x de ligne et que la deuxième est mieux pour y de ligne
Pour cette méthode je m'attend bien sur que le traitement sur un petit nombre de ligne soit plus lent que le premier mais pour un trés gros volume au moins je n'aurais pas de dépassement de capacité mémoire au moins ça c'est sûr.
mais vais-je gagner du temps sur les gros volumes????
encore là teste
(dit autrement de l'accés en base peutil être plus rapide que des traitements en mémoire saturée?
merci beaucoup pour votre réponse...
-- La boîte à prog http://www.laboiteaprog.com
Cédric Chabanois
Difficile à lire ce post, il y a beaucoup de fautes d'orthographe.
Il vaut mieux : - faire le moins de requêtes possibles - stocker le moins de choses possibles en mémoire.
1) je récupère les informations grâce à une grosse requête. 2) je traite un groupe de lignes 3) j'écris dans le fichier direct 4) je recommence en 2) tant que j'ai besoin
Enfin on ne voit pas ta requête et on ne sait pas exactement ce que tu veux faire, ce n'est peut-être pas possible ...
Cédric
wrote:
Bonjour,
Voici ma petite question:
- J'ai un traitement de nuit qui récupère des informations dans une base, les traites et les inscrient dans un fichier.
- Le traitement actuel est fait comme suit: 1) je récupère les informations grâce à une grosse requête. 2) je stock chaque lignes dans un objets (un objet par ligne) 3) je fait mais différents traitements sur ces objets et stock les résultats dans d'autres objets. 4) je me décide enfin à écrire les objets résultats dans un fichier texte.
- Le problème est que je constate un grand ralentissement du traitement quand le nombre de ligne retournée par la requête est conséquent. (ce rallentissement n'est pas proportionnel au nombre de ligne : s'il faut 1s pour une ligne il me faut 100s pour 100lignes mais le constat est plutôt 400s pour 100 lignes)
- bref j'arrive même parfois à dépassé la capacité mémoire (exception).
tout ça est assez logique et s'explique.
Question: Serait il plus rapide de faire une requête par ligne (ou groupe de lignes liées), traiter ce groupe e ligne et écrire direcetement dans le fichier le résultat et répété ce process autant de fois que j'ai de groupe de ligne à traiter. bref privilégier plus d'acces à la base et moins de stockage en mémoire?
la meilleur solution est de testé...
tu verras... peut-être que la première solution est mieux pour un nombre x de ligne et que la deuxième est mieux pour y de ligne
Pour cette méthode je m'attend bien sur que le traitement sur un petit nombre de ligne soit plus lent que le premier mais pour un trés gros volume au moins je n'aurais pas de dépassement de capacité mémoire au moins ça c'est sûr.
mais vais-je gagner du temps sur les gros volumes????
encore là teste
(dit autrement de l'accés en base peutil être plus rapide que des traitements en mémoire saturée?
merci beaucoup pour votre réponse...
Difficile à lire ce post, il y a beaucoup de fautes d'orthographe.
Il vaut mieux :
- faire le moins de requêtes possibles
- stocker le moins de choses possibles en mémoire.
1) je récupère les informations grâce à une grosse requête.
2) je traite un groupe de lignes
3) j'écris dans le fichier direct
4) je recommence en 2) tant que j'ai besoin
Enfin on ne voit pas ta requête et on ne sait pas exactement ce que tu
veux faire, ce n'est peut-être pas possible ...
Cédric
f.lhermitte@free.fr wrote:
Bonjour,
Voici ma petite question:
- J'ai un traitement de nuit qui récupère des informations dans une
base, les traites et les inscrient dans un fichier.
- Le traitement actuel est fait comme suit:
1) je récupère les informations grâce à une grosse requête.
2) je stock chaque lignes dans un objets (un objet par ligne)
3) je fait mais différents traitements sur ces objets et stock les
résultats dans d'autres objets.
4) je me décide enfin à écrire les objets résultats dans un fichier
texte.
- Le problème est que je constate un grand ralentissement du
traitement quand le nombre de ligne retournée par la requête est
conséquent. (ce rallentissement n'est pas proportionnel au nombre de
ligne : s'il faut 1s pour une ligne il me faut 100s pour 100lignes
mais le constat est plutôt 400s pour 100 lignes)
- bref j'arrive même parfois à dépassé la capacité mémoire
(exception).
tout ça est assez logique et s'explique.
Question: Serait il plus rapide de faire une requête par ligne (ou
groupe de
lignes liées), traiter ce groupe e ligne et écrire direcetement dans
le fichier le résultat et répété ce process autant de fois que j'ai de
groupe de ligne à traiter. bref privilégier plus d'acces à la base et
moins de stockage en mémoire?
la meilleur solution est de testé...
tu verras... peut-être que la première solution est mieux pour un nombre
x de ligne et que la deuxième est mieux pour y de ligne
Pour cette méthode je m'attend bien sur que le traitement sur un petit
nombre de ligne soit plus lent que le premier mais pour un trés gros
volume au moins je n'aurais pas de dépassement de capacité mémoire au
moins ça c'est sûr.
mais vais-je gagner du temps sur les gros volumes????
encore là teste
(dit autrement de l'accés en base peutil être plus rapide que des
traitements en mémoire saturée?
Difficile à lire ce post, il y a beaucoup de fautes d'orthographe.
Il vaut mieux : - faire le moins de requêtes possibles - stocker le moins de choses possibles en mémoire.
1) je récupère les informations grâce à une grosse requête. 2) je traite un groupe de lignes 3) j'écris dans le fichier direct 4) je recommence en 2) tant que j'ai besoin
Enfin on ne voit pas ta requête et on ne sait pas exactement ce que tu veux faire, ce n'est peut-être pas possible ...
Cédric
wrote:
Bonjour,
Voici ma petite question:
- J'ai un traitement de nuit qui récupère des informations dans une base, les traites et les inscrient dans un fichier.
- Le traitement actuel est fait comme suit: 1) je récupère les informations grâce à une grosse requête. 2) je stock chaque lignes dans un objets (un objet par ligne) 3) je fait mais différents traitements sur ces objets et stock les résultats dans d'autres objets. 4) je me décide enfin à écrire les objets résultats dans un fichier texte.
- Le problème est que je constate un grand ralentissement du traitement quand le nombre de ligne retournée par la requête est conséquent. (ce rallentissement n'est pas proportionnel au nombre de ligne : s'il faut 1s pour une ligne il me faut 100s pour 100lignes mais le constat est plutôt 400s pour 100 lignes)
- bref j'arrive même parfois à dépassé la capacité mémoire (exception).
tout ça est assez logique et s'explique.
Question: Serait il plus rapide de faire une requête par ligne (ou groupe de lignes liées), traiter ce groupe e ligne et écrire direcetement dans le fichier le résultat et répété ce process autant de fois que j'ai de groupe de ligne à traiter. bref privilégier plus d'acces à la base et moins de stockage en mémoire?
la meilleur solution est de testé...
tu verras... peut-être que la première solution est mieux pour un nombre x de ligne et que la deuxième est mieux pour y de ligne
Pour cette méthode je m'attend bien sur que le traitement sur un petit nombre de ligne soit plus lent que le premier mais pour un trés gros volume au moins je n'aurais pas de dépassement de capacité mémoire au moins ça c'est sûr.
mais vais-je gagner du temps sur les gros volumes????
encore là teste
(dit autrement de l'accés en base peutil être plus rapide que des traitements en mémoire saturée?
merci beaucoup pour votre réponse...
f.lhermitte
Désolé pour les fautes d'orthographe (je n'ai pas relu le document avant de le poster).
Merci pour vos réponses.
Le mix entre requêtes et mémoire me semble évident maintenant. Mais pendant tout le traitement (grosse requête + traitement par groupe) le resultset reste ouvert?
Mais la piste est interressante, je vais faire un test de traitement par paquet (X lignes), traiter le paquet, récupérer le paquet suivant le traiter... avec X lignes en paramètre dans un properties et faire varier X pour trouver le X optimum.
Merci beaucoup fl
Désolé pour les fautes d'orthographe (je n'ai pas relu le document
avant de le poster).
Merci pour vos réponses.
Le mix entre requêtes et mémoire me semble évident maintenant. Mais
pendant tout le traitement (grosse requête + traitement par groupe) le
resultset reste ouvert?
Mais la piste est interressante, je vais faire un test de traitement
par paquet (X lignes), traiter le paquet, récupérer le paquet suivant
le traiter... avec X lignes en paramètre dans un properties et faire
varier X pour trouver le X optimum.
Désolé pour les fautes d'orthographe (je n'ai pas relu le document avant de le poster).
Merci pour vos réponses.
Le mix entre requêtes et mémoire me semble évident maintenant. Mais pendant tout le traitement (grosse requête + traitement par groupe) le resultset reste ouvert?
Mais la piste est interressante, je vais faire un test de traitement par paquet (X lignes), traiter le paquet, récupérer le paquet suivant le traiter... avec X lignes en paramètre dans un properties et faire varier X pour trouver le X optimum.
Merci beaucoup fl
Cédric Chabanois
Le mix entre requêtes et mémoire me semble évident maintenant. Mais pendant tout le traitement (grosse requête + traitement par groupe) le resultset reste ouvert?
Oui. En quoi est-ce génant ? Tu bloques une connection mais je ne pense pas que ce soit très pénalisant d'autant que çà ne doit pas durer des heures quand même. Enfin c'est à voir quand même, tu as raison.
Cédric
Le mix entre requêtes et mémoire me semble évident maintenant. Mais
pendant tout le traitement (grosse requête + traitement par groupe) le
resultset reste ouvert?
Oui. En quoi est-ce génant ?
Tu bloques une connection mais je ne pense pas que ce soit très
pénalisant d'autant que çà ne doit pas durer des heures quand même.
Enfin c'est à voir quand même, tu as raison.
Le mix entre requêtes et mémoire me semble évident maintenant. Mais pendant tout le traitement (grosse requête + traitement par groupe) le resultset reste ouvert?
Oui. En quoi est-ce génant ? Tu bloques une connection mais je ne pense pas que ce soit très pénalisant d'autant que çà ne doit pas durer des heures quand même. Enfin c'est à voir quand même, tu as raison.
