Vues MySQL/procédures stockées/déclencheurs

        Ce chapitre vise à présenter plusieurs objets de stockage tels que les vues MySQL, les procédures stockées et les déclencheurs. Le contenu de l'article présente ce qu'est une vue, qu'est-ce qu'une procédure stockée et qu'est-ce qu'un déclencheur ? Et comment créer, interroger, modifier et supprimer une vue, une procédure stockée et un trigger ? Et à travers les exemples correspondants, nous présenterons plus en détail leurs méthodes d'utilisation et approfondirons votre compréhension.

1. Voir

Qu'est-ce qu'une vue ? 

        View (View) est une table virtuelle. Les données de la vue n'existent pas réellement dans la base de données. Les données de ligne et de colonne proviennent des tables utilisées dans la requête de la vue personnalisée et sont générées dynamiquement lorsque la vue est utilisée.

        En termes simples, la vue enregistre uniquement la logique SQL de la requête, pas le résultat de la requête. Ainsi, lorsque nous créons une vue, le travail principal consiste à créer cette instruction de requête SQL.

C'est un peu pâle de dire ça, je crois que vous ne comprenez toujours pas bien, expliquons-le davantage pour vous en créant, modifiant et supprimant une vue :

① Créer une vue

-- [ WITH [ CASCADED | LOCAL ] CHECK OPTION ] 是视图检查选项, 后面会讲到
CREATE [OR REPLACE] [force] VIEW 视图名称[(列名列表)] AS SELECT语句 [ WITH [ CASCADED | LOCAL ] CHECK OPTION ] [with read only]

-- 示例：创建一个查询tb_user表的视图user_v_1, 查询字段是id,name
create or replace view user_v_1 as select id,name from tb_user where id <= 10;

Remarque : La vue ici est une table virtuelle, pas une table réelle, mais une encapsulation logique de l'instruction select .

②Vue de   la requête

-- 查看创建视图语句
SHOW CREATE VIEW 视图名称; 
-- 查看视图数据
SELECT * FROM 视图名称 ...... ;

③ modifier la vue

-- 方式一：和创建视图语句一致, 但这里必须使用 [OR REPLACE] 
CREATE [OR REPLACE] VIEW 视图名称[(列名列表)] AS SELECT语句 [ WITH [ CASCADED | LOCAL ] CHECK OPTION ] 
-- 方式二
ALTER VIEW 视图名称[(列名列表)] AS SELECT语句 [ WITH [ CASCADED | LOCAL ] CHECK OPTION ]

④Supprimer la vue 

DROP VIEW [IF EXISTS] 视图名称 [,视图名称] ...

Afficher les options de vérification

        Avant d'introduire l'option essayer de vérifier, examinons un exemple pour voir pourquoi nous devrions utiliser essayer de vérifier ?

-- 为tb_user表创建一个视图
create or replace view user_v_1 as select id,name from tb_user where id <= 10; 
-- 查询该视图的数据(id<=10)
select * from user_v_1; 
-- 向视图插入两条数据
insert into user_v_1 values(6,'Tom'); 
insert into user_v_1 values(17,'Tom22');
-- 查询tb_user表的数据, 这两条数据都能成功的在 tb_user 表中查看到
select * from tb_user;
-- 再次查询该视图的数据, 能看到id=6的数据, 不能看到id=17的数据
select * from user_v_1; 

Pourquoi ne puis-je pas trouver les données de id=17 dans la vue ?

        Parce que lorsque nous avons créé la vue, la condition spécifiée est id<=10, et les données avec l'id 17 ne sont pas éligibles, donc elles ne sont pas interrogées, mais ces données ont bien été insérées avec succès dans la table de base. Si nous spécifions des conditions lorsque nous définissons une vue, alors lorsque nous insérons, modifions et supprimons des données, pouvons-nous fonctionner uniquement lorsque les conditions sont remplies, sinon nous ne pouvons pas fonctionner ? La réponse est oui, ce qui nécessite l'aide de l'option d'inspection de la vue.

Solution:

Nous pouvons ajouter l' option de vérification [WITH [ CASCADED | LOCAL ] CHECK OPTION ]        à la fin de l'instruction qui crée la vue , et MySQL vérifiera chaque ligne modifiée via la vue, comme l'insertion, la mise à jour et la suppression, afin qu'il soit conforme à la définition de la vue. Si la définition n'est pas satisfaite, l'erreur suivante sera signalée et l'opération échouera :

        De plus, MySQL permet de créer une vue basée sur une autre vue et vérifie également la cohérence des règles de la vue dépendante. Afin de déterminer l'étendue de la vérification, mysql fournit deux options : CASCADED et LOCAL , la valeur par défaut est CASCADED. Ensuite, nous décrivons les deux options :

① EN CASCADE (cascade)

        Par exemple, la vue v2 est basée sur la vue v1, si l'option de vérification est spécifiée en cascade lors de la création de la vue v2, mais que l'option de vérification n'est pas spécifiée lors de la création de la vue v1. Ensuite, lors de la vérification de la v2, non seulement la portée limitée de la v2 sera vérifiée, mais également la portée limitée de la vue associée de la v1 v1 sera mise en cascade.

② LOCALE (locale)

        Par exemple, la vue v2 est basée sur la vue v1 et l'option de vérification est spécifiée comme locale lors de la création de la vue v2. (1) Si l'option de vérification n'est pas spécifiée lors de la création de la vue v1, seule v2 sera vérifiée lorsque la portée limitée de vérification v2 est exécutée. , la vue associée v1 de v2 ne sera pas vérifiée ; (2) Si l'option de vérification est spécifiée lors de la création de la vue v1, lorsque la plage limitée de v2 est cochée, la plage limitée de v1 sera vérifié en même temps. (MySQL 8.0 est valide)

La principale différence entre CASCADED et LOCAL est :
        les deux rechercheront la vue de manière récursive, la différence est :
                CASCADED exécutera sa plage limitée, que la vue précédente ait ou non une option de vérification ;
                tandis que LOCAL vérifiera si la vue précédente a une option de vérification , S'il y en a, la portée limitée sera mise en œuvre, sinon, elle ne sera pas mise en œuvre ;

Les données de la vue ne peuvent pas être mises à jour par hasard ! ! !

         Il doit exister une relation un à un entre les lignes de la vue et les lignes de la table sous-jacente afin de mettre à jour la vue (insérer, supprimer, mettre à jour des données, etc.). Une vue ne peut pas être mise à jour si elle contient l'un des éléments suivants :

• Fonctions d'agrégat ou de fenêtre (SUM(), MIN(), MAX(), COUNT(), etc.)
• DISTINCT
• PAR GROUPE
• AYANT
• UNION ou UNION TOUS 

Si l'un des éléments ci-dessus est utilisé, il n'y a pas de correspondance un à un entre les données de ligne ou les champs de la vue et les données de ligne ou les champs de la table de base, et l'opération de mise à jour échouera ! ! ! !

Concernant la vue, voyons enfin ce qu'elle fait !

• Les vues de simplicité
  　　　simplifient non seulement la compréhension des données par les utilisateurs, mais également leurs opérations. Les requêtes fréquemment utilisées peuvent être définies comme des vues, afin que les utilisateurs n'aient pas à spécifier à chaque fois toutes les conditions pour les opérations suivantes.
• Sécurité
  　　　La base de données peut être autorisée, mais pas autorisée, sur des lignes spécifiques et des colonnes spécifiques de la base de données. Grâce aux vues, les utilisateurs ne peuvent interroger et modifier que les données qu'ils peuvent voir
• Les vues d'indépendance des données
  　　　peuvent aider les utilisateurs à protéger l'impact des modifications de la structure de la table de base. Autrement dit, lorsque le nom du champ de la table de base change, nous pouvons toujours utiliser l'alias pour protéger le changement du nom du champ lors de la création de la vue pour répondre aux besoins du programme

---

Deuxièmement, la procédure stockée

Que sont les procédures stockées ?

        Une procédure stockée est un ensemble d'instructions SQL qui ont été compilées et stockées à l'avance dans la base de données. L'appel d'une procédure stockée peut simplifier considérablement le travail des développeurs d'applications, réduire la transmission de données entre la base de données et le serveur d'applications et améliorer l'efficacité. de l'informatique. Pour résumer en une phrase : les procédures stockées sont l'encapsulation et la réutilisation du code au niveau du langage SQL de la base de données . 

 Quelles sont les caractéristiques des procédures stockées ?

• Encapsulation et réutilisation : vous pouvez encapsuler un certain code SQL métier dans une procédure stockée et l'appeler directement si nécessaire.
• Vous pouvez recevoir des paramètres et renvoyer des données​​​​ : dans une procédure stockée, vous pouvez transmettre des paramètres et recevoir des valeurs de retour.
• Réduisez l'interaction réseau et améliorez l'efficacité : si plusieurs SQL sont impliqués, chaque exécution est une transmission réseau. Et s'il est encapsulé dans une procédure stockée, nous n'avons besoin d'interagir qu'une seule fois avec le réseau.

De même, nous allons plus loin en créant, appelant, visualisant et supprimant une vue (dans les quatre étapes suivantes, la première case est la syntaxe, et les autres cases ou diagrammes sont des exemples) :

①　Créer une procédure stockée 

CREATE PROCEDURE 存储过程名称 ([ 参数列表 ]) 
BEGIN
    -- SQL语句 
END ;

-- 示例：创建一个存储过程p1, 用来封装查询tb_user表数据总量的SQL语句
create procedure p1()
begin
	select count(*) from tb_user;
end;

②Appeler　la procédure stockée

CALL 名称 ([ 参数 ]);

③Afficher　la procédure stockée

-- 查询某个存储过程的定义
SHOW CREATE PROCEDURE 存储过程名称 ;
-- 查询指定数据库的存储过程及状态信息 
SELECT * FROM INFORMATION_SCHEMA.ROUTINES WHERE ROUTINE_SCHEMA = 'xxx';

-- 示例：查询存储过程p1的定义
show create procedure p1;
-- 示例：查询itcast数据库的存储过程及状态信息 
select * from information_schema.ROUTINES where ROUTINE_SCHEMA = 'itcast';

④　Supprimer la procédure stockée

DROP PROCEDURE [ IF EXISTS ] 存储过程名称;

Avis:

        Dans la ligne de commande, lors de l'exécution du SQL pour créer une procédure stockée, le terminateur de l'instruction SQL doit être spécifié via le délimiteur de mot-clé.

        La ligne de commande se termine par ; par défaut, et les instructions SQL qui exécutent les requêtes et les suppressions se terminent également par ;, donc pour éviter que l'instruction qui crée le processus d'exécution dans la ligne de commande ne se termine prématurément, le terminateur de la ligne de commande doit être modifié.

Lors de la création d'une procédure stockée ci-dessus, seule une simple instruction de requête est utilisée, mais dans un système d'entreprise complexe, si vous souhaitez concevoir une procédure stockée complexe, vous devez impliquer de nombreuses structures grammaticales. Faisons une analyse de la structure grammaticale dans la procédure stockée :

La structure grammaticale des procédures stockées --- variables

        Il existe trois types de variables dans MySQL : les variables système, les variables définies par l'utilisateur et les variables locales.

1. Variables système

        Les variables système sont fournies par le serveur MySQL, non définies par l'utilisateur, et appartiennent au niveau du serveur. Divisé en variables globales (GLOBAL), variables de session (SESSION).

• Variables globales (GLOBAL) : Variables globales pour toutes les sessions.
• Variables de session (SESSION) : les variables de session sont spécifiques à une seule session et ne prendront pas effet dans une autre fenêtre de session.

Si SESSION / GLOBAL n'est pas spécifié, la valeur par défaut est la variable de session SESSION.

①　Afficher les variables système

-- 查看所有系统变量
SHOW [ SESSION | GLOBAL ] VARIABLES;
-- 可以通过LIKE模糊匹配方 式查找变量
SHOW [ SESSION | GLOBAL ] VARIABLES LIKE '......';
-- 查看指定变量的值 123
SELECT @@[SESSION.|GLOBAL.]系统变量名;

-- 示例：
show session variables ;       -- 查看当前会话的系统变量  
show global variables ;        -- 查看全局的系统变量

show variables like 'auto%';   -- 查看当前会话以'auto'开头的系统变量

select @@session.autocommit;    -- 查看当前会话的autocommit变量的值
select @@global.autocommit;    -- 查看全局的autocommit变量的值

②Définir　les variables système

SET [SESSION|GLOBAL] 系统变量名 = 值 ; 
SET @@[SESSION.|GLOBAL.]系统变量名 = 值 ;

2. Variables définies par l'utilisateur

Les variables définies par l'utilisateur sont des variables définies par les utilisateurs en fonction de leurs besoins. Les variables utilisateur n'ont pas besoin d'être déclarées au préalable et peuvent être utilisées directement avec "@nom de la variable"         lorsqu'elles sont utilisées . Sa portée est la connexion actuelle. ( Remarque : il y a deux ＠＠ variables système et aucune des variables locales à introduire ensuite )

①　Attribuer des valeurs aux variables définies par l'utilisateur

-- 方式一
SET @var_name = expr [, @var_name = expr] ... ; 
SET @var_name := expr [, @var_name := expr] ... ;
-- 赋值时，可以使用 = ，也可以使用 :=

-- 方式二
-- 查询的同时为其赋值
SELECT @var_name := expr [, @var_name := expr] ... ; 
-- 将某表的某个字段的数据赋值给变量
SELECT 字段名 INTO @var_name FROM 表名;

-- 示例：
set @myname = 'itcast';      -- 设置自定义变量myname的值为itcast
set @mygender := '男',@myhobby := 'java';

select @mycolor := 'red';    -- 设置自定义变量mycolor的值为red，并使用
select count(*) into @mycount from tb_user;    -- 从tb_user表的总数据量并赋值给mycount变量

②　Utiliser des variables définies par l'utilisateur

SELECT @var_name ;

Remarque :
        Les variables définies par l'utilisateur n'ont pas besoin d'être déclarées ou initialisées, et peuvent leur être directement affectées. Si elles sont utilisées directement sans affectation, la valeur obtenue sera NULL.

3. Variables locales

        Les variables locales sont des variables qui sont définies localement et prennent effet selon les besoins.Avant d'y accéder, une instruction DECLARE est requise. Peut être utilisée comme variable locale et paramètre d'entrée dans une procédure stockée, la portée d'une variable locale est le bloc BEGIN ... END dans lequel elle est déclarée .

CREATE PROCEDURE 表名()
BEGIN
		-- 声明一个局部变量
		DECLARE 变量名 变量类型 [DEFAULT ... ] ;
        -- 变量类型就是数据库字段类型：INT、BIGINT、CHAR、VARCHAR、DATE、TIME等。
        -- DEFAULT　是局部变量的默认值，选用
		
		-- 为局部变量赋值
		SET 变量名 = 值 ; 
		SET 变量名 := 值 ; 
		SELECT 字段名 INTO 变量名 FROM 表名 ... ;
END

-- 示例：
create procedure p2() 
begin
    declare stu_count int default 0;              -- 声明局部变量stu_count，值默认为0
    select count(*) into stu_count from student;  -- 为局部变量stu_count赋值
    select stu_count;                             -- 使用/输出局部变量stu_count
end; 

call p2();    -- 调用存储过程

La structure grammaticale de la procédure stockée --- si jugement

        si est utilisé pour le jugement conditionnel, la structure grammaticale spécifique est :

IF 条件1 THEN 
    ..... 
ELSEIF 条件2 THEN    　-- 可选 
    ..... 
ELSE                　　-- 可选 
    ..... 
END IF;

La structure grammaticale de la procédure stockée --- paramètres

CREATE PROCEDURE 存储过程名称 ([ IN/OUT/INOUT 参数名 参数类型 ]) 
BEGIN
        -- SQL语句 
END ;

Regardons un exemple :

-- 示例：根据传入参数score，判定当前分数对应的分数等级，并返回。
-- score >= 85分，等级为优秀。
-- score >= 60分 且 score < 85分，等级为及格。
-- score < 60分，等级为不及格。
create procedure p4(in score int, out result varchar(10))
begin
    if score >= 85 then 
        set result := '优秀'; 
    elseif score >= 60 then
        set result := '及格'; 
    else
        set result := '不及格'; 
    end if; 
end;

-- 定义用户变量 @result来接收返回的数据, 用户变量可以不用声明 
call p4(18, @result); 
select @result;

La structure grammaticale de la procédure stockée --- cas

        case est similaire à la fonction de contrôle de flux et a les deux formats de syntaxe suivants : 

Grammaire un :

-- 含义： 当case_value的值为 when_value1时，执行statement_list1，当值为 when_value2时， 执行statement_list2， 否则就执行 statement_list 
CASE case_value 
    WHEN when_value1 THEN statement_list1 
    [ WHEN when_value2 THEN statement_list2]
     ... 
    [ ELSE statement_list ] 
END CASE;

Grammaire deux :

-- 含义： 当条件search_condition1成立时，执行statement_list1，当条件search_condition2成 立时，执行statement_list2， 否则就执行 statement_list 
CASE
    WHEN search_condition1 THEN statement_list1 
    [WHEN search_condition2 THEN statement_list2] 
    ... 
    [ELSE statement_list] 
END CASE;

Avis:

        S'il existe plusieurs conditions de jugement, vous pouvez utiliser et ou ou pour connecter plusieurs conditions.

La structure grammaticale de la procédure stockée --- boucle 

        Il existe trois principaux types de boucles dans MySQL : while, repeat, loop, et nous les présenterons une par une ci-dessous :

ｗｈｉｌｅ

        Une boucle while est une instruction de contrôle de boucle conditionnelle. Une fois la condition remplie, exécutez l'instruction SQL dans le corps de la boucle. La syntaxe spécifique est :

-- 先判定条件，如果条件为true，则执行逻辑，否则，不执行逻辑 
WHILE 条件 DO 
    SQL逻辑... 
END WHILE;

ｒｅｐｅａｔ 

        repeat est une instruction de contrôle de boucle conditionnelle, lorsque la condition déclarée par until est satisfaite, la boucle se termine. La syntaxe spécifique est :

-- 先执行一次逻辑，然后判定UNTIL条件是否满足，如果满足，则退出。如果不满足，则继续下一次循环 
REPEAT
    SQL逻辑... 
    UNTIL 条件 
END REPEAT;

ｌｏｏｐ 

        LOOP implémente une boucle simple. Si vous n'ajoutez pas de conditions pour quitter la boucle dans la logique SQL, vous pouvez l'utiliser pour implémenter une boucle infinie simple.

LOOP peut être utilisé avec les deux instructions suivantes :

• LEAVE : utilisé avec la boucle pour sortir de la boucle.
• ITERATE : il doit être utilisé dans une boucle, et sa fonction est de sauter les instructions restantes de la boucle actuelle et d'entrer directement dans la boucle suivante.

[begin_label:] LOOP 
    SQL逻辑... 
    LEAVE label; -- 退出指定标记的循环体 
    ITERATE label; -- 直接进入下一次循环
END LOOP [end_label];
-- 上述语法中出现的 begin_label，end_label，label 指的都是我们所自定义的标记。

La structure grammaticale de la procédure stockée --- curseur curseur

        Le curseur (CURSOR) est un type de données utilisé pour stocker les ensembles de résultats de requête, qui peuvent être utilisés pour parcourir les procédures et fonctions stockées. L'utilisation des curseurs comprend la déclaration des curseurs, OPEN, FETCH et CLOSE, et leurs syntaxes sont les suivantes :

①Curseur de déclaration　

DECLARE 游标名称 CURSOR FOR 查询语句 ;
-- 其和声明局部变量相似, 是不过这里的数据类型为 cursor，且后面带有查询语句

②　Ouvrir le curseur

OPEN 游标名称 ;

③　Obtenir l'enregistrement du curseur

FETCH 游标名称 INTO 变量 [, 变量 ] ;

④Fermer　le curseur

CLOSE 游标名称 ;

La structure grammaticale des procédures stockées - gestionnaires conditionnels

        Le gestionnaire de conditions (Handler) peut être utilisé pour définir les étapes de traitement correspondantes lorsque des problèmes sont rencontrés lors de l'exécution de la structure de contrôle de flux. La syntaxe spécifique est :

DECLARE handler_action HANDLER FOR condition_value [, condition_value] ... statement ; 

handler_action 的取值： 
    CONTINUE: 继续执行当前程序 
    EXIT: 终止执行当前程序 
condition_value 的取值： 
    SQLSTATE sqlstate_value: 状态码，如 02000 
    SQLWARNING: 所有以01开头的SQLSTATE代码的简写 
    NOT FOUND: 所有以02开头的SQLSTATE代码的简写 
    SQLEXCEPTION: 所有没有被SQLWARNING 或 NOT FOUND捕获的SQLSTATE代码的简写

Examinons l'utilisation spécifique des curseurs et des gestionnaires de conditions à travers un exemple :

-- 示例: 根据传入的参数uage，来查询用户表tb_user中，所有的用户年龄小于等于uage的用户姓名（name）和专业（profession），
-- 并将用户的姓名和专业插入到所创建的一张新表(id,name,profession)中。

create procedure p(in uage int) 
begin
    declare uname varchar(100); 
    declare upro varchar(100); 
    -- A. 声明游标, 存储查询结果集
    declare u_cursor cursor for select name,profession from tb_user where age <= uage;
    -- B. 声明条件处理程序 ： 当SQL语句执行抛出的状态码为02000时，将关闭游标u_cursor，并退出 
    declare exit handler for SQLSTATE '02000' close u_cursor; 

    -- C. 准备: 创建表结构
    drop table if exists tb_user_pro; 
    create table if not exists tb_user_pro( 
        id int primary key auto_increment, 
        name varchar(100), 
        profession varchar(100) 
    );

    -- D. 开启游标
    open u_cursor; 

    while true do 
        -- E. 获取游标中的记录
        fetch u_cursor into uname,upro; 
        -- F. 插入数据到新表中
        insert into tb_user_pro values (null, uname, upro); 
    end while; 

    -- G. 关闭游标
    close u_cursor; 
end; 

-- 调用执行过程
call p(30);

Dans le cas ci-dessus, si le gestionnaire conditionnel n'est pas déclaré, une erreur '02000' sera signalée lors de l'appel du processus d'exécution, car la condition de la boucle while est vraie et il n'y a pas de condition de sortie, similaire à une exception de pointeur nul, mais le résultat de l'appel peut toujours être un succès, c'est-à-dire que les exigences peuvent être remplies avec succès :

À ce stade, nous avons appris les connaissances sur les procédures stockées. Examinons ensuite les fonctions stockées similaires aux procédures stockées :

fonction stockée 

         Une fonction stockée est une procédure stockée avec une valeur de retour, et les paramètres de la fonction stockée ne peuvent être que de type IN. La syntaxe spécifique est la suivante :

CREATE FUNCTION 存储函数名称 ([ 参数列表 ]) 
RETURNS 返回类型 [characteristic ...] 
BEGIN
    -- SQL语句 
    RETURN ...; 
END ;

description caractéristique (doit en avoir une):

• DETERMINISTE : les mêmes paramètres d'entrée produisent toujours le même résultat
• NO SQL : ne contient pas d'instructions SQL.
• READS SQL DATA : Contient des instructions qui lisent des données, mais pas des instructions qui écrivent des données.

Regardons un exemple pour en savoir plus sur les fonctions stockées :

-- 计算从1累加到n的值，n为传入的参数值。
create function fun1(n int) 
returns int deterministic 
begin
    declare total int default 0; 

    while n>0 do 
        set total := total + n; 
        set n := n - 1; 
    end while; 

    return total; 
end; 

select fun1(50);

---

3. Déclencheur

        Un déclencheur est un objet de base de données lié à une table, qui déclenche et exécute un ensemble d'instructions SQL définies dans le déclencheur avant (BEFORE) ou après (AFTER) l'insertion/la mise à jour/la suppression. Cette fonctionnalité du déclencheur peut aider l'application à garantir l'intégrité des données, les enregistrements de journaux, la vérification des données et d'autres opérations côté base de données.

        Utilisez les alias OLD et NEW pour faire référence au contenu de l'enregistrement modifié dans le déclencheur, comme dans d'autres bases de données. Actuellement, les déclencheurs ne prennent en charge que les déclencheurs au niveau de la ligne, pas les déclencheurs au niveau de l'instruction .

①　Créer un déclencheur

CREATE TRIGGER trigger_name 
BEFORE/AFTER INSERT/UPDATE/DELETE ON tbl_name FOR EACH ROW -- 行级触发器
BEGIN
    trigger_stmt ; 
END;

②　Afficher les déclencheurs

SHOW TRIGGERS ;

③　Supprimer le déclencheur

DROP TRIGGER [schema_name.]trigger_name ; -- 如果没有指定 schema_name，默认为当前数据库 。

Voyons comment utiliser un déclencheur à travers un exemple :

        Exigence : Enregistrez le journal des modifications de données de la table tb_user via un déclencheur et insérez le journal des modifications dans la table de journal user_logs, y compris l'ajout, la modification et la suppression.

a. Créez d'abord la table de journal user_logs

create table user_logs( 
    id int(11) not null auto_increment, 
    operation varchar(20) not null comment '操作类型, insert/update/delete', 
    operate_time datetime not null comment '操作时间', 
    operate_id int(11) not null comment '操作的ID', 
    operate_params varchar(500) comment '操作参数', 
    primary key(`id`) 
)engine=innodb default charset=utf8;

b. Définir des déclencheurs pour l'insertion de données

create trigger tb_user_insert_trigger
after insert on tb_user for each row
begin
		insert into user_logs(id, operation, operate_time, operate_id, operate_params)
		values(null, 'insert', now(), new.id, 
            concat('插入的数据内容为: id=', new.id, ',name=', new.name, ',phone=', new.phone, ',email=', new.email, ',profession=', new.profession));
end;

Données d'insertion de test :

c. Définir des déclencheurs qui modifient les données

create trigger tb_user_update_trigger
after update on tb_user for each row
begin
		insert into user_logs(id, operation, operate_time, operate_id, operate_params)
		values(null, 'update', now(), new.id, 
		    concat('更新之前的数据: id=', old.id, ',name=', old.name, ',phone=', old.phone, ',email=', old.email, ',profession=', old.profession, 
		        ' | 更新之后的数据: id=', new.id, ',name=', new.name, ',phone=', new.phone, ',email=', new.email, ',profession=', new.profession));
end;

Tester les données de mise à jour :

Avis:

        Si vous utilisez l'instruction update tb_user set age = 18 where id <= 5, 5 éléments de données seront mis à jour. À ce stade, 5 éléments de données de journal seront insérés dans la table user_logs, car le déclencheur actuel prend en charge le niveau ligne déclencheurs .

d. Définir des déclencheurs pour supprimer des données

create trigger tb_user_delete_trigger
after delete on tb_user for each row
begin
		insert into user_logs(id, operation, operate_time, operate_id, operate_params)
		values(null, 'update', now(), old.id, 
		    concat('删除之前的数据: id=', old.id, ',name=', old.name, ',phone=', old.phone, ',email=', old.email, ',profession=', old.profession));
end;

Tester la suppression des données :