Anweisungen für gemeinsame MySQL-Mehrtabellenabfragen

1. Multi-Table-Verbindungstypen
1. Kartesisches Produkt (Cross Join) in MySQL kann CROSS JOIN sein oder CROSS weglassen, was JOIN ist, oder ',' verwenden, wie zum Beispiel:

Weil Es wird zurückgegeben. Das Ergebnis ist das Produkt der beiden verbundenen Datentabellen. Daher wird die Verwendung bei WHERE-, ON- oder USING-Bedingungen im Allgemeinen nicht empfohlen, da es sehr langsam ist, wenn zu viele Datentabellenelemente vorhanden sind. Verwenden Sie im Allgemeinen LEFT [OUTER] JOIN oder RIGHT [OUTER] JOIN

2. INNER JOIN INNER JOIN wird in MySQL als Equijoin bezeichnet. Das heißt, Sie müssen die Equijoin-Bedingungen in CROSS und INNER JOIN in MySQL angeben zusammen. join_table: table_reference [INNER |. CROSS] JOIN table_factor [join_condition]

SELECT * FROM table1 CROSS JOIN table2 
SELECT * FROM table1 JOIN table2 
SELECT * FROM table1,table2

3. Äußere Verknüpfungen werden in MySQL in linke äußere Verknüpfungen und rechte Verknüpfungen unterteilt, d. h. zusätzlich zur Rückgabe von Ergebnissen erfüllen die Join-Bedingungen. Darüber hinaus müssen Ergebnisse zurückgegeben werden, die die Join-Bedingungen in der linken Tabelle (linker Join) oder rechten Tabelle (rechter Join) nicht erfüllen, und NULL wird entsprechend verwendet.

Beispiel:

Benutzertabelle:

id | name
———
1 | libk
2 | zyfon
3 | daodao

Benutzeraktionstabelle:

user_id | action
—————
1 | jump
1 | kick
1 | jump
2 | run
4 | swim

sql:

select id, name, action from user as u
left join user_action a on u.id = a.user_id

Ergebnis:

id | name  | action
——————————–
1 | libk     | jump      ①
1 | libk     | kick       ②
1 | libk     | jump      ③
2 | zyfon   | run        ④
3 | daodao | null       ⑤

Analyse:
Beachten Sie, dass es einen Datensatz von user_id=4, action=swim in user_action gibt, dieser jedoch nicht in erscheint das Ergebnis. ,
Der Benutzer mit id=3 und name=daodao in der Benutzertabelle hat keinen entsprechenden Datensatz in user_action, erscheint aber im Ergebnissatz
Da es sich jetzt um einen Links-Join handelt, funktioniert alles basiert auf links.
Die Ergebnisse 1, 2, 3 und 4 sind alle Datensätze sowohl in der linken als auch in der rechten Tabelle. 5 ist ein Datensatz nur in der linken Tabelle, aber nicht in der rechten Tabelle.

Arbeitsprinzip:

Lesen Sie einen aus der linken Tabelle, wählen Sie alle Datensätze (n) der rechten Tabelle aus, die übereinstimmen, und verbinden Sie sie zu n Datensätzen (einschließlich wiederholter Zeilen, z. B. Ergebnis). 1 und Ergebnis 3) Wenn rechts keine Tabelle vorhanden ist, die der Ein-Bedingung entspricht, sind die verbundenen Felder null. Fahren Sie dann mit dem nächsten Element fort.

Erweiterung:
Wir können die Regel verwenden, Null anzuzeigen, wenn in der rechten Tabelle keine Übereinstimmung vorhanden ist, um alle Datensätze zu finden, die in der linken Tabelle, aber nicht in der rechten Tabelle enthalten sind Die zur Beurteilung verwendete Spalte muss als nicht null deklariert werden.
Zum Beispiel:
sql:

select id, name, action from user as u
left join user_action a on u.id = a.user_id
where a.user_id is NULL

(Hinweis:

1. Wenn der Spaltenwert null ist, sollten Sie stattdessen is null verwenden of =NULL
  2. Die a.user_id-Spalte hier muss als NOT NULL deklariert werden.

)

Das Ergebnis der obigen SQL:

id | name | action
————————–
3 | daodao | NULL
 
——————————————————————————–

Allgemeine Verwendung:

a. LEFT [OUTER] JOIN:

Zusätzlich zur Rückgabe von Ergebnissen, die die Join-Bedingungen erfüllen, müssen Sie auch die Datenspalten im anzeigen Linke Tabelle, die die Join-Bedingungen nicht erfüllt. Entspricht

SELECT columns_name FROM table1 LEFT [OUTER] JOIN table2 ON table1.column=table2.column
RIGHT [OUTER] JOIN :

RIGHT ähnelt nur LEFT JOIN. Zusätzlich zur Anzeige der Ergebnisse, die die Verbindungsbedingungen erfüllen, müssen auch die Datenspalten in der rechten Tabelle angezeigt werden, die die Verbindungsbedingungen nicht erfüllen entsprechend

SELECT columns_name FROM table1 RIGHT [OUTER] JOIN table2 ON table1.column= table2.column
Tipps:

1 auf a.c1 = b.c1 entspricht der Verwendung (c1)
2. INNER JOIN und (Komma) sind semantisch äquivalent
3. Wenn MySQL Informationen aus einer Tabelle abruft, können Sie es auffordern, den Index auszuwählen.
Diese Funktion kann nützlich sein, wenn EXPLAIN zeigt, dass MySQL den falschen Index aus der Liste möglicher Indizes verwendet.
Durch die Angabe von USE INDEX (key_list) können Sie MySQL anweisen, den am besten geeigneten der möglichen Indizes zu verwenden, um Zeilen in der Tabelle zu finden.
Die optionale Second-Choice-Syntax IGNORE INDEX (key_list) kann verwendet werden, um MySQL anzuweisen, keinen bestimmten Index zu verwenden. Zum Beispiel:

mysql> SELECT * FROM table1 USE INDEX (key1,key2)
-> WHERE key1=1 AND key2=2 AND key3=3;
mysql> SELECT * FROM table1 IGNORE INDEX (key3)
-> WHERE key1=1 AND key2=2 AND key3=3;

2. Einschränkungen der Tabellenverbindung
Anzeigebedingungen WHERE, ON, USING hinzufügen

1. WHERE-Klausel

mysql>
SELECT * FROM table1,table2 WHERE table1.id=table2.id;

2 . ON

mysql>
SELECT * FROM table1 LEFT JOIN table2 ON table1.id=table2.id;
SELECT * FROM table1 LEFT JOIN table2 ON table1.id=table2.id
LEFT JOIN table3 ON table2.id=table3.id;

3. Wenn die beiden Spalten der Join-Bedingung der beiden Tabellen den gleichen Namen haben, können Sie beispielsweise USING

verwenden :

SELECT FROM LEFT JOIN USING ()

Beispiele für die Verbindung von mehr als zwei Tabellen:

mysql>
 
SELECT artists.Artist, cds.title, genres.genre 
  
FROM cds 
  
LEFT JOIN genres N cds.genreID = genres.genreID 
  
LEFT JOIN artists ON cds.artistID = artists.artistID;

oder

mysql>
 
SELECT artists.Artist, cds.title, genres.genre 
  
FROM cds 
  
LEFT JOIN genres ON cds.genreID = genres.genreID 
  
 LEFT JOIN artists -> ON cds.artistID = artists.artistID
  
 WHERE (genres.genre = 'Pop');

Weitere Dinge, die Sie beachten sollten, wenn es darauf ankommt Bei Abfragen mit mehreren Tabellen in MySQL müssen Sie basierend auf der Abfragesituation entscheiden, welche Verbindungsmethode effizienter ist.

1. Cross-Join (kartesisches Produkt) oder Inner-Join [INNER | die Verbindungsbedingungen WHERE, ON, USING.

PS: Grundlegende JOIN-Verwendung

Zuerst gehen wir davon aus, dass es 2 Tabellen A und B gibt. Ihre Tabellenstrukturen und Felder sind:

Tabelle A:

ID-Name

1 Tim

2 Jimmy
3 John
4 Tom

Tabelle B:

ID-Hobby

1 Fußball
2 Basketball
2 Tennis
4 Fußball

1. Innerer Join:

Select A.Name, B.Hobby from A, B where A.id = B.id

Dies ist ein impliziter innerer Join:

Name Hobby
Tim Football
Jimmy Basketball
Jimmy Tennis
Tom Soccer

Seine Funktion ist die gleiche wie

Select A.Name from A INNER JOIN B ON A.id = B.id

是一样的。这里的INNER JOIN换成CROSS JOIN也是可以的。

2．  外左联结

Select A.Name from A Left JOIN B ON A.id = B.id

 典型的外左联结，这样查询得到的结果将会是保留所有A表中联结字段的记录，若无与其相对应的B表中的字段记录则留空，结果如下：

Name Hobby
Tim Football
Jimmy Basketball，Tennis
John
Tom Soccer

所以从上面结果看出，因为A表中的John记录的ID没有在B表中有对应ID，因此为空，但Name栏仍有John记录。
3．  外右联结
如果把上面查询改成外右联结：

Select A.Name from A Right JOIN B ON A.id = B.id

则结果将会是：

Name Hobby
Tim Football
Jimmy Basketball
Jimmy Tennis
Tom Soccer

这样的结果都是我们可以从外左联结的结果中猜到的了。

说到这里大家是否对联结查询了解多了？这个原本看来高深的概念一下子就理解了，恍然大悟了吧（呵呵，开玩笑了）？最后给大家讲讲MySQL联结查询中的某些参数的作用：
1．USING (column_list)：其作用是为了方便书写联结的多对应关系，大部分情况下USING语句可以用ON语句来代替，如下面例子：

a LEFT JOIN b USING (c1,c2,c3)

其作用相当于下面语句

a LEFT JOIN b ON a.c1=b.c1 AND a.c2=b.c2 AND a.c3=b.c3

只是用ON来代替会书写比较麻烦而已。

2．NATURAL [LEFT] JOIN：这个句子的作用相当于INNER JOIN，或者是在USING子句中包含了联结的表中所有字段的Left JOIN（左联结）。

3．STRAIGHT_JOIN：由于默认情况下MySQL在进行表的联结的时候会先读入左表，当使用了这个参数后MySQL将会先读入右表，这是个MySQL的内置优化参数，大家应该在特定情况下使用，譬如已经确认右表中的记录数量少，在筛选后能大大提高查询速度。

最后要说的就是，在MySQL5.0以后，运算顺序得到了重视，所以对多表的联结查询可能会错误以子联结查询的方式进行。譬如你需要进行多表联结，因此你输入了下面的联结查询：

SELECT t1.id,t2.id,t3.id
FROM t1,t2
LEFT JOIN t3 ON (t3.id=t1.id)
WHERE t1.id=t2.id;

但是MySQL并不是这样执行的，其后台的真正执行方式是下面的语句：

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;

MySQL联合查询效率较高，以下例子来说明联合查询（内联、左联、右联、全联）的好处：

T1表结构（用户名,密码）   
userid（int）   usernamevarchar（20）   passwordvarchar（20）   
1   jack  jackpwd   
2   owen  owenpwd   


T2表结构（用户名,密码）   
userid（int）   jifenvarchar（20）   dengjivarchar（20）   
    1   20   3   
    3   50   6   


第一：内联（inner join）
如果想把用户信息、积分、等级都列出来，那么一般会这样写：

select * from T1, T3 where T1.userid = T3.userid
（其实这样的结果等同于select * from T1 inner join T3 on T1.userid=T3.userid ）。

把两个表中都存在userid的行拼成一行（即内联），但后者的效率会比前者高很多，建议用后者（内联）的写法。

SQL语句：
select * from T1 inner join T2 on T1.userid = T2.userid

运行结果   
T1.userid   username   password   T2.userid   jifen   dengji   
1   jack   jackpwd   1   20   3   

第二：左联（left outer join）
显示左表T1中的所有行，并把右表T2中符合条件加到左表T1中；
右表T2中不符合条件，就不用加入结果表中，并且NULL表示。

SQL语句：
select * from T1 left outer join T2 on T1.userid = T2.userid

运行结果   
T1.userid   username   password   T2.userid   jifen   dengji   
1   jack   jackpwd   1   20   3   
2   owen   owenpwd   NULL   NULL   NULL   

第三：右联（right outer join）。

Zeigen Sie alle Zeilen in der rechten Tabelle T2 an und fügen Sie die übereinstimmenden Bedingungen in der linken Tabelle T1 zur rechten Tabelle T2 hinzu.
Wenn die Bedingungen in der linken Tabelle T1 nicht erfüllt sind, besteht keine Notwendigkeit zum Hinzufügen Sie werden in die Ergebnistabelle übernommen und NULL wird angezeigt.

SQL-Anweisung:
select * from T1 Right Outer Join T2 on T1.userid = T2.userid

Laufende Ergebnisse
T1.userid Benutzername Passwort T2.userid jifen dengji
1 jack jackpwd 1 20 3
NULL NULL NULL 3 50 6

Viertens: Full Join Outer

Zeigen Sie alle Zeilen in der linken Tabelle T1 und der rechten Tabelle T2 an, d. h. kombinieren Sie die linke Join-Ergebnistabelle + die rechte Join-Ergebnistabelle und filtern Sie dann die Duplikate heraus.

SQL-Anweisung:
wählen Sie * aus T1 Full Outer Join T2 auf T1.userid = T2.userid

Laufende Ergebnisse
T1.userid Benutzername Passwort T2.userid jifen dengji
1 jack jackpwd 1 20 3
2 owen owenpwd NULL NULL NULL
NULL NULL NULL 3 50 6

Zusammenfassend lässt sich sagen, dass die Effizienz bei gemeinsamen Abfragen tatsächlich relativ ist hoch, 4 Wenn diese Kombinationsmethode flexibel einsetzbar ist, werden grundsätzlich komplexe Anweisungsstrukturen einfacher.