it-swarm.com.de

MySQL: Schnelle Aufschlüsselung der Join-Typen

Ich möchte eine kurze Aufschlüsselung der Arten von MySQL-Joins. Ich weiß davon, der Rest weiß nicht, was sie bedeuten.

  • komma getrennt (wofür gena steht diese Abkürzung?): SELECT * FROM a, b WHERE b.id = a.beeId AND ...
  • zeige Informationen von a an, auch wenn es keine Übereinstimmungen in b gibt: SELECT * FROM a LEFT OUTER JOIN b ON b.id = a.beeId WHERE ...

Ich habe andere Verknüpfungen gesehen, möchte aber wissen, was sie unterscheidet, was INNER/OUTER ist und was das Hinzufügen von LEFT ändert.

Ich weiß bereits, wie Verknüpfungen funktionieren. Ich möchte nur wissen, ob es andere Arten von Verknüpfungen gibt oder ob es nur verschiedene Möglichkeiten gibt, das gleiche Ergebnis zu erzielen.

143
Bryan Field
435
Rufinus

Basierend auf Ihrem Kommentar finden Sie einfache Definitionen für jeden Typ am besten unter W3Schools In der ersten Zeile jedes Typs finden Sie eine kurze Erläuterung des Join-Typs

  • JOIN: Gibt Zeilen zurück, wenn in beiden Tabellen mindestens eine Übereinstimmung vorliegt
  • LEFT JOIN: Gibt alle Zeilen aus der linken Tabelle zurück, auch wenn die rechte Tabelle keine Übereinstimmungen enthält
  • RIGHT JOIN: Gibt alle Zeilen aus der rechten Tabelle zurück, auch wenn die linke Tabelle keine Übereinstimmungen enthält
  • FULL JOIN: Gibt Zeilen zurück, wenn eine Übereinstimmung in einer der Tabellen vorliegt

END EDIT

Kurz gesagt, das kommagetrennte Beispiel, das Sie gegeben haben

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

wenn Sie jeden Datensatz aus den Tabellen a und b auswählen und die Tabellen durch Kommas trennen, kann dies auch in Spalten wie verwendet werden

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

Anschließend werden die angewiesenen Informationen in der Zeile abgerufen, in der die Spalten b.id und a.beeId in Ihrem Beispiel übereinstimmen. In Ihrem Beispiel werden alle Informationen aus den Tabellen a und b abgerufen, in denen die b.id gleich a.beeId ist. In meinem Beispiel werden alle Informationen aus der b-Tabelle und nur die Informationen aus der a.beeName-Spalte abgerufen, wenn die b.id der a.beeId entspricht. Beachten Sie, dass es auch eine AND-Klausel gibt, mit deren Hilfe Sie Ihre Ergebnisse verfeinern können.

Einige einfache Tutorials und Erklärungen zu mySQL-Joins und Left-Joins finden Sie in den mySQL-Tutorials von Tizag. Sie können sich auch Keith J. Browns Website ansehen, um weitere Informationen zu Joins zu erhalten, die auch ganz gut sind.

Ich hoffe das hilft dir

26
Ryan

Vollständige äußere Verknüpfung gibt es in MySQL nicht. Möglicherweise müssen Sie eine Kombination aus linker und rechter Verknüpfung verwenden.

11
IBEANS

Ich habe 2 Tabellen wie folgt:

> 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 Tabellen

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 es um beide Tabellen geht:

> 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 die erste Tabelle

LEFT JOIN kümmert sich um die erste Tabelle, die Sie geben, und nicht um die zweite. Daher erhalten Sie immer die Zeilen aus der ersten Tabelle, 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 mit allen Zeilen von table_b - nur mit denen, 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 die zweite Tabelle

a RIGHT JOIN b gibt Ihnen 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_a, das wir in der LEFT JOIN Sektion gesehen haben.

Ä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 |
+------+------+------+------+------+

Sind die gleichen Zeilen wie table_a LEFT JOIN table_b.

Kein Join gibt dir Kopien von allem

Wenn Sie Ihre Tabellen ohne JOIN-Klausel, nur durch Kommas getrennt, schreiben, erhalten Sie jede Zeile der ersten Tabelle neben jeder Zeile der zweiten Tabelle in jeder möglichen Kombination:

> 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 |
+------+------+------+------+------+

(Dies ist aus meinem Blog-Post Beispiele für SQL-Join-Typen )

10
Andy Balaam