MySQL: Schnelle Aufschlüsselung der Join-Typen

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

• Komma getrennt (wofür genau ist diese Abkürzung?):SELECT * FROM a, b WHERE b.id = a.beeId AND ...
• Informationen von a anzeigen, auch wenn in b keine Übereinstimmungen vorhanden sind: SELECT * FROM a LEFT OUTER JOIN b ON b.id = a.beeId WHERE ...

Ich habe gesehen , andere schließt sich, aber wollen wissen , was sie von anderen unterscheidet, was ist INNER/ OUTER, wirkt sich das Hinzufügen LEFTDinge ändern.

Ich weiß bereits, wie Verknüpfungen funktionieren. Ich möchte nur wissen, ob es andere Arten von Verknüpfungen gibt oder ob es sich nur um unterschiedliche Methoden handelt, um das gleiche Ergebnis zu erzielen.

(c) Gefunden auf G + "Datenvisualisierung"

oder sehen Sie sich die folgenden Links für eine gute Übersicht an:

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

Basierend auf Ihrem Kommentar finden Sie bei W3Schools am besten einfache Definitionen. Die erste Zeile jedes Typs enthält eine kurze Erläuterung des Join-Typs

• JOIN: Gibt Zeilen zurück, wenn in beiden Tabellen mindestens eine Übereinstimmung vorhanden ist
• 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 in einer der Tabellen eine Übereinstimmung vorliegt

END EDIT

Kurz gesagt, das durch Kommas getrennte Beispiel, von dem Sie gegeben haben

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

Wenn jeder Datensatz aus den Tabellen a und b mit den Kommas zwischen den Tabellen ausgewählt wird, 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 Spalte b.id und die Spalte a.beeId in Ihrem Beispiel übereinstimmen. In Ihrem Beispiel werden also alle Informationen aus den Tabellen a und b abgerufen, wobei die b.id gleich a.beeId ist. In meinem Beispiel werden alle Informationen aus der Tabelle b und nur Informationen aus der Spalte a.beeName 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 Links-Joins finden Sie in den mySQL-Tutorials von Tizag. Sie können auch die Website von Keith J. Brown besuchen, um weitere Informationen zu Joins zu erhalten, die ebenfalls recht gut sind.

ich hoffe das hilft dir

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 )

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