Discussion :

[viviboss]

Bonjours,

Voilà, j'ai une table de BDD qui a un champ "dépendance". Ce champ est un ID de la même table, permettant donc de gérer les dépendances de cette table (ex : texte1 dépend de texte2 dépend de texte3 dépend de texte4.....)

Je ne sais pas combien il peu y avoir de niveau de dépendance, et j'aimerais écrire une méthode dans une classe permettant de tester la profondeur de dépendance, et renvoyer un tableau organisé prenant en compte ces dépendances....

Je me casse la tête sur ce PB : je suppose fortement qu'il faut utiliser du récursif, mais ca n'a jamais été mon fort....

Alors si vous aviez quelques exemples à me donner, ce serait cool

Parce que là, je galère et j'ai mal à la tête (Il faut que ce soit une méthode, absolument....)

Voici ma table :

Code SQL :

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 `core_boites` (
  `id_core_boite` bigint(20) NOT NULL auto_increment,
  `id_emplacement_template` bigint(20) NOT NULL,
  `nom` varchar(255) NOT NULL,
  `description` tinytext NOT NULL,
  `date_intro` datetime NOT NULL,
  `date_modif` datetime NOT NULL,
  `css` varchar(255) NOT NULL,
  `width` varchar(255) NOT NULL,
  `height` varchar(255) NOT NULL,
  `publie` tinyint(1) NOT NULL,
  `dependance` bigint(20) NOT NULL,
  `ordre` int(11) NOT NULL,
  `unite_taille` varchar(255) NOT NULL,
  PRIMARY KEY  (`id_core_boite`)
)

Le champ dépendance contient en fait un id_core_boite...

J'ai fait plusieurs tests, mais de rage j'ai tout supprimé...

Merci à vous pour tout aide apporté !!!

[cerede2000]

Code SQL :

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 `core_boites` (
  `id_core_boite` bigint(20) NOT NULL auto_increment,
  `id_emplacement_template` bigint(20) NOT NULL,
  `nom` varchar(255) NOT NULL,
  `description` tinytext NOT NULL,
  `date_intro` datetime NOT NULL,
  `date_modif` datetime NOT NULL,
  `css` varchar(255) NOT NULL,
  `width` varchar(255) NOT NULL,
  `height` varchar(255) NOT NULL,
  `publie` tinyint(1) NOT NULL,
  `dependance` bigint(20) NOT NULL,
  `ordre` int(11) NOT NULL,
  `unite_taille` varchar(255) NOT NULL,
  PRIMARY KEY  (`id_core_boite`)
)

Le champ dépendance contient en fait un id_core_boite...

La table dépend d'elle meme?

[viviboss]

....Et bien oui..... Je n'ai pas trouvé de facons "plus naturel" de faire une dépendance de même données : imaginons un forum, avec un seul style de données : du texte.

Et bien, pour faire suivre un thread (plusieurs réponses à un sujet, le tout étant de type texte), le champ dépendance prendrait bien la clé primaire de la même table.... (bien évidemment, sans jamais se prendre lui-même en dépendance, ca n'aurait pas de sens....)

Ainsi :
message1
--message2
--message3
--message4
--message5

sont de même type, mais les messages de 2 à 5 dépendent de message 1...

[jeff_!]

hello,
tu devrai peut etudier la methode des nesteed Tree ( representation intervallaire/arbre)
des explications sont dispo sur ce site ou sur phpriot.com

[viviboss]

Ok merci je vais voir....

Sinon, voilà ou j'en suis arrivé :

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
65
66
67
68
 
public function retourDependance($id_dep){
 
		$this->count+=1;
 
		parent::__construct();
 
		$query="SELECT * FROM core_boites WHERE dependance=".$id_dep;
		$res=parent::idConnect()->query($query);
		$num_rows=$res->num_rows;
 
		$this->tabcount[$this->count]=$num_rows;
 
		if($num_rows==0){
 
			$res->free_result();
			parent::__destruct();
 
			if(is_array($this->tabdep)){
 
				$this->tabdep['niveaux']=$this->niveaux;
				$this->tabdep['tabniveaux']=$this->tabniveaux;
 
				print_r($this->tabdep);
 
				$this->tabdep=null;
				$this->tabniveaux=null;
 
				$tabtemp=array_keys($this->tabcount);
				$maxtemp=max($tabtemp);
 
			/***************************************************/
			//Ici, on détermine le niveaux auquel commencera la nouvelle occurence récursive : pour cela, on compte le nombre de résultat que renvoi la première occurence,
			//et on compte le nombre de récursivité total. Ensuite, on divise ce nombre par le résultat de la première occurence afin de savoir exactement à quel niveau de dépendance
			//on doit reprendre le compte des niveaux (en fait, il s'agit de la profondeur des dépendances.....)
 
				//Si le max n'est pas pair, on fait en sorte qu'il le soit, en ajoutant 1 et retirant 2 au résultat total
				if($maxtemp%2!=0){
					$this->niveaux=(($maxtemp+1)/$this->tabcount[1])-2;
				}else{
					//Si le max est pair, on enlève que 1
					$this->niveaux=($maxtemp/$this->tabcount[1])-1;
				}
			}else{
				return false;
			}
 
		}else{
 
			$this->niveaux+=1;
			$this->tabniveaux[$this->niveaux]=$num_rows;
 
			while($row=$res->fetch_assoc()){
				$this->tabdep[$id_dep][$this->niveaux][$row['id_core_boite']]=$row['nom'];
			}
			$res->free_result();
			parent::__destruct();
 
			$tabcle=array_keys($this->tabdep[$id_dep][$this->niveaux]);
			foreach($tabcle as $value){
				$this->retourDependance($value);
			}
 
		}
 
 
 
	}

...C'est un peu lourd, je vais retravailler un peu le code, mais ca affiche ce que je veux (test fait sur une arrborescence complexe : 3 niveaux + des nieaux intermediaires...La prise de tete!!!! )

Je dois travailler en core un peu, car la récursivité dans une méthode faisant appel à une BDD est très contraignante......