Discussion :

[morgan47]

Bonjour,

Je créée un site de recherche de permutant, j'ai donc 5 table, une table membres et une table annonce.

Une table membre habituel : idmembre,pseudo,.......

Une table annonce : idmembe,
regiondepart,departementdepart,villedepart,
regiondestination,departementdestination,villedestination

une table region, une table departement, une table ville.

Les membres doivent remplir dans leurs annonces au minimum le souhait de région.

Voici la requete que j'utilise pour trouver les permutant à 2 membres (merci au forum pour l'avoir trouvé):

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
 
$sql = "SELECT
		S1m.pseudo AS pseudo1, S1m.id_membre AS id_membre1,
		S1.id_permutation AS id_permutation1, S1.precisions_comp as precisions_comp1,
		S1from_region.nom_region AS from_region1, S1from_departement.nom_departement AS from_departement1, S1from_ville.ville_nom_reel AS from_ville1, 
		S1from_direction.nom_direction AS from_direction1, S1.service_from AS service_from1,
		S1to_region.nom_region AS to_region1, S1to_departement.nom_departement AS to_departement1, S1to_ville.ville_nom_reel AS to_ville1, 
		S1to_direction.nom_direction AS to_direction1, S1.service_to AS service_to1,
 
		S2m.pseudo AS pseudo2, S2m.id_membre AS id_membre2,
		S2.id_permutation AS id_permutation2, S2.precisions_comp as precisions_comp2,
		S2from_region.nom_region AS from_region2, S2from_departement.nom_departement AS from_departement2, S2from_ville.ville_nom_reel AS from_ville2,
		S2from_direction.nom_direction AS from_direction2, S2.service_from AS service_from2, 
		S2to_region.nom_region AS to_region2, S2to_departement.nom_departement AS to_departement2, S2to_ville.ville_nom_reel AS to_ville2,
		S2to_direction.nom_direction AS to_direction2, S2.service_to AS service_to2 
	FROM
		t_permutation S1
		INNER JOIN t_permutation S2 $jointure 
						AND (S1.statut = S2.statut)
 
		LEFT JOIN t_membres S1m ON S1.id_membre = S1m.id_membre
		LEFT JOIN t_villes S1from_ville ON S1.id_ville_from = S1from_ville.id_ville
		LEFT JOIN t_departements AS S1from_departement ON S1.id_departement_from = S1from_departement.id_departement
		LEFT JOIN t_regions AS S1from_region ON S1.id_region_from = S1from_region.id_region
		LEFT JOIN t_villes S1to_ville ON S1.id_ville_to = S1to_ville.id_ville
		LEFT JOIN t_departements AS S1to_departement ON S1.id_departement_to = S1to_departement.id_departement
		LEFT JOIN t_regions AS S1to_region ON S1.id_region_to = S1to_region.id_region
 
		LEFT JOIN t_membres S2m ON S2.id_membre = S2m.id_membre
		LEFT JOIN t_villes S2from_ville ON S2.id_ville_from = S2from_ville.id_ville
		LEFT JOIN t_departements AS S2from_departement ON S2.id_departement_from = S2from_departement.id_departement
		LEFT JOIN t_regions AS S2from_region ON S2.id_region_from = S2from_region.id_region
		LEFT JOIN t_villes S2to_ville ON S2.id_ville_to = S2to_ville.id_ville
		LEFT JOIN t_departements AS S2to_departement ON S2.id_departement_to = S2to_departement.id_departement
		LEFT JOIN t_regions AS S2to_region ON S2.id_region_to = S2to_region.id_region
 
	WHERE
		S1.id_ville_from = '".$_POST['dest_ville']."'
                AND ((S1.id_ville_to = '".$_POST['prov_ville']."') 
						OR (S1.id_ville_to = 0 AND S1.id_departement_to = '".$_POST['prov_departement']."') 
						OR (S1.id_departement_to = 0 AND S1.id_region_to = '".$_POST['prov_region']."'))
		AND S1.statut = '1'";

Je trouve cette requête très lourde avec toutes les jointures. n'y a t'il pas un solution pour réduire les jointures.


Merci pour votre précieuse aide.
Cordialement,
Morgan

[bstevy]

elle est lourde à l'execution, ou lourde à votre gout ?
Parce qu'a premiere vue, elle m'a l'air pas trop trop mal cette tite requete.

Donc si y'a pas de problème de perf, ca sert peut etre pas à grand chose de chercher à la modifier.

[morgan47]

Lourde a mon gout. Pas de soucis cote performance.

Par contre si je rajoute un 3eme membres ca commence a ramer un peu.

[escartefigue]

quelles sont les métriques : volumétrie de chaque table, volumétrie moyenne sélectionnée par la requete, temps cpu
quelle est la fréquence d'exécution ?

[morgan47]

Alors la tu me parles chinois....

[escartefigue]

1. volumétrie de chaque table : nombre de lignes de chacune des tables de la requête
2. volumétrie moyenne requete : nombre de lignes que la requête sélectionne en moyenne
3. temps CPU : temps processeur consommé par la requête (ne pas confondre avec le temps total qui lui dépend des autres événements qui sollicitent la machine
4. fréquence d'exécution : cette requete doit s'éxécuter tous les jours, une fois par mois, à la demande, sur sollicitation d'une transaction TP...

[Artemus24]

Salut à tous.

@ morgan47 : c'est une plaisanterie ???? Un select avec 16 jointures ! Et questions performances, cela doit ramer.
Il faut revoir d'urgence la conception de votre base de données car il y a un problème de fond.

Et quel est la volumétrie que vous disposez pour affirmer :

Lourde a mon gout. Pas de soucis cote performance.

@+

[morgan47]

Bonjour,

Et bien j'ai essayé de concevoir au mieux et de reflechir à un autre modèle je ne vois pas.

Ma table est créé telle quelle :

id_demande, id_membre, id_region_prov, id_departement_prov_ id_ville_prov, id_service_prov, id_region_des, id_departement_dest, id_ville_dest, id_service_dest

Chaque id correspond a un autre table, les nom sont parlant, mais par exemple, j'ai la table région avec la liste des regions françaises, idem pour les département et les villes.

Comme mon but est de trouver des permutants entre eux, je fais cela x2 ou x3 en fonction de la recherche.

Je ne vois pas comment faire mieux.

Concernant la volumétrie, je ne peux pas répondre, le projet étant en développement, je n'ai pas assez de recul.

[SQLpro]

@ morgan47 : c'est une plaisanterie ???? Un select avec 16 jointures ! Et questions performances, cela doit ramer.
Il faut revoir d'urgence la conception de votre base de données car il y a un problème de fond.

Ce n'est en aucun cas le nombre de jointure qui pose problème. j'ai actuellement en production des requêtes avec plus de 100 jointures et les résultats parviennent en mois d'une seconde ce qui, compte tenu de la volumétrie (7 To) est parfaitement satisfaisant... mais c'est du SQL Server !
Le contraire, c'est à dire éviter les jointures en mettant tout dans la même base serait imbécile et suicidaire !
Lisez l'article que j'ai écrit à ce sujet : http://blog.developpez.com/sqlpro/p1...mances_petites

Il est évident que, comme MySQL est doté de l'un des plus mauvais optimiseur, le nombre de jointure peut poser problème dans certains cas. Il en est de même avec PostGreSQL qui est optimisé par défaut jusqu'à 12 jointures et après utilise GEQO qui optimise de façon bien moins fiable. Oracle ou SQL Server savent optimiser sans problème des dizaines de jointures !

A +