MySQL: ventilation rapide des types de jointures
Je voudrais une ventilation rapide des types de jointures MySQL. Je connais cela, le reste, je ne suis pas sûr de ce que cela signifie.
- séparés par des virgules (quoi exactement est ce raccourci pour?):
SELECT * FROM a, b WHERE b.id = a.beeId AND ... - affiche les informations de a, même s'il n'y a pas de correspondance dans b:
SELECT * FROM a LEFT OUTER JOIN b ON b.id = a.beeId WHERE ...
J'ai vu d'autres jointures, mais je veux savoir ce qui les rend différentes, ce qui est INNER/OUTER, ajouter LEFT change les choses.
Je sais déjà comment les jointures fonctionnent, je veux juste savoir s’il existe d’autres types de jointures, ou s’il ne s’agit que de différentes manières d’obtenir le même résultat.
En vous basant sur votre commentaire, vous trouverez les définitions simples les plus simples à l’adresse suivante: W3Schools La première ligne de chaque type explique brièvement le type de jointure.
- JOIN: retourne les lignes quand il y a au moins une correspondance dans les deux tables
- LEFT JOIN: Renvoie toutes les lignes de la table de gauche, même s'il n'y a pas de correspondance dans la table de droite
- RIGHT JOIN: Renvoie toutes les lignes de la table de droite, même s'il n'y a pas de correspondance dans la table de gauche
- FULL JOIN: Renvoie les lignes lorsqu'il y a une correspondance dans l'une des tables
END EDIT
En résumé, l’exemple séparé par des virgules que vous avez donné
SELECT * FROM a, b WHERE b.id = a.beeId AND ...
sélectionne chaque enregistrement des tables a et b avec les virgules séparant les tables, ceci peut être utilisé aussi dans les colonnes comme
SELECT a.beeName,b.* FROM a, b WHERE b.id = a.beeId AND ...
Vous obtenez ensuite les informations demandées dans la ligne où la colonne b.id et la colonne a.beeId ont une correspondance dans votre exemple. Ainsi, dans votre exemple, toutes les informations des tables a et b seront obtenues, où b.id est égal à a.beeId. Dans mon exemple, il obtiendra toutes les informations de la table b et uniquement celles de la colonne a.beeName lorsque b.id est égal à a.beeId. Notez qu'il existe également une clause AND, cela aidera à affiner vos résultats.
Pour des tutoriels simples et des explications sur les jointures mySQL et les jointures à gauche, consultez les tutoriels mySQL de Tizag. Vous pouvez également consulter site Web de Keith J. Brown pour plus d'informations sur les jointures, ce qui est également très bon.
J'espère que ceci vous aide
La jointure externe complète n'existe pas dans MySQL, vous devrez peut-être utiliser une combinaison de jointures gauche et droite.
J'ai 2 tables comme ça:
> SELECT * FROM table_a;
+------+------+
| id | name |
+------+------+
| 1 | row1 |
| 2 | row2 |
+------+------+
> SELECT * FROM table_b;
+------+------+------+
| id | name | aid |
+------+------+------+
| 3 | row3 | 1 |
| 4 | row4 | 1 |
| 5 | row5 | NULL |
+------+------+------+
INNER JOIN s'intéresse aux deux tables
INNER JOIN se soucie des deux tables, de sorte que vous n'obtenez une ligne que si les deux tables en ont une. S'il y a plus d'une paire correspondante, vous obtenez plusieurs lignes.
> SELECT * FROM table_a a INNER JOIN table_b b ON a.id=b.aid;
+------+------+------+------+------+
| id | name | id | name | aid |
+------+------+------+------+------+
| 1 | row1 | 3 | row3 | 1 |
| 1 | row1 | 4 | row4 | 1 |
+------+------+------+------+------+
Si vous inversez l'ordre, cela ne fait aucune différence pour INNER JOIN, car cela concerne les deux tables:
> SELECT * FROM table_b b INNER JOIN table_a a ON a.id=b.aid;
+------+------+------+------+------+
| id | name | aid | id | name |
+------+------+------+------+------+
| 3 | row3 | 1 | 1 | row1 |
| 4 | row4 | 1 | 1 | row1 |
+------+------+------+------+------+
Vous obtenez les mêmes lignes, mais les colonnes sont dans un ordre différent car nous avons mentionné les tables dans un ordre différent.
LEFT JOIN s'intéresse uniquement à la première table
LEFT JOIN se soucie de la première table que vous lui donnez, et de la seconde. Vous obtenez donc toujours les lignes de la première table, même s'il n'y a pas de ligne correspondante dans la seconde:
> SELECT * FROM table_a a LEFT JOIN table_b b ON a.id=b.aid;
+------+------+------+------+------+
| id | name | id | name | aid |
+------+------+------+------+------+
| 1 | row1 | 3 | row3 | 1 |
| 1 | row1 | 4 | row4 | 1 |
| 2 | row2 | NULL | NULL | NULL |
+------+------+------+------+------+
Ci-dessus, vous pouvez voir toutes les lignes de table_a même si certaines ne correspondent à rien de la table b, mais pas toutes les lignes de table_b - seules celles correspondant à quelque chose dans table_a.
Si nous inversons l'ordre des tables, LEFT JOIN se comporte différemment:
> SELECT * FROM table_b b LEFT JOIN table_a a ON a.id=b.aid;
+------+------+------+------+------+
| id | name | aid | id | name |
+------+------+------+------+------+
| 3 | row3 | 1 | 1 | row1 |
| 4 | row4 | 1 | 1 | row1 |
| 5 | row5 | NULL | NULL | NULL |
+------+------+------+------+------+
Nous obtenons maintenant toutes les lignes de table_b, mais uniquement les lignes correspondantes de table_a.
RIGHT JOIN ne s'intéresse qu'à la deuxième table
a RIGHT JOIN b vous obtient exactement les mêmes lignes que b LEFT JOIN a. La seule différence est l'ordre par défaut des colonnes.
> SELECT * FROM table_a a RIGHT JOIN table_b b ON a.id=b.aid;
+------+------+------+------+------+
| id | name | id | name | aid |
+------+------+------+------+------+
| 1 | row1 | 3 | row3 | 1 |
| 1 | row1 | 4 | row4 | 1 |
| NULL | NULL | 5 | row5 | NULL |
+------+------+------+------+------+
Ce sont les mêmes lignes que table_b LEFT JOIN table_a, que nous avons vu dans la section LEFT JOIN.
De même:
> SELECT * FROM table_b b RIGHT JOIN table_a a ON a.id=b.aid;
+------+------+------+------+------+
| id | name | aid | id | name |
+------+------+------+------+------+
| 3 | row3 | 1 | 1 | row1 |
| 4 | row4 | 1 | 1 | row1 |
| NULL | NULL | NULL | 2 | row2 |
+------+------+------+------+------+
Est-ce que les mêmes lignes que table_a LEFT JOIN table_b.
Aucune jointure ne vous donne une copie de tout
Si vous écrivez vos tables sans aucune clause JOIN, simplement séparées par des virgules, vous obtenez toutes les lignes de la première table écrites à côté de chaque ligne de la deuxième table, dans toutes les combinaisons possibles:
> SELECT * FROM table_b b, table_a;
+------+------+------+------+------+
| id | name | aid | id | name |
+------+------+------+------+------+
| 3 | row3 | 1 | 1 | row1 |
| 3 | row3 | 1 | 2 | row2 |
| 4 | row4 | 1 | 1 | row1 |
| 4 | row4 | 1 | 2 | row2 |
| 5 | row5 | NULL | 1 | row1 |
| 5 | row5 | NULL | 2 | row2 |
+------+------+------+------+------+
(Ceci est tiré de mon article de blog Exemples de types de jointure SQL )