Garder uniquement la valeur MIN

Version imprimable

1 pièce(s) jointe(s)

Bonjour,

J'ai un problème sur la requête suivante :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 SELECT OFS.ID_OFS, OFS_ARTICLE.REF, OFS_ARTICLE.CLASSE_CLI, OFS.QTE_BONNE FROM OFS FULL JOIN OFS_ARTICLE ON OFS_ARTICLE.CD_OFS_ARTICLE = OFS.CD_OFS_ARTICLE FULL JOIN CLIENT ON CLIENT.CD_CLIENT = OFS.CD_CLIENT WHERE OFS.ETAT_OF <> 'SO' AND OFS.ETAT_OF <> 'T' AND OFS.ETAT_OF <> 'S' AND OFS_ARTICLE.PROC_PREM <> '0' AND OFS_ARTICLE.REF NOT LIKE 'EPR%' AND OFS_ARTICLE.REF NOT LIKE 'STR%' AND OFS_ARTICLE.REF NOT LIKE 'CONT%'
Je cherche à ne plus avoir de doublons (voir pièce jointe Excel), je m'explique :

Si on prend l'exemple de la référence (colonne B) V528.84654.200.00, je souhaite uniquement afficher la ligne de l'OF (Ordre de Fabrication : colonne A) le plus petit. Pour cette référence, il faudrait donc un code qui me permette de n'afficher que la ligne 8 (OF 29546) sans afficher la ligne 51 (OF 31398). Même logique pour tous les autres doublons, je veux uniquement afficher les lignes des OF les plus petits.

J'ai imaginé utiliser la fonction MIN en SQL mais je n'arrive pas à faire marcher mon code, auriez-vous une solution ?

Bien cordialement,

Marin SIMONS

Bonjour,
Pour commencer je ne vois pas l'utlité de la table CLIENT (ni données extraites de cette table ni conditions sur celle-ci), donc votre requête (avant élimination des doublons) peut s'écrire comme suit:

Code:

1
2
3
4
5
6
7
8
9
10
SELECT OFS.ID_OFS,
       OFS_ARTICLE.REF,
       OFS_ARTICLE.CLASSE_CLI,
       OFS.QTE_BONNE
FROM   OFS, 
       OFS_ARTICLE
 --    CLIENT
WHERE  OFS_ARTICLE.CD_OFS_ARTICLE = OFS.CD_OFS_ARTICLE
--AND  CLIENT.CD_CLIENT = OFS.CD_CLIENT 
AND    OFS.ETAT_OF <> 'SO' AND OFS.ETAT_OF <> 'T' AND OFS.ETAT_OF <> 'S' AND OFS_ARTICLE.PROC_PREM <> '0' AND OFS_ARTICLE.REF NOT LIKE 'EPR%' AND OFS_ARTICLE.REF NOT LIKE 'STR%' AND OFS_ARTICLE.REF NOT LIKE 'CONT%'

Maintenat on peut isoler les 2 premières colonnes concernés par le regroupement qu'on fera par la suite.
Donc on prend uniquement les 2 premières colonnes avec leurs tables, les jointures et les conditions sur ces 2 tables

Code:

1
2
3
4
5
6
SELECT OFS.ID_OFS,
       OFS_ARTICLE.REF
FROM   OFS, 
       OFS_ARTICLE
WHERE  OFS_ARTICLE.CD_OFS_ARTICLE = OFS.CD_OFS_ARTICLE
AND    OFS.ETAT_OF <> 'SO' AND OFS.ETAT_OF <> 'T' AND OFS.ETAT_OF <> 'S' AND OFS_ARTICLE.PROC_PREM <> '0' AND OFS_ARTICLE.REF NOT LIKE 'EPR%' AND OFS_ARTICLE.REF NOT LIKE 'STR%' AND OFS_ARTICLE.REF NOT LIKE 'CONT%'

Pour éliminer les doublons on fait un regroupement par rapport à al 2ème colonne et on obtient ça:

Code:

1
2
3
4
5
6
7
SELECT MIN(OFS.ID_OFS),
       OFS_ARTICLE.REF 
FROM   OFS, 
       OFS_ARTICLE
WHERE  OFS_ARTICLE.CD_OFS_ARTICLE = OFS.CD_OFS_ARTICLE
AND    OFS.ETAT_OF <> 'SO' AND OFS.ETAT_OF <> 'T' AND OFS.ETAT_OF <> 'S' AND OFS_ARTICLE.PROC_PREM <> '0' AND OFS_ARTICLE.REF NOT LIKE 'EPR%' AND OFS_ARTICLE.REF NOT LIKE 'STR%' AND OFS_ARTICLE.REF NOT LIKE 'CONT%'
GROUP BY OFS_ARTICLE.REF;

Maintenant on ramène toutes les colonnes que vous voudriez extraire et on fait une "Jointure" avec le résultat intermédiare qu'on a ramené dans la requête précédente:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
SELECT OFS.ID_OFS,
       OFS_ARTICLE.REF,
       OFS_ARTICLE.CLASSE_CLI,
       OFS.QTE_BONNE
WHERE  OFS_ARTICLE.CD_OFS_ARTICLE = OFS.CD_OFS_ARTICLE
AND    (OFS.ID_OFS, OFS_ARTICLE.REF) IN
                                       (SELECT MIN(OFS.ID_OFS) ,
                                               OFS_ARTICLE.REF 
                                        FROM   OFS, 
                                               OFS_ARTICLE
                                        WHERE  OFS_ARTICLE.CD_OFS_ARTICLE = OFS.CD_OFS_ARTICLE
                                        AND    OFS.ETAT_OF <> 'SO' AND OFS.ETAT_OF <> 'T' AND OFS.ETAT_OF <> 'S' AND OFS_ARTICLE.PROC_PREM <> '0' AND OFS_ARTICLE.REF NOT LIKE 'EPR%' AND OFS_ARTICLE.REF NOT LIKE 'STR%' AND OFS_ARTICLE.REF NOT LIKE 'CONT%'
                                        GROUP BY OFS_ARTICLE.REF);

29/11/2020, 09h55
CinePhil

Les jointures s'écrivent depuis 1992 avec l'opérateur JOIN. Ça fait bientôt 30 ans ; il serait temps de s'y mettre ! :roll:

1 pièce(s) jointe(s)

Bonjour,

Merci bien pour ces éclaircissements. Le code suivant fonctionne :

Code:

1
2
3
4
5
6
7
SELECT MIN(OFS.ID_OFS),
       OFS_ARTICLE.REF 
FROM   OFS, 
       OFS_ARTICLE
WHERE  OFS_ARTICLE.CD_OFS_ARTICLE = OFS.CD_OFS_ARTICLE
AND    OFS.ETAT_OF <> 'SO' AND OFS.ETAT_OF <> 'T' AND OFS.ETAT_OF <> 'S' AND OFS_ARTICLE.PROC_PREM <> '0' AND OFS_ARTICLE.REF NOT LIKE 'EPR%' AND OFS_ARTICLE.REF NOT LIKE 'STR%' AND OFS_ARTICLE.REF NOT LIKE 'CONT%'
GROUP BY OFS_ARTICLE.REF;

Néanmoins, le code suivant affiche une erreur :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
SELECT OFS.ID_OFS,
       OFS_ARTICLE.REF,
       OFS_ARTICLE.CLASSE_CLI,
       OFS.QTE_BONNE
WHERE  OFS_ARTICLE.CD_OFS_ARTICLE = OFS.CD_OFS_ARTICLE
AND    (OFS.ID_OFS, OFS_ARTICLE.REF) IN
                                       (SELECT MIN(OFS.ID_OFS) ,
                                               OFS_ARTICLE.REF 
                                        FROM   OFS, 
                                               OFS_ARTICLE
                                        WHERE  OFS_ARTICLE.CD_OFS_ARTICLE = OFS.CD_OFS_ARTICLE
                                        AND    OFS.ETAT_OF <> 'SO' AND OFS.ETAT_OF <> 'T' AND OFS.ETAT_OF <> 'S' AND OFS_ARTICLE.PROC_PREM <> '0' AND OFS_ARTICLE.REF NOT LIKE 'EPR%' AND OFS_ARTICLE.REF NOT LIKE 'STR%' AND OFS_ARTICLE.REF NOT LIKE 'CONT%'
                                        GROUP BY OFS_ARTICLE.REF);

Pièce jointe 585261

Cordialement,

Marin SIMONS

Ma foi, ce code (ajout FROM) semble marcher :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
SELECT OFS.ID_OFS,
       OFS_ARTICLE.REF,
       OFS_ARTICLE.CLASSE_CLI,
       OFS.QTE_BONNE
FROM   OFS, 
       OFS_ARTICLE
WHERE  OFS_ARTICLE.CD_OFS_ARTICLE = OFS.CD_OFS_ARTICLE
AND    (OFS.ID_OFS, OFS_ARTICLE.REF) IN
                                       (SELECT MIN(OFS.ID_OFS) ,
                                               OFS_ARTICLE.REF 
                                        FROM   OFS, 
                                               OFS_ARTICLE
                                        WHERE  OFS_ARTICLE.CD_OFS_ARTICLE = OFS.CD_OFS_ARTICLE
                                        AND    OFS.ETAT_OF <> 'SO' AND OFS.ETAT_OF <> 'T' AND OFS.ETAT_OF <> 'S' AND OFS_ARTICLE.PROC_PREM <> '0' AND OFS_ARTICLE.REF NOT LIKE 'EPR%' AND OFS_ARTICLE.REF NOT LIKE 'STR%' AND OFS_ARTICLE.REF NOT LIKE 'CONT%'
                                        GROUP BY OFS_ARTICLE.REF);

Je vous remercie !

Marin

29/11/2020, 18h44
escartefigue

Bonsoir,

Sauf que vous n'avez pas tenu compte de l'observation de Cinephil :

Citation:

Envoyé par CinePhil

Les jointures s'écrivent depuis 1992 avec l'opérateur JOIN. Ça fait bientôt 30 ans ; il serait temps de s'y mettre ! :roll:

Ce faisant, vous utilisez une requête potentiellement non optimisée. L'utilisation de l'opérateur JOIN est recommandée et facilite la lecture ;)
29/11/2020, 18h51
marin95600

J'ai essayé de réutiliser mes FULL JOIN avec la logique de "Mahdois" et je ne suis pas parvenu à faire marcher mon code.

Bonsoir Marin95600,

La clause WHERE qui rapproche les tables sur la colonne CD_OFS_ARTICLE correspond à une équi-jointure (INNER JOIN). Donc pour traduire la requête de Mahdois :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
SELECT OFS.ID_OFS,
       OFS_ARTICLE.REF,
       OFS_ARTICLE.CLASSE_CLI,
       OFS.QTE_BONNE
FROM   OFS 
   INNER JOIN OFS_ARTICLE ON OFS_ARTICLE.CD_OFS_ARTICLE = OFS.CD_OFS_ARTICLE
WHERE  (OFS.ID_OFS, OFS_ARTICLE.REF) IN
                                       (SELECT MIN(OFS.ID_OFS) , OFS_ARTICLE.REF 
                                        FROM    OFS 
						INNER JOIN OFS_ARTICLE ON OFS_ARTICLE.CD_OFS_ARTICLE = OFS.CD_OFS_ARTICLE
                                        WHERE OFS.ETAT_OF <> 'SO' 
                                          AND OFS.ETAT_OF <> 'T' 
                                          AND OFS.ETAT_OF <> 'S' 
                                          AND OFS_ARTICLE.PROC_PREM <> '0' 
                                          AND OFS_ARTICLE.REF NOT LIKE 'EPR%' 
                                          AND OFS_ARTICLE.REF NOT LIKE 'STR%' 
                                          AND OFS_ARTICLE.REF NOT LIKE 'CONT%'
                                        GROUP BY OFS_ARTICLE.REF);

Pourquoi chercher à faire une requête FULL JOIN ? J'imagine mal des ordres de fabrication sans article, devez-vous lister les articles sans ordre de fabrication ?

Essayez ainsi :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
  select min(ofs.id_ofs) as id_ofs
       , art.ref
       , art.classe_cli
       , min(ofs.qte_bonne) keep(dense_rank first order by ofs.id_ofs asc) as qte_bonne
    from ofs
    join ofs_article art on art.cd_ofs_article = ofs.cd_ofs_article
   where ofs.etat_of not in ('SO', 'T', 'S')
     and art.proc_prem   <> '0'
     and art.ref   not like 'EPR%'
     and art.ref   not like 'STR%'
     and art.ref   not like 'CONT%'
group by art.ref
       , art.classe_cli;