(SQL/PSM) 1 Extension de SQL ( PSM ) Langage de programmation procédural Clauses SQL intégrées dans le code procédural SQL/PSM est donc un langage de programmation, propre à mysql : Intégre directement les clauses SQL d interrogation, de manipulation (généralement pas de définition des données) Permet l encapsulation des données dans du code Gestion des exceptions 2 SQL Application SQL SQL SGBD SQL Application SQL IF... THEN SQL ELSE SQL END IF ; SQL Bloc SQL/PSM MySQL SQL/PSM 3 1
SQL/PSM regroupe les requêtes SQL en un seul bloc qui est envoyé au serveur en un seul appel Amélioration des performances (moins de communications sur le ( réseau Le bloc SQL/PSM peut être stocké sur le serveur. Seul l appel de l exécution du bloc et le résultat transiteront sur le réseau Permet de créer des bibliothèques de code réutilisable Programmation de fonctions, procédures, packages 4 Gestion des variables variables locales variables d environnement extérieures à SQL/PSM Structures de contrôle traitements conditionnels traitements répétitifs Utilisation des curseurs définition utilisation de curseurs explicites attributs des curseurs modification des valeurs d un curseur Gestion des erreurs anomalies programme utilisateur erreurs Oracle erreurs prédéfinies 5 Bloc anonyme : bloc SQL/PSM imbriqué dans une application ou créé interactivement Procédure enregistrée : bloc nommé enregistré dans le serveur MySQL et qui peut être invoqué par son nom Package : module SQL/PSM qui regroupe un ensemble de procédures Trigger : bloc associé à une table et déclenché automatiquement lors d une requête 6 2
Tout bloc SQL/PSM est de la forme suivante Clauses SQL Instructions SQL / PSM END ; Un bloc peut contenir un ou plusieurs autres blocs 7 DELIMITER // DECLARE salaire_v NUMBER(5); SELECT salaire INTO salaire_v FROM emp; // DELIMITER ; 8 Oracle dbms_output.put_line( Hello World ) ; END ; / SQL> set serveroutput on ; SQL> @C:\Mes Documents\monfichier.sql SQL > Hello World 9 3
MySQL DELIMITER // SELECT Hello World ; // DELIMITER ; 10 Utiliser les variables pour : L enregistrement temporaire des données comme dans tout langage de programmation procédural. La manipulation de données enregistrées afin de réaliser des calculs et autres manipulations sans accéder à la base de données La réutilisabilité : une fois déclarée, une variable peut être utilisée plusieurs fois dans une application. La facilité de maintenance : en utilisant %TYPE et %ROWTYPE (présenté plus tard), on déclare des variables ayant le même type que des attributs de tables, si la définition de la table change, le type de la variable change de même. Réduction des coûts de maintenance N existe pas en MySQL 11 Scalaires Valeurs simples, les principaux types sont ceux de SQL Composites Les enregistrements permettent de définir des données structurées 12 4
Syntaxe : DECLARE var_name [, var_name]... Type [DEFAULT value] Exemple : DECLARE dateemprunt_v DATE; DECLARE nodept _v NUMBER(2) DEFAULT 10 ; DECLARE lieu_v VARCHAR(13) DEFAULT Lou'; 13 Syntaxe SET @variable = valeur; SELECT @t := valeur; Remarques Peuvent contenir des entiers, réels et des chaînes de caractères Elles n ont pas besoin d être initialisées 14 Exemple SET @unentier_v = 123; SELECT @unechaine_v := variable ; SELECT @unentier_v; +-------------+ @unentier_v +-------------+ 123 +-------------+ 5
Toute variable doit être déclarée pour pouvoir être utilisée Une variable au maximum déclarée par ligne Les noms de variable doivent commencer par une lettre et ont 30 caractères au maximum Portée de bloc pour les variables, masquage de variables dans les sousblocs Nom des tables, attributs,..., objets de la base ont la priorité sur les noms de variables Par convention, utiliser les suffixes _c pour les constantes _v pour les variables _g pour les variables globales 16 Affectation d'une valeur à une variable SET var_name = expr [, var_name = expr]... Stockage du résultat d'une requête SELECT... INTO <nom_de_variable> FROM... WHERE... 17 Syntaxe : TYPE <nom_type> IS RECORD ( <nomchamps> <type> [ [NOT NULL] [ := <expression> ] ],... ) ; Exemple (pas dans MySQL) : DECLARE TYPE client_t IS RECORD ( numero NUMBER(4), nom CHAR(20), adresse CHAR(20) ) ; client1_v client_t ; client1_v.numero := 2516 ;... END ; // 18 6
Arithmétique +, -, *, /, ** Concaténation de chaîne CONCAT() Parenthèse pour contrôler les priorités des opérations Affectation SET Comparaison =, <> (!=), <, >, <=, >=, IS NULL, LIKE, BETWEEN, IN Logique AND (&&), OR ( ), NOT (!) 19 Incrémenter l index d une boucle SET compte_v = compte_v + 1; Affectation de la valeur d un drapeau booléen SET egales_v = (n1_v = n2_v); Rechercher si une variable a une valeur SET affecte_v = (nemp_v IS NOT NULL) 20 Branchements conditionnels IF - THEN - END IF IF - THEN - ELSE - END IF IF - THEN - ELSIF - END IF CASE Boucles LOOP - END LOOP FOR - END LOOP WHILE - END LOOP Note : la commande EXIT permet de sortir de tout type de boucle 21 7
Syntaxe IF <condition> THEN commandes ; [ELSIF <condition> THEN commandes ; ]* [ELSE commandes ; ] END IF ; Note : vous pouvez utiliser l expression IS NULL dans les conditions 22 Exemple IF nomemploye_v = 'Tiger' THEN SET salaire_v = salaire_v * 3 ; ELSIF nomemploye_v = 'Scott' THEN SET salaire_v = salaire_v * 2.5 ; ELSE SET salaire_v = salaire_v * 2 ; END IF; 23 Syntaxe CASE expression WHEN expr1 THEN instruction 1; WHEN expr2 THEN instruction 2; ELSE instructionsn; END CASE; 24 8
Syntaxe LOOP commandes ;... LEAVE[WHEN <condition>] ; END LOOP ; Note : sans commande LEAVE, les boucles LOOP sont infinies 25 Exemple DELIMITER // DECLARE a INT DEFAULT 0; simple_loop: LOOP SET a = a + 1; SELECT a; IF a = 5 THEN LEAVE simple_loop; END IF; END LOOP simple_loop; // 26 Syntaxe WHILE <condition> LOOP commandes ;... END LOOP ; Exemple DECLARE v1 INT DEFAULT 5; WHILE v1 > 0 DO SET v1 = v1-1; END WHILE; 27 9
Syntaxe REPEAT commandes ;... UNTIL <condition> END REPEAT ; Exemple DECLARE v1 INT DEFAULT 5; REPEAT SET v1 = v1-1; UNTIL v1 > 0 END REPEAT; 28 DECLARE numdept_v NUMBER(2); DECLARE loc_v VARCHAR(15); SELECT INTO FROM WHERE... numdept, lieu numdept_v, loc_v Dept nomdept = 'Comptabilté'; ATTENTION La requête doit retourner un et un seul n-uplet. Si ce n est pas le cas, les exceptions NO_DATA_FOUND ou TOO_MANY_ROWS sont levées 29 DELIMITER // DECLARE sommesalaires_v NUMBER(10); DECLARE numdept_v NUMBER(10); SET numdept_v = 10; SELECT SUM(salaire) INTO sommesalaires_v FROM Employe WHERE numdept = nodept_v;... // DELIMITER ; 30 10
La première commande INSERT/UPDATE/DELETE/CREATE/DROP d un bloc entame une nouvelle transaction La fin du bloc ne termine pas la transaction Pour terminer explicitement une transaction, utiliser les commandes SQL : COMMIT : valide les modifications faites depuis le début de la transaction en cours, et entame une nouvelle transaction ROLLBACK : annule toutes les modifications faites depuis le début de la transaction en cours, et entame une nouvelle transaction Note Une transaction doit être un ensemble homogène de manipulations de la base de données Il faut réfléchir à tous les endroits où il est légitime de mettre un COMMIT 31 DECLARE numdpt_v NUMBER(10); DECLARE majorationsalaire_v NUMBER(10); COMMIT ; SET numdpt_v = 10; SET majorationsalaire_v = 2000; DELETE FROM Emp WHERE numdpt = numdpt_v ; UPDATE Emp SET salaire = salaire + majorationsalaire_v WHERE job = Analyste ; COMMIT ; END ; 32 Nécessite l utilisation de curseur Les curseurs sont des zones de travail privées, utilisées pour stocker le résultat d une requête et qu il est possible de parcourir 33 11
Jusqu à présent, l utilisation de l instruction SELECT est limitée aux requêtes renvoyant une et une seule valeur Toute requête renvoyant un résultat de cardinalité différente de 1 aboutit à un échec Définition : un curseur est un mécanisme permettant d utiliser une instruction SELECT renvoyant un nombre quelconque de n-uplets Note : à toute requête SQL exécutée par le serveur Oracle est associé un curseur 34 Un curseur peut être considéré comme une fenêtre sur l ensemble des résultats d une requête Curseur On distingue deux types de curseurs Curseurs implicites : déclarés implicitement par SQL/PSM lors de tout SELECT Curseurs explicites : créés par le programmeur 35 Les curseurs doivent être utilisés lorsque l on désire parcourir la totalité du résultat d une requête SELECT En particulier si cette requête renvoie un résultat de cardinalité > 1 Le curseur pointe toujours sur une valeur du résultat de la requête à laquelle il est associé Un curseur permet De garder trace d une requête SELECT De parcourir n-uplet par n-uplet le résultat d un SELECT D accéder à la totalité du résultat d un SELECT 36 12
Protocole d utilisation 1. Déclaration 2. Ouverture 3. Utilisation 4. Fermeture Attributs associés aux curseurs Fonctions associées aux curseurs Parcours de curseurs 37 Syntaxe CURSOR <nom de curseur> FOR <instruction SELECT> ; Notes Ne pas utiliser de clause INTO dans l instruction SELECT Si vous voulez manipuler les n-uplets dans un ordre spécifique, utilisez la clause ORDER BY dans la requête On peut déclarer autant de curseurs que l on souhaite Le contenu du curseur n est pas calculé au moment de sa déclaration, mais au moment de son ouverture 38 Avec Oracle Attributs des curseurs : en utilisant les attributs de curseurs, vous pouvez tester le résultat de vos requêtes SQL SQL%ROWCOUNT : nombre de n-uplets affectés par la dernière requête SQL ( entier ) SQL%FOUND : booléen, vaut TRUE si la dernière requête SQL a affecté au moins un tuple et faux sinon SQL%NOTFOUND : booléen, vaut TRUE si la dernière requête SQL n a affecté aucun tuple et faux sinon SQL%ISOPEN : booléen indiquant si le curseur est ouvert ou fermé (par défaut, les curseurs implicites sont toujours fermés à la fin de la requête) Note : à la place de SQL, utilisez le nom de votre curseur pour identifier l état d un curseur explicite 39 13
Exemple DELETE FROM emp WHERE nomemp='tiger' ; IF (SQL%NOTFOUND) THEN dbms_output.put_line('pas d employé'); END IF; / Supprimer des n-uplets de la table Employe, afficher le nombre de n-uplets supprimés DECLARE nbrenupletssupp_v VARCHAR2(64); numdept_v Employe.noDept%TYPE := 10 ; DELETE FROM emp WHERE numdept = numdept_v ; nbrenupletssupp_v := TO_CHAR(SQL%ROWCOUNT) n- uplets supprimés ; DBMS_OUTPUT.PUT_LINE(nbreNupletsSupp_v) ; END ; 41 Pas d attributs associés OPEN cur1; OPEN cur2; DECLARE EXIT HANDLER FOR NOT FOUND LOOP FETCH cur1 INTO a, b; FETCH cur2 INTO c; IF b < c THEN INSERT INTO test.t3 VALUES (a,b); ELSE INSERT INTO test.t3 VALUES (a,c); END IF; END LOOP; CLOSE cur1; CLOSE cur2; 14
Redéfinir l instruction exécutée par une condition DECLARE handler_type HANDLER FOR condition_value [, condition_value]... statement handler_type: CONTINUE EXIT UNDO condition_value: SQLSTATE [VALUE] sqlstate_value condition_name SQLWARNING NOT FOUND SQLEXCEPTION mysql_error_code Exemple DECLARE CONTINUE HANDLER FOR SQLSTATE '23000' SET @x2 = 1; 23000 : apparaît lorsqu on essaye d insérer une valeur de clé dupliquée SET @quit = 0; DECLARE CONTINUE HANDLER FOR NOT FOUND SET @quit = 1; Utiliser les fonctions associées aux curseurs pour accéder au contenu du résultat OPEN <nom de curseur> Ouverture du curseur, exécution la requête associée, positionnement du pointeur juste avant le premier n-uplet du résultat Si le résultat de la requête est vide, aucune erreur n est levée FETCH... Déplacement du pointeur vers le prochain n-uplet du curseur affectation du nouveau n-uplet pointé à une variable CLOSE <nom de curseur> Fermeture du curseur Désallocation de la mémoire associée Perte des données associées au curseur ( utilisation Fermer systématiquement les curseurs après 45 15
Exemple DECLARE CURSOR departementventes_curs FOR SELECT * FROM dept WHERE nomdept = Ventes ; DECLARE undepartement_num NUMBER(10); OPEN departementventes_curs; DECLARE EXIT HANDLER FOR NOT FOUND LOOP FETCH departementventes_curs.numdept INTO undepartement_num; END LOOP CLOSE departementventes_curs; 46 Syntaxe FETCH <nom de curseur> INTO [[<varible1>, <varible2>,...] <nom de record> ] ; Notes Inclure le même nombre de variables dans la clause INTO qu il y a d attributs dans le SELECT associé au curseur Mettre les variables dans le bon ordre Oracle Il est aussi possible d utiliser un record (type correspondant à un n-uplet) ayant le type adapté Avant le premier appel à la fonction FETCH, l attribut %NOTFOUND du curseur vaut NULL => a prendre en compte pour éviter des boucles infinies 47 DECLARE CURSOR departementventes_curs FOR SELECT * FROM dept; DECLARE undepartement_num NUMBER(10); DECLARE compteur_v NUMBER(10); SET compteur_v = 0; OPEN departementventes_curs; DECLARE EXIT HANDLER FOR NOT FOUND LOOP FETCH departementventes_curs.numdept INTO undepartement_num; SET compteur_v = compteur_v + 1; END LOOP; CLOSE departementventes_curs; SELECT compteur_v; 48 16
Syntaxe Déclaration CURSOR <nom de curseur> ( [<nom de paramètre> [IN] <type> [:= <valeur>] ]* ) IS <instruction SELECT utilisant les paramètres>; Ouverture OPEN <nom de curseur> (<valeur1>, <valeur2>,... ) Boucle FOR <nom de record> IN <nom de curseur> (<valeur1>, <valeur2>,... ) LOOP <instructions>... END LOOP ; 49 DECLARE CURSOR departement_curs (nomdept_p varchar) IS SELECT * FROM Departement WHERE nomdept = nomdept_p ; compteur_v number := 0 ; FOR chaquedepartement_row IN departement_curs ( VENTE ) LOOP... compteur_v := compteur_v +1 ;... END LOOP ;... END ; 50 SELECT classique : non verrouillé Problème : modification des n-uplets possible entre le moment de l interrogation (SELECT) et celui des opérations de modification (UPDATE) Solution : SELECT FOR UPDATE Permet de verrouiller tous les n-uplets jusqu au prochain commit (et donc jusqu à leur modification) Permet de garantir qu aucun autre utilisateur modifiera les données entre le SELECT et l UPDATE/DELETE/INSERT correspondant 51 17
[DECLARE]... Anonyme [EXCEPTION]... PROCEDURE <nom>...... Procédure [EXCEPTION]... Fonction FUNCTION <nom> RETURN <type>...... RETURN <valeur> ; [EXCEPTION]... Commentaires -- commentaires sur une ligne /* commentaires sur plusieurs lignes */ 52 CREATE <procedure or function name> [( (IN OUT INOUT) name type [(IN OUT INOUT) name2 type]*,... )] IN (valeur par défaut) indique que le paramètre transmis par le programme appelant n'est pas modifiable par la fonction OUT indique que le paramètre est modifiable par la procédure INOUT indique que le paramètre est transmis par le programme appelant et renseigné par la fonction 53 Appel d une procédure CALL <procedure_name> [(parameters)]; Appel d une fonction SELECT <function>([parameters]) SET <variable> = <function>([parameters]) 54 18
CREATE PROCEDURE modifierqteobjet(produit INT, nvlqte INT) UPDATE Produit SET qte = nvlqte WHERE idproduit = produit; // CALL modifierqteobjet(10,20); SELECT * FROM produit WHERE idproduit = 20; IDPRODUIT DESCRIPTION PRIXUNITAIRE QUANTITÉ ---------- -------------------- ------------ --------------- 20 vis35 2.25 20 55 Suppression de procédures ou de fonctions DROP PROCEDURE [IF EXISTS] nom_procedure DROP FUNCTION [IF EXISTS] nom_fonction 56 Automatiser des actions lors de certains événements du type (AFTER BEFORE) (INSERT DELETE UPDATE) Syntaxe CREATE REPLACE TRIGGER nom_trigger (BEFORE AFTER) (INSERT UPDATE DELETE) ON nom_table FOR EACH ROW Instructions SQL/PSM 57 19
Utilisation des variables new et old Si nous ajoutons/modifions un client nous pouvons accéder/modifier le nom de ce client à partir de la variable : new.nom Dans le cas de suppression ou modification, les anciennes valeurs sont dans la variable :old.nom 58 59 Un package est constitué d une signature / spécification (partie publique) et d un corps ( package (implémentation du La signature du package contient des éléments (prototypes de fonctions, variables) accessibles à tous les utilisateurs du paquetage Le corps du package contient l implémentation des fonctions et la partie privée du package (fonctions et variables locales) Droit d exécution d'un package : accès à la spécification mais pas au corps (nécessite droit de modification) La surcharge de fonction est possible (plusieurs procédures ou fonctions de même nom, avec des signatures différentes) Chaque session qui utilise le package possède une instance du package (il n y a donc pas partage ( variables des 60 20
La signature d un package contient Prototypes des procédures et des fonctions du package Constantes et variables Curseurs Définitions d'exceptions 61 Le corps d un package contient Le corps des procédures et fonctions dont le prototype a été défini dans la signature D'autres procédures, fonctions, variables,... privées Bloc d'initialisation possible 62 CREATE PACKAGE nompaquetage AS listedessignaturesdesfonctions&procédures END nompaquetage ; CREATE PACKAGE BODY nompaquetage AS délaration [déclaration] séquenceénoncésinitialisation END nompaquetage; nompaquetage.nomobjet 63 21
CREATE OR REPLACE PACKAGE Func_Geom IS PI NUMBER := 3.1416; FUNCTION Perimetre(rayon IN NUMER) RETURN NUMBER; FUNCTION Surface(rayon IN NUMBER) RETURN NUMBER;... / 64 CREATE OR REPLACE PACKAGE BODY Func_Geom IS val_approx NUMBER := 4; /* Private variable */ FUNCTION Perimetre(rayon IN NUMBER) RETURN NUMBER IS RETURN 2*PI*rayon; FUNCTION Surface(rayon IN NUMBER) RETURN NUMBER IS RETURN PI*rayon*rayon; END Func_Geom; / 65 Dans une fonction... val = Func_Geom.surface(2);... Dans une requête SQL SELECT Func_Geom.surface(rayon) FROM Information_Place; 66 22
67 Procédure exécutée au niveau serveur BD active Permet le maintien de contraintes d intégrité Statiques : alternatives aux mécanismes déclaratifs type CHECK par exemple Préférer les mécanismes déclaratif s'il est possible de les utiliser Dynamiques Permet le maintien d'éléments dérivés Colonne dérivée (contenue d'une colonne calculée à partir d'une ou ( colonnes plusieurs autres (... d'archivage, Tables dérivée (copie de tables pour base répartie, table Sécurité (ex: refus de modification), audit des opérations, 68 Généralement, un déclencheur est associé à un événement sur une table Sous ORACLE, un déclencheur (trigger) peut être associé à pratiquement tout événement de la base (... logon, (DDL, startup, 69 23
Utilisé pour spécifier des contraintes plus complexes que les contraintes statiques telles que Contraintes portant sur plusieurs tables Contraintes nécessitant l utilisation de sous-requêtes Permet d'utiliser des traitement procéduraux: Ecriture de procédures SQL/PSM, JAVA,... 70 Déclenché par un événement particulier Le trigger est généralement associé à une table précise Il est alors déclenché en réaction à un événement sur cette table : INSERT, UPDATE ou DELETE Il est possible de spécifier des conditions supplémentaires : clause WHEN Possible déclenchement en cascade : un trigger peut déclencher d autres triggers en cascade Attention au cycle de déclencheur : trigger A déclenche trigger B qui déclencher trigger A qui... Résultat du trigger Le trigger se termine correctement s il ne soulève pas d exception et si les modifications effectuées ne violent pas d autres contraintes (autres triggers ou ( statiques contraintes Si le trigger est interrompu, toutes les opérations effectuées sont annulées ( implicite (rollback 71 Résultat du trigger Le trigger se termine correctement s il ne soulève pas d exception et si les modifications effectuées ne violent pas d autres contraintes (autres triggers ou ( statiques contraintes Si le trigger est interrompu, toutes les opérations effectuées sont annulées ( implicite (rollback 72 24
CREATE TRIGGER nom-trigger BEFORE AFTER INSERT xor UPDATE xor DELETE ON nom-table FOR EACH ROW bloc d instructions SQL/PSM INSERT OR UPDATE OR DELETE ON nom-table Précise le ou les événements provoquant l'exécution du trigger BEFORE AFTER Spécifie l'exécution de la procédure comme étant avant (BEFORE) ou après (AFTER) l exécution de l événement déclencheur BEFORE : vérification de l'insertion AFTER : copie ou archivage des opérations 73 FOR EACH ROW Indique que le trigger est exécuté pour chaque ligne modifiée / insérée / supprimée ORACLE : si cette clause est omise, le trigger est exécuté une seul fois pour chaque commande UPDATE, INSERT, DELETE, quelque soit le nombre de lignes modifiées, insérées ou supprimées 74 Dans le code SQL/PSM associé à un trigger de niveau ligne, on peut accéder aux valeurs des attributs de la ligne modifiée, avant et après la modification utilisation des variables OLD et NEW Pour un trigger sur INSERT : les valeurs des attributs du n-uplet inséré sont dans NEW.<nom attribut> Pour un trigger sur UPDATE : les valeurs de l'ancien n-uplet sont dans OLD.<nom attribut> les valeurs du n-uplet après modification sont dans :new.<nom attribut> Pour un trigger sur DELETE les valeurs des attributs du n-uplet supprimé sont dans OLD.<nom attribut> 75 25
Déclencheur de ligne (spécifié par FOR EACH ROW) Exécutés une fois pour chaque ligne affectée par l événement spécifié Permet d accéder aux valeurs des lignes affectées avant (OLD) et après (NEW) l opération Si le triggers est précisé comme étant déclenché avant l événement (BEFORE) les valeurs du n-uplet peuvent être modifiées avant leur insertion dans la base de données (e.g. SET NEW.attribut = NEW.attribut + 1) ( ROW ORACLE : déclencheur d instruction (par défaut, sans FOR EACH Exécuté une seule fois avant ou après la totalité de l événement, indépendamment du nombre de lignes affectés Restrictions : ne permet pas d accéder ou de modifier les valeurs des lignes affectées avant ou après l événement 76 Mutation : tant que les modifications (INSERT, UPDATE ou DELETE) d une table ne sont pas terminées (modifications totalement terminées et validées), celle-ci est dite en cours de mutation Un trigger ne peut lire ou modifier une table en cours de mutation Un trigger AFTER (pas de clause FOR EACH ROW), peut modifier la table associée à l événement déclencheur Validation : un déclencheur ne peut ni exécuter d instruction COMMIT ou ROLLBACK, ni appeler de fonction, procédure ou sous-programme de package invoquant ces instructions 77 DECLARE Bloc d instructions SQL/PSM Le bloc d instructions SQL/PSM peut contenir Des Instructions SQL : SELECT, INSERT, UPDATE, DELETE,... mais pas de COMMIT et ROLLBACK ( FOR Instructions de contrôle de flux (IF, LOOP, WHILE, Faire appel à des procédures et fonctions SQL/PSM 78 26
Désactivation du trigger (ORACLE) ALTER TRIGGER <nomtrigger> DISABLE ; Activation de déclencheur (ORACLE) ALTER TRIGGER <nomtrigger> ENABLE ; Suppression de déclencheur DROP TRIGGER <nomtrigger> ; 79 Empêcher une augmentation du prix d'un circuit de plus de 10% du prix actuel CREATE TRIGGER circuitrestreindreaugmentationprix BEFORE UPDATE ON Circuit FOR EACH ROW IF(NEW.prixInscription > OLD.prixInscription * 1.1) THEN SET NEW.prixInscription = OLD.prixInscription ; END IF ; END ; 80 Sous MySQL : impossible d empécher une insertion Exemple : NbPlaceDisponible d'un circuit toujours compris entre 0 et 100 CREATE TRIGGER VERIFIER_CIRCUIT BEFORE INSERT ON Circuit FOR EACH ROW IF(NEW.nbPlaceDisponible <= 0) OR (NEW.nbPlaceDisponible > 100) THEN... END IF; CHECK préférable 81 27
Le nombre d articles en stock est ajusté en fonction des livraisons reçues/envoyées CREATE TRIGGER AI_AjusterQuantitéEnStock AFTER INSERT ON Livraison FOR EACH ROW UPDATE Article SET quantiteenstock = quantiteenstock NEW.quantiteLivree WHERE IdArticle = NEW.IdArticle; END CREATE TRIGGER AU_AjusterQuantiteStock AFTER UPDATE ON Livraison FOR EACH ROW UPDATE Article SET quantiteenstock = quantiteenstock - (NEW.quantiteLivree - OLD.quantiteLivree) WHERE IdArticle = OLD.IdArticle; END 82 Ordre d exécution des TRIGGER? BEFORE avant AFTER,... Entre TRIGGER de même type? Forcer un ordre en les combinant Combiner plusieurs TRIGGER Vérifier quel est l événement déclencheur Pour ORACLE, tester IF INSERTING, DELETING, UPDATING Attention à l ordre d exécution des déclencheurs 83 Exécuter les TRIGGER BEFORE STATEMENT Pour chaque ligne touchée par l'opération Exécuter les TRIGGER BEFORE ROW Exécuter l'opération Exécuter les TRIGGER AFTER ROW Fin pour Exécuter les TRIGGER AFTER STATEMENT 84 28
Peuvent être complexes à coder Pas de respect de standard Contraintes particulières aux langages de codage Pas de mise à jours sur la table affectée 85 SQL> CREATE TRIGGER BUArticleBornerAugPrix 2 BEFORE UPDATE ON Article 3 FOR EACH ROW 4 5 IF(NEW.prixUnitaire > OLD.prixUnitaire*1.1) 6 THEN 6 SET NEW.prixUnitaire = OLD.prixUnitaire*1.1; 7 END IF; 8 9 / Déclencheur créé. 86 SQL> -- Test du TRIGGER BUArticleBornerAugPrix SQL> SELECT * FROM Article WHERE IdArticle = 10 2 / IDARTICLE DESCRIPTION PRIXUNITAIRE QUANTITÉENSTOCK --------- -------------------- ------------ --------------- 10 Boule de cèdre 10,99 10 SQL> UPDATE Article 2 SET prixunitaire = 15.99 3 WHERE IdArticle = 10 4 / 1 ligne mise à jour. SQL> SELECT * FROM Article WHERE IdArticle = 10 2 / IDARTICLE DESCRIPTION PRIXUNITAIRE QUANTITÉENSTOCK --------- -------------------- ------------ --------------- 10 Boule de cèdre 12,09 10 87 29