Eins, Lagerung

PS: Gespeicherte Prozeduren sind eine wichtige Funktion des Datenbankspeichers, aber MySQL unterstützt gespeicherte Prozeduren vor 5.0 nicht, wodurch MySQL in der Anwendung stark reduziert wird. Glücklicherweise hat MySQL 5.0 endlich damit begonnen, gespeicherte Prozeduren zu unterstützen, was die Verarbeitungsgeschwindigkeit der Datenbank erheblich verbessern und gleichzeitig die Flexibilität der Datenbankprogrammierung verbessern kann.

1. Speicherübersicht

Eine gespeicherte Prozedur ist eine Reihe von SQL-Anweisungen, um eine bestimmte Funktion auszuführen. Der Zweck der Verwendung gespeicherter Prozeduren besteht darin, allgemeine oder komplexe Aufgaben im Voraus mit SQL-Anweisungen zu schreiben und unter einem bestimmten Namen zu speichern. Dieser Prozess wird kompiliert und optimiert und auf dem Datenbankserver gespeichert, sodass er als gespeicherte Prozedur bezeichnet wird. Wenn die Datenbank in Zukunft denselben Dienst wie die definierte gespeicherte Prozedur bereitstellen soll, müssen Sie nur "CALL gespeicherte Prozedurname" aufrufen, um die entsprechende Funktion zu verwenden!
Die SQL-Anweisung zum Betreiben der Datenbank muss kompiliert und bei der Ausführung ausgeführt werden. Die gespeicherte Prozedur verwendet eine andere Methode zum Ausführen von SQL-Anweisungen.
Eine gespeicherte Prozedur ist eine programmierbare Funktion, die in der Datenbank erstellt und gespeichert wird und im Allgemeinen aus SQL-Anweisungen und einigen speziellen Kontrollstrukturen besteht! Wenn Sie entsprechende spezifische Funktionen auf verschiedenen Anwendungen oder Plattformen ausführen möchten, sind gespeicherte Prozeduren besonders geeignet!

2. Lagervorteile

Nachdem die gekapselte gespeicherte Prozedur erstellt wurde, kann sie im Programm mehrmals aufgerufen werden, ohne dass die SQL-Anweisung der gespeicherten Prozedur neu geschrieben werden muss, und Datenbankfachleute können die gespeicherte Prozedur jederzeit ändern, ohne die Anwendung zu beeinflussen, die sie als Quellcode aufruft.
Kann die Funktion und Flexibilität von SQL-Anweisungen verbessern. Gespeicherte Prozeduren können mit Flusssteuerungsanweisungen geschrieben werden, die eine hohe Flexibilität aufweisen und komplexe Beurteilungen und komplexere Berechnungen durchführen können.
Kann den Netzwerkverkehr reduzieren. Da die gespeicherte Prozedur auf der Serverseite ausgeführt wird und die Ausführungsgeschwindigkeit hoch ist, wird beim Aufruf der gespeicherten Prozedur auf dem Clientcomputer nur die Anrufanweisung im Netzwerk übertragen, wodurch die Netzwerklast verringert werden kann.
Nachdem die gespeicherte Hochleistungsprozedur einmal ausgeführt wurde, befindet sich der generierte Binärcode im Puffer. Bei nachfolgenden Aufrufen muss nur der Binärcode aus dem Puffer ausgeführt werden, wodurch die Effizienz und Leistung des Systems verbessert wird.
Verbessern Sie die Datenbanksicherheit und Datenintegrität. Verwenden Sie gespeicherte Prozeduren, um alle Datenbankvorgänge abzuschließen, und steuern Sie programmgesteuert den Zugriff auf Datenbankinformationen.

3. Syntax zur Erstellung gespeicherter Prozeduren

mysql> delimiter ??  #更改其默认的分隔符为“??”，也可以是其他任意符号，只要不是默认的“;”就行
mysql> create  procedure name() #定义存储过程name
    -> begin #存储过程开始
    -> ……  #存放的可以是一些sql语句的集合，当然，它同样有一些判断、循环等语句！！！
    -> end ?? #存储过程结束

mysql> delimiter ;   #更改为默认的分割符,注意中间必须有空格！！！
mysql> call name();  #调用刚才定义的name存储过程

1. Benutzerdefinierte gespeicherte Prozeduren

1.1 Tabelle zuerst einfügen

mysql> create database cunchu;
Query OK, 1 row affected (0.00 sec)

mysql> use cunchu;
Database changed
mysql> create table roster
    -> (
    -> id int,
    -> name varchar(20),
    -> sex varchar(20),
    -> scores float
    -> );
Query OK, 0 rows affected (0.00 sec)

mysql> insert into roster
    -> values 
    -> (1,'张三','男',90.5),
    -> (2,'李四','男',85.5),
    -> (3,'王五','女',78.5),
    -> (4,'刘三','女',66.5),
    -> (5,'赵四','男',50.5);
Query OK, 5 rows affected (0.00 sec)
Records: 5  Duplicates: 0  Warnings: 0

mysql> select * from roster;
+------+--------+------+--------+
| id   | name   | sex  | scores |
+------+--------+------+--------+
|    1 | 张三   | 男   |   90.5 |
|    2 | 李四   | 男   |   85.5 |
|    3 | 王五   | 女   |   78.5 |
|    4 | 刘三   | 女   |   66.5 |
|    5 | 赵四   | 男   |   50.5 |
+------+--------+------+--------+
5 rows in set (0.00 sec)

1.2 Eine gespeicherte Prozedur schreiben

Im folgenden Beispiel werden alle Daten im Dienstplan angezeigt! ! !

mysql> delimiter !!
mysql> create procedure test1()
    -> begin
    -> select * from roster;   #查询roster表内容
    -> end !!
Query OK, 0 rows affected (0.00 sec)

mysql> delimiter ;
mysql> call test1();
+------+--------+------+--------+
| id   | name   | sex  | scores |
+------+--------+------+--------+
|    1 | 张三   | 男   |   90.5 |
|    2 | 李四   | 男   |   85.5 |
|    3 | 王五   | 女   |   78.5 |
|    4 | 刘三   | 女   |   66.5 |
|    5 | 赵四   | 男   |   50.5 |
+------+--------+------+--------+
5 rows in set (0.00 sec)

Query OK, 0 rows affected (0.00 sec)

2. Die gespeicherte Prozedur der while-Anweisung

Das folgende Beispiel zeigt, wie viel von 1 + 2 + 3 + 4 …… + 100 gleich ist! ! !

mysql> delimiter @@  

mysql> create procedure test2()
    -> begin 
    -> declare i int; 			 #定义i为变量名称
    -> declare summary int;  	 #定义summary为变量名称
    -> set i=1;					 #设置变量的初始值为1
    -> set summary=0;			 #设置变量的初始值为0
    -> while i<=100  			 #当i小于或等于100时，执行以下操作
    -> do			 
    -> set summary=summary+i;
    -> set i=i+1;
    -> end while ;				 #循环结束
    -> select summary;			 #查询summary的值
    -> end @@
Query OK, 0 rows affected (0.00 sec)

mysql> delimiter ;
mysql> call test2();
+---------+
| summary |
+---------+
|    5050 |
+---------+
1 row in set (0.00 sec)

Query OK, 0 rows affected (0.00 sec)

3. Gespeichertes Verfahren der if-Urteilserklärung

Das folgende Beispiel zeigt männliche Studenten in der Liste! ! !

mysql> delimiter @@
mysql> create procedure test3(in t char)
    -> begin
    -> if t="男" then  						 #if语句定义t为男
    -> select * from roster where sex="男";   #查询roster中sex为男
    -> else
    -> select * from roster where sex="女";	 #查询roster中sex为女
    -> end if;  							  #if语句结束
    -> end @@
Query OK, 0 rows affected (0.00 sec)

mysql> delimiter ;
mysql> call test3("男");
+------+--------+------+--------+
| id   | name   | sex  | scores |
+------+--------+------+--------+
|    1 | 张三   | 男   |   90.5 |
|    2 | 李四   | 男   |   85.5 |
|    5 | 赵四   | 男   |   50.5 |
+------+--------+------+--------+
3 rows in set (0.00 sec)

Query OK, 0 rows affected (0.00 sec)

mysql> call test3("女");
+------+--------+------+--------+
| id   | name   | sex  | scores |
+------+--------+------+--------+
|    3 | 王五   | 女   |   78.5 |
|    4 | 刘三   | 女   |   66.5 |
+------+--------+------+--------+
2 rows in set (0.00 sec)

Query OK, 0 rows affected (0.00 sec)

4. Die gespeicherte Prozedur der case-Anweisung

Das folgende Beispiel zeigt die Ergebnisse im Dienstplan! ! !

mysql> delimiter @@
mysql> create procedure test4(in t int)
    -> begin
    -> case t												  
    -> when 1 then
    -> select * from roster where scores>90;                  #查询roster表中scores为大于90
    -> when 2 then
    -> select * from roster where scores>80 and scores<=90;	  #查询roster表中scores为大于80和小于90
    -> when 3 then
    -> select * from roster where scores>60 and scores<=80;	  #查询roster表中scores为大于90和小于80
    -> when 4 then 
    -> select * from roster where scores<60;  				  #查询roster表中scores为小于60
    -> else
    -> select * from roster;								  #查询结果无则执行这条命令
    -> end case;                                         
    -> end @@
Query OK, 0 rows affected (0.00 sec)

mysql> delimiter ;
mysql> call test4(1);
+------+--------+------+--------+
| id   | name   | sex  | scores |
+------+--------+------+--------+
|    1 | 张三   | 男   |   90.5 |
+------+--------+------+--------+
1 row in set (0.00 sec)

Query OK, 0 rows affected (0.00 sec)

mysql> call test4(2);
+------+--------+------+--------+
| id   | name   | sex  | scores |
+------+--------+------+--------+
|    2 | 李四   | 男   |   85.5 |
+------+--------+------+--------+
1 row in set (0.00 sec)

Query OK, 0 rows affected (0.00 sec)

mysql> call test4(3);
+------+--------+------+--------+
| id   | name   | sex  | scores |
+------+--------+------+--------+
|    3 | 王五   | 女   |   78.5 |
|    4 | 刘三   | 女   |   66.5 |
+------+--------+------+--------+
2 rows in set (0.00 sec)

Query OK, 0 rows affected (0.00 sec)

mysql> call test4(4);
+------+--------+------+--------+
| id   | name   | sex  | scores |
+------+--------+------+--------+
|    5 | 赵四   | 男   |   50.5 |
+------+--------+------+--------+
1 row in set (0.00 sec)

Query OK, 0 rows affected (0.00 sec)

mysql> call test4(5);
+------+--------+------+--------+
| id   | name   | sex  | scores |
+------+--------+------+--------+
|    1 | 张三   | 男   |   90.5 |
|    2 | 李四   | 男   |   85.5 |
|    3 | 王五   | 女   |   78.5 |
|    4 | 刘三   | 女   |   66.5 |
|    5 | 赵四   | 男   |   50.5 |
+------+--------+------+--------+
5 rows in set (0.00 sec)

Query OK, 0 rows affected (0.00 sec)

5. Ändern Sie die gespeicherte Prozedur

Grammatik:

mysql> help alter procedure
Name: 'ALTER PROCEDURE'
Description:
Syntax:
ALTER PROCEDURE proc_name [characteristic ...]

characteristic: {
    COMMENT 'string'
  | LANGUAGE SQL
  | { CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA }
  #      包含SQL      没有sql   读取SQL数据        修改SQL数据
  | SQL SECURITY { DEFINER | INVOKER }
  #                 定义者  | 调用程序
}

Ändern Sie die Definition des Dienstplans für gespeicherte Prozeduren, ändern Sie die Lese- und Schreibberechtigungen in MODIFIES SQL DATA und geben Sie an, dass der Aufrufer sie ausführen kann

mysql> alter procedure test1  MODIFIES SQL DATA  SQL SECURITY INVOKER;
Query OK, 0 rows affected (0.00 sec)

mysql> show create procedure test1\G;
*************************** 1. row ***************************
           Procedure: test1
            sql_mode: ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
    Create Procedure: CREATE DEFINER=`root`@`localhost` PROCEDURE `test1`()
    MODIFIES SQL DATA
    SQL SECURITY INVOKER
begin
select * from roster;
end
character_set_client: utf8
collation_connection: utf8_general_ci
  Database Collation: utf8_general_ci
1 row in set (0.00 sec)

6. Speicher löschen

Der Prozedurname gibt den Namen der gespeicherten Prozedur an, die gelöscht werden soll.
IF EXISTS gibt dieses Schlüsselwort an, um Fehler zu vermeiden, die durch das Löschen einer nicht vorhandenen gespeicherten Prozedur verursacht werden. Hinweis: Nach dem Namen der gespeicherten Prozedur befinden sich keine Parameterliste oder Klammern. Vor dem Löschen müssen Sie sicherstellen, dass die gespeicherte Prozedur keine Abhängigkeiten aufweist. Andernfalls werden andere damit verbundene gespeicherte Prozeduren nicht ausgeführt.

mysql> drop procedure if exists test1;
Query OK, 0 rows affected (0.00 sec)

mysql> call test1();
ERROR 1305 (42000): PROCEDURE cunchu.test1 does not exist

Zweitens der Auslöser

1. Übersicht

Der Trigger in der MySQL-Datenbank ist eine spezielle gespeicherte Prozedur. Der Unterschied besteht darin, dass die CALL-Anweisung zum Aufrufen der gespeicherten Prozedur verwendet wird und die Ausführung des Triggers weder von der CALL-Anweisung aufgerufen werden muss noch muss manuell gestartet, solange es sich um ein vordefiniertes Ereignis handelt. In diesem Fall wird es automatisch von MySQL aufgerufen.

2. Vorteile von Triggern

Die Ausführung des Triggerprogramms erfolgt automatisch und unmittelbar nachdem die Daten in der Triggerprogramm-bezogenen Tabelle entsprechend geändert wurden.
Der Trigger kann andere Tabellen über die Kaskade verwandter Tabellen in der Datenbank ändern.
Das Triggerprogramm kann komplexere Überprüfungen und Operationen implementieren als FOREIGN KEY-Einschränkungen und CHECK-Einschränkungen.

3. Die Rolle der Auslöser

Der Trigger ist eng mit der Tabelle verbunden und wird hauptsächlich zum Schutz der Daten in der Tabelle verwendet. Insbesondere wenn mehrere Tabellen mit einem bestimmten Grad an gegenseitiger Verbindung vorhanden sind, können Trigger es verschiedenen Tabellen ermöglichen, die Datenkonsistenz aufrechtzuerhalten. Der Trigger kann nur aktiviert werden, wenn INSERT-, UPDATE- und DELETE-Operationen ausgeführt werden.

4. Die von MySQL unterstützten Trigger sind

INSERT-Trigger

Innerhalb des INSERT-Triggercodes kann auf eine virtuelle Tabelle mit dem Namen NEW (ohne Berücksichtigung der Groß- und Kleinschreibung) verwiesen werden, um auf die eingefügte Zeile zuzugreifen.
Im Trigger BEFORE INSERT kann auch der Wert in NEW aktualisiert werden, dh der eingefügte Wert kann geändert werden (sofern er über die entsprechende Operationsberechtigung verfügt).
Für die Spalte AUTO_INCREMENT enthält NEW den Wert 0, bevor INSERT ausgeführt wird, und enthält den neuen automatisch generierten Wert, nachdem INSERT ausgeführt wurde.

UPDATE-Trigger

Innerhalb des UPDATE-Triggercodes kann auf eine virtuelle Tabelle mit dem Namen NEW (ohne Berücksichtigung der Groß- und Kleinschreibung) verwiesen werden, um auf den aktualisierten Wert zuzugreifen.
Innerhalb des UPDATE-Triggercodes kann auf eine virtuelle Tabelle mit dem Namen OLD (ohne Berücksichtigung der Groß- und Kleinschreibung) verwiesen werden, um auf den Wert zuzugreifen, bevor die UPDATE-Anweisung ausgeführt wird.
In einem BEFORE UPDATE-Trigger kann der Wert in NEW auch aktualisiert werden, dh es ist zulässig, den in der UPDATE-Anweisung zu verwendenden Wert zu ändern (sofern er über die entsprechende Operationsberechtigung verfügt). Die Werte in OLD sind alle schreibgeschützt und können nicht aktualisiert werden. Hinweis: Wenn der Trigger so konzipiert ist, dass er den Aktualisierungsvorgang der Tabelle selbst auslöst, können nur Trigger vom Typ VOR verwendet werden. Trigger vom Typ NACH sind nicht zulässig.

DELETE-Trigger

Innerhalb des DELETE-Triggercodes können Sie auf eine virtuelle Tabelle mit dem Namen OLD (ohne Berücksichtigung der Groß- und Kleinschreibung) verweisen, um auf die gelöschten Zeilen zuzugreifen. Die Werte in OLD sind alle schreibgeschützt und können nicht aktualisiert werden.

5. Bei der Verwendung von Triggern behandelt MySQL Fehler auf folgende Weise

Wenn bei Transaktionstabellen der Trigger fehlschlägt und die resultierende gesamte Anweisung fehlschlägt, werden alle von der Anweisung vorgenommenen Änderungen zurückgesetzt. Bei nicht transaktionalen Tabellen kann ein solches Zurücksetzen nicht durchgeführt werden, selbst wenn die Anweisung fehlschlägt Fehler sind weiterhin gültig.
Wenn der BEFORE-Trigger fehlschlägt, führt MySQL die Operation für die entsprechende Zeile nicht aus.
Wenn während der Ausführung des Triggerprogramms BEFORE oder AFTER ein Fehler auftritt, schlägt die gesamte Anweisung, die das Triggerprogramm aufruft, fehl.
Erst wenn der BEFORE-Trigger und die Zeilenoperation erfolgreich ausgeführt wurden, führt MySQL den AFTER-Trigger aus.

Triggersyntax erstellen:

Hilfe anzeigen

mysql> help create trigger
Name: 'CREATE TRIGGER'
Description:
Syntax:
CREATE
    [DEFINER = user]
    TRIGGER trigger_name
    trigger_time trigger_event
    ON tbl_name FOR EACH ROW
    [trigger_order]
    trigger_body

trigger_time: { BEFORE | AFTER }
 #                 之前 | 之后
trigger_event: { INSERT | UPDATE | DELETE }

trigger_order: { FOLLOWS | PRECEDES } other_trigger_name

Grammatik:

mysql> delimiter $$           #更改其默认的分隔符为“$$”，也可以是其他任意符号，只要不是默认的“;”就行
mysql> create trigger test    #为触发器定义名字为test
    -> after insert           #选择after
    -> on 表名 for each row
    -> begin                  #开启
    -> ……                     #自定义sql语句
    -> end $$				  #结束
    
mysql> delimiter ;			  #更改为默认的分割符,注意中间必须有空格！！！

1. Erstellen Sie eine Tabelle und fügen Sie Daten ein

mysql> create table goods
    -> ( 
    -> g_id int,
    -> g_name varchar(30),
    -> quantity int 
    -> );
Query OK, 0 rows affected (0.08 sec)

mysql> create table orders 
    -> (
    -> o_id int ,
    -> g_id int,
    -> counts int,
    -> price int
    -> );
Query OK, 0 rows affected (0.01 sec)

mysql> insert into goods
    -> values 
    -> (1,'apple','100'),
    -> (2,'banana','100'),
    -> (3,'pineapple','100');
Query OK, 3 rows affected (0.01 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> select * from goods;
+------+-----------+----------+
| g_id | g_name    | quantity |
+------+-----------+----------+
|    1 | apple     |      100 |
|    2 | banana    |      100 |
|    3 | pineapple |      100 |
+------+-----------+----------+
3 rows in set (0.00 sec)

2. Anweisung einfügen

Das folgende Beispiel zeigt, dass die Inventartabelle das entsprechende Produkt automatisch abzieht, nachdem das Produkt verkauft wurde! ! !

mysql> delimiter $$ 
mysql> create trigger test5
    -> after insert 
    -> on orders for each row
    -> begin
    -> update goods set quantity=quantity-new.counts where g_id=new.g_id;
    -> end $$
Query OK, 0 rows affected (0.00 sec)

mysql> delimiter ;

#查看原先数据
mysql> select * from goods;
+------+-----------+----------+
| g_id | g_name    | quantity |
+------+-----------+----------+
|    1 | apple     |      100 |
|    2 | banana    |      100 |
|    3 | pineapple |      100 |
+------+-----------+----------+
3 rows in set (0.00 sec)

#插入数据
mysql> insert into orders values(1,2,10,55);
Query OK, 1 row affected (0.00 sec)

#查看插入之后的对应数据是否对应
mysql> select * from orders;
+------+------+--------+-------+
| o_id | g_id | counts | price |
+------+------+--------+-------+
|    1 |    2 |     10 |    55 |
+------+------+--------+-------+
1 row in set (0.00 sec)

mysql> select * from goods;
+------+-----------+----------+
| g_id | g_name    | quantity |
+------+-----------+----------+
|    1 | apple     |      100 |
|    2 | banana    |       90 |
|    3 | pineapple |      100 |
+------+-----------+----------+
3 rows in set (0.00 sec)

3.update Anweisung

mysql> delimiter $$
mysql> create trigger test6
    -> after update 
    -> on orders for each row
    -> begin
    -> update goods set quantity=quantity-(new.counts-old.counts) where g_id=new.g_id;
    -> end $$
Query OK, 0 rows affected (0.00 sec)

mysql> delimiter ;

3.2 Erhöhen

Das Folgende ist für Kunden, die Bestellung steigt, die Inventartabelle ändert sich automatisch! ! !

#查看俩个表的数据
mysql> select * from goods;    
+------+-----------+----------+
| g_id | g_name    | quantity |
+------+-----------+----------+
|    1 | apple     |      100 |
|    2 | banana    |       90 |
|    3 | pineapple |      100 |
+------+-----------+----------+
3 rows in set (0.00 sec)

mysql> select * from orders;
+------+------+--------+-------+
| o_id | g_id | counts | price |
+------+------+--------+-------+
|    1 |    2 |     10 |    55 |
+------+------+--------+-------+
1 row in set (0.00 sec)

#更新数据
mysql> update orders set counts=20 where o_id = 1;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

#查看更新之后的俩表的数据
mysql> select * from orders;
+------+------+--------+-------+
| o_id | g_id | counts | price |
+------+------+--------+-------+
|    1 |    2 |     20 |    55 |
+------+------+--------+-------+
1 row in set (0.00 sec)

mysql> select * from goods;
+------+-----------+----------+
| g_id | g_name    | quantity |
+------+-----------+----------+
|    1 | apple     |      100 |
|    2 | banana    |       80 |
|    3 | pineapple |      100 |
+------+-----------+----------+
3 rows in set (0.00 sec)

3.3 Reduzieren

Das Folgende zeigt, dass der Bestand nach der Rückkehr des Kunden automatisch in Echtzeitdaten umgewandelt wird! ! !

#更改数据
mysql> update orders set counts =5 where o_id=1;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

#查看更改之后的数据
mysql> select * from orders;
+------+------+--------+-------+
| o_id | g_id | counts | price |
+------+------+--------+-------+
|    1 |    2 |      5 |    55 |
+------+------+--------+-------+
1 row in set (0.00 sec)

mysql> select * from goods;
+------+-----------+----------+
| g_id | g_name    | quantity |
+------+-----------+----------+
|    1 | apple     |      100 |
|    2 | banana    |       95 |
|    3 | pineapple |      100 |
+------+-----------+----------+
3 rows in set (0.00 sec)

4. Anweisung löschen

Das Folgende sind die Daten, die der automatischen Konvertierung in der Tabelle entsprechen, nachdem der Kunde zurückgekehrt ist! ! !

mysql> delimiter $$
mysql> create trigger test7
    -> after delete
    -> on orders for each row 
    -> begin
    -> update goods set quantity=quantity+old.counts where g_id=old.g_id;
    -> end $$
Query OK, 0 rows affected (0.00 sec)

mysql> delimiter ;

#查看原先数据
mysql> select * from orders;
+------+------+--------+-------+
| o_id | g_id | counts | price |
+------+------+--------+-------+
|    1 |    2 |      5 |    55 |
+------+------+--------+-------+
1 row in set (0.00 sec)

mysql> select * from goods;
+------+-----------+----------+
| g_id | g_name    | quantity |
+------+-----------+----------+
|    1 | apple     |      100 |
|    2 | banana    |       95 |
|    3 | pineapple |      100 |
+------+-----------+----------+
3 rows in set (0.00 sec)

#删除出货表的数据
mysql> delete from orders where o_id =1;
Query OK, 1 row affected (0.01 sec)

#查看删除之后的对应数据
mysql> select * from orders;
Empty set (0.00 sec)

mysql> select * from goods;
+------+-----------+----------+
| g_id | g_name    | quantity |
+------+-----------+----------+
|    1 | apple     |      100 |
|    2 | banana    |      100 |
|    3 | pineapple |      100 |
+------+-----------+----------+
3 rows in set (0.00 sec)

5. Löschen Sie den Auslöser

#查看触发器
mysql> show create trigger test7\G
*************************** 1. row ***************************
               Trigger: test7
              sql_mode: ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
SQL Original Statement: CREATE DEFINER=`root`@`localhost` trigger test7
after delete
on orders for each row 
begin
update goods set quantity=quantity+old.counts where g_id=old.g_id;

end
  character_set_client: utf8
  collation_connection: utf8_general_ci
    Database Collation: utf8_general_ci
               Created: 2020-12-27 20:40:01.82
1 row in set (0.00 sec)

#删除触发器
mysql> drop trigger test7;
Query OK, 0 rows affected (0.00 sec)

mysql> show create trigger test7\G
ERROR 1360 (HY000): Trigger does not exist

Linux-MySQL-Speicher und Trigger