Ich habe 2 Tabellen wie diese:
> 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 kümmert sich um beide Tische
INNER JOIN kümmert sich um beide Tabellen, sodass Sie nur dann eine Zeile erhalten, wenn beide Tabellen eine haben. Wenn es mehr als ein übereinstimmendes Paar gibt, erhalten Sie mehrere Zeilen.
> 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 |
+------+------+------+------+------+
Für INNER JOIN macht es keinen Unterschied, ob Sie die Reihenfolge umkehren, da beide Tabellen betroffen sind:
> 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 |
+------+------+------+------+------+
Sie erhalten die gleichen Zeilen, aber die Spalten sind in einer anderen Reihenfolge, da wir die Tabellen in einer anderen Reihenfolge erwähnt haben.
LEFT JOIN kümmert sich nur um den ersten Tisch
LEFT JOIN kümmert sich um die erste Tabelle, die Sie geben, und kümmert sich nicht viel um die zweite, sodass Sie immer die Zeilen aus der ersten Tabelle erhalten, auch wenn in der zweiten keine entsprechende Zeile vorhanden ist:
> 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 |
+------+------+------+------+------+
Oben sehen Sie alle Zeilen von table_a, obwohl einige von ihnen mit nichts in Tabelle b übereinstimmen, aber nicht alle Zeilen von table_b - nur diejenigen, die mit etwas in table_a übereinstimmen.
Wenn wir die Reihenfolge der Tabellen umkehren, verhält sich LEFT JOIN anders:
> 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 |
+------+------+------+------+------+
Jetzt erhalten wir alle Zeilen von table_b, aber nur übereinstimmende Zeilen von table_a.
RIGHT JOIN kümmert sich nur um den zweiten Tisch
a RIGHT JOIN bSie erhalten genau die gleichen Zeilen wie b LEFT JOIN a. Der einzige Unterschied ist die Standardreihenfolge der Spalten.
> 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 |
+------+------+------+------+------+
Dies sind die gleichen Zeilen wie table_b LEFT JOIN table_aim Abschnitt LEFT JOIN.
Ähnlich:
> 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 |
+------+------+------+------+------+
Ist die gleichen Zeilen wie table_a LEFT JOIN table_b.
Kein Join gibt Ihnen Kopien von allem
Keine Join-Klausel: Wenn Sie Ihre Tabellen ohne JOIN-Klausel schreiben, nur durch Kommas getrennt, erhalten Sie jede Zeile der ersten Tabelle neben jeder Zeile der zweiten Tabelle in jeder möglichen Kombination:
> 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 |
+------+------+------+------+------+
(Dies ist aus meinem Blog-Beitrag Beispiele für SQL-Join-Typen )
