Detaillierte Erklärung zur Verwendung von Join zur Optimierung von SQL in MySQL

Detaillierte Erklärung zur Verwendung von Join zur Optimierung von SQL in MySQL

0. Bereiten Sie relevante Tabellen für die folgenden Tests vor

Zugehörige Anweisungen zur Tabellenerstellung finden Sie unter: https://github.com/YangBaohust/my_sql

Tabelle User1, Lerngruppe +----+-----------+-----------------+---------------------------------+
| ID | Benutzername | Kommentar | Mobiltelefon |
+----+-----------+-----------------+---------------------------------+
| 1 | Tang-Mönch | Sandelholz-Verdienst-Buddha | 138245623,021-382349 |
| 2 | Sun Wukong | Kämpfender Buddha | 159384292,022-483432,+86-392432 |
| 3 | Zhu Bajie | Altarreiniger | 183208243,055-8234234 |
| 4 | Sha Seng | Arhat mit goldenem Körper | 293842295,098-2383429 |
| 5 | NULL | Weißes Drachenpferd | 993267899 |
+----+-----------+-----------------+---------------------------------+

Benutzer2-Tabelle, Wukongs Freundeskreis +----+-----------+-----------+
| ID | Benutzername | Kommentar |
+----+--------------+-----------+
| 1 | Sun Wukong | Der Affenkönig |
| 2 | Bullendämonenkönig | Bruder Niu |
| 3 | Prinzessin Iron Fan | Frau Niu |
| 4 | Bodhi Patriarch | Trauben |
| 5 | NULL | Jingjing|
+----+--------------+-----------+

user1_kills-Tabelle, die Anzahl der auf der Reise in den Westen getöteten Monster +----+-----------+---------------------+-----------+
| ID | Benutzername | Zeitzeichen | Kills |
+----+-----------+---------------------+----------+
| 1 | So Wukong | 10.01.2013 00:00:00 | 10 |
| 2 | So Wukong | 01.02.2013 00:00:00 | 2 |
| 3 | So Wukong | 05.02.2013 00:00:00 | 12 |
| 4 | So Wukong | 12.02.2013 00:00:00 | 22 |
| 5 | Zhu Bajie | 11.01.2013 00:00:00 | 20 |
| 6 | Zhu Bajie | 07.02.2013 00:00:00 | 17 |
| 7 | Zhu Bajie | 08.02.2013 00:00:00 | 35 |
| 8 | Sha Seng | 10.01.2013 00:00:00 | 3 |
| 9 | Sha Seng | 22.01.2013 00:00:00 | 9 |
| 10 | Sha Seng | 11.02.2013 00:00:00 | 5 |
+----+-----------+---------------------+----------+

user1_equipment-Tabelle, Questgruppenausrüstung +----+-----------+--------------+-----------------+-----------------+
| ID | Benutzername | Waffen | Kleidung | Schuhe |
+----+-----------+--------------+-----------------+-----------------+
| 1 | Tang-Mönch| Neun-Ringe-Stab| Bunte Soutane| Mönchsschuhe|
| 2 | Sun Wukong| Goldene Keule| Goldene Rüstung| Wolkenlaufschuhe aus Lotusseide|
| 3 | Zhu Bajie| Neunzinkige Harke| Mönchskutte| Mönchsschuhe|
| 4 | Sha-Mönch| Dämonenbezwingerstab| Mönchsrobe| Mönchsschuhe|
+----+-----------+--------------+-----------------+-----------------+

1. Verwenden Sie Left Join, um die Not-In-Klausel zu optimieren

Beispiel: Finde die Leute in der Pilgergruppe heraus, die nicht zu Wukongs Freundeskreis gehören

+----+-----------+-----------------+--------------------------+
| ID | Benutzername | Kommentar | Mobiltelefon |
+----+-----------+-----------------+--------------------------+
| 1 | Tang-Mönch | Sandelholz-Verdienst-Buddha | 138245623,021-382349 |
| 3 | Zhu Bajie | Altarreiniger | 183208243,055-8234234 |
| 4 | Sha Seng | Arhat mit goldenem Körper | 293842295,098-2383429 |
+----+-----------+-----------------+--------------------------+

Nicht schriftlich:

Wählen Sie * von Benutzer1 a, wobei a.Benutzername nicht in ist (wählen Sie Benutzername von Benutzer2, wobei Benutzername nicht null ist);

Schreibmethode für Left Join:

Schauen Sie sich zunächst den äußeren Join-Datensatz an, der durch user_name verbunden ist

wähle a.*, b.* von Benutzer1 a links, schließe dich Benutzer2 b an auf (a.Benutzername = b.Benutzername);
+----+-----------+-----------------+---------------------------------+------+-----------+-----------+
| ID | Benutzername | Kommentar | Mobiltelefon | ID | Benutzername | Kommentar |
+----+-----------+-----------------+---------------------------------+------+-----------+-----------+
| 2 | Sun Wukong | Kämpfender Buddha | 159384292,022-483432,+86-392432 | 1 | Sun Wukong | Der Affenkönig |
| 1 | Tang-Mönch | Sandelholz-Verdienst-Buddha | 138245623,021-382349 | NULL | NULL | NULL |
| 3 | Zhu Bajie | Altarreiniger | 183208243,055-8234234 | NULL | NULL | NULL |
| 4 | Sha Seng | Goldener Körper Arhat | 293842295,098-2383429 | NULL | NULL | NULL |
| 5 | NULL | Weißes Drachenpferd | 993267899 | NULL | NULL | NULL |
+----+-----------+-----------------+---------------------------------+------+-----------+-----------+

Es ist ersichtlich, dass alle Daten in Tabelle a angezeigt werden und die Daten in Tabelle b nur angezeigt werden, wenn b.user_name gleich a.user_name ist, und der Rest ist mit Nullwerten gefüllt. Um die Personen auf der Reise nach Westen herauszufinden, die nicht zu Wukongs Freundeskreis gehören, müssen Sie nur eine Filterbedingung hinzufügen, dass b.user_name in b.user_name null ist.

Wähle a.* von Benutzer1 a links, schließe dich Benutzer2 b an auf (a.Benutzername = b.Benutzername), wobei b.Benutzername null ist;
+----+-----------+-----------------+--------------------------+
| ID | Benutzername | Kommentar | Mobiltelefon |
+----+-----------+-----------------+--------------------------+
| 1 | Tang-Mönch | Sandelholz-Verdienst-Buddha | 138245623,021-382349 |
| 3 | Zhu Bajie | Altarreiniger | 183208243,055-8234234 |
| 4 | Sha Seng | Arhat mit goldenem Körper | 293842295,098-2383429 |
| 5 | NULL | Weißes Drachenpferd | 993267899 |
+----+-----------+-----------------+--------------------------+

Hier stellen wir fest, dass im Ergebnissatz noch ein weißes Drachenpferd vorhanden ist, daher können wir weiterhin die Filterbedingung „a.user_name ist nicht null“ hinzufügen.

wähle a.* von Benutzer1 a links, schließe dich Benutzer2 b an auf (a.Benutzername = b.Benutzername), wobei b.Benutzername null ist und a.Benutzername nicht null ist;

2. Verwenden Sie Left Join, um skalare Unterabfragen zu optimieren

Beispiel: Überprüfen Sie die Spitznamen der Personen in der Gruppe „Reise nach Westen“ in Wukongs Freundeskreis

+-----------+-----------------+-----------+
| Benutzername | Kommentar | Kommentar2 |
+-----------+-----------------+-----------+
| Tang-Mönch | Sandelholz-Verdienst-Buddha | NULL |
| Sun Wukong| Kämpfender Buddha| Der Affenkönig|
| Zhu Bajie| Altarreiniger| NULL |
| Sha-Mönch | Goldener Körper-Arhat | NULL |
| NULL | Weißes Drachenpferd | NULL |
+-----------+-----------------+-----------+

Unterabfrage schreiben:

Wählen Sie a.Benutzername, a.Kommentar, (wählen Sie Kommentar von Benutzer2 b, wobei b.Benutzername = a.Benutzername) Kommentar2 von Benutzer1 a;

Schreibmethode für Left Join:

Wähle a.Benutzername, a.Kommentar, b.Kommentar Kommentar2 von Benutzer1 a links, schließe dich Benutzer2 b an (a.Benutzername = b.Benutzername);

3. Verwenden Sie Join, um aggregierte Unterabfragen zu optimieren

Beispiel: Finden Sie das Datum, an dem jedes Mitglied der Pilgergruppe die meisten Monster getötet hat

+----+-----------+---------------------+----------+
| ID | Benutzername | Zeitzeichen | Kills |
+----+-----------+---------------------+----------+
| 4 | So Wukong | 12.02.2013 00:00:00 | 22 |
| 7 | Zhu Bajie | 08.02.2013 00:00:00 | 35 |
| 9 | Sha Seng | 22.01.2013 00:00:00 | 9 |
+----+-----------+---------------------+----------+

Methode zum Schreiben aggregierter Unterabfragen:

wähle * aus user1_kills a, wobei a.kills = (wähle max(b.kills) aus user1_kills b, wobei b.Benutzername = a.Benutzername);

Schreibmethode beitreten:

Schauen wir uns zunächst den Ergebnissatz der Selbstassoziation der beiden Tabellen an. Um Platz zu sparen, nehmen wir nur Zhu Bajies Monstertötungsdaten.

Wähle a.*, b.* aus user1_kills a, schließe dich user1_kills b an auf (a.user_name = b.user_name), sortiere nach 1;
+----+-----------+---------------------+-------+----+-----------+---------------------+-----------+
| ID | Benutzername | Zeitzeichen | Kills | ID | Benutzername | Zeitzeichen | Kills |
+----+-----------+---------------------+-------+----+-----------+---------------------+-----------+
| 5 | Zhu Bajie | 11.01.2013 00:00:00 | 20 | 5 | Zhu Bajie | 11.01.2013 00:00:00 | 20 |
| 5 | Zhu Bajie | 11.01.2013 00:00:00 | 20 | 6 | Zhu Bajie | 07.02.2013 00:00:00 | 17 |
| 5 | Zhu Bajie | 11.01.2013 00:00:00 | 20 | 7 | Zhu Bajie | 08.02.2013 00:00:00 | 35 |
| 6 | Zhu Bajie | 07.02.2013 00:00:00 | 17 | 7 | Zhu Bajie | 08.02.2013 00:00:00 | 35 |
| 6 | Zhu Bajie | 07.02.2013 00:00:00 | 17 | 5 | Zhu Bajie | 11.01.2013 00:00:00 | 20 |
| 6 | Zhu Bajie | 07.02.2013 00:00:00 | 17 | 6 | Zhu Bajie | 07.02.2013 00:00:00 | 17 |
| 7 | Zhu Bajie | 08.02.2013 00:00:00 | 35 | 5 | Zhu Bajie | 11.01.2013 00:00:00 | 20 |
| 7 | Zhu Bajie | 08.02.2013 00:00:00 | 35 | 6 | Zhu Bajie | 07.02.2013 00:00:00 | 17 |
| 7 | Zhu Bajie | 08.02.2013 00:00:00 | 35 | 7 | Zhu Bajie | 08.02.2013 00:00:00 | 35 |
+----+-----------+---------------------+-------+----+-----------+---------------------+-----------+

Es ist ersichtlich, dass wir, wenn die beiden Tabellen über den Benutzernamen selbst verknüpft sind, nur eine Gruppierung nach allen Feldern in Tabelle a durchführen und das Maximum (Kills) in Tabelle b nehmen müssen. Solange a.kills=max(b.kills) ist, ist die Anforderung erfüllt. Das SQL lautet wie folgt

Wähle a.* aus user1_kills a, schließe dich user1_kills b an auf (a.user_name = b.user_name), gruppiere nach a.id, a.user_name, a.timestr, a.kills, wobei a.kills = max(b.kills) ist;

4. Verwenden Sie „Join“ zur Gruppenauswahl

Beispiel: Aktualisieren Sie das dritte Beispiel, um die ersten beiden Daten herauszufinden, an denen jede Person in der Pilgergruppe die meisten Monster getötet hat

+----+-----------+---------------------+----------+
| ID | Benutzername | Zeitzeichen | Kills |
+----+-----------+---------------------+----------+
| 3 | So Wukong | 05.02.2013 00:00:00 | 12 |
| 4 | So Wukong | 12.02.2013 00:00:00 | 22 |
| 5 | Zhu Bajie | 11.01.2013 00:00:00 | 20 |
| 7 | Zhu Bajie | 08.02.2013 00:00:00 | 35 |
| 9 | Sha Seng | 22.01.2013 00:00:00 | 9 |
| 10 | Sha Seng | 11.02.2013 00:00:00 | 5 |
+----+-----------+---------------------+----------+

In Oracle kann dies durch analytische Funktionen erreicht werden

wähle b.* aus (wähle a.*, Zeilennummer() über (Partition nach Benutzername, Sortierung nach Kills, absteigend) cnt aus Benutzer1_Kills a) b, wobei b.cnt <= 2;

Leider meldet das obige SQL einen Fehler in MySQL: FEHLER 1064 (42000): In Ihrer SQL-Syntax liegt ein Fehler vor, weil MySQL keine analytischen Funktionen unterstützt. Dies kann jedoch auf folgende Weise erreicht werden.

Erstens sind die beiden Tabellen selbstassoziiert. Um Platz zu sparen, werden nur die Daten von Sun Wukong herausgenommen.

wähle a.*, b.* aus user1_kills a, schließe dich user1_kills b an auf (a.user_name=b.user_name und a.kills<=b.kills), sortiere nach a.user_name, a.kills desc;
+----+-----------+---------------------+-------+----+-----------+---------------------+-----------+
| ID | Benutzername | Zeitzeichen | Kills | ID | Benutzername | Zeitzeichen | Kills |
+----+-----------+---------------------+-------+----+-----------+---------------------+-----------+
| 4 | So Wukong | 12.02.2013 00:00:00 | 22 | 4 | So Wukong | 12.02.2013 00:00:00 | 22 |
| 3 | So Wukong | 05.02.2013 00:00:00 | 12 | 3 | So Wukong | 05.02.2013 00:00:00 | 12 |
| 3 | So Wukong | 05.02.2013 00:00:00 | 12 | 4 | So Wukong | 12.02.2013 00:00:00 | 22 |
| 1 | So Wukong | 10.01.2013 00:00:00 | 10 | 1 | So Wukong | 10.01.2013 00:00:00 | 10 |
| 1 | So Wukong | 10.01.2013 00:00:00 | 10 | 3 | So Wukong | 05.02.2013 00:00:00 | 12 |
| 1 | So Wukong | 10.01.2013 00:00:00 | 10 | 4 | So Wukong | 12.02.2013 00:00:00 | 22 |
| 2 | So Wukong | 01.02.2013 00:00:00 | 2 | 1 | So Wukong | 10.01.2013 00:00:00 | 10 |
| 2 | So Wukong | 01.02.2013 00:00:00 | 2 | 3 | So Wukong | 05.02.2013 00:00:00 | 12 |
| 2 | So Wukong | 01.02.2013 00:00:00 | 2 | 4 | So Wukong | 12.02.2013 00:00:00 | 22 |
| 2 | So Wukong | 01.02.2013 00:00:00 | 2 | 2 | So Wukong | 01.02.2013 00:00:00 | 2 |
+----+-----------+---------------------+-------+----+-----------+---------------------+-----------+

Aus der obigen Tabelle wissen wir, dass die Anzahl der von Sun Wukong getöteten Monster 22 und 12 beträgt. Dann müssen wir nur noch eine Gruppierung nach allen Feldern der Tabelle a durchführen und die ID der Tabelle b zählen. Wenn der Zählwert kleiner oder gleich 2 ist, ist die Anforderung erfüllt. Das SQL wird wie folgt umgeschrieben:

wähle a.* aus user1_kills a, schließe dich user1_kills b an auf (a.user_name=b.user_name und a.kills<=b.kills), gruppiere nach a.id, a.user_name, a.timestr, a.kills mit count(b.id) <= 2;

5. Verwenden Sie den kartesischen Produkt-Join, um eine Spalte in mehrere Zeilen umzuwandeln

Beispiel: Jede Telefonnummer der Abfragegruppe in eine Zeile umwandeln

Ursprüngliche Daten:

+--------------+---------------------------------+
| Benutzername | Mobiltelefon |
+--------------+---------------------------------+
| Tang-Mönch | 138245623,021-382349 |
| Sun Wukong | 159384292,022-483432,+86-392432 |
| Zhu Bajie | 183208243,055-8234234 |
| Sha Seng | 293842295,098-2383429 |
| NULL | 993267899 |
+--------------+---------------------------------+

Die Daten, die Sie erhalten möchten:

+-------------+----------+
| Benutzername | Mobiltelefon |
+-------------+----------+
| Tang-Mönch | 138245623 |
| Tang-Mönch | 021-382349 |
| Sonne Wukong | 159384292 |
| Sun Wukong | 022-483432 |
| Sun Wukong | +86-392432 |
| Zhu Bajie | 183208243 |
| Zhu Bajie | 055-8234234 |
| Sha Seng | 293842295 |
| Sha Seng | 098-2383429 |
| NULL | 993267899 |
+-------------+----------+

Sie sehen, dass Tang Seng zwei Telefone hat und daher zwei Leitungen benötigt. Wir können zunächst die Anzahl der Telefonnummern für jede Person ermitteln und dann ein kartesisches Produkt mit einer Sequenztabelle durchführen. Um Platz zu sparen, werden nur die Daten von Tang Seng herausgenommen.

wähle a.id, b.* aus tb_sequence, einen Cross Join (wähle Benutzername, Mobiltelefon, Länge (Mobiltelefon) – Länge (ersetze (Mobiltelefon, ',', '')) +1 Größe aus Benutzer1) b, sortiere nach 2,1;
+----+-----------+---------------------------------+------+
| ID | Benutzername | Mobiltelefon | Größe |
+----+-----------+---------------------------------+------+
| 1 | Tang-Mönch | 138245623,021-382349 | 2 |
| 2 | Tang-Mönch | 138245623,021-382349 | 2 |
| 3 | Tang-Mönch | 138245623,021-382349 | 2 |
| 4 | Tang-Mönch | 138245623,021-382349 | 2 |
| 5 | Tang-Mönch | 138245623,021-382349 | 2 |
| 6 | Tang-Mönch | 138245623,021-382349 | 2 |
| 7 | Tang-Mönch | 138245623,021-382349 | 2 |
| 8 | Tang-Mönch | 138245623,021-382349 | 2 |
| 9 | Tang-Mönch | 138245623,021-382349 | 2 |
| 10 | Tang-Mönch | 138245623,021-382349 | 2 |
+----+--------------------------+---------------------------------+------+

a.id entspricht der Anzahl der Telefonnummern und size ist die Gesamtzahl der Telefonnummern. Daher können wir eine Korrelationsbedingung (a.id <= b.size) hinzufügen und die obige SQL-Anweisung anpassen.

wähle b.user_name, ersetze (Teilzeichenfolge (Teilzeichenfolgenindex (b.mobile, ',', a.id), char_length (Teilzeichenfolgenindex (mobile, ',', a.id-1)) + 1), ',', '') als Mobiltelefon aus tb_sequence, ein Cross Join (wähle Benutzername, concat (mobile, ',') als Mobiltelefon, Länge (mobile)-Länge (ersetze (mobile, ',', ''))+1 Größe aus Benutzer1) b auf (a.id <= b.size);

6. Verwenden Sie die kartesische Produktassoziation, um mehrere Spalten in mehrere Zeilen umzuwandeln

Beispiel: Verwandle jedes Ausrüstungsteil in der Questgruppe in eine Reihe

Ursprüngliche Daten:

+----+-----------+--------------+-----------------+-----------------+
| ID | Benutzername | Waffen | Kleidung | Schuhe |
+----+-----------+--------------+-----------------+-----------------+
| 1 | Tang-Mönch| Neun-Ringe-Stab| Bunte Soutane| Mönchsschuhe|
| 2 | Sun Wukong| Goldene Keule| Goldene Rüstung| Wolkenlaufschuhe aus Lotusseide|
| 3 | Zhu Bajie| Neunzinkige Harke| Mönchskutte| Mönchsschuhe|
| 4 | Sha-Mönch| Dämonenbezwingerstab| Mönchsrobe| Mönchsschuhe|
+----+-----------+--------------+-----------------+-----------------+

Die Daten, die Sie erhalten möchten:

+--------------+----------+-----------------+
| Benutzername | Ausrüstung | equip_mame |
+--------------+----------+-----------------+
| Tang-Mönch | Waffen | Neun-Ringe-Stab |
| Tang-Mönch | Kleidung | Bunte Soutane |
| Tang-Mönch | Schuh | Mönchsschuhe |
| Sun Wukong| Waffen | Goldene Keule|
| Sun Wukong| Kleidung | Shuttle Golden Armor|
| Sun Wukong | Schuh | Schuhe aus Lotusseide in Wolkenform |
| Sha Seng| Waffen | Dämonenbezwingerstab|
| Sha Seng| Kleidung | Mönchskleidung|
| Sha Seng| Schuh | Mönchsschuhe|
| Zhu Bajie| Arme | Neunzinkiger Rechen|
| Zhu Bajie| Kleidung | Mönchskleidung|
| Zhu Bajie| Schuh | Mönchsschuhe|
+--------------+----------+-----------------+

So schreiben Sie Vereinigung:

wähle user_name, 'arms' als Ausrüstung, arms equip_mame von user1_equipment
Vereinigung alle
wähle user_name, 'clothing' als Ausrüstung, clothing equip_mame von user1_equipment
Vereinigung alle
wähle user_name, 'shoe' als equipment, shoe equip_mame aus user1_equipment
Sortieren nach 1, 2;

So schreiben Sie „Join“:

Betrachten wir zunächst die Wirkung des Descartes-Datensatzes am Beispiel von Tang Seng

wähle a.*, b.* aus user1_equipment, einen Cross Join tb_sequence b, wobei b.id <= 3;
+----+-----------+--------------+-----------------+-----------------+----+
| ID | Benutzername | Waffen | Kleidung | Schuhe | ID |
+----+-----------+--------------+-----------------+-----------------+----+
| 1 | Tang-Mönch| Neun-Ringe-Stab| Bunte Soutane| Mönchsschuhe| 1 |
| 1 | Tang-Mönch | Neun-Ringe-Stab | Bunte Soutane | Mönchsschuhe | 2 |
| 1 | Tang-Mönch | Neun-Ringe-Stab | Bunte Soutane | Mönchsschuhe | 3 |
+----+-----------+--------------+-----------------+-----------------+----+

Anwendungsfall zur Verarbeitung der obigen Ergebnisse

wählen Sie den Benutzernamen aus, 
Fall wenn b.id = 1 dann 'Arme' 
wenn b.id = 2 dann 'Kleidung'
wenn b.id = 3, dann endet 'Schuh' als Ausrüstung,
Fall, wenn b.id = 1 dann Arme enden Arme,
Fall, wenn b.id = 2 dann Kleidung Ende Kleidung,
Fall, wenn b.id = 3 dann Schuh Ende Schuh
von user1_equipment ein Cross Join tb_sequence b, wobei b.id <=3;
+-----------+----------+--------------+-----------------+-----------------+
| Benutzername | Ausrüstung | Waffen | Kleidung | Schuhe |
+-----------+----------+--------------+-----------------+-----------------+
| Tang-Mönch | Waffen | Neun-Ringe-Stab | NULL | NULL |
| Tang-Mönch | Kleidung | NULL | Bunte Soutane | NULL |
| Tang Monk | Schuh | NULL | NULL | Mönchsschuhe |
+-----------+----------+--------------+-----------------+-----------------+

Verwenden Sie die Funktion „Coalesce“, um mehrere Datenspalten zusammenzuführen

wählen Sie den Benutzernamen aus, 
Fall wenn b.id = 1 dann 'Arme' 
wenn b.id = 2 dann 'Kleidung'
wenn b.id = 3, dann endet 'Schuh' als Ausrüstung,
verschmelzen (Fall, wenn b.id = 1, dann Arme enden,
Fall, wenn b.id = 2 dann Kleidung Ende,
Fall, wenn b.id = 3 dann Schuhende) equip_mame
von user1_equipment ein Cross Join tb_sequence b, wobei b.id <=3, sortiert nach 1, 2;

7. Verwenden Sie Join, um die Tabelle zu aktualisieren, die sich selbst in der Filterbedingung enthält

Beispiel: Für Personen, die sowohl in der Gruppe „Reise nach Westen“ als auch in Wukongs Freundeskreis sind, aktualisieren Sie das Kommentarfeld in der Gruppe „Reise nach Westen“ auf „Diese Person ist in Wukongs Freundeskreis“.

Es ist für uns selbstverständlich, zuerst die Personen herauszufinden, deren Benutzername sowohl in Benutzer1 als auch in Benutzer2 vorhanden ist, und dann die Tabelle Benutzer1 zu aktualisieren. Das SQL lautet wie folgt

aktualisiere Benutzer1, setze Kommentar = „Diese Person ist in Wukongs Freundeskreis“, wobei Benutzername in (wähle a.Benutzername aus Benutzer1 a, schließe dich Benutzer2 b an (a.Benutzername = b.Benutzername));

Leider meldet das obige SQL einen Fehler in MySQL: FEHLER 1093 (HY000): Sie können in der FROM-Klausel nicht die Zieltabelle „user1“ für die Aktualisierung angeben, was darauf hinweist, dass die Zieltabelle in der FROM-Klausel nicht aktualisiert werden kann.

Gibt es einen anderen Weg? Wir können die In-Methode in eine Join-Methode umwandeln.

wähle c.*, d.* von Benutzer1 c beitreten (wähle a.Benutzername von Benutzer1 a beitreten Benutzer2 b auf (a.Benutzername = b.Benutzername)) d auf (c.Benutzername = d.Benutzername);
+----+-----------+--------------+---------------------------------+-----------+
| ID | Benutzername | Kommentar | Mobiltelefon | Benutzername |
+----+-----------+--------------+---------------------------------+-----------+
| 2 | Sun Wukong | Kämpfender Buddha | 159384292,022-483432,+86-392432 | Sun Wukong |
+----+-----------+--------------+---------------------------------+-----------+

Aktualisieren Sie dann die Ansicht nach dem Beitritt

aktualisiere Benutzer1 c beitreten (wähle a.Benutzername aus Benutzer1 a beitreten Benutzer2 b am (a.Benutzername = b.Benutzername)) d am (c.Benutzername = d.Benutzername) setze c.Kommentar = „Diese Person ist in Wukongs Freundeskreis“;

Überprüfen Sie user1 erneut. Sie können sehen, dass user1 erfolgreich geändert wurde

wähle * von Benutzer1;
+----+--------------+-----------------------------------------+---------------------------------+
| ID | Benutzername | Kommentar | Mobiltelefon |
+----+--------------+-----------------------------------------+---------------------------------+
| 1 | Tang-Mönch | Sandelholz-Verdienst-Buddha | 138245623,021-382349 |
| 2 | Sun Wukong | Diese Person gehört zu Wukongs Freundeskreis | 159384292,022-483432,+86-392432 |
| 3 | Zhu Bajie | Altarreiniger | 183208243,055-8234234 |
| 4 | Sha Seng | Arhat mit goldenem Körper | 293842295,098-2383429 |
| 5 | NULL | Weißes Drachenpferd | 993267899 |
+----+--------------+-----------------------------------------+---------------------------------+

8. Verwenden Sie Join, um doppelte Daten zu entfernen

Fügen Sie zunächst zwei Daten in die Tabelle user2 ein

in Benutzer2 (Benutzername, Kommentar) Werte einfügen (,,Kommentar',,Kommentar');
in Benutzer2 (Benutzername, Kommentar) Werte einfügen (,,Kommentar',,Kommentar');

Beispiel: Löschen Sie doppelte Daten in der Tabelle „user2“ und behalten Sie nur die Daten mit großen ID-Nummern

+----+--------------+-----------+
| ID | Benutzername | Kommentar |
+----+--------------+-----------+
| 1 | Sun Wukong | Der Affenkönig |
| 2 | Bullendämonenkönig | Bruder Niu |
| 3 | Prinzessin Iron Fan | Frau Niu |
| 4 | Bodhi Patriarch | Trauben |
| 5 | NULL | Jingjing|
| 6 | Sun Wukong | Der Affenkönig |
| 7 | Bullendämonenkönig | Bruder Niu |
+----+--------------+-----------+

Überprüfen Sie zuerst doppelte Datensätze

wähle a.*, b.* von Benutzer2 a, verbinde (wähle Benutzername, Kommentar, max(id) ID aus Benutzer2, Gruppe nach Benutzername, Kommentar mit count(*) > 1) b auf (a.Benutzername=b.Benutzername und a.Kommentar=b.Kommentar), sortiere nach 2;
+----+--------------+--------------+-----------+-----------+-----------+------+
| ID | Benutzername | Kommentar | Benutzername | Kommentar | ID |
+----+--------------+-----------+-----------+-----------+-----------+------+
| 1 | Sun Wukong| Der Affenkönig| Sun Wukong| Der Affenkönig| 6 |
| 6 | Sun Wukong| Der Affenkönig| Sun Wukong| Der Affenkönig| 6 |
| 2 | Bullendämonenkönig| Bruder Niu| Bullendämonenkönig| Bruder Niu| 7 |
| 7 | Bullendämonenkönig| Bruder Niu| Bullendämonenkönig| Bruder Niu| 7 |
+----+--------------+--------------+-----------+-----------+-----------+------+

Löschen Sie dann einfach die Daten, wobei (a.id < b.id)

lösche a von Benutzer2, a verbinde (wähle Benutzername, Kommentar, max(id)-ID aus Benutzer2-Gruppe nach Benutzername, Kommentar mit count(*) > 1) b auf (a.Benutzername=b.Benutzername und a.Kommentar=b.Kommentar), wobei a.id < b.id;

Überprüfen Sie Benutzer2 und Sie können sehen, dass die doppelten Daten gelöscht wurden.

wähle * von Benutzer2;
+----+--------------+-----------+
| ID | Benutzername | Kommentar |
+----+--------------+-----------+
| 3 | Prinzessin Iron Fan | Frau Niu |
| 4 | Bodhi Patriarch | Trauben |
| 5 | NULL | Jingjing|
| 6 | Sun Wukong | Der Affenkönig |
| 7 | Bullendämonenkönig | Bruder Niu |
+----+--------------+-----------+

Zusammenfassen:

Das ist alles, was ich dazu zu sagen habe. Wenn Sie interessiert sind, können Sie weitere Daten erstellen und die Ausführungszeiten verschiedener SQL-Anweisungen vergleichen. Die Beispiele in diesem Artikel stammen aus dem Kurs „SQL Development Skills“ auf MOOC.com.

Das ist alles für diesen Artikel. Ich hoffe, dass der Inhalt dieses Artikels für Ihr Studium oder Ihre Arbeit von gewissem Referenzwert ist. Vielen Dank für Ihre Unterstützung von 123WORDPRESS.COM.

Das könnte Sie auch interessieren:
  • Grundlegende MySQL-Tabellenabfragen – häufige Fehler beim Left-Join
  • Analyse des Unterschieds zwischen der Verwendung von Left Join-Einstellungsbedingungen in „on“ und „where“ in MySQL
  • Zusammenfassung verschiedener gängiger Abfragebeispiele für Join-Tabellen in MySQL
  • MySQL 8.0.18 Hash Join unterstützt keine Links-/Rechts-Joins. Probleme mit Links- und Rechts-Joins
  • Mysql 8.0.18 Hash-Join-Test (empfohlen)
  • Neue Funktionen in MySQL 8.0: Hash Join
  • Stabile Version von MySQL 8.0.18 veröffentlicht! Hash Join ist wie erwartet da
  • Abfrageprozess und Optimierungsmethode der (JOIN/ORDER BY)-Anweisung in MySQL
  • Tiefgreifendes Verständnis der MySQL-Selbstverbindung und Join-Assoziation
  • Beispielanalyse für MySQL-Jointabelle und automatische ID-Inkrementierung

<<:  jQuery implementiert die Funktion zum Deaktivieren der Steuertaste zum Senden des Bestätigungscodes

>>:  Implementierung der gemeinsamen Nutzung von Daten zwischen Docker Volume-Containern

Artikel empfehlen

Ein kleiner HTML-Code fügt die Baidu-Suchleiste in Ihre Seite ein

<html> <Kopf> <meta http-equiv=&quo...

CSS-Code zur Unterscheidung von IE8/IE9/IE10/IE11 Chrome Firefox

Das Debuggen der Website-Kompatibilität ist wirkl...

JS Asynchronous Stack Tracing: Warum „await“ besser ist als „Promise“

Überblick Der grundlegende Unterschied zwischen a...

Nofollow sorgt dafür, dass die Links in Kommentaren und Nachrichten wirklich funktionieren

Kommentare und Nachrichten waren ursprünglich ein...

So installieren Sie PHP7.4 und Nginx auf Centos

Vorbereiten 1. Laden Sie das erforderliche Instal...

Linux verwendet den Befehl scp, um Dateien auf den lokalen Computer zu kopieren und lokale Dateien auf den Remote-Server zu kopieren

Wie unten dargestellt: Kopieren Sie die Dateien d...

Lösen Sie das Problem, dass MySQL „not in“ verwendet, um Nullwerte einzuschließen

Beachten! ! ! Wählen Sie * vom Benutzer, wobei di...

Lösung für die Ausnahmen 1449 und 1045 bei der Verbindung mit MySQL

Lösung für die Ausnahmen 1449 und 1045 bei der Ve...

Erfahrungsaustausch zur Optimierung von MySQL-Big-Data-Abfragen (empfohlen)

Ernsthafte MySQL-Optimierung! Wenn die MySQL-Date...

Lassen Sie IE6, IE7, IE8 CSS3-abgerundete Ecken und Schattenstile unterstützen

Ich möchte eine Seite mit CSS3-abgerundeten Ecken...

Die Verwendung und Methoden von async und await in JavaScript

asynchrone Funktion und await-Schlüsselwort in JS...

Vue-Element implementiert das Hinzufügen, Löschen und Ändern von Daten in Tabellen

In diesem Artikel wird der spezifische Code des V...

Wie können wir für Jiedaibao werben, damit sich jeder anmeldet? Methoden und Fähigkeiten zur Förderung von Jiedaibao

Jiedaibao ist eine Softwareplattform für Handykre...

Einführung in HTML DOM_PowerNode Java Academy

Was ist DOM? Mit JavaScript können Sie das gesamt...

Analysieren Sie die Rolle von rel="nofollow" in HTML und die Verwendung des rel-Attributs

Durch das Hinzufügen des Attributs rel="nofo...