oracle : le PL-SQL

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

 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)

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 %TYPE
 Variables %ROWTYPE
 TYPE RECORD 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
TYPE nomTypeTableau IS TABLE OF
{typeScalaire | variable%TYPE | table.colonne%TYPE} [NOT NULL]
| table%ROWTYPE
[INDEX BY BINARY_INTEGER];
nomTableau nomTypeTableau;

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;

[<<é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];

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 ];

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

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

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.

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

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

nomException EXCEPTION;
PRAGMA EXCEPTION_INIT(nomException, numéroErreurOracle);
RAISE_APPLICATION_ERROR(numéroErreur, message [, {TRUE | FALSE}]);
numéroErreur entre –20 000 et –20 999

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

 é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

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

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:db8utlfiledir','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');
WHEN UTL_FILE.INVALID_PATH THEN
DBMS_OUTPUT.PUT_LINE('UTL_FILE.INVALID_PATH');
WHEN UTL_FILE.READ_ERROR THEN
DBMS_OUTPUT.PUT_LINE('UTL_FILE.READ_ERROR');
WHEN UTL_FILE.WRITE_ERROR THEN
DBMS_OUTPUT.PUT_LINE('UTL_FILE.WRITE_ERROR');
WHEN OTHERS THEN
DBMS_OUTPUT.PUT_LINE('Autres erreurs');
END;

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

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

begin
UTL_MAIL.send(sender => ‘source@gmail.fcom',
recipients => ‘cible@hotmail.com',
cc => NULL,
bcc => NULL,
subject => ‘email de test',
message => ‘message de utl_mail ‘);
end;
begin
UTL_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})

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;

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;

…
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;

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

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 ;

DECLARE
Salary NUMBER(7,2) ;
v_Null NUMBER := NULL ;
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 ;

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_name emp.name_id%TYPE ;
Emp_rec emp%ROWTYPE ;
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 ;

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;

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;
/

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

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

 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è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)).

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

oracle : le PL-SQL

Contenu connexe

Tendances (18)

En vedette (20)

Similaire à oracle : le PL-SQL (20)

Dernier (20)

oracle : le PL-SQL