Discussion :

[grinder59]

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

[Say hello]

Mon point de vue de noob : A maintenir/retenir ca va être chiant, surtout si tu n'est pas le seul a l'utiliser.
J'aurais tendance a dire de faire plus simple, a créer chaque requete en fonction du besoin quitte a multiplier les objets pour enregistrer ce que tu souhaite.

Avec PDO et prepare/execute tu peux envoyer t'es données via un tableau. Je créé le bon nombre de marqueur (?) en fonction du nombre d'objet dans le tableau, ca me suffit pour la simplification.

Je met les conditions en dure dans le code sous forme de chaine de caractère (marqueur ? dedans) avec la table et le tableau de donnée.