MySQL : Répartition rapide des types de jointures

Question

J'aimerais avoir une explication rapide des types de jointures MySQL. Je connais certaines d'entre elles, mais je ne suis pas sûr de la signification des autres.

• séparés par des virgules (ce que exactement c'est un diminutif ?) : 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 joints, mais je veux savoir ce qui les rend différents, ce qui est INNER / OUTER l'ajout de LEFT changer les choses.

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 moyens différents d'obtenir le même résultat.

Answer 1

(c) Trouvé sur G+ "Data Visualization" (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

Answer 2

D'après votre commentaire, les définitions simples de chacun d'eux se trouvent à l'adresse suivante W3Schools La première ligne de chaque type donne une brève explication du type de jointure.

• JOIN : Retourne 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 correspondance dans la table de gauche.
• FULL JOIN : Retourne les lignes lorsqu'il y a une correspondance dans l'une des tables.

FIN EDIT

En bref, l'exemple de séparation par virgule que vous avez donné de

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

sélectionne tous les enregistrements des tables a et b en séparant les tables par des virgules. Cette méthode peut également être utilisée dans des colonnes telles que

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

Il récupère alors les informations instruites dans la ligne où la colonne b.id et la colonne a.beeId ont une correspondance dans votre exemple. Ainsi, dans votre exemple, il obtiendra toutes les informations des tables a et b où la colonne b.id est égale à la colonne a.beeId. Dans mon exemple, il obtiendra toutes les informations de la table b et seulement celles de la colonne a.beeName lorsque b.id est égal à a.beeId. Notez qu'il existe également une clause AND, qui vous 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 qui est très bien aussi.

J'espère que cela vous aidera

Answer 3

J'ai 2 tableaux comme celui-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 s'intéresse aux deux tables

INNER JOIN s'intéresse aux 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 s'intéresse aux 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 parce que 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, 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 |
+------+------+------+------+------+

Au-dessus, vous pouvez voir toutes les lignes de la table_a même si certaines d'entre elles ne correspondent à rien dans la table b, mais pas toutes les lignes de la table_b - seulement celles qui correspondent à quelque chose dans la 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 la table_b, mais seulement les lignes correspondantes de la table_a.

RIGHT JOIN ne s'intéresse qu'à la deuxième table.

a RIGHT JOIN b vous donne exactement les mêmes rangs 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 rangs 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 |
+------+------+------+------+------+

Il s'agit des mêmes rangs que table_a LEFT JOIN table_b .

Pas de jointure du tout vous donne des copies de tout

Si vous écrivez vos tableaux sans aucune clause JOIN, en les séparant simplement par des virgules, vous obtenez chaque ligne du premier tableau écrite à côté de chaque ligne du second tableau, 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 jointures SQL )

Answer 4

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

Answer 5

SELECT 'Insert' as Type, A.* 
FROM CustomerStaging A
LEFT JOIN CustomerStagingB B ON A.employee_id = B.employee_id
WHERE B.employee_id is null

UNION

SELECT 'Update' as Type,A.*
FROM CustomerStaging A
JOIN CustomerStagingB B ON A.employee_id = B.employee_id
WHERE            
         A.Field2 <> B.Field2
      or A.Field3 <> B.Field3
      etc     

UNION

SELECT 'Delete' as Type,B.* FROM CustomerStaging A
RIGHT JOIN CustomerStagingB B ON A.employee_id = B.employee_id
WHERE A.employee_id is null;