mysql Trigger Auslöser Kurzbeschreibung

kurze Einführung

Mysql Trigger gehört zu einer erweiterte Funktion, die als vereinfachte Version der gespeicherten Prozedur angesehen werden kann. Und wirklichen gespeicherte Prozedur unterscheidet ist, dass es nicht Aufruf aufgerufen wird, sondern automatisch nach Erfassung des Betriebszustands ausgeführt erfüllt ist, ähnlich wie die Beziehung zwischen Systemüberwachung und Alarmmeldungen.

mysql Trigger unterstützt nur Triggerleitung wird immer auf einen Datensatz gerichtet. mysql Trigger für den Einsatz an der Reihe \ update \ Löschvorgänge ausgelöst, und zwar, um zu bestimmen, welche Aktion durch tatsächliche vom Benutzer definiert ausgelöst wird. Aber jedes Ereignis für jede Tabelle kann nur einen Trigger definieren.

mysql Triggertriggerzeit wird in zwei Teile geteilt: vor und nach, die vor oder nach dem Triggerereignis Ausführung ist. Zum Beispiel sagt, dass vor Insert-Trigger vor dem Einfügevorgang.

Auslöser relativ vorteilhaft ist es möglich, die Kommunikation zwischen dem Client und dem Server zu reduzieren, die die Leistung verbessern kann, sondern den spezifischen Server hinter der Arbeitsfront abdecken kann, kann die Vertraulichkeit der Daten verbessern, sondern auch konsistente Daten sicherstellen kann, natürlich auf den Betrieb innodb Tabelle beschränkt ist, wird der Trigger innodb Tabelle in der gleichen Transaktion durchgeführt.

Es gibt Vorteile und Nachteile werden die gleichen sein, weil verstecken viele Betonarbeiten, der Auslöser schwieriger zu beheben Probleme sein wird, unklar, ob der Server einen Trigger Betrieb hat, ist es fast unmöglich, das Problem zu lokalisieren.

Unter Berücksichtigung der Vor- und Nachteile ein Triggersystem verwendet wird, und dann entscheiden, ob Trigger in ihrem eigenen System zu verwenden.

Syntaxregeln

create trigger [trigger_name] [trigger_time] [trigger_event] on [table_name] for each row [trigger_operation]

Name des Auslösers erstellt werden ;: trigger_name
trigger_time: die Ausführungszeit des Auslösers;
trigger_event: Trigger abhängig auslösenden Ereignis;
table_name: die Rolle der Trigger - Tabelle;
trigger_operation: spezifische Trigger - Aktion Anweisungen;

Beispiele

Erstellen Sie zwei Tabellen, eine t_trigger_user zu retten Personalinformationen, Gehaltsinformationen verwendet, um ein t_trigger_salary Personal zu sparen. Zwei leere Tabelle, die die spezifische Tabellenstruktur zu testen, wie folgt:

mysql> show create table t_trigger_user\G
*************************** 1. row ***************************
       Table: t_trigger_user
Create Table: CREATE TABLE `t_trigger_user` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(32) DEFAULT '',
  `age` int(3) unsigned DEFAULT '0',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8
1 row in set (0.00 sec)

mysql> show create table t_trigger_salary\G
*************************** 1. row ***************************
       Table: t_trigger_salary
Create Table: CREATE TABLE `t_trigger_salary` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `salary` int(10) unsigned DEFAULT '0',
  `uid` int(10) NOT NULL,
  `name` varchar(32) DEFAULT '',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8
1 row in set (0.00 sec)

Legen Sie den Testbetrieb des Abzugs

Zuerst erzeugen ein Trigger-basierte Einfügevorgang t_trigger_user Tabelle (standardmäßig alle unsere Operationen nach einer bestimmten Operation ausgelöst werden), um den Auslöser zu vollständigen verwendet „ , wenn neue Daten t_trigger_user Tischeinsatz, Einsatz eine Reihe synchron t_trigger_salary Tabelle relevante Informationen. "
Erstellen Sie einen Trigger nach Einsatz

mysql> create trigger user_insert after insert on t_trigger_user for each row insert into t_trigger_salary(uid,name) values(new.id,new.name);

Ausführen von Operationen auf den Tisch, wo der Trigger t_trigger_user einzufügen, und dann die Informationen in beiden Tabellen sehen

mysql> insert into t_trigger_user(name,age) values('lily',21);                                                                           
Query OK, 1 row affected (0.01 sec)

mysql> select * from t_trigger_user;
+----+------+------+
| id | name | age  |
+----+------+------+
|  2 | lily |   21 |
+----+------+------+
1 row in set (0.00 sec)

mysql> select * from t_trigger_salary;
+----+--------+-----+------+
| id | salary | uid | name |
+----+--------+-----+------+
|  1 |      0 |   2 | lily |
+----+--------+-----+------+
1 row in set (0.00 sec)

Man kann sehen, t_trigger_user Tisch nach einem Trigger Einfügevorgang zu schaffen, nachdem die Einfügeoperation Durchführung Dateneinfügung erfolgreich ist, auch den Trigger der Ausführung zu t_trigger_salary auch Einsatz einer Tabelle von Daten gebrannt.

Aus dem gleichen Grunde, den Test erneut Trigger-Update und Löschvorgänge Betrieb zu erreichen.

aktualisieren beispielhaften Betrieb des Triggers

mysql> delimiter //
mysql> create trigger update_user after update on t_trigger_user for each row
    -> begin
    -> if new.name != old.name
    -> then
    -> update t_trigger_salary set name=new.name where uid=old.id;
    -> end if;
    -> end
    -> //
Query OK, 0 rows affected (0.00 sec)

mysql> update t_trigger_user set name='anvil' where id=2;
    -> //
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> delimiter ;
mysql> select * from t_trigger_user;
+----+-------+------+
| id | name  | age  |
+----+-------+------+
|  2 | anvil |   21 |
+----+-------+------+
1 row in set (0.00 sec)

mysql> select * from t_trigger_salary;
+----+--------+-----+-------+
| id | salary | uid | name  |
+----+--------+-----+-------+
|  1 |      0 |   2 | anvil |
+----+--------+-----+-------+
1 row in set (0.00 sec)

Löschbeispielhaften Betrieb des Auslösers

mysql> create trigger delete_user after delete on t_trigger_user for each row delete from t_trigger_salary where uid=old.id;
Query OK, 0 rows affected (0.01 sec)

mysql> delete from t_trigger_user where id=2;
Query OK, 1 row affected (0.00 sec)

mysql> select * from t_trigger_user;
Empty set (0.00 sec)

mysql> select * from t_trigger_salary;
Empty set (0.00 sec)

Ja, es [trigger_operation] löst nicht nur unterstützt eine einzelne SQL-Anweisung von Operationen wird Aussage auch durch eine Reihe von Operationen unterstützt beginnen ... .end einpacken.

Wenn der Trigger ausgelöst wird, dann trat der Fehler bei der Betätigung des Auslösers wird nicht ausgeführt, das gleiche, die Trigger-Aktion Aussagen Auslösung wird nicht wirklich durchgeführt werden.