Optimisation requêtes en POO

Version imprimable

Bonjour,

Je suis novice en Php et en POO et je dois créer une requête qui retourne des informations sur une parcelle dont la géométrie est stockée dans une table PostGreSQL, selon qu'elle fasse partie de telle ou telle zone d'un PLU (infos et géométrie stockées dans une autre table), recoupe telle prescription ou non (infos et géométrie stockées dans d'autres tables selon le type de géométrie), ...
J'arrive au résultat escompté, mais je pense qu'il y a possibilité de faire mieux niveau code.
Quelles optimisations pourraient être faites ?
J'ai essayé l'hydratation de mes objets mais sans succès

Code:

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
function getContrainte(){
 
	$database = new Database();
	$db = $database->getConnection();
 
	$id = '************';
 
	$contraintes = array();
 
	$plu = $db->query("SELECT DISTINCT plu.typezone,plu.libelle,plu.libelong FROM plu.zones_plu AS plu  
	JOIN  plu.parcelle AS parcelle ON ST_Intersects(ST_BUFFER(plu.geom,-1), parcelle.geom) GROUP BY plu.typezone,plu.libelle,plu.libelong,parcelle.label HAVING parcelle.label = '" . $id . "' ");
 
	while($donnees = $plu->fetch(PDO::FETCH_ASSOC)){
		$contrainte = new RestContrainte($donnees);
		$contrainte->groupe = 'zonage';
		$contrainte->ssgroupe = $donnees['typezone'];
		$contrainte->libelle = $donnees['libelle'];
		$contrainte->texte = $donnees['libelong'];
	array_push($contraintes,$contrainte);
	}
 
	$pscsurf = $db->query("SELECT DISTINCT pscsurf.libelle,pscsurf.typepsc,pscsurf.txt FROM plu.psc_surf AS pscsurf 
	JOIN plu.parcelle AS parcelle ON ST_Intersects(pscsurf.geom, parcelle.geom) GROUP BY pscsurf.libelle,pscsurf.typepsc,pscsurf.txt,parcelle.label HAVING parcelle.label = '" . $id . "' ");
 
	$psclin = $db->query("SELECT DISTINCT psclin.libelle,psclin.typepsc,psclin.txt FROM plu.psc_lin AS psclin
	JOIN plu.parcelle AS parcelle ON ST_Intersects(psclin.geom, parcelle.geom) GROUP BY psclin.libelle,psclin.typepsc,psclin.txt,parcelle.label HAVING parcelle.label = '" . $id . "' ");
 
	$pscpct = $db->query("SELECT DISTINCT pscpct.libelle,pscpct.typepsc,pscpct.txt FROM plu.psc_pct AS pscpct
	JOIN plu.parcelle AS parcelle ON ST_Intersects(pscpct.geom, parcelle.geom) GROUP BY pscpct.libelle,pscpct.typepsc,pscpct.txt,parcelle.label HAVING parcelle.label = '" . $id . "' ");
 
	while($donnees = $pscsurf->fetch(PDO::FETCH_ASSOC)){
		$contrainte = new RestContrainte($donnees);
		$contrainte->groupe = 'prescription';
		$contrainte->ssgroupe = $donnees['typepsc'];
		$contrainte->libelle = $donnees['libelle'];
		$contrainte->texte = $donnees['txt'];
	array_push($contraintes,$contrainte);
	}
 
	while($donnees = $psclin->fetch(PDO::FETCH_ASSOC)){
		$contrainte = new RestContrainte($donnees);
		$contrainte->groupe = 'prescription';
		$contrainte->ssgroupe = $donnees['typepsc'];
		$contrainte->libelle = $donnees['libelle'];
		$contrainte->texte = $donnees['txt'];
	array_push($contraintes,$contrainte);
	}
 
	while($donnees = $pscpct->fetch(PDO::FETCH_ASSOC)){
		$contrainte = new RestContrainte($donnees);
		$contrainte->groupe = 'prescription';
		$contrainte->ssgroupe = $donnees['typepsc'];
		$contrainte->libelle = $donnees['libelle'];
		$contrainte->texte = $donnees['txt'];
	array_push($contraintes,$contrainte);
	}
        return $contraintes;
	}

et ma classe RestContrainte()

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class RestContrainte {
 
	public $groupe;
	public $ssgroupe;
	public $libelle;
	public $texte;
 
	public function __construct() {
		$this->groupe = null;
		$this->ssgroupe = null;
		$this->libelle = null;
		$this->texte = null;
	}
}

08/08/2018, 18h11
Invité

Bonjour,

Puisqu'elles renvoient les mêmes données (colonnes), on peut regrouper les 4 requêtes en une seule : SQL UNION
08/08/2018, 20h18
hippipers

Super, merci @jreaux62 !
09/08/2018, 10h59
grunk

Généralement les requêtes SQL dans des boucles qui dépile une requête précédente sont à bannir.
Pour la simple et bonne raison que tu peux te retrouver à bombarder ton serveur de centaines voir de millier de requêtes là ou une jointure aurait fait le travail avec une requête.

Merci pour ta réponse @Grunk !
Par contre qu'entends tu par là ?
Mes requêtes SQL ne sont pas dans des boucles qui dépilent une requête précédente a priori.

Avant, j'avais fait une unique requête SQL comme suit, mais le temps de réponse était bien plus long

Code:

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
$tout = $db->query("SELECT parcelle.label,
	st_collect(plu.geom ORDER BY plu.libelle) ,
	string_agg(DISTINCT plu.libelle, ',' ORDER BY plu.libelle) AS plu_libelle,
	st_collect(plu.geom ORDER BY plu.typezone) ,
	string_agg(DISTINCT plu.typezone, ',' ORDER BY plu.typezone) AS plu_typezone,
	st_collect(plu.geom ORDER BY plu.libelong),
	string_agg(DISTINCT plu.libelong, ',' ORDER BY plu.libelong) AS plu_libelong,
	st_collect(pscsurf.geom ORDER BY pscsurf.libelle) ,
	string_agg(DISTINCT pscsurf.typepsc, ',' ORDER BY pscsurf.typepsc) AS psc_surf_typepsc,
	string_agg(DISTINCT pscsurf.libelle, ',' ORDER BY pscsurf.libelle) AS psc_surf_libelle,
	string_agg(DISTINCT pscsurf.txt, ',' ORDER BY pscsurf.txt) AS psc_surf_txt,
	st_collect(psclin.geom ORDER BY psclin.libelle),
	string_agg(DISTINCT psclin.typepsc, ',' ORDER BY psclin.typepsc) AS psc_lin_typepsc,
	string_agg(DISTINCT psclin.libelle, ',' ORDER BY psclin.libelle) AS psc_lin_libelle,
	string_agg(DISTINCT psclin.txt, ',' ORDER BY psclin.txt) AS psc_lin_txt,
	st_collect(pscpct.geom ORDER BY pscpct.libelle),
	string_agg(DISTINCT pscpct.typepsc, ',' ORDER BY pscpct.typepsc) AS psc_pct_typepsc,
	string_agg(DISTINCT pscpct.libelle, ',' ORDER BY pscpct.libelle) AS psc_pct_libelle,
	string_agg(DISTINCT pscpct.txt, ',' ORDER BY pscpct.txt) AS psc_pct_txt
        FROM plu.parcelle AS parcelle
	JOIN plu.zones_plu AS plu ON ST_Intersects(ST_BUFFER(parcelle.geom,-1), plu.geom)
	LEFT JOIN plu.psc_surf AS pscsurf ON ST_Intersects (ST_BUFFER(parcelle.geom,-1), pscsurf.geom) 
	LEFT JOIN plu.psc_lin AS psclin ON ST_Intersects (ST_BUFFER(parcelle.geom,-1), psclin.geom) 
	LEFT JOIN plu.psc_pct AS pscpct ON ST_Intersects (ST_BUFFER(parcelle.geom,-1), pscpct.geom)
        GROUP BY parcelle.label
	HAVING parcelle.label = '" . $id . "'
	");

09/08/2018, 15h53
grunk

Au temps pour moi j'avais mal lu ton code précédent , il n'ya effectivement pas de requête dans des boucles.

Après en ce qui concerne une requete vs plusieurs on privilégie souvent une requête unique quand les performances ne sont pas affectée. Il peut arriver qu'un ensemble de jointure soit plus lent que 3 ou 4 requête séparées (comme dans ton cas à priori) et dans ce cas , il est effectivement plus judicieux de séparer les requêtes.
09/08/2018, 21h45
hippipers

Yes, merci pour tes conseils @Grunk