Discussion :

[thierrybatlle]

Bonjour à tous,

J'ai un problème un peu bizarre sur une requête.
Voici des captures d'écran pour mettre en place le contexte.

MCD :


Le contenu des 3 tables :
T_Mouvement :

T_Stock

T_TypeMouvement


Ce que je veux : récupérer tout les mouvements de façon unique avec des informations contenues dans d'autres tables.

Ma requête 1 :

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
 
SELECT DISTINCT 
	T_Produit.IDProduit AS IDProduit,	
	T_Produit.CodeProduit AS CodeProduit,	
	T_Produit.Libelle AS Libelle,	
	T_Mouvement.IDTypeMouvement AS IDTypeMouvement,	
	T_Mouvement.DateMouvement AS DateMouvement,	
	T_Stock.NumLot AS NumLot,	
	T_Mouvement.IDMouvement AS IDMouvement,	
	T_Stock.Poids AS Poids,	
	T_Stock.DLUO AS DLUO,	
	T_Stock.DLC AS DLC
FROM 
	T_Produit,	
	T_Stock,	
	T_Mouvement
WHERE 
	T_Produit.IDProduit = T_Mouvement.IDProduit
	AND		T_Produit.IDProduit = T_Stock.IDProduit
	AND
	(
		T_Produit.CodeProduit = {ParamCodeProduit}
		AND	T_Mouvement.IDTypeMouvement <> 2
	)

Résultat :

IDProduit	CodeProduit	Libellé	IDTypeMouvement	DateMouvement	NumLot	IDMouvement	Poids	DLUO	DLC
3	07612464336538	Lait UHT	1	11/03/2016	140	3	8	NULL	14/07/2004
3	07612464336538	Lait UHT	1	21/03/2016	140	10	8	NULL	14/07/2004

Ma requête fonctionne comme je le souhaite

Dans ma requête 2 je rajoute le champ "quantité" qui est contenu dans la table "Stock", voici la requête :

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
 
SELECT DISTINCT 
	T_Produit.IDProduit AS IDProduit,	
	T_Produit.CodeProduit AS CodeProduit,	
	T_Produit.Libelle AS Libelle,	
	T_Mouvement.IDTypeMouvement AS IDTypeMouvement,	
	T_Mouvement.DateMouvement AS DateMouvement,	
	T_Stock.NumLot AS NumLot,	
	T_Mouvement.IDMouvement AS IDMouvement,	
	T_Stock.Poids AS Poids,	
	T_Stock.DLUO AS DLUO,	
	T_Stock.DLC AS DLC,	
	T_Stock.Quantite AS Quantite
FROM 
	T_Produit,	
	T_Stock,	
	T_Mouvement
WHERE 
	T_Produit.IDProduit = T_Mouvement.IDProduit
	AND		T_Produit.IDProduit = T_Stock.IDProduit
	AND
	(
		T_Produit.CodeProduit = {ParamCodeProduit}
		AND	T_Mouvement.IDTypeMouvement <> 2
	)

Résultat :

IDProduit	CodeProduit	Libellé	IDTypeMouvement	DateMouvement	NumLot	IDMouvement	Poids	DLUO	DLC	Quantité
3	07612464336538	Lait UHT	1	11/03/2016	140	3	8	NULL	14/07/2004	80,00
3	07612464336538	Lait UHT	1	21/03/2016	140	10	8	NULL	14/07/2004	80,00
3	07612464336538	Lait UHT	1	11/03/2016	140	3	8	NULL	14/07/2004	40,00
3	07612464336538	Lait UHT	1	21/03/2016	140	10	8	NULL	14/07/2004	40,00

Et là le résultat de ma requête s'affiche avec des doublons !!!!!

Je vous remercie bien.

[tatayo]

Bonjour,
Je pense que tu as une "erreur" dans tes jointures, car dans le deuxième résultat il n'y a pas de doublons (au sens SQL).
Si tu regardes les mouvements du 11/03, il y a une ligne avec une quantité de 40, et une autre avec une quantité de 80.
Le problème est visiblement du au fait qu'un mouvement n'est pas lié à un stock.
Donc tu as une ligne par stock, d'où les "doublons". Tu aurais 3 lignes de stock, les lignes du résultat seraient "triplées".
Mais du point de vue SQL, le résultat est normal.

Tatayo.

[tbc92]

Ta requête commence par SELECT DISTINCT

C'est le mot DISTINCT qui te piège.
Personnellement je conseille à tous mes collègues de ne jamais utiliser ce mot DISTINCT. C'est un cache-misère , ou plutôt un cache-problème.

Soit la requête marche et donne le résultat voulu, sans spécifier le mot distinct, soit on veut regrouper X lignes identiques en une seule, et il faut utiliser GROUP BY, et spécifier les colonnes de regroupement.

Quand tu fait select DISTINCT code_article , quantite from ....
Le dédoublonnement se fait, non pas sur la colonne code_article toute seule, mais sur toutes les colonnes de la requête.

Si tu tiens à utiliser DISTINCT, je conseille toujours de faire une première requête , sans le mot DISTINCT. Puis, modifier la requête en ajoutant le mot DISTINCT. Et surtout chercher à comprendre pourquoi c'est pareil, ou pourquoi c'est différent.

L'avantage de passer par GROUP BY, c'est qu'on lui dit EXPLICITEMENT les colonnes qui servent à faire le regroupement. On contrôle la situation. Avec DISTINCT, on fonce les yeux fermés, et 3 fois sur 4, on se trompe.

[tatayo]

tbc92: je ne suis pas d'accord.
DISTINCT et GROUP BY ont chacun un rôle différent, et sont tous les deux utiles.

• DISTINCT permet de dédoublonner le résultat d'une requête.
• GROUP BY permet de faire des regroupement.

Ce n'est pas la même chose !

Par exemple si je veux la liste des clients qui ont acheté un produit donné (mais sans calcul de somme, de moyenne, bref sans regroupement), ma requête va forcément renvoyer des doublons. Comme je veux une liste sans doublon, DISTINCT est tout indiqué. De même dans le cas d'une sous-requête avec un (NOT) IN. Ce n'est pas un regroupement, mais une élimination de doublon.
Par contre, si je veux disons un chiffre d'affaire par client sur une période, là je vais devoir utiliser un GROUP BY, vu que je dois faire une somme.

Chaque opérateur son utilité, il faut juste les utiliser à bon escient.

Par contre je suis d'accord avec toi sur un point: avant de faire la chasse aux doublons dans le résultat d'une requête, il faut se demander pourquoi des lignes sont en doublons. Là se trouve souvent le piège...

Tatayo.

[tbc92]

@tatayo
On est globalement d'accord, mais ...
Group by sert à faire des regroupements, oui, mais peut parfaitement être utilisé pour dédoublonner le résultat d'une requête :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

select distinct id_client from facture

est strictement équivalent à :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

select id_client from facture group by id_client

Peut-être rajouter un order by ... et peut-être une différence en terme de performance (?)

En fait j'ai tellement vu des gens faire une requête bugguée ... et ajouter un distinct, croyant corriger le bug. Alors qu'en fait ils ne corrigeaient pas le bug, ils le rendaient simplement moins facile à détecter.
Dans 9 cas sur 10, quand un non-expert utilise la clause distinct, ça cache un loup.
Alors que quand un non-expert utilise la clause group by, il le fait en connaissance de cause.

[tatayo]

Malheureusement, ce n'est pas vrai avec MySQL...
La requête suivante fonctionne très bien avec ce "sgbd":

Code sql :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
select client.nom,client.prenom
from client
group by client.nom

Aucune erreur, mais le résultat n'est pas du tout celui souhaité. MySQL va dédoublonner sur le nom seul, et dieu seul sait quel prénom va être retenu pour chaque nom (à priori le premier qu'il trouve !).
Avec un DISTINCT, on récupère bien une liste de couple unique nom/prénom.
Ok, c'est un cas particulier, du au support catastrophique de la norme par MySQL.

Sinon je viens de faire un test rapide sur ma base (MaxDb):

Code sql :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
explain select distinct art_c_ref from article
//
explain select art_c_ref from article group by art_c_ref

Et le résultat pour la première:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
OWNER	TABLENAME	COLUMN_OR_INDEX	STRATEGY	PAGECOUNT
TORPEDO	ARTICLE	I_GRPDIM	INDEX SCAN	       235
			ONLY INDEX ACCESSED	
			DISTINCT OPTIMIZATION (A)	
			   RESULT IS NOT COPIED , COSTVALUE IS	       235

Et pour la deuxième:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
OWNER	TABLENAME	COLUMN_OR_INDEX	STRATEGY	PAGECOUNT
TORPEDO	ARTICLE	I_GRPDIM	INDEX SCAN	       235
			ONLY INDEX ACCESSED	
			     RESULT IS COPIED   , COSTVALUE IS	       705

Comme on peut le voir, les plans d'exécutions ne sont pas les mêmes, ni le coût de la requête (235 contre 705). Donc non, ces deux requêtes ne sont pas strictement équivalentes, même si elles donnent le même résultat !


Je vois aussi beaucoup de requêtes mal écrites (il suffit de faire un tour sur la section dédiée du forum), mais je préfère largement expliquer les rôles respectifs de DISTINCT et GROUP BY, et quand les utiliser, plutôt que de conseiller de laisser tomber le premier pour utiliser un "effet secondaire" du deuxième.

Tatayo.