conception : table des dépendances

Version imprimable

[résolu] conception : table des dépendances

Bonjour,

un petit problème de conception...

Voilà ce que je veux faire : gérer les dépendances entre programmes.
Exemple : un programme A appelle B, qui lui même appelle C.
Je veux pouvoir connaître tous les programmes appellant C directement
ou indirectement. Donc A et B dans mon exemple.

J'avais pensé à une simple table TAPPEL (APPELLANT, APPELLE), c'est
simple à remplir :
Code:

1 2 3 APPELLANT APPELLE A B B C
Ensuite la requête
Code:

1 2 3 SELECT APPELLANT FROM TAPPEL WHERE APPELLE = 'C'
me ramène seulement B ; pour avoir aussi A je dois faire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 SELECT APPELLANT FROM TAPPEL WHERE APPELLE = 'C' UNION SELECT APPELLANT FROM TAPPEL WHERE APPELLE IN ( SELECT APPELLANT FROM TAPPEL WHERE APPELLE = 'C' )
mais si j'ai plus de 2 niveaux d'appel (ex : C appelle D et je veux connaître
tous les appellants de D) je dois rajouter encore une UNION et ainsi de suite...

Bref vous l'aurez compris, je voudrai que tout cela fonctionne quelque soit
le niveau d'imbrication... Alors une idée ? Une requête qui permet de faire cela ?
Ou peut-être une table faite différemment ?

Merci d'avance...

07/10/2005, 08h08
Médiat

Trois solutions :
ORACLE : CONNECT BY
NORME SQL : WITH RECURSIVE
AUTRES : Conception intervallaire
07/10/2005, 08h23
TheLeadingEdge

Bonjour,

A liste de Médiat j'ajouterais les extensions à Group By
Group By ROLLUP,
Group By CUBE ou
Group By GROUPING SET de DB2

A +
07/10/2005, 08h47
Médiat

Je ne connais pas Group By GROUPING SET de DB2
mais par contre je connais
Group By ROLLUP,
Group By CUBE
et je ne vois pas en quoi cela peut apporter une aide dans une structure hiérarchique (ce sont deux moyens de calculer des "groupes de groupes"), il me semble que la difficulté est justement de définir les groupes, mais je serais heureux de me tromper :lol: .

Bon déjà merci pour les suggestions.

Je suis sous DB2.

J'essaie le RECURSIVE qui me semble assez adapté,
mais j'ai du mal à faire la requête...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
WITH RECURSIVE TEMP ( APPELLANT ) AS         
(                                            
( SELECT APPELLANT                           
     FROM                                    
     TAPPEL                                  
     WHERE APPELLE = 'C' )            
  UNION                                      
( SELECT PP.APPELLANT                        
     FROM TAPPEL PP, TEMP                    
     WHERE PP.APPELLE = TEMP.APPELLANT ) )   
SELECT DISTINCT APPELLANT                    
FROM TEMP ;

me donne :

Code:

1
2
SQLCODE = -104, ERROR:  ILLEGAL SYMBOL "TEMP". SOME SYMBOLS THAT MIGHT
BE LEGAL ARE: AS

Vous voyez le problème ??

Je vais jeter un oeil à ce GROUP BY GROUPING SET sinon...

La conception intervallaire ca a l'air fort intéressant, mais
ca va peut être me demander un temps d'apprentissage
important :oops:

Re,

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
WITH RECUR ( APPELLANT ) AS          
(                                            
( 
SELECT 	APPELLANT                            
FROM	TAPPEL SRC                                
WHERE 	SRC.APPELLE = 'C' 
)         
UNION ALL                                    
(
SELECT 	SRC.APPELLANT                        
FROM 	RECUR RECUR,
	TAPPEL SRC                   
WHERE	RECUR.APPELLANT = SRC.APPELLE
) 
)    
SELECT DISTINCT APPELLANT                    
FROM RECUR;    
 
CONNECT RESET;

(A vérifier )

07/10/2005, 09h48
gregolak
Citation:

Envoyé par TheLeadingEdge

(A vérifier )

Yes, ca marche ! :D

Par contre il me met un WARNING car cela peut donner
une boucle infinie.
Code:

1 2 SQLCODE = 347, WARNING: THE RECURSIVE COMMON TABLE EXPRESSION RECUR MAY CONTAIN AN INFINITE LOOP
Mais bon c'est pas hyper grave...

Merci beaucoup à tous.
07/10/2005, 09h57
TheLeadingEdge

Citation:

Envoyé par gregolak

Merci beaucoup à tous.

Avec plaisir,
quant au 'grouping set' je suis en train de m'embarquer ds 1 gros délire, je crois que Médiat à raison.

A +

j'y suis presque...

Je reviens à la charge...
J'essaie d'ajouter à ma requête le "niveau
d'appel"

Si A appelle B
Et B appelle C
Et C appelle D

que j'interroge avec 'D'
je voudrais avoir

Code:

tout ca pour pouvoir faire un ORDER BY dans le select global
et ainsi avoir mes programmes dans le bon ordre...

Donc je mets 1 dans le 1er sous select mais comment faire pour
la partie récursive ?? Je suis un peu perdu là...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
WITH RECUR ( APPELLANT, NUM ) AS                  
(                                                 
   (  SELECT APPELLANT, 1                         
        FROM TAPPEL SRC                           
       WHERE SRC.APPELLE = 'D'             
   )                                              
UNION ALL                                         
   (  SELECT    SRC.APPELLANT, ???                  
        FROM    RECUR   RECUR,                    
                TAPPEL  SRC                       
       WHERE    RECUR.APPELLANT = SRC.APPELLE     
   )                                              
)                                                 
SELECT DISTINCT APPELLANT, NUM                    
FROM RECUR

merci d'avance (encore !)

ah ben tiens j'ai réussi, voici la réponse :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
WITH RECUR ( APPELLANT, PROFONDEUR ) AS                          
(                                                                
   (  SELECT APPELLANT, 1 AS PROFONDEUR                          
        FROM TAPPEL SRC                                          
       WHERE SRC.APPELLE = 'D '                            
   )                                                             
UNION ALL                                                        
   (  SELECT    SRC.APPELLANT, RECUR.PROFONDEUR + 1 AS PROFONDEUR
        FROM    RECUR   RECUR,                                   
                TAPPEL  SRC                                      
       WHERE    RECUR.APPELLANT = SRC.APPELLE                    
   )                                                             
)                                                                
 
(...)

Re,

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
WITH RECUR ( NIVEAU, APPELLANT ) AS          
(                                            
( 
SELECT 	1,
	APPELLANT                            
FROM	TAPPEL SRC                                
WHERE 	SRC.APPELLE = 'C' 
)         
UNION ALL                                    
(
SELECT 	RECUR.NIVEAU + 1,
	SRC.APPELLANT                        
FROM 	RECUR RECUR,
	TAPPEL SRC                   
WHERE	RECUR.APPELLANT = SRC.APPELLE
) 
)    
SELECT 	NIVEAU,
	APPELLANT                    
FROM RECUR;

A +

07/10/2005, 15h41
gregolak

Merci merci encore !!!
09/10/2005, 16h10
SQLpro

Bonjour,

en ce qui concerne les requêtes récursives j'ai fait un article complet sur le sujet qui indique comment faire les niveau, chemin,etc... et même éviter la récursivité de SQL. Hélas l'article est en anglais. Mais il paraitra en français dans SQL Server Magazine.

A lire : http://www.sqlservercentral.com/columnists/fBROUARD/recursivequeriesinsql1999andsqlserver2005.asp

Bien entendu la version française sera publié sur SQpro.developpez.com avant la fin de cette année.

A +