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 => ‘[email protected]', recipients => ‘[email protected]', cc => NULL, bcc => NULL, subject => ‘email de test', message => ‘message de utl_mail ‘); end;
beginUTL_MAIL.send_attach_raw(sender => ‘[email protected]', recipients => ‘[email protected]', 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).