Discussion :

[cryosore]

Bonjour

J'ai une table ressemblant à peu de chose prés à ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
IdProjet                         IdDette                     TypeProjet    
---------                  --------------               --------------
1                                     1                                 1
1                                     2                                 3
1                                     3                                 1
1                                     4                                 11
1                                     5                                 13
1                                     6                                 3

Je recherche à un moyen de concatener toutes les id par type de projet et par IdProjet

Au final je souhaite à terme réaliser ceci comme résultat final

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
IdProjet                         IdDette                     TypeProjet    
---------                  --------------               --------------
1                                     1 , 3                             1
1                                     2 , 6                             3
1                                     4                                 11
1                                     5                                 13

Sachant que je ne souhaite que pour 1 id et qu'il y'a maximum 13 type de projet.

J'ai actuellement ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
BEGIN
	SET NOCOUNT ON;
 
	DECLARE @ID_PROJET INT
	SET @ID_PROJET = 1
	DECLARE @COMPTEUR INTEGER
	SET @COMPTEUR = 0
	DECLARE @LIMITE INTEGER
	SET @LIMITE = 13
	DECLARE @VALEUR INTEGER
	DECLARE @PASSAGE INTEGER
 
	WHILE (@COMPTEUR <= @LIMITE)
		BEGIN
			SELECT @VALEUR = count(fd.Type)
				from dbo.FinancementDette as fd 
				where fd.IdProjet = @ID_PROJET
				and fd.Type = @COMPTEUR
 
			IF (@VALEUR > 0)
 
					SELECT fd.Id, fd.Type
					from dbo.FinancementDette as fd 
					where fd.IdProjet = @ID_PROJET
					and fd.Type = @COMPTEUR 
 
			SET @COMPTEUR = @COMPTEUR+1	
		END
END

Cette procedure fonctionne bien mais je dois maintenant faire une concatenation de chaque resultat de colonne puis un UNION pour remettre toutes ces données sous un seul resultat

Voila le resultat aujourdh'ui

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
IdProjet                         IdDette                     TypeProjet    
---------                  --------------               --------------
1                                     1                                1
1                                     3                                1
 
IdProjet                         IdDette                     TypeProjet    
---------                  --------------               --------------
1                                     2                                1
1                                     6                                3

etc

Auriez vous une idée pour la suite de ma procédure car je bloque.

Merci de vos futures réponses

[Waldar]

Par exemple, en une seule requête.

Données

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
DECLARE @MaTable TABLE
(
  IdProjet   tinyint,
  IdDette    tinyint,
  TypeProjet tinyint
);
 
INSERT INTO @MaTable
select 1, 1,  1 union all
select 1, 2,  3 union all
select 1, 3,  1 union all
select 1, 4, 11 union all
select 1, 5, 13 union all
select 1, 6,  3;

Requête

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
With CTInit (IdProjet, IdDette, TypeProjet, RNA, RND)
AS
(
select IdProjet, cast(IdDette as varchar(max)), TypeProjet,
       row_number() over(partition by IdProjet, TypeProjet order by IdDette  asc),
       row_number() over(partition by IdProjet, TypeProjet order by IdDette desc)
  from @MaTable
)
  ,  CTRec (IdProjet, IdDette, TypeProjet, RNA, RND)
AS
(
select IdProjet, IdDette, TypeProjet, RNA, RND
  from CTInit
 where RNA = 1
 union all
select R.IdProjet, R.IdDette + ', ' + I.IdDette, R.TypeProjet, I.RNA, I.RND
  from CTRec AS R
       inner join CTInit AS I
         on I.IdProjet   = R.IdProjet
        and I.TypeProjet = R.TypeProjet
        and I.RNA        = R.RNA + 1
)
  select IdProjet, IdDette, TypeProjet
    from CTRec
   where RND = 1
order by IdProjet ASC, TypeProjet ASC;

Résultat

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
IdProjet IdDette TypeProjet
-------- ------- ----------
1        1, 3    1
1        2, 6    3
1        4       11
1        5       13

Il y a peut-être plus simple en utilisant le XML Path.

[Waldar]

La syntaxe est effectivement beaucoup plus courte avec le FOR XML PATH :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
SELECT b.IdProjet,
       STUFF( (SELECT ', ' + cast(IdDette as varchar)
               FROM @MaTable AS a
               WHERE b.IdProjet   = a.IdProjet
                 AND b.TypeProjet = a.TypeProjet
               FOR XML PATH('')),1 ,1, '')) AS IdDette,
       b.TypeProjet
FROM @MaTable AS b
GROUP BY b.IdProjet, b.TypeProjet;

[cryosore]

Je vous remercie grandement Waldar pour votre aide précieuse

[mikedavem]

Pour avoir testé les 2 méthodes sur des gros volumes de données , j'ai trouvé que la concaténation des données via XML PATH était beaucoup plus rapide ... La méthode via les CTE récursives étaient même plus longue que d'employer un curseur

Si qqn a des retours la dessus ...

++

[elsuket]

Bonjour,

Même chose pour moi : l'utilisation de la récursivité sur des gros volumes est contre-performante, surtout quand un parent peut avoir plusieurs enfants : dans ce cas SQL Server ne peut pas estimer proprement ... et comme d'habitude, c'est contre-performant

L'utilisation de la clause FOR XML PATH ('') est de loin la plus rapide lorsqu'il y a besoin de réaliser de la concaténation, et l'expression de la requête n'en est que plus simple

@++