Einführung in die Verwendung und den Unterschied zwischen „in“ und „exists“ in MySQL

Geben Sie zunächst einen Code ein

für(int i=0;i<1000;i++){
 für(int j=0;j<5;j++){
 System.out.println("hallo");
 }
}

 für(int i=0;i<5;i++){
 für(int j=0;j<1000;j++){
 System.out.println("hallo");
 }
}

Bei der Analyse des obigen Codes können wir feststellen, dass sich die beiden Codezeilen bis auf die Reihenfolge der Schleifen nicht unterscheiden. Bei der tatsächlichen Ausführung sollten auch die von beiden verbrauchte Zeit und der von ihnen verbrauchte Speicherplatz gleich sein. Aber das ist nur in Java möglich. Lassen Sie uns nun das Szenario ändern. Die äußerste Schleife ist eine Verbindungsoperation in der Datenbank und die innere Schleife ist eine Suchoperation. Nun werden die Ergebnisse der beiden Operationen sehr unterschiedlich sein.

Der Grund hierfür liegt in den Eigenschaften der Datenbank. Im Vergleich zu Abfragevorgängen in der Datenbank verbraucht der Verbindungsaufbau mehr Ressourcen. Der erste Code stellte 1.000 Verbindungen her, aber jede Verbindung führte nur 5 Abfragen aus, was offensichtlich eine Verschwendung ist.

Daher sollten wir beim Bedienen der Datenbank die Vorgehensweise befolgen, dass kleine Tabellen große Tabellen steuern (kleine Datensätze große Datensätze steuern).

in und existiert

Tabellenstruktur

tbl_emp ist die Mitarbeitertabelle und deptld die Abteilungs-ID. tbl_dept ist die Abteilungstabelle. Die Mitarbeitertabelle enthält Gäste und ihr Feld „deptld“ ist -1

mysql> Beschreibung tbl_emp;
+--------+----------+------+-----+---------+----------------+
| Feld | Typ | Null | Schlüssel | Standard | Extra |
+--------+----------+------+-----+---------+----------------+
| id | int(11) | NEIN | PRI | NULL | auto_increment |
| Name | varchar(20) | JA | | NULL | |
| deptld | int(11) | JA | MUL | NULL | |
+--------+----------+------+-----+---------+----------------+
3 Zeilen im Satz (0,00 Sek.)

mysql> Beschreibung tbl_dept;
+----------+----------+------+-----+---------+----------------+
| Feld | Typ | Null | Schlüssel | Standard | Extra |
+----------+----------+------+-----+---------+----------------+
| id | int(11) | NEIN | PRI | NULL | auto_increment |
| deptName | varchar(30) | JA | MUL | NULL | |
| locAdd | varchar(40) | JA | | NULL | |
+----------+----------+------+-----+---------+----------------+
3 Zeilen im Satz (0,01 Sek.)

Wir wissen, dass ein Unternehmen viel mehr Mitarbeiter hat als eine Abteilung. Jetzt haben wir eine solche Anforderung: Fragen Sie die Mitarbeiter ab, die zu diesem Unternehmen gehören (außer zu Besuch weilende Gäste). Zur Lösung können wir den folgenden Code verwenden.

Verwendung in

# Fragen Sie zuerst alle IDs in der Abteilungstabelle ab und vergleichen Sie sie dann mit dem Feld „deptld“ in der Mitarbeitertabelle. Wenn sie gefunden werden, behalten Sie sie.

mysql> wähle * aus tbl_emp a, wobei a.deptld in (wähle ID aus tbl_dept);

Das Schlüsselwort in ist wie die Verkettung von oder. Die von der Unterabfrage im obigen SQL gefundenen Ergebnisse sind beispielsweise 1, 2 und 3. Die SQL-Anweisung entspricht der folgenden Form

mysql> select * from tbl_emp a where a.deptld=1 oder a.deptld=2 oder a.deptld=3

Im Allgemeinen dient das Schlüsselwort in dazu, alle Ergebnisse der Unterabfrage zu finden. Angenommen, der Ergebnissatz ist B mit insgesamt m Datensätzen. Dann wird der Ergebnissatz der Unterabfragebedingung in m Teile zerlegt und anschließend werden m Abfragen ausgeführt. Es ist ersichtlich, dass hier hauptsächlich der Index von A verwendet wird und die Tabelle B nur geringe Auswirkungen auf die Abfrage hat.

Verwendung von Exists

mysql> wähle * aus tbl_emp a, wo vorhanden (wähle 1 aus tbl_dept b, wo a.deptld = b.id);

Ausgänge: Fügen Sie die Daten der Hauptabfrage zur bedingten Überprüfung in die Unterabfrage ein und bestimmen Sie basierend auf dem Überprüfungsergebnis (Wahr oder Falsch), ob die Datensätze in der Hauptabfrage beibehalten werden sollen.

for (i = 0; i < count(A); i++) { //Gesamtzahl der Datensätze in Aa durchlaufen = get_record(A, i); //Datensätze einzeln aus Tabelle Aif abrufen (B.id = a[id]) //Wenn die Unterbedingung metersult[] = a ist;
}
Ergebnis zurückgeben;

Es ist ersichtlich, dass hauptsächlich der Index der Tabelle B verwendet wird und der Index der Tabelle A kaum Einfluss auf die Effizienz der Abfrage hat.

abschließend

mysql> wähle * aus tbl_emp a, wobei a.deptld in (wähle ID aus tbl_dept);

Wenn die Anzahl der Datensätze in tbl_dept kleiner ist als die in tbl_emp, ist es effizienter, sie in

mysql> wähle * aus tbl_emp a, wo vorhanden (wähle 1 aus tbl_dept b, wo a.deptld = b.id);

Wenn die Anzahl der Datensätze in tbl_dept die von tbl_emp übersteigt, ist es effizienter, in

Hier ist eine Einführung in den Unterschied zwischen IN und EXISTS

1. IN-Abfrageanalyse

WÄHLEN SIE * AUS A, WO id IN (WÄHLEN SIE id AUS B);

Äquivalent zu: 1. SELECT id FROM B -----> Führe die Abfrage zuerst aus

2. SELECT * FROM A WHERE A.id = B.id

Die Abfrage im obigen in() wird nur einmal ausgeführt. Sie fragt alle IDs in B ab und speichert sie im Cache. Anschließend wird geprüft, ob die in Tabelle A abgefragte ID im Cache vorhanden ist. Wenn dies der Fall ist, werden die Abfragedaten von A zum Ergebnissatz hinzugefügt, bis alle Ergebnissätze in Tabelle A durchlaufen sind.

Nachfolgend finden Sie eine Analyse der IN-Abfrage durch Durchlaufen des Ergebnissatzes

Aus dem obigen Programm können wir ersehen, dass die Verwendung der in()-Abfrage nicht geeignet ist, wenn die Daten in Tabelle B umfangreich sind, da dabei alle Daten in Tabelle B einmal durchlaufen werden.

Zum Beispiel:

1. Tabelle A enthält 100 Datensätze und Tabelle B 1000 Datensätze. Die maximal mögliche Durchquerung beträgt also 100*1000 Mal, was sehr ineffizient ist.

2. Wenn Tabelle A 1000 Datensätze und Tabelle B 100 Datensätze enthält, können maximal 1000 * 100 Datensätze durchlaufen werden, die Anzahl der inneren Schleifen wird reduziert und die Effizienz erheblich verbessert.

Fazit: Die IN()-Abfrage eignet sich für den Fall, dass die Daten in Tabelle B kleiner sind als die in Tabelle A. Die IN()-Abfrage ruft Daten aus dem Cache ab.

2. EXISTS-Abfrageanalyse

Syntax: SELECT-Feld FROM Tabelle WHERE EXISTS (Unterabfrage);

Wählen Sie * aus a, wobei "Existiert" (wählen Sie 1 aus b, wobei "B.id = A.id");

Die obige Abfrage entspricht:

WÄHLEN SIE * AUS A;
WÄHLE I AUS B, WO B.id = A.id;

Die EXISTS()-Abfrage führt die Abfrage SELECT * FROM A aus, führt sie A.length-mal aus und speichert die Ergebnisse der EXISTS()-Abfrage nicht im Cache, da die EXISTS()-Abfrage einen Booleschen Wert von true oder false zurückgibt, der sich nur darauf bezieht, ob Datensätze in der EXISTS()-Abfrage vorhanden sind, und nichts mit dem spezifischen Ergebnissatz zu tun hat.

Die Abfrage EXISTS() fügt den Ergebnissatz der Hauptabfrage zur Überprüfung in die Unterabfrage ein und entscheidet, ob das Datenergebnis der Hauptabfrage gespeichert wird, je nachdem, ob das Überprüfungsergebnis wahr oder falsch ist.

Zusammenfassen

Das Obige ist eine Einführung in die Verwendung und Unterschiede von in und exists in MySQL. Ich hoffe, es wird Ihnen hilfreich sein. Wenn Sie Fragen haben, hinterlassen Sie mir bitte eine Nachricht und ich werde Ihnen rechtzeitig antworten. Ich möchte auch allen für ihre Unterstützung der Website 123WORDPRESS.COM danken!