Eine detaillierte Einführung in die Join-Operation in MySQL

Dieser Artikel stellt hauptsächlich die relevanten Informationen zum Mysql-Beitrittsvorgang vor. Freunde, die sie benötigen, können sich auf

Arten des Beitritts

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 geben The zurück Die Ergebnisse sind alle

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

• Jedes Komma im table_reference-Eintrag wird als äquivalent zu einer inneren Vereinigung angesehen

• Der Standard-JOIN ist INNER JOIN

• CROSS JOIN ist syntaktisch ä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 des Inner Join 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

Outer Join

Linker Join

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

Das Ergebnis ist

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

Aus den obigen Ergebnissen können wir das erkennen, weil die Namen der Datensätze java1 und java2 in der Java-Tabelle keine Entsprechung haben Namen in der MySQL-Tabelle sind leer. Alle Spalten von Java enthalten jedoch weiterhin Java1- und Java2-Datensätze, und alle Spalten der MySQL-Tabelle sind NULL. Der verbleibende blaue Datensatz ist das Ergebnis des inneren Joins

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 kein Gegenstück in

anderen Tabellen hat, können Sie diese Methode verwenden, um Datensätze in solchen Tabellen zu finden:

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

Diese SQL findet heraus, wer in Java ist, aber für diejenigen, die Befinden sich nicht in MySQL, ist es offensichtlich, dass die Mitarbeiter „Java1“ und „Java2“ die Anforderungen erfüllen.

Right 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 von Right Join und Left Join sind ähnlich, außer Diesmal speichert die MySQL-Tabelle 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 gleichzeitig 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;

Die Klammern sind hier also sehr wichtig Ich werde in Zukunft so etwas schreiben

Vergessen Sie nicht, bei der Abfrage noch ein paar Klammern zu schreiben , dadurch können zumindest viele Fehler vermieden werden

Das obige ist der detaillierte Inhalt vonEine detaillierte Einführung in die Join-Operation in MySQL. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!