Join-Operation in MySQL

Arten von Verknüpfungen

1. Innerer Join: Die Felder in den beiden Tabellen, die über eine Join-Beziehung verfügen, bilden einen Datensatz, der die Datensätze verbindet, die die Join-Beziehung erfüllen.

2. Äußerer Join: unterteilt in äußeren linken Join und äußeren rechten Join.

Hintergrund des Falles

Tabelle Java erstellen (Name varchar(255));
in Java-Werte einfügen ('java1'), ('java2'), ('blau'); 
Tabelle MySQL erstellen (Name varchar(255));
in MySQL-Werte einfügen ('mysql1'), ('mysql2'), ('blau');

Innerer Join

Wählen Sie * aus Java, MySQL, wobei java.name = mysql.name;
Wählen Sie * aus Java JOIN MySQL ON java.name = mysql.name;
Wählen Sie * aus Java INNER JOIN mysql auf java.name = mysql.name;
Wählen Sie * aus Java CROSS JOIN MySQL auf java.name = mysql.name;
Wählen Sie * aus Java STRAIGHT_JOIN MySQL auf Java.Name = MySQL.Name;

Diese vier Anweisungen sind alle Inner Joins und die zurückgegebenen Ergebnisse sind

+------+------+
| Name | Name |
+------+------+
| blau | blau |
+------+------+

• Jedes Komma in einem table_reference-Eintrag wird als innerer Join behandelt.
• Der Standard-JOIN ist INNER JOIN
• CROSS JOIN ist syntaktisch äquivalent zu INNER JOIN
• STRAIGHT_JOIN ist dasselbe wie JOIN. Bis auf eine Sache wird die linke Tabelle vor der rechten Tabelle gelesen. STRAIGH_JOIN kann in Situationen verwendet werden, in denen der Join-Optimierer die Tabellen in der falschen Reihenfolge anordnen würde.

Die Syntax für einen Inner Join lautet wie folgt:

Tabelle verbinden:
 Tabellenreferenz [INNER | CROSS] JOIN Tabellenfaktor [Joinbedingung]
 | Tabellenreferenz STRAIGHT_JOIN Tabellenfaktor
 | Tabellenreferenz STRAIGHT_JOIN Tabellenfaktor ON-Bedingung

Äußerer Join

Linke Verbindung

Wählen Sie * aus Java LEFT JOIN MySQL ON Java.Name = mysql.Name;

sich herausstellen

+----------+------+
| Name | Name |
+----------+------+
| java1 | NULL |
| java2 | NULL |
| blau | blau |
+----------+------+

Aus den obigen Ergebnissen können wir daher ersehen, dass die Tabelle „Java“ leer ist, weil es für die Namen der Datensätze „Java1“ und „Java2“ in der Java-Tabelle keinen entsprechenden Namen in der MySQL-Tabelle gibt. Alle Spalten von „Java“ enthalten jedoch weiterhin Datensätze „Java1“ und „Java2“ und alle Spalten der MySQL-Tabelle sind NULL. Der verbleibende blaue Datensatz ist das Ergebnis des inneren Verbunds zwischen der Java-Tabelle und der MySQL-Tabelle.

Wenn im ON- oder USING-Teil eines LEFT JOIN keine passenden Datensätze für die rechte Tabelle vorhanden sind, wird für die rechte Tabelle eine Zeile verwendet, bei der alle Spalten auf NULL gesetzt sind. Mit dieser Methode können Sie Datensätze in einer Tabelle finden, für die es in einer anderen Tabelle keine Entsprechung gibt:

Wählen Sie * aus Java LEFT JOIN mysql auf java.name = mysql.name, wobei mysql.name NULL ist;

Dieses SQL findet Personen, die Java, aber nicht MySQL verwenden. Offensichtlich erfüllen die Personen „Java1“ und „Java2“ die Anforderung.

Richtige Verbindung

Wählen Sie * aus Java RECHTS JOIN MySQL ON Java.Name = mysql.Name;

Das zurückgegebene Ergebnis ist

+------+--------+
| Name | Name |
+------+--------+
| NULL | mysql1 |
| NULL | mysql2 |
| blau | blau |
+------+--------+

Der rechte Join hat ähnliche Ergebnisse wie der linke Join, außer dass dieses Mal die MySQL-Tabelle alle Ergebnissätze enthält.

Outer-Join-Syntax

Join_Tabelle:| Tabellenreferenz LINKS [AUSSEN] JOIN Tabellenreferenz Join_Bedingung
 | Tabellenreferenz NATURAL [LEFT [OUTER]] JOIN Tabellenfaktor
 | Tabellenreferenz RECHTS [AUSSEN] JOIN Tabellenreferenz Joinbedingung
 | Tabellenreferenz NATURAL [RIGHT [OUTER]] JOIN Tabellenfaktor

USING(column_list)-Klausel

Wird verwendet, um eine Reihe von Spalten zu benennen, die in beiden Tabellen vorhanden sein müssen.

Wählen Sie java.*, mysql.* aus. Von Java links verbinden Sie mysql mit Hilfe von (Name);

Ergebnisse

+----------+------+
| Name | Name |
+----------+------+
| java1 | NULL |
| java2 | NULL |
| blau | blau |
+----------+------+

Reihenfolge der Operationen für Verknüpfungen

Wählen Sie * aus t1 links Join (t2, t3, t4) auf (t2.a = t1.a und t3.b = t1.b und t4.c = t1.c);
--Entspricht SELECT * FROM t1 LEFT JOIN (t2 CROSS JOIN t3 CROSS JOIN t4) ON (t2.a=t1.a AND t3.b=t1.b AND t4.c=t1.c)

Auswirkung von Klammern auf die Join-Reihenfolge

WÄHLEN SIE t1.id, t2.id, t3.id VON t1, t2 LINKS VERBINDEN SIE t3 AUF (t3.id=t1.id), WO t1.id=t2.id;
--Tatsächlich lautet die Ausführung: SELECT t1.id, t2.id, t3.id FROM t1, ( t2 LEFT JOIN t3 ON (t3.id=t1.id) ) WHERE t1.id=t2.id;
--Sollte wie folgt geschrieben werden: SELECT t1.id,t2.id,t3.id FROM (t1,t2) LEFT JOIN t3 ON (t3.id=t1.id) WHERE t1.id=t2.id;

Die Klammern sind hier sehr wichtig. Vergessen Sie daher beim Schreiben solcher Abfragen in Zukunft nicht, ein paar weitere Klammern zu schreiben. Dies kann zumindest viele Fehler vermeiden

Oben ist die vom Herausgeber eingeführte Mysql-Join-Operation. Ich hoffe, sie ist für alle hilfreich. Wenn Sie Fragen haben, hinterlassen Sie mir bitte eine Nachricht und der Herausgeber wird Ihnen rechtzeitig antworten. Ich möchte auch allen für ihre Unterstützung der Website 123WORDPRESS.COM danken!