MySQL: ventilation rapide des types de jointures

(c) Trouvé sur G + “Visualisation de 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 sont mieux trouvées sur W3Schools. La première ligne de chaque type donne une brève explication du type de jointure.

• JOIN: renvoie les lignes lorsqu’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 correspondances dans la table de gauche
• FULL JOIN: retourne des lignes quand il y a une correspondance dans l’une des tables

END EDIT

En résumé, l’exemple 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 reçoit alors les informations demandées dans la ligne où la colonne b.id et la colonne a.beeId correspondent dans votre exemple. Donc, dans votre exemple, il récupérera toutes les informations des tables a et b où 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 didacticiels simples et des explications sur les jointures mySQL et les jointures à gauche, consultez les didacticiels mySQL de Tizag. Vous pouvez également consulter le site Web de Keith J. Brown pour plus d’informations sur les jointures, ce qui est très bien aussi.

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 jointure gauche et droite.

J’ai 2 tables comme ceci:

 > 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’avez qu’une ligne 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 | +------+------+------+------+------+ 

Il n’y a aucune différence pour INNER JOIN si vous inversez l’ordre, car il se préoccupe 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 s’intéresse qu’à 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, 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 d’entre elles ne correspondent à rien dans 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 | +------+------+------+------+------+ 

Maintenant, nous obtenons toutes les lignes de table_b, mais seulement les lignes correspondantes de table_a.

RIGHT JOIN ne se soucie que de la deuxième table

a RIGHT JOIN b vous procure 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 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 .

Pas de jointure du tout vous donne des copies de tout

Si vous écrivez vos tables sans clause JOIN, simplement 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 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 provient de mon article de blog Exemples de types de jointure SQL )