oracle : le PL-SQL

oracle : le PL-SQL

1. PL-SQL Le SQL procédural d’Oracle

2. 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

3. 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

4. Structure

5. Portée des objets

6. Identificateurs

7. 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

8. 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

9. 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 … ]… );

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

11. Structures de contrôle IF condition THEN instructions; END IF; IF condition THEN instructions; ELSE instructions; END IF; IF condition1 THEN instructions; ELSIF condition2 THEN instructions; ELSE instructions; END IF;

12. Structures de contrôle [<< étiquette>>] CASE variable WHEN expr1 THEN instructions1; WHEN expr2 THEN instructions2; … WHEN exprN THEN instructionsN ; [ELSE instructionsN +1;] END CASE [ étiquette]; [<< étiquette>>] CASE WHEN condition1 THEN instructions1; WHEN condition2 THEN instructions2; … WHEN conditionN THEN instructionsN ; [ELSE instructionsN +1;] END CASE [ étiquette];

13. Structures de contrôle

14. Structures de contrôle WHILE condition LOOP instructions; END LOOP; LOOP instructions; EXIT [WHEN condition;] END LOOP; FOR compteur IN [REVERSE] valeurInf .. valeurSup LOOP instructions; END LOOP; CONTINUE [ etiquette ] [ WHEN condition ];

15. Interaction avec la base SELECT liste INTO { nomVariablePLSQL [, nomVariablePLSQL ]… | nomRECORD } FROM nomTable …;

16. Interaction avec la base

17. 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

18. Transactions

19. 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 )] } };

20. 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

21. 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 )] } };

22. Appel

23. Structures

24. Curseurs

25. Curseurs

26. Curseurs

27. Curseurs

28. Exceptions EXCEPTION WHEN exception1 [OR exception2 …] THEN instructions; [ WHEN exception3 [OR exception4 …] THEN instructions; ] [ WHEN OTHERS THEN instructions; ]

29. Exceptions

30. Exceptions

31. Exceptions

32. 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

33. Exceptions

34. Déclencheurs

35. 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

36. é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

37. 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 [ ];

38. Paquetages (packages)

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

40. 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;

41. SQL> @$ORACLE_HOME/ rdbms / admin /utlmail.sql SQL> @$ORACLE_HOME/ rdbms / admin /prvtmail.plb SMTP_OUT_SERVER ='XXX.XX.X.X‘ Package UTL_MAIL

42. Package UTL_MAIL

43. 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);

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

45. 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

46. DBMS_SQL CREATE 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;

47. 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;

48. 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;

49. SQL dynamique natif EXECUTE 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

50. SQL dynamique DECLARE 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 ;

51. SQL dynamique DECLARE 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 ;

52. SQL dynamique create function row_count ( tab_name VARCHAR2) RETURN NUMBER AS rows NUMBER; begin EXECUTE 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 ;

53. 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;

54. SQL dynamique DECLARE TYPE EmpCurTyp IS REF CURSOR ; emp_cv EmpCurTyp ; emp_rec employees %ROWTYPE; sql_stmt VARCHAR2(200); v_job VARCHAR2(10) := ’ST_CLERK’; BEGIN sql_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; /

55. Utilisateur

56. 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

57. Utilisateur

58. Profil

59. 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

60. Profil

61. Privilèges système

62. 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

63. Privilèges système

64. Privilèges objets

65. Privilèges objets

66. 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

67. Privilèges predefinis

68. Role

69. Rôles prédéfinis

70. Activation Désactivation IDENTIFIED ind ique 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).