Mettre une condition dans la partie ON(jointure) ou where?

Bonjour,
SVP,j'aimerai comprendre la différence entre mettre une condition dans la partie on ou where?parceque j'ai remarqué que des fois il n y a pas de difference et des fois l'emplacement de la condition retourne deux resultats diffirents?

Code:

---

1 2 3 4

table produit id_produit nom_produit

---

Code:

---

1 2 3 4 5

table Produit_vendus id_facture id_produit quantité

---

qu'elle est la difference entre les deux requetes malgre que leurs resultats est identique
requete 1

Code:

---

1 2 3 4 5

select a.* from produit a inner join Produit_vendus b on a.id_produit=b.id_produit and b.quantite>100

---

requete 2

Code:

---

1 2 3 4 5 6

select a.* from produit a inner join Produit_vendus b on a.id_produit=b.id_produit Where b.quantite>100

---

Merci d'avance

Bonjour
Dans ta requête, il n'y a pas de différence, il peut y avoir une différence de résultat sur l'emplacement de prédicat dans les requête avec des jointures externes (LEFT JOIN, RIGHT JOIN, FULL JOIN).
Le résultat avec une jointure externe génère du NULL, du coup en filtrant dans le WHERE ça fait sortir les valeurs null, dans le ON ça laisse la valeur NULL + le résultat du WHERE.

Ce n'est effectivement pas la même chose.
Aussi, c'est plus parlant avec des LEFT JOIN (plutôt que des INNER JOIN).

Quelques exemples...

1. Ceci :

Code:

---

1 2 3 4 5

SELECT * FROM produit A LEFT JOIN Produit_vendus B ON (A.id_produit = B.id_produit AND B.quantite > 100)

---

...devrait retourner le même résultat que cela :

Code:

---

1 2 3 4 5 6 7 8

SELECT * FROM produit A LEFT JOIN ( SELECT * FROM Produit_vendus B.quantite > 100 ) B ON (A.id_produit = B.id_produit)

---

2. Il est possible de faire des jointures uniquement sous certaines conditions :

Code:

---

1 2 3 4 5

SELECT * FROM produit A LEFT JOIN Produit_vendus B ON (A.nom_produit LIKE 'abc%' AND A.id_produit = B.id_produit)

---

Ici, on effectue la jointure que pour les enregistrements de A dont le champs "nom_produit" commence par "abc".
Pour les enregistrements de A dont le champs "nom_produit" ne commence pas par "abc", les champs de B apparaîtront comme NULL.

Ça m'est arrivé une fois, on m'a demandé de faire une vue avec plein de cas particuliers (en partant d'une table A, suivant les valeurs de certains champs de A, on va chercher des informations complémentaires dans les table B ou C ou D ou E...).

J'avais le choix entre une requête avec plein d'UNIONs et des conditions partout :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

SELECT a.id, a.foo, a.bar, b.val AS valB, CAST(NULL AS INT) AS valC, CAST(NULL AS INT) AS valD, ... FROM A INNER JOIN B ON (A.id = B.id_A) WHERE a.foo IN (1, 2)   UNION ALL   SELECT a.id, a.foo, a.bar, NULL, c.val, NULL, ... FROM a INNER JOIN c ON (a.id = c.id_A) WHERE a.bar IN (2, 3, 4)     UNION ALL ...

---

...ou alors faire une requête avec des conditions dans les jointures :

Code:

---

1 2 3 4 5 6 7 8 9 10

SELECT a.id, a.foo, a.bar, a.val AS val1, c.val AS valC, d.val AS valD, ... FROM a LEFT JOIN b ON (a.foo IN (1, 2) AND a.id = b.id_A)   LEFT JOIN c ON (a.bar IN (2, 3, 4) AND a.id = c.id_A) ...

---

La deuxième avait beaucoup d'avantages :
- plus lisible
- pour certaines valeurs (a.foo = 2, a.bar = 3), on se retrouve avec des cas complexes qu'il faut gérer (doublons). Avec la deuxième solution, c'est plus beaucoup plus simple à gérer (on spécifie exactement dans quelles conditions la jointure doit avoir lieu)
- si on a des index sur les champs ayant une condition dans la jointure (a.foo, a.bar), et que ceux-ci sont suffisamment discriminants pour les valeurs qui nous intéressent, alors SQL Server arrive à optimiser

Voilà, c'étaient deux exemple de conditions dans une jointure :
1. condition sur des champs de la table de droite
2. condition sur des champs de la table de gauche

...ainsi que des équivalents sans condition dans la jointure, mais dans le WHERE (et des UNIONs à vous rendre fou)

Pour des raisons de compatibilité, il vaut mieux éviter les valeurs littérales dans la clause ON.

En effet, Access par exemple, mais aussi certaines vieilles versions d'Oracle notamment, ne supportent pas de valeurs littérales dans le ON :

Code:

---

1 2 3 4

select * from tableA A iner join tableB B on B.col1 = A.col1 and B.col2 = 'Z'

---

=> Plante

Code:

---

1 2 3 4 5

select * from tableA A iner join tableB B on B.col1 = A.col1 WHERE B.col2 = 'Z'

---

=> Fonctionne

Donc en présence d'une telle restriction, bien réfléchir si la valeur littérales est réellement nécessaire, car si le code doit être porté sur Access par exemple, il faudra passer par une vue, ce qui obligera à réécrire une partie du code inutilement.