Analyse der geplanten Aufgaben und Ereignisplanungsbeispiele von MySQL

Dieser Artikel beschreibt anhand von Beispielen die geplanten Aufgaben und die Ereignisplanung von MySQL. Teilen Sie uns die Einzelheiten zu Ihrer Information mit:

MySQL-Ereignisse sind Aufgaben, die basierend auf einem vordefinierten Zeitplan ausgeführt werden. Daher werden sie manchmal als geplante Ereignisse bezeichnet. MySQL-Ereignisse werden auch als „Zeitauslöser“ bezeichnet, da sie durch die Zeit ausgelöst werden und nicht wie ein Auslöser eine Tabelle aktualisieren. MySQL-Ereignisse ähneln Cron-Jobs in UNIX oder dem Taskplaner in Windows. Wir können MySQL-Ereignisse verwenden, wenn wir außerhalb der Spitzenzeiten Datenbanktabellen optimieren, Protokolle bereinigen, Daten archivieren oder komplexe Berichte erstellen.

MySQL verwendet einen speziellen Thread namens „Event Dispatching Thread“, um alle geplanten Ereignisse auszuführen. Wir können den Status des Ereignisplanungs-Threads anzeigen, indem wir den folgenden Befehl ausführen:

PROZESSLISTE ANZEIGEN;

Führen Sie die obige Abfrageanweisung aus und erhalten Sie die folgenden Ergebnisse:

mysql> PROZESSLISTE ANZEIGEN;
+----+------+-----------------+----------+---------+------+----------+------------------+
| ID | Benutzer | Host | db | Befehl | Zeit | Status | Info |
+----+------+-----------------+----------+---------+------+----------+------------------+
| 2 | root | localhost:50405 | NULL | Ruhezustand | 1966 | | NULL |
| 3 | root | localhost:50406 | yiibaidb | Ruhezustand | 1964 | | NULL |
| 4 | root | localhost:50407 | yiibaidb | Abfrage | 0 | wird gestartet | PROZESSLISTE ANZEIGEN |
+----+------+-----------------+----------+---------+------+----------+------------------+
3 Reihen im Set

Standardmäßig ist der Ereignisdispatcher-Thread nicht aktiviert. Um den Event-Dispatcher-Thread zu aktivieren und zu starten, müssen die folgenden Befehle ausgeführt werden:

Setzen Sie den Event_Scheduler global auf ON.

Um nun den Status des Ereignisplaner-Threads anzuzeigen, führen Sie den Befehl SHOW PROCESSLIST erneut aus. Das Ergebnis ist wie folgt:

mysql> PROZESSLISTE ANZEIGEN;
+----+-----------------+-----------------+----------+---------+------+------------------------+------------------+
| ID | Benutzer | Host | db | Befehl | Zeit | Status | Info |
+----+-----------------+-----------------+----------+---------+------+------------------------+------------------+
| 2 | root | localhost:50405 | NULL | Ruhezustand | 1986 | | NULL |
| 3 | root | localhost:50406 | luyaran | Schlaf | 1984 | | NULL |
| 4 | root | localhost:50407 | luyaran | Abfrage | 0 | wird gestartet | PROZESSLISTE ANZEIGEN |
| 5 | event_scheduler | localhost | NULL | Daemon | 6 | Warte auf leere Warteschlange | NULL |
+----+-----------------+-----------------+----------+---------+------+------------------------+------------------+
4 Reihen im Set

Um den Thread des Ereignisplaners zu deaktivieren und zu stoppen, setzen Sie den Wert von event_scheduler auf OFF, indem Sie den Befehl SET GLOBAL ausführen:

SETZEN SIE GLOBAL event_scheduler = OFF;

Wie wir wissen, ist ein Ereignis ein benanntes Objekt, das SQL-Anweisungen enthält. Das Erstellen eines Ereignisses ähnelt dem Erstellen anderer Datenbankobjekte (z. B. gespeicherte Prozeduren oder Trigger). Gespeicherte Prozeduren werden jedoch nur ausgeführt, wenn sie direkt aufgerufen werden. Trigger sind mit einem Ereignis (z. B. Einfügen, Aktualisieren oder Löschen) in einer Tabelle verknüpft. Wenn das Ereignis eintritt, kann es in einem oder mehreren regelmäßigen Intervallen ausgeführt werden. Und was ist mit Veranstaltungen? Als nächstes versuchen wir, mit der Anweisung CREATE EVENT ein Ereignis zu erstellen. Werfen wir einen Blick auf die Syntaxstruktur:

EREIGNIS ERSTELLEN [WENN NICHT EXISTIEREN] event_name
IM ZEITPLAN Zeitplan
TUN
Ereignistext

Schauen wir uns die Bedeutung der Parameter im obigen SQL genauer an:

Geben Sie zunächst den Ereignisnamen nach der CREATE EVENT-Klausel an. Ereignisnamen müssen innerhalb des Datenbankschemas eindeutig sein.

Zweitens, fügen Sie nach der ON SCHEDULE-Klausel eine Tabelle hinzu. Wenn es sich bei dem Ereignis um ein einmaliges Ereignis handelt, verwenden Sie die Syntax: AT timestamp [+ INTERVAL], wenn es sich bei dem Ereignis um ein wiederkehrendes Ereignis handelt, verwenden Sie die EVERY-Klausel: EVERY interval STARTS timestamp [+INTERVAL] ENDS timestamp [+INTERVAL]

Drittens: Platzieren Sie die DO-Anweisung nach dem DO-Schlüsselwort. Beachten Sie, dass gespeicherte Prozeduren innerhalb des Ereignistexts aufgerufen werden können. Wenn Sie zusammengesetzte SQL-Anweisungen haben, können Sie diese in einen BEGIN END-Block einfügen.

Lassen Sie uns zur Demonstration eine Nachrichtentabelle erstellen:

CREATE TABLE IF NOT EXISTS-Meldungen (
  Ich würde INT PRIMARY KEY AUTO_INCREMENT,
  Nachricht VARCHAR(255) NOT NULL,
  erstellt am DATETIME NICHT NULL
);

Lassen Sie uns nun mit der Anweisung CREATE EVENT ein Ereignis erstellen:

EREIGNIS ERSTELLEN, WENN NICHT VORHANDEN test_event_01
PLANMÄSSIG UM CURRENT_TIMESTAMP
TUN
 INSERT INTO Nachrichten(Nachricht, erstellt am)
 VALUES('MySQL-Ereignis 1 testen',NOW());

Überprüfen Sie die Nachrichtentabelle. Sie werden sehen, dass 1 Datensatz vorhanden ist. Dies bedeutet, dass das Ereignis bei seiner Erstellung ausgeführt wurde:

mysql> SELECT * FROM Nachrichten;
+----+--------------------+---------------------+
| ID | Nachricht | erstellt am |
+----+--------------------+---------------------+
| 1 | MySQL-Ereignis 1 testen | 03.08.2017 04:23:11 |
+----+--------------------+---------------------+
1 Reihe im Set

Um alle Ereignisse für die Datenbank (testdb) anzuzeigen, verwenden Sie die folgende Anweisung:

EREIGNISSE AUS testdb ANZEIGEN;

Beim Ausführen der obigen Abfrage werden keine Zeilen zurückgegeben, da Ereignisse automatisch gelöscht werden, wenn sie ablaufen. In unserem Fall handelt es sich um ein einmaliges Ereignis, das abläuft, wenn die Ausführung abgeschlossen ist. Um dieses Verhalten zu ändern, können Sie die Klausel ON COMPLETION PRESERVE verwenden. Die folgende Anweisung erstellt ein weiteres einmaliges Ereignis, das 1 Minute nach seiner Erstellungszeit ausgeführt wird und nach der Ausführung nicht gelöscht wird:

EREIGNIS ERSTELLEN test_event_02
ZEITPLANMÄSSIG UM CURRENT_TIMESTAMP + INTERVALL 1 MINUTE
BEI FERTIGSTELLUNG BEWAHREN
TUN
  INSERT INTO Nachrichten(Nachricht, erstellt am)
  VALUES('MySQL-Ereignis 2 testen',NOW());

Warten Sie eine Minute und überprüfen Sie die Nachrichtentabelle. Sie werden sehen, dass ein weiterer Datensatz hinzugefügt wurde:

mysql> SELECT * FROM Nachrichten;
+----+--------------------+---------------------+
| ID | Nachricht | erstellt am |
+----+--------------------+---------------------+
| 1 | MySQL-Ereignis 1 testen | 03.08.2017 04:23:11 |
| 2 | MySQL-Ereignis 2 testen | 03.08.2017 04:24:48 |
+----+--------------------+---------------------+
2 Reihen im Set

Wenn Sie die Anweisung SHOW EVENTS erneut ausführen, werden Sie sehen, dass die Ereignisse auf die Klausel ON COMPLETION PRESERVE zurückzuführen sind:

mysql> EREIGNISSE AUS testdb ANZEIGEN;
+--------+--------------+----------------+-----------+----------+---------------------+----------------+----------------+--------+------+----------+------------+----------------------+----------------------+--------------------+
| Db | Name | Definierer | Zeitzone | Typ | Ausführen am | Intervallwert | Intervallfeld | Beginnt | Endet | Status | Urheber | character_set_client | collation_connection | Datenbanksortierung |
+--------+--------------+----------------+-----------+----------+---------------------+----------------+----------------+--------+------+----------+------------+----------------------+----------------------+--------------------+
| testdb | test_event_02 | root@localhost | SYSTEM | EINMAL | 03.08.2017 04:24:48 | NULL | NULL | NULL | NULL | DEAKTIVIERT | 0 | utf8 | utf8_general_ci | utf8_general_ci |
+--------+--------------+----------------+-----------+----------+---------------------+----------------+----------------+--------+------+----------+------------+----------------------+----------------------+--------------------+
1 Reihe im Set

Lassen Sie uns ein wiederkehrendes Ereignis erstellen, das jede Minute ausgeführt wird und innerhalb einer Stunde nach seiner Erstellungszeit abläuft:

EREIGNIS ERSTELLEN test_event_03
PER ZEITPLAN JEDE MINUTE
STARTET CURRENT_TIMESTAMP
ENDET CURRENT_TIMESTAMP + INTERVALL 1 STUNDE
TUN
  INSERT INTO Nachrichten(Nachricht, erstellt am)
  VALUES('MySQL-Wiederkehrendes Ereignis testen',NOW());

Wir sollten beachten, dass wir die Klauseln STARTS und ENDS verwenden, um die Gültigkeitsdauer des Ereignisses zu definieren. Warten Sie 3 bis 5 Minuten und überprüfen Sie dann die Daten der Nachrichtentabelle, um die Ausführung dieses Loop-Ereignisses zu testen und zu überprüfen:

mysql> SELECT * FROM Nachrichten;
+----+----------------------------+---------------------+
| ID | Nachricht | erstellt am |
+----+----------------------------+---------------------+
| 1 | MySQL-Ereignis 1 testen | 03.08.2017 04:23:11 |
| 2 | MySQL-Ereignis 2 testen | 03.08.2017 04:24:48 |
| 3 | Wiederkehrendes MySQL-Ereignis testen | 03.08.2017 04:25:20 |
| 4 | Wiederkehrendes MySQL-Ereignis testen | 03.08.2017 04:26:20 |
| 5 | Wiederkehrendes MySQL-Ereignis testen | 03.08.2017 04:27:20 |
+----+----------------------------+---------------------+
5 Reihen im Set

Anschließend können wir das Ereignis mit der Anweisung DROP EVENT löschen. Sehen Sie sich die Syntaxstruktur an:

DROP EVENT [WENN EXISTIERT] Ereignisname;

Um das Ereignis test_event_03 zu löschen, können wir das folgende SQL verwenden:

EREIGNIS LÖSCHEN, WENN EXISTIERT: test_event_03;

Okay, das ist alles zu diesem Eintrag.

Leser, die an weiteren MySQL-bezogenen Inhalten interessiert sind, können sich die folgenden Themen auf dieser Site ansehen: „Zusammenfassung der Kenntnisse im Bereich MySQL-Indexoperationen“, „Zusammenfassung der Kenntnisse im Bereich MySQL-Allgemeinfunktionen“, „Zusammenfassung der Kenntnisse im Bereich MySQL-Protokolloperationen“, „Zusammenfassung der Kenntnisse im Bereich MySQL-Transaktionsoperationen“, „Zusammenfassung der Kenntnisse im Bereich MySQL-gespeicherte Prozeduren“ und „Zusammenfassung der Kenntnisse im Zusammenhang mit MySQL-Datenbanksperren“.

Ich hoffe, dass dieser Artikel für jedermann beim Entwurf einer MySQL-Datenbank hilfreich ist.