Discussion :

[DEV-10]

Bonjour

J'ai une table_1 qui contient deux colonnes : Enfant et Parent de type cher (4)

Chaque Parent peut avoir plusieurs enfants et chaque enfants peut avoir plusieurs enfants aussi et ainsi de suite.

Voici un extrait de la table :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
Enfant    Parent
5000      6000
6000      8000
4000      8000
3500      8000
3501      8000
5700      5000
5701      5000
5702      5000
5400      5702
5401      5702
5402      5702

On remarque que :

Le Parent 6000 a comme enfant : 5000

Le Parent 8000 a comme enfant : 6000,4000,3500,3501

Le Parent 5000 a comme enfant : 5700,5701,5702

Le Parent 5702 a comme enfant : 5400, 5401, 5402

Dans une autre table Table_2 je lis dans la premiere ligne le champ X1 et je le cherche dans la table Table_2. lorsque je le trouve, je dois afficher toute la hiérarchie de cet individu X1

Je fais la même chose pour toute les lignes de la table table_2 .

Exemple : Pour la parent 5000, je dois avoir la hiérarchie suivante :

5000
5700
5701
5702
5400
5401
5402

Merci d'avance.

[DEV-10]

J'ai essayé la requête suivante mais ca me donne pas le bon résultat.

Code :

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

1
2
3
4
5
 
select B.Enfant
   from Table_1 A, Table_2 B 
   where (A.Enfant = B.Parent)
   order by A.Parent

après certaine lecture, je réalize que c'est plus compliqué de ce que je pensais.

J'ai lu cet article mais je n'arrive toujours pas à trouver la bonne solution.

http://sqlpro.developpez.com/cours/arborescence/

merci de me donner d'autres pistes.

[DEV-10]

Il y a aussi cet exemple mais dans ma table il n'y a pas de champ pour le niveau. Moi j'ai juste deux colonnes : fils, pere

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
DECLARE @Id_personne int
SET @Id_personne=1;
 
WITH Table_CTE(Id, Nom, Niveau) AS 
(
SELECT Id, Nom, 0 AS Niveau
FROM Personne
WHERE Id_parent=@Id_personne
 
UNION ALL
 
SELECT e.Id, e.Nom, Niveau + 1
FROM Personne e
INNER JOIN Table_CTE d
ON e.Id_parent= d.Id
)
 
SELECT Id, Nom
FROM Table_CTE

[Waldar]

Même réponse qu'ici :
http://www.developpez.net/forums/d31...e/#post4585359

Evitez de multiplier les mêmes questions, c'est inutile et ici vous étiez au bon endroit !

[elsuket]

Bonjour,

Il est possible sous SQL Server 2000 d'introduire la récursivité comme on le fait en programmation fonctionnelle: en appelant une procédure ou une fonction dans la spécification de celle-ci.
OLn puet obtenir le niveau de profondeur de récursivité avec la fonction système @@NESTLEVEL

J'ai donc supposé votre table comme suit :

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
CREATE TABLE Gringos
(
	Enfant INT,
	Parent INT
)
 
INSERT INTO dbo.Gringos VALUES (5000, 6000)
INSERT INTO dbo.Gringos VALUES (6000, 8000)
INSERT INTO dbo.Gringos VALUES (4000, 8000)
INSERT INTO dbo.Gringos VALUES (3500, 8000)
INSERT INTO dbo.Gringos VALUES (3501, 8000)
INSERT INTO dbo.Gringos VALUES (5700, 5000)
INSERT INTO dbo.Gringos VALUES (5701, 5000)
INSERT INTO dbo.Gringos VALUES (5702, 5000)
INSERT INTO dbo.Gringos VALUES (5400, 5702)
INSERT INTO dbo.Gringos VALUES (5401, 5702)
INSERT INTO dbo.Gringos VALUES (5402, 5702)

Voici la définition de la procédure stockée que je vous propose :

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
CREATE PROCEDURE dbo.GetGenealogie
	@racine INT
AS
BEGIN
	SET NOCOUNT ON
 
	DECLARE @ParentID INT
 
	PRINT REPLICATE('-', @@NESTLEVEL * 4) + CAST(@racine AS VARCHAR)
 
	SELECT @ParentID = MIN(Enfant)
	FROM dbo.Gringos
	WHERE Parent = @racine
 
	WHILE @ParentID IS NOT NULL
	BEGIN
		EXEC dbo.GetGenealogie @ParentID
 
		SELECT @ParentID = MIN(Enfant)
		FROM dbo.Gringos
		WHERE Parent = @racine
		AND Enfant > @ParentID
	END
END
GO

Celle-ci imprime dans la console de l'Analyseur de requêtes la hiérarchie que vous recherchez.

Ce que l'on peut faire, c'est créer une table "tampon" que vous purgez à chaque recherche et dans laquelle vous stockez la hiérarchie que vous avez trouvé.
Il ne vous reste plus ensuite qu'à spécifier la jointure entre cette table et la table table_2 pour obtenir les données dont vous avez besoin :

Considérons la table "tampon" suivante :

Code :

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

1
2
3
4
5
CREATE TABLE Hierarchie
(
	IDGringo INT NOT NULL,
	Profondeur TINYINT NOT NULL
)

Modifions le code de notre procédure :

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
ALTER PROCEDURE dbo.GetGenealogie
	@racine INT
AS
BEGIN
	SET NOCOUNT ON
 
	DECLARE @ParentID INT
 
	--PRINT REPLICATE('-', @@NESTLEVEL * 4) + CAST(@racine AS VARCHAR)
	SELECT @racine, @@NESTLEVEL
 
	SELECT @ParentID = MIN(Enfant)
	FROM dbo.Gringos
	WHERE Parent = @racine
 
	WHILE @ParentID IS NOT NULL
	BEGIN
		EXEC dbo.GetGenealogie @ParentID
 
		SELECT @ParentID = MIN(Enfant)
		FROM dbo.Gringos
		WHERE Parent = @racine
		AND Enfant > @ParentID
	END
END
GO

Il nous suffit ensuite d'exécuter :

Code :

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

1
2
INSERT INTO dbo.Hierarchie
EXEC dbo.GetGenealogie 6000

Un SELECT * nous retourne :

Code :

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

1
2
3
4
5
6
7
8
9
10
IDGringo	Profondeur
---------------------------
6000		1
5000		2
5700		3
5701		3
5702		3
5400		4
5401		4
5402		4

@++

[DEV-10]

Merci beaucoup elsuket, les deux sortes de procédure me donne les bons résultats.