Beispiel für die gemeinsame Nutzung einer Join-Operation in MySQL

Dieser Artikel stellt hauptsächlich die relevanten Informationen zum MySQL-Beitrittsvorgang vor. Freunde, die ihn benötigen, können darauf verweisen.

Art der Verknüpfung

1. Innerer Join: Ein Join, der einen Datensatz bildet, indem er die Datensätze kombiniert, deren Felder in den beiden Tabellen eine Join-Beziehung haben und mit der Join-Beziehung übereinstimmen.

2． Äußere Verknüpfung: unterteilt in äußere linke Verknüpfung und äußere rechte Verknüpfung.

Fallhintergrund

create table java (name varchar(255));
insert into java values ('java1'),('java2'),('blue'); 
create table mysql (name varchar(255));
insert into mysql values ('mysql1'),('mysql2'),('blue');

Inner Join

select * from java,mysql where java.name=mysql.name;
SELECT * FROM java JOIN mysql ON java.name=mysql.name;
SELECT * FROM java INNER JOIN mysql ON java.name=mysql.name;
SELECT * FROM java CROSS JOIN mysql ON java.name=mysql.name;
SELECT * FROM java STRAIGHT_JOIN mysql ON java.name=mysql.name;

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

+------+------+
| name | name |
+------+------+
| blue | blue |
+------+------+

• Jedes Komma im table_reference-Eintrag wird als innere Vereinigung behandelt

• Die Standard-JOINs sind INNER JOIN

• CROSS JOIN ist grammatikalisch äquivalent zu INNER JOIN

• STRAIGHT_JOIN ist dasselbe wie JOIN. Bis auf einen Unterschied 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 sortiert.

Die Syntax der inneren Verknüpfung lautet wie folgt:

join_table:
 table_reference [INNER | CROSS] JOIN table_factor [join_condition]
 | table_reference STRAIGHT_JOIN table_factor
 | table_reference STRAIGHT_JOIN table_factor ON condition

Äußere Verknüpfung

Linke Verknüpfung

SELECT * FROM java LEFT JOIN mysql ON java.name=mysql.name;

Die Ergebnis ist

+-------+------+
| name | name |
+-------+------+
| java1 | NULL |
| java2 | NULL |
| blue | blue |
+-------+------+

Aus den obigen Ergebnissen ist also ersichtlich, dass die Namen der Datensätze java1 und java2 in der Java-Tabelle keine entsprechenden Namen in der MySQL-Tabelle haben und daher leer sind Alle Java-Spalten haben weiterhin Java1- und Java2-Datensätze, alle Spalten der MySQL-Tabelle sind NULL. Der verbleibende blaue Datensatz ist das Ergebnis der internen Verbindung zwischen der Java-Tabelle und der MySQL-Tabelle.

Wenn es im ON- oder USING-Abschnitt des LEFT JOIN keinen passenden Datensatz für die rechte Tabelle gibt, wird für die rechte Tabelle eine Zeile verwendet, in der alle Spalten auf NULL gesetzt sind. Wenn eine Tabelle keinen entsprechenden Teil in anderen Tabellen hat, können Sie diese Methode verwenden, um Datensätze in dieser Tabelle zu finden:

SELECT * FROM java LEFT JOIN mysql ON java.name=mysql.name WHERE mysql.name IS NULL;

Dieses SQL findet Personen in Java, aber nicht in MySQL. Hier ist es offensichtlich, dass die Die Mitarbeiter „Java1“ und „Java2“ erfüllen die Anforderungen.

Rechter Join

SELECT * FROM java RIGHT JOIN mysql ON java.name=mysql.name;

Das zurückgegebene Ergebnis ist

+------+--------+
| name | name |
+------+--------+
| NULL | mysql1 |
| NULL | mysql2 |
| blue | blue |
+------+--------+

Die Ergebnisse des rechten Joins ähneln denen des linken Joins, außer dass diesmal die MySQL-Tabelle gespeichert wird alle Ergebnismengen.

Die Syntax des Outer Joins

join_table:| table_reference LEFT [OUTER] JOIN table_reference join_condition
 | table_reference NATURAL [LEFT [OUTER]] JOIN table_factor
 | table_reference RIGHT [OUTER] JOIN table_reference join_condition
 | table_reference NATURAL [RIGHT [OUTER]] JOIN table_factor

USING(column_list)-Klausel

wird verwendet, um eine Reihe von Spalten zu benennen, die in beiden Tabellen vorhanden sein müssen 🎜>

SELECT java.*,mysql.* FROM java LEFT JOIN mysql USING (name);

Das Ergebnis wird zurückgegeben

+-------+------+
| name | name |
+-------+------+
| java1 | NULL |
| java2 | NULL |
| blue | blue |
+-------+------+

Die Reihenfolge der Operationen des Joins

SELECT * FROM t1 LEFT JOIN (t2, t3, t4) ON (t2.a=t1.a AND t3.b=t1.b AND t4.c=t1.c);
--相当于
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)

Der Einfluss von Klammern auf die Reihenfolge des Joins

SELECT t1.id,t2.id,t3.id FROM t1,t2 LEFT JOIN t3 ON (t3.id=t1.id) WHERE t1.id=t2.id;
--实际上这么执行
SELECT t1.id,t2.id,t3.id FROM t1,( t2 LEFT JOIN t3 ON (t3.id=t1.id) ) WHERE t1.id=t2.id;
--应该这么写
SELECT t1.id,t2.id,t3.id FROM (t1,t2) LEFT JOIN t3 ON (t3.id=t1.id) WHERE t1.id=t2.id;

Klammern sind hier sehr wichtig, daher sollten wir beim Schreiben solcher Abfragen in Zukunft nicht vergessen, noch ein paar Klammern zu schreiben. Dies kann zumindest viele Fehler vermeiden.

Verwandte Empfehlungen:

Detaillierte Beispiele für den Unterschied zwischen Split und Join in JavaScript

Teilen von Anwendungsbeispielen für Join in MySQL

Beispiel für die Vereinfachung von JOIN ON mithilfe von JOIN USING in SQL

Das obige ist der detaillierte Inhalt vonBeispiel für die gemeinsame Nutzung einer Join-Operation in MySQL. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!