Requetes nombreuses a effectuer-> tps d'execution trop long

Bonjour,

Voila à l'intérieur d'un programme j'effectue des requetes vers SQL Server Express.
des INSERT UPDATE etc... rien de trop méchant en somme.
J'ai pourtant un soucis avec une fonction d'UPDATE sur une table qui est défini ainsi:

champ1| champ2| champ3| champ4| champ5| champ6

alors je dois faire un update des 2 champs 1&2 en fonction des champs 3,4,5et 6...
ce qui donne ceci dans mon prog :

 for ( i_fur=0; i_fur<NB_FUR; i_fur++)
 {
      // For top and bottom
      for ( i_top=0; i_top<s_furndata[i_fur].top_bot; i_top++)
      {
         // For all thermal profils
         for ( i_thprf=0; i_thprf<s_furndata[i_fur].nb_thprf; i_thprf++)
         {
            // For all points of thermal profil
            for ( i_prf=0; i_prf<N_PROFIL; i_prf++)
            {
               strcpy(strExec, "UPDATE MaTableSET ");
               sprintf(temp," champ1= %f", Val1 );
               strcat(strExec,temp);
               strcat(strExec, ",");
               sprintf(temp," champ2 = %f",Val2);
               strcat(strExec,temp);
               sprintf(temp," WHERE champ3 = %d",i_fur);
               strcat(strExec,temp);
               sprintf(temp," AND champ4 = %d",i_top);
               strcat(strExec,temp);
               sprintf(temp," AND champ5 = %d",i_thprf);
               strcat(strExec,temp);
               sprintf(temp," AND champ6 = %d",i_prf);
               strcat(strExec,temp);

               try
               {
                  // Insere des éléments
                  // ===================
                  HRESULT retour = recordset->Open(strExec,
                     connection.GetInterfacePtr(), adOpenForwardOnly,
                     adLockReadOnly, adCmdText);
               }
               catch(_com_error &e)
               {
                  MessageBox(0, (LPCSTR) e.Description(), 0, 0);
                  status = false;
               }
            }// For all points of thermal profil
         }// For all thermal profils
      } // For top and bottom
   } // for all furnaces

Alors le probleme est donc sur les boucles qui vont pour les 3 premieres varier entre 1 et 2 max. mais pr la derniere
N_PROFIL = 1000
on se retrouve avec dans mon cas 4000 updates a faire ce qui prend 20secondes ....
et du coup mon programme prend une sacré claque dans la gueule quand il passe a cet endroit!
je voudrais savoir si il existe une solution pour faire ces updates plus rapidement: changer la requete SQL par exemple sur les conditions pour qu'elles
affectent plus d'enregistrements dans une meme requete
ou carrément si quelqu'un a une idée pour redimensionner ma table (la reconstituer d'une autre maniére)
peut etre que la solution est la ...

j'espere que mon POST sera assez explicite, et merci de votre aide future ....

bon je vais tenter d'etre plus clair

j'ai 1000pts a écrire j'écris les coordonnées x et y ( = champ 1 et 2)
chacun de ces points dépend d'autres variables et doit etre unique

donc j'aurais mille pts pr 0,0,0,pt1
                                        0,0,0,pt2
                                        0,0,0,pt3
.                                        .....
                                        0,0,0,pt1000

puis                                 0,0,1,pt1
                                        0,0,1,pt2
                                        0,0,1,pt3
                                            ......
                                        0,0,1,pt1000

puis                                 0,1,1,pt1
                                        0,1,1,pt2
                                        0,1,1,pt3
                                        ......
                                        0,1,1,pt1000

puis                                 1,1,1,pt1
                                        1,1,1,pt2
                                        1,1,1,pt3
                                        ......
                                        1,1,1,pt1000

etc...
ce qui me donne dans mon cas 4000 requetes et 20sec pr ttes les faire....bof bof :(

 

Essaye de lock ta table, ensuite tu passes toute tes requetes, enfin tu fait un commit.
Ca sera surement plus rapide, et tu pourras faire un rollback au cas ou.

Shell

salut, lol
excuse moi mais dans ta réponse je n'ai rien compris (mode boulet j'avoue)
lock ? (pour moi c'est un gars de LOST)
commit? (avec son pote Wallace? Wallace et ...)
rollback?  ( heu.... pas de blague la ...)

 

Jette un oeil sur google pour les définitions de ces termes, tu trouveras surement des exemples à l'appui.
Pour faire simple, le SQL permet d'envoyer des requetes mais de ne pas les appliquer jusqu'à ce qu'un COMMIT soit effectué.

En gros:
- tu vérouilles ta table pour éviter els accès concurenciels (LOCK)
- tu envoies toute tes requetes (a ce stade elle ne sont pas encore appliqué sur la table mais stockées)
- finallement valide l'envoie de toute tes requetes et celle ci vont toutes s'executer d'une traite (COMMIT)

Le ROLLBACK permet de revenir en arrière et d'annuler les changements au cas ou, étant donné que seule le COMMIT va pouvoir définitivement valider tes données insérées par les requetes successives.

Shell