【MySQL 12】Trigger

Trigger ist eine spezielle Art gespeicherter Prozedur, die sich von den zuvor vorgestellten gespeicherten Prozeduren unterscheidet. Trigger werden hauptsächlich durch Ereignisse ausgelöst und automatisch aufgerufen und ausgeführt. Gespeicherte Prozeduren können über den Namen der gespeicherten Prozedur aufgerufen werden.
Die Hauptfunktion von Triggern besteht darin, eine Datenintegrität und -konsistenz zwischen zwei oder mehr Tabellen zu erreichen, die komplexer ist als die referenzielle Integrität, und so sicherzustellen, dass Änderungen an den Daten in den Tabellen den Festlegungen des Datenbankdesigners entsprechen.
Eine spezielle gespeicherte Prozedur, die automatisch ausgeführt wird, wenn ein Trigger etwas in eine Tabelle einfügt, aktualisiert oder löscht. Trigger werden im Allgemeinen für Einschränkungen mit komplexeren Prüfeinschränkungen verwendet.
Der Unterschied zwischen Triggern und gewöhnlichen gespeicherten Prozeduren besteht darin, dass Trigger auf einer bestimmten Tabelle ausgeführt werden. Bei Vorgängen wie Aktualisieren, Einfügen und Löschen ruft das System automatisch den entsprechenden Trigger für die Tabelle auf und führt ihn aus.
Trigger in SQL Server 2005 können in zwei Kategorien unterteilt werden: DML-Trigger und DDL-Trigger wirken sich auf eine Vielzahl von Anweisungen in der Datendefinitionssprache aus und werden unter anderem durch Create-, Alter- und Drop-Anweisungen ausgelöst.

DML-Trigger sind unterteilt in:

1. Nach-Trigger (ausgelöst nach)
b. Auslöser zum Löschen
2. Anstelle von Trigger (ausgelöst vor)
3. Unterschied
Nach dem Trigger: Es ist erforderlich, dass der Trigger erst ausgelöst wird, nachdem eine bestimmte Operation zum Einfügen, Aktualisieren und Löschen ausgeführt wurde, und kann nur in definiert werden der Tisch.
Anstelle von Trigger: Zeigt an, dass die definierten Vorgänge (Einfügen, Aktualisieren, Löschen) nicht ausgeführt werden, sondern nur der Trigger selbst. Anstelle von Triggern können Sie diese auch in der Tabelle oder in der Ansicht definieren.

eingefügte Tabelle und gelöschte Tabelle

Bei der Verwendung von Triggern erstellt SQL Server für jeden Trigger zwei spezielle temporäre Tabellen, nämlich die eingefügte Tabelle und die gelöschte Tabelle. Diese beiden Tabellen werden im Speicher gespeichert und haben dieselbe Struktur wie die Tabelle, in der der Trigger erstellt wurde. Sie werden vom System verwaltet und verwaltet und können von Benutzern nicht geändert werden. Jeder Trigger kann nur auf seine eigene temporäre Tabelle zugreifen. Nach der Ausführung des Triggers werden die beiden Tabellen automatisch freigegeben.

(1) Die eingefügte Tabelle wird zum Speichern von Kopien von Zeilen verwendet, die von Einfüge- oder Aktualisierungsanweisungen betroffen sind. Wenn ein Einfüge- oder Aktualisierungsvorgang ausgeführt wird, werden neue Datenzeilen sowohl zur Basistabelle als auch zur eingefügten Tabelle hinzugefügt, die den Auslöser aktivieren.

(2) Die gelöschte Tabelle wird zum Speichern von Kopien von Zeilen verwendet, die von Lösch- oder Aktualisierungsanweisungen betroffen sind. Wenn ein Lösch- oder Aktualisierungsvorgang ausgeführt wird, wird die angegebene Originaldatenzeile aus der Basistabelle gelöscht und dann in die gelöschte Tabelle übertragen. Im Allgemeinen sind in der Basistabelle und der gelöschten Tabelle nicht dieselben Datenzeilen vorhanden.
Beschreibung:
Der Aktualisierungsvorgang ist in zwei Schritte unterteilt: Zuerst werden die geänderten Originaldatenzeilen in der Basistabelle in die gelöschte Tabelle übertragen und dann die geänderten neuen Datenzeilen aus der eingefügten Tabelle in die Basistabelle kopiert . Mit anderen Worten: Für den Aktualisierungsvorgang speichert die gelöschte Tabelle den alten Wert vor der Änderung und die eingefügte Tabelle speichert den neuen Wert nach der Änderung.

Vier Elemente der Trigger-Erstellungssyntax:

Syntax:

1.监视地点(table) 
2.监视事件(insert/update/delete) 
3.触发时间(after/before) 
4.触发事件(insert/update/delete)

Produkttabelle

delimiter &&create trigger trigger
Nameafter/before insert/update/delete on 表名
for each row   #这句话在mysql是固定的
beginsql语句;
end&&

Bestelltabelle

mysql> create table g(
    -> id int auto_increment primary key,    -> name varchar(10),    -> num int    -> );

Produkt einfügen:

mysql> create table o(
    -> idd int auto_increment primary key,    -> gid int,    -> much int    -> );

Wenn wir den Auslöser nicht verwendet haben: Angenommen, wir haben jetzt 3 Produkte 1 verkauft, müssen wir zwei Dinge tun

mysql> insert into g (name,num) value ('juzi',20);mysql> select * from g;
+----+------+------+| id | name | num  |
+----+------+------+|  3 | juzi |   20 |
+----+------+------+

1 in die Bestelltabelle aufnehmen

2. Restmenge von Produkt 1 in der Produkttabelle aktualisieren

insert into o(gid,much) values(1,3);

Trigger erstellen:

update g set num=num-3 where id=1;

Ausführung:

delimiter &
mysql> create trigger trg1
    -> after insert on o    -> for each row    -> begin    -> update g set num = num -3 where id = 1;    -> end&

insert into o(gid,much) values(1,3)$

Ergebnis:

Sie werden feststellen, dass sich die Menge von Produkt 1 auf 7 geändert hat, was bedeutet, dass wir einfügen Eine Bestellung löst den Aktualisierungsvorgang automatisch für uns aus.

Aber jetzt gibt es ein Problem, denn die Nummer und die ID in unserem Trigger sind fest codiert, sodass die Menge von Produkt 1 unabhängig davon, welches Produkt wir kaufen, am Ende aktualisiert wird. Beispiel: Wir fügen einen weiteren Datensatz in die Bestelltabelle ein: insert into o(gid,much) Values(2,3) Nach der Ausführung werden wir feststellen, dass sich die Menge von Produkt 1 auf 4 geändert hat, die Menge von Produkt 2 jedoch Dies ist offensichtlich nicht der Fall, den wir wollen. Wir müssen den Trigger ändern, den wir zuvor erstellt haben.

Wie referenzieren wir den Wert der Zeile im Trigger, d. h. wir müssen den Wert von gid oder much in unserem neu eingefügten Bestelldatensatz abrufen?

Beim Einfügen wird die neu eingefügte Zeile durch new dargestellt, und der Wert jeder Spalte in der Zeile wird durch new.column name dargestellt.

Jetzt können wir unseren Trigger also so ändern

Der zweite Trigger wird erstellt, löschen wir zuerst den ersten Trigger

create trigger tg2 
after insert on o 
for each row 
begin 
update g set num=num-new.much where id=new.gid;(注意此处和第一个触发器的不同) 
end$

Drop Trigger tg1$

Testen Sie es erneut und fügen Sie einen Bestelldatensatz ein: insert into o(gid,much) Values(2,3)$

Nach der Ausführung wird festgestellt, dass sich die Menge von Produkt 2 auf 7 geändert hat. Okay, das ist genau jetzt.

Es gibt noch zwei Situationen:

1.当用户撤销一个订单的时候，我们这边直接删除一个订单，我们是不是需要把对应的商品数量再加回去呢？

2.当用户修改一个订单的数量时，我们触发器修改怎么写?

我们先分析一下第一种情况：

监视地点：o表

监视事件：delete

触发时间：after

触发事件：update

对于delete而言：原本有一行,后来被删除，想引用被删除的这一行，用old来表示，old.列名可以引用被删除的行的值。

那我们的触发器就该这样写：

create trigger tg3
after delete on o
for each row
begin
update g set num = num + old.much where id = old.gid;(注意这边的变化)
end$

创建完毕。

再执行

delete from o where oid = 2$

会发现商品2的数量又变为10了。

第二种情况：

监视地点：o表

监视事件：update

触发时间：after

触发事件：update

对于update而言：被修改的行，修改前的数据，用old来表示，old.列名引用被修改之前行中的值；

修改的后的数据，用new来表示，new.列名引用被修改之后行中的值。

那我们的触发器就该这样写：

create trigger tg4
after update on o
for each row
begin
update g set num = num+old.much-new.much where id = old/new.gid;
end$

先把旧的数量恢复再减去新的数量就是修改后的数量了。

我们来测试下：先把商品表和订单表的数据都清掉，易于测试。

假设我们往商品表插入三个商品，数量都是10，

买3个商品1：

insert into o(gid,much) values(1,3)$

这时候商品1的数量变为7；

我们再修改插入的订单记录:

update o set much = 5 where oid = 1$

我们变为买5个商品1，这时候再查询商品表就会发现商品1的数量只剩5了，说明我们的触发器发挥作用了。

以上就是 【MySQL 12】触发器的内容，更多相关内容请关注PHP中文网（www.php.cn）！