oracle : le pl-sql

PL-SQLLe SQL procédural d’Oracle

Faire cohabiter des structures de contrôle (si, pour et tant que) avec des instructions SQL (principalement SELECT, INSERT, UPDATE et DELETE).

Eviter les encombrements reseau : En effet, un bloc PL/SQL donne lieu à un seul échange entre le client et le serveur

La modularité (un bloc d’instruction peut être composé d’un autre, etc.) : un bloc peut être nommé pour devenir une procédure ou une fonction cataloguée, donc réutilisable. Une procédure, ou fonction, cataloguée peut être incluse dans un paquetage (package) pour mieux contrôler et réutiliser ces composants logiciels.

La portabilité : un programme PL/SQL est indépendant du système d’exploitation qui héberge le serveur Oracle. En changeant de système, les applicatifs n’ont pas à être modifiés.

L’intégration avec les données des tables : on retrouvera avec PL/SQL tous les types de données et instructions disponibles sous SQL, et des mécanismes pour parcourir des résultats de requêtes (curseurs), pour traiter des erreurs (exceptions), pour manipuler des données complexes (paquetages DBMS_xxx) et pour programmer des transactions (COMMIT, ROLLBACK, SAVEPOINT).

Avantages

un bloc de code, executé comme une commande SQL, via un interpréteur standard (SQL+ ou iSQL*PLus)

un fichier de commande PL/SQL un programme stocké (procédure, fonction,

package ou trigger)

Appel

Structure

Portée des objets

Identificateurs

Variables

identificateur [CONSTANT] typeDeDonnée [NOT NULL] [:= | DEFAULT expression];

CONSTANT précise qu’il s’agit d’une constante ; NOT NULL pose une contrainte en ligne sur la variable ; DEFAULT permet d’initialiser la variable (équivaut à

l’affectation :=).

c_pi CONSTANT NUMBER := 3.14159;v_rayon NUMBER DEFAULT 1.5;v_aire NUMBER := c_pi * v_rayon**2;v_trouvé BOOLEAN NOT NULL := TRUE;

VALUE_ERROR

l’affectation comme on la connaît dans les langages de programmation (variable := expression) ;

par la directive DEFAULT ; par la directive INTO d’une requête (SELECT … INTO variable FROM …).

Variables

Variables %TYPE Variables %ROWTYPE TYPE RECORD

Variables

DECLARE v_cat Produit.categorie%TYPE; r_prod Produit%ROWTYPE;BEGIN SELECT * INTO r_prod FROM produit WHERE refProd=5;

v_cat=r_prod.categorie; r_prod.nom=‘nouvp’;

insert into produit values r_prod; …

TYPE nomRecord IS RECORD( nomChamp typeDonnées [[NOT NULL] {:= | DEFAULT} expression][,nomChamp typeDonnées… ]… );

Type TABLE

Variables

TYPE nomTypeTableau IS TABLE OF{typeScalaire | variable%TYPE | table.colonne%TYPE} [NOT NULL]| table%ROWTYPE[INDEX BY BINARY_INTEGER];

nomTableau nomTypeTableau;

Structures de contrôle

IF condition THENinstructions;END IF;

IF condition THENinstructions;ELSEinstructions;END IF;

IF condition1 THENinstructions;ELSIF condition2 THENinstructions;ELSEinstructions;END IF;

Structures de contrôle

[<<étiquette>>]CASE variableWHEN expr1 THEN instructions1;WHEN expr2 THEN instructions2;…WHEN exprN THEN instructionsN;[ELSE instructionsN+1;]END CASE [étiquette];

[<<étiquette>>]CASEWHEN condition1 THEN instructions1;WHEN condition2 THEN instructions2;…WHEN conditionN THEN instructionsN;[ELSE instructionsN+1;]END CASE [étiquette];

Structures de contrôle

Structures de contrôle WHILE condition LOOPinstructions;END LOOP;LOOPinstructions;EXIT [WHEN condition;]END LOOP;

FOR compteur IN [REVERSE] valeurInf..valeurSup LOOPinstructions;END LOOP;

CONTINUE [ etiquette ] [ WHEN condition ];

Interaction avec la base

SELECT liste INTO { nomVariablePLSQL [,nomVariablePLSQL]… |nomRECORD } FROM nomTable …;

Interaction avec la base

l’atomicité des instructions qui sont considérées comme une seule opération (principe du tout ou rien) ;

la cohérence (passage d’un état cohérent de la base à un autre état cohérent) ;

l’isolation des transactions entre elles (lecture consistante, mécanisme décrit plus loin) ;

la durabilité des opérations (les mises à jour perdurent même si une panne se produit aprèsla transaction).

Transactions

Transactions

Procédures

CREATE [OR REPLACE] PROCEDURE [schéma.]nomProcédure[(paramètre [ IN | OUT | IN OUT ] [NOCOPY] typeSQL[{:= | DEFAULT} expression][,paramètre [ IN | OUT | IN OUT ] [NOCOPY] typeSQL[{:= | DEFAULT} expression]… ) ] ][AUTHID { CURRENT_USER | DEFINER }]{ IS | AS }[PRAGMA AUTONOMOUS_TRANSACTION;]{ corpsduSousProgrammePL/SQL | LANGUAGE {JAVA NAME 'nomMéthodeJava' |C [NAME nomSourceC] LIBRARY nomLibrairie [AGENT IN (paramètre)][WITH CONTEXT] [PARAMETERS ( paramètres )] } };

IN désigne un paramètre d’entrée, out un paramètre de sortie et in out un paramètre d’entrée et de sortie. Il est possible d’initialiser chaque paramètre par une valeur.

NOCOPY permet de transmettre directement le paramètre. On l’utilise pour améliorer les performances lors du passage de volumineux paramètres de sortie comme les record, les tables index-by (les paramètres IN sont toujours passés en NOCOPY).

La clause AUTHID détermine si la procédure s’exécute avec les privilèges de son propriétaire (option par défaut, on parle de definer-rights procedure) ou de l’utilisateur courant (on parle de invoker-rights procedure).

PRAGMA AUTONOMOUS_TRANSACTION déclare le sous-programme en tant que transaction autonome (lancée par une autre transaction dite « principale »). Les transactions autonomes permettent de mettre en suspens la transaction principale puis de reprendre la transaction principale

corpsduSousProgrammePL/SQL contient la déclaration et les instructions de la procédure, toutes deux écrites en PL/SQL.

Procédures

Fonctions

CREATE [OR REPLACE ] FUNCTION [schéma.]nomFonction[(paramètre [ IN | OUT | IN OUT ] [NOCOPY] typeSQL[{:= | DEFAULT} expression][,paramètre [ IN | OUT | IN OUT ] [NOCOPY] typeSQL[{:= | DEFAULT} expression]… ) ] ]RETURN typeSQL[ AUTHID { DEFINER | CURRENT_USER } ]{IS | AS}{ corpsduSousProgrammePL/SQL |LANGUAGE {JAVA NAME 'nomMéthodeJava' |C [NAME nomSourceC] LIBRARY nomLibrairie [AGENT IN (paramètre)][WITH CONTEXT] [PARAMETERS ( paramètres )] } };

Appel

Structures

Curseurs

Curseurs

Curseurs

Curseurs

Exceptions

EXCEPTIONWHEN exception1 [OR exception2 …] THENinstructions;[WHEN exception3 [OR exception4 …] THENinstructions; ][WHEN OTHERS THENinstructions; ]

Exceptions

Exceptions

Exceptions

Exceptions

nomException EXCEPTION;

PRAGMA EXCEPTION_INIT(nomException, numéroErreurOracle);

RAISE_APPLICATION_ERROR(numéroErreur, message [, {TRUE | FALSE}]);

numéroErreur entre –20 000 et –20 999

Exceptions

Déclencheurs

BEFORE | AFTER | INSTEAD OF précise la chronologie entre l’action à réaliser par le déclencheur LMD et la réalisation de l’événement (exemple BEFORE INSERT programmera l’exécution du déclencheur avant de réaliser l’insertion).

DELETE | INSERT | UPDATE précise la nature de l’événement pour les déclencheurs LMD.

ON {[schéma.] nomTable | nomVue} spécifie la table, ou la vue, associée au déclencheur LMD.

REFERENCING permet de renommer des variables. FOR EACH ROW différencie les déclencheurs LMD au niveau ligne

ou au niveau état.

Déclencheurs

événementBase identifie la nature d’un déclencheur d’instance (STARTUP ou SHUTDOWN pour exécuter le déclencheur au démarrage ou à l’arrêt de la base), d’un déclencheur d’erreurs (SERVERERROR ou SUSPEND pour exécuter le déclencheur dans le cas d’une erreur particulière ou quand une transaction est suspendue) ou d’un déclencheur de connexion (LOGON ou LOGOFF pour exécuter le déclencheur lors de la connexion ou de la déconnexion à la base).

actionStructureBase spécifie la nature d’un déclencheur LDD (CREATE, ALTER, DROP, etc. pour exécuter par exemple le déclencheur lors de la création, la modification ou la suppression d’un objet de la base).

ON {[schéma.]SCHEMA | DATABASE}} précise le champ d’application du déclencheur (de type LDD, erreur ou connexion). Utilisez DATABASE pour les déclencheurs qui s’exécutent pour quiconque commence l’événement, ou SCHEMA pour les déclencheurs qui ne doivent s’exécuter que dans le schéma courant.

WHEN conditionne l’exécution du déclencheur

Déclencheurs

Paquetages (packages)

CREATE [OR REPLACE] PACKAGE[AUTHID {CURRENT_USER | DEFINER}] {IS | AS}[déclarationTypeRECORD…] [déclarationSUBTYPE …][déclarationCONSTANT …] [déclarationEXCEPTION …][déclarationRECORD …] [déclarationVariable …][déclarationCURSOR …] [déclarationFonction …][déclarationProcédure …]END [ ];

Paquetages (packages)

Package UTL_FILE

F1 := UTL_FILE.FOPEN('MYDIR','MYFILE','R'); UTL_FILE.GET_LINE(F1,V1); UTL_FILE.FCLOSE(F1);

CREATE OR REPLACE PROCEDURE test_file_pack IS file_handle UTL_FILE.FILE_TYPE; BEGIN file_handle := UTL_FILE.FOPEN('l:\db8\utlfiledir','file1.txt','w'); DBMS_OUTPUT.PUT_LINE('Start'); UTL_FILE.PUT_LINE(file_handle,'Bonjour chez Vous !'); UTL_FILE.PUT_LINE(file_handle,' on est le ' || to_char(sysdate)); UTL_FILE.FFLUSH(file_handle); UTL_FILE.FCLOSE(file_handle); DBMS_OUTPUT.PUT_LINE('Fin !'); EXCEPTION WHEN NO_DATA_FOUND THEN DBMS_OUTPUT.PUT_LINE('No_data_found'); UTL_FILE.FCLOSE(file_handle); WHEN UTL_FILE.INVALID_PATH THEN DBMS_OUTPUT.PUT_LINE('UTL_FILE.INVALID_PATH'); UTL_FILE.FCLOSE(file_handle); WHEN UTL_FILE.READ_ERROR THEN DBMS_OUTPUT.PUT_LINE('UTL_FILE.READ_ERROR'); UTL_FILE.FCLOSE(file_handle); WHEN UTL_FILE.WRITE_ERROR THEN DBMS_OUTPUT.PUT_LINE('UTL_FILE.WRITE_ERROR'); UTL_FILE.FCLOSE(file_handle); WHEN OTHERS THEN DBMS_OUTPUT.PUT_LINE('Autres erreurs'); UTL_FILE.FCLOSE(file_handle); END;

SQL> @$ORACLE_HOME/rdbms/admin/utlmail.sql

SQL> @$ORACLE_HOME/rdbms/admin/prvtmail.plb

SMTP_OUT_SERVER ='XXX.XX.X.X‘

Package UTL_MAIL

Package UTL_MAIL

UTL_MAIL.SEND_ATTACH_VARCHAR2 ( sender IN VARCHAR2 CHARACTER SET ANY_CS, recipients IN VARCHAR2 CHARACTER SET ANY_CS, cc IN VARCHAR2 CHARACTER SET ANY_CS DEFAULT NULL, bcc IN VARCHAR2 CHARACTER SET ANY_CS DEFAULT NULL, subject IN VARCHAR2 CHARACTER SET ANY_CS DEFAULT NULL, message IN VARCHAR2 CHARACTER SET ANY_CS, mime_type IN VARCHAR2 DEFAULT 'text/plain; charset=us-ascii', priority IN PLS_INTEGER DEFAULT NULL attachment IN RAW, att_inline IN BOOLEAN DEFAULT TRUE, att_mime_type IN VARCHAR2 CHARACTER SET ANY_CS DEFAULT 'text/plain; charset=us-ascii', att_filename IN VARCHAR2 DEFAULT NULL);

beginUTL_MAIL.send(sender => ‘source@gmail.fcom', recipients => ‘cible@hotmail.com', cc => NULL, bcc => NULL, subject => ‘email de test', message => ‘message de utl_mail ‘); end;

beginUTL_MAIL.send_attach_raw(sender => ‘sender@yahoo.com', recipients => ‘aicha@gmail.com', subject => ‘sj',attachment => HEXTORAW('616262646566C2AA'), message => ‘email avec fichier attaché', att_filename => 'os.sql'); end;

Fonction OPEN_CURSOR RETURN INTEGER ;Cette fonction ouvre un curseur et renvoie un INTEGER.

Procédure PARSE (pointeur IN INTEGER, requête_sql IN VARCHAR2,DBMS.NATIVE) ;Cette procédure analyse la chaîne ‘requête_sql‘ suivant la version sous laquellel’utilisateur est connecté.

Fonction EXECUTE (pointeur IN INTEGER) RETURN INTEGER ;Cette fonction exécute l’ordre associé au curseur et renvoie le nombre de lignestraitées dans le cas d’un INSERT, DELETE ou UPDATE.

Procédure CLOSE_CURSOR (pointeur IN OUT INTEGER) ;Cette procédure ferme le curseur spécifié, met l’identifiant du curseur à NULL etlibère la mémoire allouée au curseur

Procédure BIND_VARIABLE( pointeur IN INTEGER, nom_variable_substitutionIN VARCHAR2, valeur_variable_substitution IN {NUMBER|VARCHAR2|DATE})

DBMS_SQL

DBMS_SQLCREATE OR REPLACE PROCEDURE up (

p_salaire IN NUMBER, p_no IN NUMBER,p_table IN VARCHAR2)

IS pointeur INTEGER;exec INTEGER;

BEGIN pointeur:=DBMS_SQL.OPEN_CURSOR; DBMS_SQL.PARSE( pointeur,

'update '||p_table||' set salaire ='||p_salaire||' where no ='||p_no,DBMS_SQL.V7);

exec:=DBMS_SQL.EXECUTE(pointeur); DBMS_SQL.CLOSE_CURSOR(pointeur);END;

CREATE PROCEDURE insert_into_table ( table_name VARCHAR2, deptnumber NUMBER, deptname VARCHAR2, location VARCHAR2) IS cur_hdl INTEGER; stmt_str VARCHAR2(200); rows_processed BINARY_INTEGER; BEGIN stmt_str := 'INSERT INTO ' || table_name || ' VALUES (:deptno, :dname, :loc)'; -- open cursor cur_hdl := dbms_sql.open_cursor; -- parse cursor dbms_sql.parse(cur_hdl, stmt_str, dbms_sql.native); -- supply binds dbms_sql.bind_variable(cur_hdl, ':deptno', deptnumber); dbms_sql.bind_variable(cur_hdl, ':dname', deptname); dbms_sql.bind_variable(cur_hdl, ':loc', location); -- execute cursor rows_processed := dbms_sql.execute(cur_hdl); -- close cursor dbms_sql.close_cursor(cur_hdl); END;

DBMS_SQL…source_cursor := dbms_sql.open_cursor; DBMS_SQL.PARSE(source_cursor, 'SELECT id, name, birthdate FROM ' || source, DBMS_SQL.NATIVE); DBMS_SQL.DEFINE_COLUMN(source_cursor, 1, id_var); DBMS_SQL.DEFINE_COLUMN(source_cursor, 2, name_var, 30); DBMS_SQL.DEFINE_COLUMN(source_cursor, 3, birthdate_var); ignore := DBMS_SQL.EXECUTE(source_cursor); …LOOP IF DBMS_SQL.FETCH_ROWS(source_cursor)=0 THEN exit; END IF; -- get column values of the row DBMS_SQL.COLUMN_VALUE(source_cursor, 1, id_var); DBMS_SQL.COLUMN_VALUE(source_cursor, 2, name_var); DBMS_SQL.COLUMN_VALUE(source_cursor, 3, birthdate_var);…END LOOP;

SQL dynamique natifEXECUTE IMMEDIATE dynamic_string[ INTO { define_variable [, define_variable ...]| record_name } ][ USING [ IN | OUT | IN OUT ] bind_argument[, [ IN | OUT | IN OUT ] bind_argument] ... ]

Plus grande rapidité d’exécution : En moyenne, le SQL dynamique natif s’exécute de 1.5 à 3 fois plus rapidement.

Support des types définis : Le SQL dynamique natif supporte tous les types définis par l’utilisateur, Objets, collections, etc…

Support des types RECORD pour les ordres Select : Le SQL dynamique natif permet d’utiliser un objet de type RECORD dans une clause INTO

SQL dynamiqueDECLARE Requete VARCHAR2(256) ; Emp_id emp.emp_id%TYPE := 1214 ;BEGIN Requete := ‘CREATE TABLE XX ( ID NUMBER, LIBELLE VARCHAR2(100) )’; EXECUTE IMMEDIATE Requete ; Requete := ‘BEGIN Mon_package.Ma_procedure( :1 ); END;’; EXECUTE IMMEDIATE Requete USING Emp_id;END ;

SQL dynamiqueDECLARE Emp_id emp.emp_id%TYPE := 1214 ; Salary NUMBER(7,2) ; v_Null NUMBER := NULL ; Requete VARCHAR2(256) ;BEGIN

Requete:= ‘SELECT salary from EMP WHERE empno = :1’; EXECUTE IMMEDIATE Requete INTO salary USING Emp_id ; Requete:= ‘UPDATE EMP SET salary = :1 WHERE empno = :2’; EXECUTE IMMEDIATE Requete USING NULL, Emp_id ; Requete:= ‘UPDATE EMP SET salary = :1 WHERE empno = :2’; EXECUTE IMMEDIATE Requete USING v_Null, Emp_id ; END ;

SQL dynamiquecreate function row_count (tab_name VARCHAR2) RETURN NUMBER ASrows NUMBER;beginEXECUTE IMMEDIATE ’select count(*) from ’ || tab_name into rows;return rows;end;

DECLARE Emp_id emp.emp_id%TYPE := 1214 ; Emp_name emp.name_id%TYPE ; Emp_rec emp%ROWTYPE ; Requete VARCHAR2(256) ;BEGIN Requete:= ‘SELECT emp_name from EMP WHERE empno = :1’; EXECUTE IMMEDIATE Requete INTO Emp_name USING Emp_id ;

Requete:= ‘SELECT * from EMP WHERE empno = :1’; EXECUTE IMMEDIATE Requete INTO Emp_rec USING Emp_id ;END ;

SQL dynamique

DECLARE TYPE T_EMP_NAME is TABLE of EMP.emp_name%TYPE; TYPE T_EMP_SAL is TABLE of EMP.salary%TYPE; T_Names T_EMP_NAME ; T_Sal T_EMP_SAL ; Requete VARCHAR2(256);BEGIN Requete:= ‘SELECT emp_name, salary from EMP’;

EXECUTE IMMEDIATE Requete BULK COLLECT INTO T_Names, T_sal;

END;

SQL dynamiqueDECLARE

TYPE EmpCurTyp IS REF CURSOR;emp_cv EmpCurTyp;emp_rec employees%ROWTYPE;sql_stmt VARCHAR2(200);v_job VARCHAR2(10) := ’ST_CLERK’;

BEGINsql_stmt := ’SELECT * FROM employees WHERE job_id = :j’;OPEN emp_cv FOR sql_stmt USING v_job;LOOP FETCH emp_cv INTO emp_rec; EXIT WHEN emp_cv%NOTFOUND; DBMS_OUTPUT.PUT_LINE(’Name: ’ || emp_rec.last_name || ’

Job Id: ’ || emp_rec.job_id);END LOOP;CLOSE emp_cv;

END;/

Utilisateur

IDENTIFIED BY motdePasse permet d’affecter un mot de passe à un utilisateur local (cas le plus courant et le plus simple).

IDENTIFIED BY EXTERNALLY permet de se servir de l’authenticité du système d’exploitation pour s’identifier à Oracle (cas des compte OPS$ pour Unix).

IDENTIFIED BY GLOBALLY permet de se servir de l’authenticité d’un système d’annuaire.

DEFAULT TABLESPACE nomTablespace associe un espace disque de travail (appelé tablespace) à l’utilisateur.

TEMPORARY TABLESPACE nomTablespace associe un espace disque temporaire (dans lequel certaines opérations se dérouleront) à l’utilisateur.

QUOTA permet de limiter ou pas chaque espace alloué. PROFILE nomProfil affecte un profil (caractéristiques système relatives au

CPU et aux connexions) à l’utilisateur. PASSWORD EXPIRE pour obliger l’utilisateur à changer son mot de passe à

la première connexion (par défaut il est libre). Le DBA peut aussi changer ce mot de passe.

ACCOUNT pour verrouiller ou libérer l’accès à la base (par défaut UNLOCK).

Utilisateur

Utilisateur

Profil

SESSIONS_PER_USER : nombre de sessions concurrentes autorisées. CPU_PER_SESSION : temps CPU maximal pour une session en centièmes de secondes. CPU_PER_CALL : temps CPU autorisé pour un appel noyau en centièmes de secondes. CONNECT_TIME : temps total autorisé pour une session en minutes (pratique pour les

examens de TP minutés). IDLE_TIME : temps d’inactivité autorisé, en minutes, au sein d’une même session (pour les

étudiants qui ne clôturent jamais leurs sessions). PRIVATE_SGA : espace mémoire privé alloué dans la SGA (System Global Area). FAILED_LOGIN_ATTEMPTS : nombre de tentatives de connexion avant de bloquer l’utilisateur PASSWORD_LIFE_TIME : nombre de jours de validité du mot de passe (il expire s’il n’est pas

changé au cours de cette période). PASSWORD_REUSE_TIME : nombre de jours avant que le mot de passe puisse être utilisé à

nouveau. Si ce paramètre est initialisé à un entier, le paramètre PASSWORD_REUSE_MAX doit être passé à UNLIMITED.

PASSWORD_REUSE_MAX : nombre de modifications de mot de passe avant de pouvoir réutiliser le mot de passe courant. Si ce paramètre est initialisé à un entier, le paramètre PASSWORD_REUSE_TIME doit être passé à UNLIMITED.

PASSWORD_LOCK_TIME : nombre de jours d’interdiction d’accès à un compte après que le nombre de tentatives de connexions a été atteint

PASSWORD_GRACE_TIME : nombre de jours d’une période de grâce qui prolonge l’utilisation du mot de passe avant son changement (un message d’avertissement s’affiche lors des connexions). Après cette période le mot de passe expire.

Profil

Profil

Privilèges système

privilègeSystème : description du privilège système (exemple CREATE TABLE, CREATE SESSION, etc.).

ALL PRIVILEGES : tous les privilèges système. PUBLIC : pour attribuer le(s) privilège(s) à tous les

utilisateurs. IDENTIFIED BY désigne un utilisateur encore inexistant dans

la base. Cette option n’est pas valide si le bénéficiaire est un rôle ou est PUBLIC.

WITH ADMIN OPTION : permet d’attribuer aux bénéficiaires le droit de retransmettre le(s) privilège(s) reçu(s) à une tierce personne (utilisateur(s) ou rôle(s)).

Privilèges système

Privilèges système

Privilèges objets

Privilèges objets

privilègeObjet : description du privilège objet (ex : SELECT, DELETE, etc.).

colonne précise la ou les colonnes sur lesquelles se porte le privilège INSERT, REFERENCES, ou UPDATE (exemple : UPDATE(typeAvion) pour n’autoriser que la modification de la colonne typeAvion).

ALL PRIVILEGES donne tous les privilèges avec l’option GRANT OPTION) l’objet en question.

PUBLIC : pour attribuer le(s) privilège(s) à tous les utilisateurs.

WITH GRANT OPTION : permet de donner aux bénéficiaires le droit de retransmettre les privilèges reçus à une tierce personne (utilisateur(s) ou rôle(s)).

Privilèges objets

Privilèges predefinis

Role

Rôles prédéfinis

Activation Désactivation

IDENTIFIED indique le mot de passe du rôle si besoin est.ALL active tous les rôles (non identifies) accordes a l’utilisateur qui execute la � �commande. Cette activation n’est valable que dans la session courante. La clause �EXCEPT permet d’exclure des rôles accordes a l’utilisateur � (mais pas via d’autres �rôles) de l’activation globale.NONE désactive tous les rôles dans la session courante (role DEFAULT �inclus).