MySQL-Cursorfunktionen und -Verwendung

Definition

Wir geraten häufig in die Situation, die Ergebnisse unserer Abfrage zu durchlaufen und jedes durchlaufene Datenelement zu verarbeiten. In diesem Fall wird ein Cursor verwendet.
Also: Ein Cursor ist eine Datenbankabfragemethode zum Verarbeiten von Daten, die auf einem MySQL-Server gespeichert sind. Um die Daten in einem Ergebnissatz anzuzeigen oder zu verarbeiten, bietet er die Möglichkeit, die Daten im Ergebnissatz zeilenweise zu durchlaufen.
Cursor werden hauptsächlich bei der Schleifenverarbeitung, gespeicherten Prozeduren, Funktionen und Triggern verwendet.

Die Rolle des Cursors

Für die oben genannten Studenten müssen wir beispielsweise jeden Benutzer durchgehen und dann auf der Grundlage ihrer anderen Kommentare Punkte hinzufügen oder abziehen. Zu diesem Zeitpunkt müssen wir sämtliche Studierendendaten (inkl. Noten) abfragen.

Wählen Sie Studenten-ID, Studentenname und Punktzahl der Studenten aus;

Nach der Ausführung wird ein Satz von Studentendaten zurückgegeben. Wenn wir die Studentendaten einzeln durchlaufen und dann je nach spezifischer Situation Punkte hinzufügen müssen, müssen wir einen Cursor verwenden.
Der Cursor entspricht einem Zeiger, der auf die erste ausgewählte Datenzeile zeigt. Die nachfolgenden Daten können durch Bewegen des Zeigers durchlaufen werden.

Verwendung des Cursors

• Deklarieren Sie einen Cursor: Erstellen Sie einen Cursor und geben Sie die Auswahlabfrage an, die der Cursor durchlaufen muss. Das SQL wird nicht ausgeführt, wenn der Cursor deklariert ist.
• Öffnen Sie den Cursor: Wenn der Cursor geöffnet wird, wird die dem Cursor entsprechende Select-Anweisung ausgeführt.
• Daten durchlaufen: Verwenden Sie einen Cursor, um jede Datenzeile im Auswahlergebnis zu durchlaufen und sie dann zu verarbeiten.
• Geschäftsbetrieb: Der Prozess der Verarbeitung jeder durchlaufenen Datenzeile. Sie können jede Anweisung platzieren, die ausgeführt werden muss (Hinzufügen, Löschen, Ändern, Überprüfen): Dies hängt von der jeweiligen Situation ab
• Cursor schließen: Der Cursor muss nach der Benutzung losgelassen werden.

Hinweis: Die verwendeten temporären Felder müssen vor der Definition des Cursors deklariert werden.

Deklarieren eines Cursors

DECLARE Cursorname CURSOR FÜR Select-Anweisung;

Deklarieren Sie einen Cursor. Sie können in einer Subroutine auch mehrere Cursor definieren, aber jeder Cursor in einem Block muss einen eindeutigen Namen haben. Nach dem Deklarieren eines Cursors handelt es sich ebenfalls um eine einzelne Operation, aber die SELECT-Anweisung kann keine INTO-Klausel enthalten.
In einem Begin-End kann nur ein Cursor deklariert werden.

Cursor öffnen

ÖFFNEN Cursorname;

Öffnet einen zuvor deklarierten Cursor.

Durchlaufen von Cursordaten

FETCH Cursorname INTO Var_Liste;

Diese Anweisung ruft die nächste Zeile (sofern vorhanden) unter Verwendung des angegebenen offenen Cursors ab und bewegt den Cursorzeiger weiter. Holen Sie sich das Ergebnis der aktuellen Zeile, fügen Sie das Ergebnis in die entsprechende Variable ein und richten Sie den Cursorzeiger auf die Daten der nächsten Zeile.
Wenn Fetch aufgerufen wird, werden die Daten der aktuellen Zeile abgerufen. Wenn in der aktuellen Zeile keine Daten vorhanden sind, wird in MySQL ein Fehler „NICHT GEFUNDEN“ ausgelöst.

Cursor schließen

SCHLIESSEN Cursorname;

Denken Sie daran, den Cursor zu schließen, wenn Sie ihn nicht mehr verwenden.

Cursor-Beispiel

Schreiben Sie eine Funktion, die die Berechnung der Noten und Zusatzpunkte der Schüler beinhaltet

Datengrundlage

mysql> wähle * aus Studenten;
+-----------+----------+----------+---------+
| Studenten-ID | Studentenname | Punktzahl | Klassen-ID |
+-----------+----------+----------+---------+
| 1 | Marke | 97,5 | 1 |
| 2 | Helene | 96,5 | 1 |
| 3 | lyn | 96 | 1 |
| 4 | Sol | 97 | 1 |
| 5 | b1 | 81 | 2 |
| 6 | b2 | 82 | 2 |
| 7 | c1 | 71 | 3 |
| 8 | c2 | 72,5 | 3 |
| 9 | lala | 73 | 0 |
| 10 | EIN | 99 | 3 |
| 16 | test1 | 100 | 0 |
| 17 | Auslöser2 | 107 | 0 |
| 22 | Auslöser1 | 100 | 0 |
+-----------+----------+----------+---------+
13 Reihen im Set

Schreiben von Funktionen mit Cursorn

Die Anmerkungen hier sind sehr klar

MySQL>
/* Falls die Funktion existiert, löschen Sie sie */
Funktion löschen, wenn fun_test vorhanden ist;
/* Das Ende der Anweisung ist $*/
TRENNUNGSZEICHEN $
/*Erstellen Sie eine Funktion, um jedem Schüler, der die Anforderungen erfüllt, Punkte hinzuzufügen. Die hinzugefügten Punkte dürfen den angegebenen Wert max_score nicht überschreiten*/
FUNKTION ERSTELLEN fun_test(max_score decimal(10,2))
RÜCKGABE int
BEGINNEN
/*Definieren Sie die Echtzeitvariable „StudentId“*/
DECLARE var_studentId int DEFAULT 0;
/*Definieren Sie die Variable für den berechneten Score*/
DECLARE var_score dezimal(10,2) DEFAULT 0;
/*Definieren Sie die Cursor-Endmarkierungsvariable*/
DECLARE var_done int DEFAULT FALSE;
/*Cursor erstellen*/
DECLARE cur_test CURSOR FOR SELECT studentid, Punktzahl von Studenten, bei denen classid<>0 ist;
/*Wenn der Cursor endet, wird var_done auf true gesetzt. Sie können var_done verwenden, um zu bestimmen, ob der Cursor später beendet wurde*/
DECLARE CONTINUE HANDLER FÜR NICHT GEFUNDEN SET var_done=TRUE;
/*Cursor öffnen*/
ÖFFNEN Sie aktuellen_Test;
/*Mithilfe von „Loop“ den Cursor durchlaufen*/
select_loop:SCHLEIFE
/*Erst die Daten der aktuellen Zeile abrufen, dann die Daten der aktuellen Zeile in var_studentId, var_score einfügen. Wenn keine Datenzeile vorhanden ist, wird var_done auf true gesetzt*/
FETCH aktueller_test INTO var_studentId,var_score;
/*Verwenden Sie var_done, um festzustellen, ob der Cursor beendet ist, und beenden Sie die Schleife*/
WENN var_done DANN
VERLASSEN Sie select_loop;
ENDE, WENN;
/*Füge dem var_score-Wert einen zufälligen Wert hinzu, der die angegebene Punktzahl nicht überschreiten kann*/
setze var_score = var_score + LEAST(ROUND(rand()*10,0),max_score);
Aktualisiere die Punktzahl der Studenten, setze sie = var_score, wobei studentId = var_studentId;
ENDE DER SCHLEIFE;
/*Cursor schließen*/
SCHLIESSEN Sie cur_test;
/*Rückgabeergebnis: Sie können den erforderlichen Inhalt entsprechend der tatsächlichen Situation zurückgeben*/
RÜCKGABE 1;
ENDE $
/*Endzeichen ist auf ; gesetzt*/
TRENNUNGSZEICHEN ;
Abfrage OK, 0 Zeilen betroffen

Aufrufen einer Funktion

MySQL>
/* Der Parameter ist 8, was bedeutet, dass die Obergrenze der Bonuspunkte 8 beträgt */
wähle fun_test(8);
+-------------+
| Spaßtest(8) |
+-------------+
| 1 |
+-------------+
1 Reihe im Set

Ergebnisse anzeigen

Beim Vergleich des ursprünglichen Punktewerts wird festgestellt, dass der Punktewert mit einem zufälligen Wert addiert wurde, aber den angegebenen Punktewert 8 nicht überschreitet.

mysql> wähle * aus Studenten;
+-----------+----------+----------+---------+
| Studenten-ID | Studentenname | Punktzahl | Klassen-ID |
+-----------+----------+----------+---------+
| 1 | Marke | 105,5 | 1 |
| 2 | Helene | 98,5 | 1 |
| 3 | lyn | 97 | 1 |
| 4 | Sol | 97 | 1 |
| 5 | b1 | 89 | 2 |
| 6 | b2 | 90 | 2 |
| 7 | c1 | 76 | 3 |
| 8 | c2 | 73,5 | 3 |
| 9 | lala | 73 | 0 |
| 10 | EIN | 100 | 3 |
| 16 | test1 | 100 | 0 |
| 17 | Auslöser2 | 107 | 0 |
| 22 | Auslöser1 | 100 | 0 |
+-----------+----------+----------+---------+
13 Reihen im Set

Anzeigen des Triggerprotokolls

Es gibt 9 Daten, die die Bedingungen erfüllen und deren Punktzahl geändert wurde. Sie wurden alle durch den Auslöser im Protokoll aufgezeichnet.

MySQL>
/*Im vorherigen Artikel habe ich einen Trigger geschrieben, der die Protokollierung auslöst, wenn die Studententabelle geändert wird*/
Wählen Sie * aus dem Triggerprotokoll;
+----+--------------+------------------+-----------------------------------------+
| ID | Auslösezeit | Auslöseereignis | Memo |
+----+--------------+------------------+-----------------------------------------+
| 1 | nach | einfügen | Informationen zum neuen Studenten, ID:21 |
| 2 | nach | aktualisieren | Studenteninfo aktualisieren, ID:21 |
| 3 | nach | aktualisieren | löschen Studenteninfo,ID:21 |
| 4 | nach | Update | von:Test2,101.00 bis:Trigger2,106.00 |
| 5 | nach | Aktualisierung | von: Trigger2.106,00 bis: Trigger2.107,00 |
| 6 | nach | aktualisieren | löschen Studenteninfo,ID:11 |
| 7 | nach | Aktualisierung | von:Marke,97,50 auf:Marke,105,50 |
| 8 | nach | Aktualisierung | von:helen,96.50 auf:helen,98.50 |
| 9 | nach | Aktualisierung | von:lyn,96.00 bis:lyn,97.00 |
| 10 | nach | Aktualisierung | von:sol,97.00 bis:sol,97.00 |
| 11 | nach | Update | von:b1,81.00 bis:b1,89.00 |
| 12 | nach | Aktualisierung | von:b2,82.00 bis:b2,90.00 |
| 13 | nach | Aktualisierung | von:c1,71.00 bis:c1,76.00 |
| 14 | nach | Aktualisierung | von:c2,72.50 auf:c2,73.50 |
| 15 | nach | Aktualisierung | von:A,99.00 bis:A,100.00 |
+----+--------------+------------------+-----------------------------------------+
15 Reihen im Set

Cursor-Ausführungsprozess

Analysieren Sie anhand des obigen Beispiels den Ausführungsprozess dieses Cursors.
1. Wir haben einen Cursor erstellt und die Datenquelle wurde aus der Studententabelle übernommen.
2. Im Cursor befindet sich ein Zeiger. Wenn der Cursor geöffnet wird, wird die dem Cursor entsprechende Auswahlanweisung ausgeführt, und dieser Zeiger zeigt auf die erste Datensatzzeile im Auswahlergebnis.
3. Wenn der Abrufcursorname aufgerufen wird, werden die Daten der aktuellen Zeile abgerufen. Wenn in der aktuellen Zeile keine Daten vorhanden sind, wird eine Ausnahme „NOT FOUND“ ausgelöst.
Wenn eine NOT FOUND-Ausnahme ausgelöst wird, können wir sie mit einer Variablen markieren, wie oben gezeigt: DECLARE CONTINUE HANDLER FOR NOT FOUND SET var_done=TRUE;
Setzen Sie den Wert der Variable var_done auf TRUE. Der Wert von var_done kann verwendet werden, um den Ausgang der Schleife zu steuern: LEAVE select_loop;.
Wenn die aktuelle Zeile Daten enthält, werden die Daten der aktuellen Zeile in der entsprechenden Variablen gespeichert und der Cursorzeiger zeigt auf die nächste Datenzeile, wie in der folgenden Anweisung gezeigt: FETCH cur_test INTO var_studentId,var_score;

Zusammenfassen

1. Der Cursor wird zum Durchlaufen der Abfrageergebnisse verwendet.
2. Der Vorgang der Verwendung des Cursors: Cursor deklarieren, Cursor öffnen, Cursor durchlaufen und Cursor schließen.
3. Cursor werden hauptsächlich in der Schleifenverarbeitung, gespeicherten Prozeduren und Funktionen zum Abfragen von Ergebnismengen verwendet.
4. Der Nachteil des Cursors besteht darin, dass er nur zeilenweise arbeiten kann. Er ist nicht anwendbar, wenn die Datenmenge groß und die Geschwindigkeit zu langsam ist. Die meisten Datenbanken sind sammlungsorientiert und das Geschäft ist relativ komplex. Die Verwendung von Cursorn kann zu Deadlocks führen und andere Geschäftsvorgänge beeinträchtigen, was nicht ratsam ist. Bei großen Datenmengen kann die Verwendung eines Cursors zu Speichermangel führen.

Oben finden Sie eine detaillierte Analyse von MySQL-Cursorn. Weitere Informationen zu MySQL-Cursorn finden Sie in den anderen verwandten Artikeln auf 123WORDPRESS.COM!