Optimisation Update sur SQL SERVER 2000

Bonjour,

Je travaille actuellement sur SQL SERVER 2000 et j'ai un petit souci concernant une automatisation d'Update.

Voilà le topo :

J'ai une table T1 dans laquelle j'ai un champ C, et une autre table T2 dans laquelle j'ai un champ A et B.

T1 contient 700 000 lignes , T2 100 lignes.

Le but est de remplir TOUS les champs C de T1 dans l'ordre qu'ils se presentent avec les champs A de la table T2.

Le champ B de T2 indique le nombre d'éléments A qu'il faut placer dans les champs C de T1.

Donc dans T2 on a un truc du style
A B
01 2000
02 4000
03 1500

ce qui signifie qu'il faut placer dans le champ C de T1 l'élément 01 sur les 2000premières lignes, puis l'element 02 sur les 4000 lignes suivantes etc...

Mon problème est que je n'ai pas trouve de solutions satisfaisantes pour executer ce traitement, comme le traitement est finalement tres iteratif j'ai utilise des cursors avec update dans une procedure stockée mais cela prend vraiment trop de temps a l'execution. Idem dans une procedure VB.

Et je n'ai pas reussi a encapsuler le traitement dans des requetes SQL, car le SQL se prete peu à ce genre de traitement iteratif, là il s'agit de "poser" des données ligne à ligne jusqu'à la fin.

En plus sur sql server 2000 il n'y a pas de fonction qui renvoie le numero de ligne d'une table, c'est bien dommage car là j'aurais pu updater les 2000 premieres lignes d'un coup puis les 4000 suivantes etc... etc...

Bref... je me demande s'il y a moyen de faire ce genre de traitement sans qu'il prenne 2 heures à l'execution.

Merci par avance.

Bonjour,

Tu devrais poster ton code, il sert de base et peut permettre de comprendre d'où vient la longueur d'exécution ;)

Je pense que ça doit ressembler à quelque chose comme:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

DECLARE @VAL VARCHAR(2); DECLARE @NB VARCHAR(5);   DECLARE CUR CURSOR FOR SELECT A, B FROM T2   OPEN CUR FETCH NEXT FROM CUR INTO @VAL, @NB   WHILE @@FETCH_STATUS = 0 BEGIN DECLARE @I INT; SET @I = 1; WHILE @I <= @NB BEGIN INSERT T1 VALUES (@VAL); END FETCH NEXT FROM CUR INTO @VAL, @NB END

---

Mais je ne comprends pas l'intérêt de faire autant d'insertions dans une table. Quel en est le but ?

A+ ;)

Voici un des codes que j'ai utilisé :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

CREATE PROCEDURE ConnMarche.PT_DispatchDep AS   DECLARE @Nb as integer DECLARE @Dep as varchar(3) DECLARE @Immat as integer DECLARE @compteur as integer   DECLARE CurseurImmat CURSOR FOR SELECT Cle_Dept FROM ImmatDep   DECLARE CurseurDept CURSOR FOR SELECT Departement,Nb FROM Departement   BEGIN   Open CurseurImmat Open CurseurDept   FETCH CurseurImmat FETCH CurseurDept into @Dep,@Nb   WHILE @@Fetch_Status = 0 BEGIN set @compteur = @Nb While @compteur > 0 BEGIN   UPDATE ImmatDep SET Cle_Dept = @Dep WHERE CURRENT OF CurseurImmat   set @compteur = @compteur - 1   FETCH CurseurImmat END   FETCH CurseurDept into @Dep,@Nb END   END GO

---

La table ImmatDep est ma table T1 et la table Departement est la table T2

ImmatDep contient DEJA 700 000 lignes d'immatriculations, et la table Departement contient les departements et le nombre d'immat ex : 01 - 2000, 02 - 1500 ETC...

Le but est de remplir le champ departement (qui est NULL a la base) de toutes les lignes de la table ImmatDep avec les departements de la table Departement en respectant le nombre d'immat et le tout de façon ALEATOIRE.

Ma tactique jusqua present :
1) Creer une nouvelle table qui est le resultat d'un melange de mes 700 000 lignes de ma table ImmatDep grace a une requete de tri aleatoire.
2) Deposer mes departements ligne à ligne dans cette nouvelle table en respectant le nombre d'immat de chaque departement (c'est le but de la procedure stockee au dessus)

Pb: La duree d'execution est bcp trop longue et je vois pas trop d'autres solutions pour dispatcher mes departements de facon aleatoire sur ma table de 700 000 immatriculations.

faites cela en une requête en utilisant comme ordre aléatoire les valeurs générées par la fonction NEWID()

A +