MySQL: répartition rapide des types de jointures

Je voudrais un aperçu rapide des types de jointures MySQL. Je sais de ces derniers, le reste je ne sais pas ce qu'ils signifient.

• séparés par des virgules (à quoi correspond exactement ce raccourci?)SELECT * FROM a, b WHERE b.id = a.beeId AND ...
• afficher 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, ajoute des LEFTchoses de changement.

Je sais déjà comment fonctionnent les jointures, je veux juste savoir s'il existe d'autres types de jointures ou si ce sont simplement des façons différentes d'obtenir le même résultat.

(c) Trouvé sur Google+ "Visualisation des données"

ou consultez les liens suivants pour un bon aperçu:

http://www.khankennels.com/blog/index.php/archives/2007/04/20/getting-joins/

http://www.codinghorror.com/blog/2007/10/a-visual-explanation-of-sql-joins.html

Sur la base de votre commentaire, les définitions simples de chacun se trouvent mieux dans W3Schools La première ligne de chaque type donne une brève explication du type de jointure

• JOIN: renvoie des lignes lorsqu'il y a au moins une correspondance dans les deux tables
• JOINT GAUCHE: renvoie toutes les lignes de la table de gauche, même s'il n'y a pas de correspondance dans la table de droite
• JOINDRE DROITE: 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 des lignes lorsqu'il y a une correspondance dans l'une des tables

FIN DE LA MODIFICATION

En un mot, 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, cela peut également être utilisé dans des colonnes comme

SELECT a.beeName,b.* FROM a, b WHERE b.id = a.beeId AND ...

Il obtient alors les informations demandées dans la ligne où la colonne b.id et la colonne a.beeId ont une correspondance dans votre exemple. Donc, dans votre exemple, il obtiendra toutes les informations des tables a et b où le b.id est égal à a.beeId. Dans mon exemple, il obtiendra toutes les informations de la table b et uniquement les informations de la colonne a.beeName lorsque le b.id est égal à a.beeId. Notez qu'il existe également une clause AND, cela vous aidera à affiner vos résultats.

Pour des tutoriels simples et des explications sur les jointures mySQL et les jointures gauches, jetez un œil aux tutoriels mySQL de Tizag. Vous pouvez également consulter le site Web de Keith J. Brown pour plus d'informations sur les jointures qui sont également très bonnes.

J'espère que ceci vous aide

J'ai 2 tables comme celle-ci:

> 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 se soucie des deux tables

INNER JOIN se soucie des deux tables, donc 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    |
+------+------+------+------+------+

Cela ne fait aucune différence pour INNER JOIN si vous inversez l'ordre, car il se soucie des 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 ne se soucie que de la première table

LEFT JOIN se soucie de la première table que vous lui donnez, et ne se soucie pas beaucoup de la seconde, donc vous obtenez 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 d'entre elles ne correspondent à rien de la table b, mais pas toutes les lignes de table_b - seulement celles qui correspondent à 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 se soucie que de la deuxième table

a RIGHT JOIN bvous donne 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 |
+------+------+------+------+------+

Il s'agit des mêmes lignes que celles table_b LEFT JOIN table_aque nous avons vues 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 les mêmes lignes que table_a LEFT JOIN table_b.

Aucune jointure du tout vous donne des copies de tout

Clause No Join: Si vous écrivez vos tables sans aucune clause JOIN, juste séparées par des virgules, vous obtenez chaque ligne de la première table écrite à côté de chaque ligne de la deuxième table, dans toutes les combinaisons possibles:

> SELECT * FROM table_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 jointures SQL )

La jointure externe complète n'existe pas dans mysql, vous devrez peut-être utiliser une combinaison de jointure gauche et droite.