Optimisation fonction sur les branches

**darkterreur** · 21/08/2013, 15h58

Bonjour, Bonjour,

Comment allez vous ?
Les vacances ont été bonnes ?

Je viens vers vous car je suis a la recherche de brillants esprits afin de me débloquer dans mon problème. Je vais déjà donner le contexte.

je suis dans un esprit d'arbre, de branches, et de feuilles, c'est a dire une arborescence, avec des éléments qui ont des enfants, qui ont eux même des enfants et ainsi de suite.

Bon j'ai donc une table ou sont stocké tout les éléments seul le champs 'id_parent' affirme le lien de parenté, comme ceci :

Code sql :

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

1
2
3
4
5
6
CREATE TABLE `mc_tree_right` (
  `id_treeRight` int(11) NOT NULL AUTO_INCREMENT,
  `Libel_right` varchar(45) DEFAULT NULL,
  `id_parent` int(11) DEFAULT NULL,
  PRIMARY KEY (`id_treeRight`)
)

bon pour le moment mon code fonctionne et répond a 3 générations, mais je voudrais qu'il soit autonome peut importe le nombre de générations, que je n'ai pas a coder chaque génération a la main. Vous allez voir.

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
//retourne un tableau des données de tout les enfants	
	function all_data_child($idSheet){
		//pour la portabilité de la connexion car je ne suis pas en POO
		global $bdd;
		//retourne un tablau de donnée de la feuille courante PDO::FETCH_ASSOC
		$a_dataSheet = get_data($idSheet);
		$a_dataAllChild = $a_dataSheet[0];
		//récupere dans un tableau toute les données des enfants direct
		$a_dataChild = data_child_sheet();
		$i = 0;
		foreach($a_dataChild as $key => $value){
			foreach($value as $cle => $donnee){
				// on l'ajoute dans un tableau général
				$a_dataAllChild['child'.$i][$cle] = $donnee ;	
 
			}
			//on test si il existe des enfants pour chaque enfant que l'on traite et on recommence 
			if(exist_child($value['id_treeRight'])==true){
				 $j = 0;
				 $a_dataGrandChild = data_child_sheet($value['id_treeRight']);
				 foreach($a_dataGrandChild as $chaussette => $cravatte){
					 foreach($cravatte as $letter => $world){
 
						 $a_dataAllChild['child'.$i]['grandChild'.$j][$letter] = $world ;
 
					 }
					 //on recommence
					 if(exist_child($cravatte['id_treeRight'])==true){
						 $k = 0;
						 $a_dataGreatGrandChild = data_child_sheet($cravatte['id_treeRight']);
						 foreach($a_dataGreatGrandChild as $paper => $pen){
							 foreach($pen as $fruit => $legume){
 
								 $a_dataAllChild['child'.$i]['grandChild'.$j]['greatGrandChild'.$k][$fruit] = $legume ;
 
							 }
							 //on recommence
							 if(exist_child($pen['id_treeRight'])==true){
										 $n = 0;
										 $a_dataGreatGreatGrandChild = data_child_sheet($pen['id_treeRight']);
										 foreach($a_dataGreatGreatGrandChild as $essence => $diesel){
											 foreach($diesel as $whisky => $vodka){
 
												 $a_dataAllChild['child'.$i]['grandChild'.$j]['greatGrandChild'.$k]['greatGreatGrandChild'.$n][$whisky] = $vodka ;
 
											 }
 
											 $n++;
										 }
									}
 
							 $k++;
						 }
					}
 
					 $j++;
				 }
			}
 
			$i++;			
		}
 
		return $a_dataAllChild;
	}

Pour le moment je tourne en rond, peut être auriez vous une brillante idée ?

je précise que je ne suis pas en POO mais que j'utilise des fonctions internes sous PDO.

**darkterreur** · 22/08/2013, 12h28

Ami développeur Bonjour,

Bon j'ai trouvé diverses solutions probable.

Tout d'abord j'ai vu qu'il existait sous Oracle une fonction qui faisait exactement ce que je recherche 'connect by prior'.

Malheureusement je suis sous MySql et il n'existe pas encore d'équivalent a proprement parlé, bien que MySql soit racheté par Oracle, et que cette fonction soit en projet de développement pour MySql depuis un moment.

Sous MySql il est possible de faire une procédure stocké qui prend énormément de ressource elle est donc utilisable que pour les très petite arborescences.
Sinon une solution consiste a repenser la table et a rajouter des champs de palier comme sur une règle, sauf que si l'arborescence est modulable a souhait c'est un sacré mic mac pour rajouter quoi que ce soit car il faut recalculer toutes les tranches des voisins. Personnellement je ne trouve pas cela très adapté.
http://sqlpro.developpez.com/cours/arborescence/

Sinon j'ai trouvé une requête qui permet si lorsque l'on met dans notre table comme foreign key le champs qui contient les id pere. Il nous est possible de ressortir l'arborescence. Seul bémol, il faut se palucher la main un LEFT OUTER JOINT pour chaque sous niveau, en gros bien qu'intéressant, il n'y a rien d'automatique et on retombe sur le même problème que j'ai en PHP.
http://sqllessons.com/categories.html

Maintenant je suis passé a la récursivité en PHP, qui me parait être la meilleur solution, en utilisant la récursivité de parcours de tableau multi dimensionnelle, ou je créer mon propre tableau en sortis de fonction, et a chaque boucle récursive elle me renvoi se qu'il me faut quelque chose comme cela, reste l'ajout des données du premier noeud que je passe en paramètre que je dois faire qu'une seul fois, je ne sais pas encore trop ou le mettre.

Qu'en pensez vous ?
Bon je creuse encore et je reviens vers vous.

A bientôt !

**darkterreur** · 28/08/2013, 18h48

Bonjour, Bonjour,

Et bien je suis mon seul supporter.

Bon ce n'est pas grave cela pourra peut etre aider d'autre personne.

J'ai utilisé de la recursivité en PHP une grande premiere pour moi et cela fonctionne.

Voici le code.

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
30
31
function all_data_child($idNode){
 
		$a_dataSheet = get_data($idNode);
		$a_dataAllChild = $a_dataSheet[0];
 
		$a_temp = testRecursiveGetListChild($idNode);
		foreach($a_temp as $data){
			$a_dataAllChild[] = $data;
		}
 
		return $a_dataAllChild;
	}
 
	function testRecursiveGetListChild($idNode){	
 
		$a_dataChild = array();
 
		if(exist_child($idNode)==true){
			$a_dataChild = data_child_sheet($idNode);
 
			foreach($a_dataChild as $key => $value){
				$a_temp = testRecursiveGetListChild($value['id_treeRight']);
 
				foreach($a_temp as $valeur){
					$a_dataChild[$key][] = $valeur;
				}
			}
		}
 
		return $a_dataChild;
	}

J'aimerai bien me mettre des petits plus sur ce coup la

Merci tout de même de votre visite.

**rawsrc** · 29/08/2013, 11h24

Salut,

C'est pas mal (tu l'as eu ton point

), le seul truc c'est que si tu dois faire face à une arborescence profonde, la récursivité te fera sacrément chuter les perfs du fait des multiples appels à la base.

Une autre piste serait de générer via une procédure stockée (donc en un seul appel), un tableau plat avec tous les éléments permettant de reconstituer l'arbre en PHP.

Quelque chose qui te renverrait un tableau de ce genre :

id | id_parent | libelle

Optimisation fonction sur les branches [PHP 5.4]

Langage PHP

Discussions similaires

Partager

Partager