Hello,

Je suis en train d'essayer de développer un système qui me permettra de générer mes requêtes via de tableaux.
Je commence donc par une requête du type :
Code sql : Sélectionner tout - Visualiser dans une fenêtre à part
SELECT c1, c2, c3 FROM t1 LEFT JOIN t2 ON t1.id = t2.id LEFT JOIN t3 ON t1.id = t3.id WHERE (c1 = 10) AND (c2 = 20 OR c3 < 0)

J'ai déjà réussi à coder les objets select et from, mais je bloque sérieusement sur la génération du WHERE.

En gros, voici comment j'ai procédé :
- classe DetailClauseWhere qui contient les clauses unitaires
- classe ClauseWhere qui contient un opérateur logique (AND ou OR) et un tableau de ClauseWhere ou de DetailClauseWhere
- classe Where qui chapeaute les 2 précédentes en se chargeant de lancer le bonnes méthodes de génération des sous parties de la requête.

Voici ce que j'ai implémenté pour le moment :

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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
class DetailClauseWhere{
 
	private 
		$liaison,
		$negation,
		$colonne,
		$operateur,
		$valeur;
 
	public function __construct($l, $n, $c, $o, $v){		
		$this->liaison 	= $l;
		$this->negation = $n;
		$this->colonne	= $c;
		$this->operateur= $o;
		$this->valeur	= $v;		
	}
 
	public function getDetailClause(){
		$retour = '';
		$retour .= $this->liaison.' '.$this->negation.'('.$this->colonne.' '.$this->operateur.' '.$this->valeur.') ';
 
		return $retour;		
	}
}
 
class ClauseWhere{
 
	private $liaison, $detailclause;
 
	public function __construct($l, $cl){
		$this->liaison 	= $l;
		$this->detailclause = array();
		$this->detailclause = $cl;
	}
 
	public function getClauseWhere(){
		$retour = $this->liaison.' ( ';
		foreach ($this->detailclause as $k => $o){
			if (is_object($o) && get_class($o) == 'DetailClauseWhere'){
				$retour .= $o->getDetailClause();
			}
			else if (is_object($o) && get_class($o) == 'ClauseWhere'){
				$retour .= $o->getClauseWhere();
			}
		}
		return $retour.' ) ';
	}
 
}
 
class Where{
 
	private 
		$tabClauses;
 
	public function __construct($tab){
		$this->tabClauses = $tab;
	}
 
	public function getWhere($t = NULL){
		$where = ' WHERE ';
		$tab = $t == NULL ? $this->tabClauses : $t;
		foreach ($tab as $k => $t){
 
			if (is_array($t)){
				$where .= '('.$this->getWhere($t).')';
			}
			if (isset($t) && is_object($t) && get_class($t) == 'DetailClauseWhere'){
				$where .= $t->getDetailClause();
			}
			if (isset($t) && is_object($t) && get_class($t) == 'ClauseWhere'){
				$where .= $t->getClauseWhere();
			}			
		}
		return $where;
	}
}
 
/* 
	WHERE
			!(t1 = 10)
		AND (t2 > 0 OR t3 < 15)
*/
 
$dclause1 = new DetailClauseWhere('', '!', 't1', '=', '10');
$dclause2 = new DetailClauseWhere('', '', 't2', '>', '0');
$dclause3 = new DetailClauseWhere('OR', '', 't3', '<', '15');
 
$operateur = new Operateur('AND');
 
$detailclause = new ClauseWhere('AND', array($dclause2, $dclause3));
 
$tab = array($dclause1, $detailclause);
 
$c = new Where($tab);
echo $c->getWhere();
1. Globalement, est-ce cohérent et pas trop mal pensé ?
2. Pour créer ce bout de code sql, je vais devoir instancier pas mal d'objets imbriqués les uns dans les autres (un ClauseWhere pouvant contenir des ClauseWhere) et j'ai l'impression au final qu'avant de pouvoir générer mes requêtes, je vais devoir me rappeler comment ça fonctionne (excellent pour la productivité !). Dans cette mesure, est-ce la bonne méthode ?

Auriez vous quelques conseils pour éviter que je ne sombre dans la dépression ? (pour l'instant ça va ! ;-))

Merci de vos lumières