57041482-DRAFTPLSQLA-MODULE-1-2003-08-07-0

Auteur : Thibault BLANCHARD Version 1.3 7 aot 2003 Nombre de pages : 103

Ecole Suprieure dInformatique de Paris 23. rue Chteau Landon 75010 PARIS www.supinfo.com

Module n1 PL/SQL AVANCE

PL/SQL Avanc 2 / 103

Table des matires 1. APERU DU PL/SQL ...................................................................................................................................... 7 1.1. LA SOLUTION COMPLETE DORACLE ............................................................................................................. 7 1.2. LES PROGRAMMES EN PL/SQL ..................................................................................................................... 7

1.2.1. Les modles de programme en PL/SQL ................................................................................................ 7 1.2.2. Structure dun bloc PL/SQL anonyme................................................................................................... 7 1.2.3. Structure dun sous-programme PL/SQL.............................................................................................. 8 1.2.4. Avantages des sous-programmes .......................................................................................................... 8

1.3. LES ENVIRONNEMENTS DE DEVELOPPEMENT ................................................................................................ 8 1.3.1. SQL*Plus et Procedure Builder ............................................................................................................ 8 1.3.2. Dvelopper des fonctions et procdures avec SQL*Plus ...................................................................... 9 1.3.3. Dvelopper en utilisant Oracle Procedure Builder............................................................................... 9

1.4. APPEL DE FONCTIONS ET DE PROCEDURES..................................................................................................... 9 2. UTILISATION DE PROCEDURE BUILDER............................................................................................. 10 2.1. PROCEDURE BUILDER ................................................................................................................................. 10

2.1.1. Les composants de Procedure Builder................................................................................................ 10 2.1.2. Dvelopper des units de programmes et des units de programmes stocks..................................... 10 2.1.3. Le navigateur dobjets......................................................................................................................... 10 2.1.4. Lditeur dunits de programmes ...................................................................................................... 11 2.1.5. Lditeur dunits de programmes stockes ........................................................................................ 12

2.2. UTILISATION DE PROCEDURE BUILDER ....................................................................................................... 12 2.2.1. Cration dune unit de programme cliente........................................................................................ 12 2.2.2. Cration dune unit de programme serveur ...................................................................................... 12 2.2.3. Transfrer les programmes entre le client et le serveur...................................................................... 12

2.3. LINTERPRETEUR PL/SQL .......................................................................................................................... 12 2.4. LE PACKAGE TEXT_IO .............................................................................................................................. 13

3. CREATION DE PROCEDURES................................................................................................................... 14 3.1. APERU DES PROCEDURES .......................................................................................................................... 14 3.2. CREER DES PROCEDURES............................................................................................................................. 14

3.2.1. La syntaxe de cration de procdures................................................................................................. 14 3.2.2. Les modes de paramtres de la procdure.......................................................................................... 14 3.2.3. Dvelopper des procdures stockes................................................................................................... 15 3.2.4. Dvelopper une procdure en utilisant SQL*Plus .............................................................................. 15 3.2.5. Dvelopper une procdure en utilisant procedure builder ................................................................. 15

3.3. PROCEDURES ET PARAMETRES .................................................................................................................... 16 3.3.1. Cration de procdures avec des paramtres ..................................................................................... 16 3.3.2. Le paramtre IN .................................................................................................................................. 16 3.3.3. Le paramtre OUT .............................................................................................................................. 17 3.3.4. Le paramtre IN OUT ......................................................................................................................... 18 3.3.5. Passer des paramtres ........................................................................................................................ 19

3.4. LES SOUS PROGRAMMES.............................................................................................................................. 20 3.4.1. Dclarer des sous-programmes .......................................................................................................... 20 3.4.2. Invoquer une procdure depuis un bloc anonyme............................................................................... 21 3.4.3. Invoquer une procdure depuis une procdure stocke ...................................................................... 21

3.5. GESTION DES EXCEPTIONS........................................................................................................................... 22 3.5.1. Exceptions traites .............................................................................................................................. 22 3.5.2. Exceptions non traites ....................................................................................................................... 22

3.6. SUPPRIMER DES PROCEDURES ..................................................................................................................... 22 3.7. SUPPRIMER DES PROCEDURES SERVEUR ...................................................................................................... 22 3.8. SUPPRIMER DES PROCEDURES CLIENT ......................................................................................................... 23

4. CREATION DE FONCTIONS ...................................................................................................................... 24 4.1. LES FONCTIONS........................................................................................................................................... 24

http://www.labo-oracle.com Ce document est la proprit de Supinfo et est soumis aux rgles de droits dauteurs

4.1.1. Aperu des fonctions stockes ............................................................................................................. 24


4.1.2. Syntaxe pour la cration de fonctions ................................................................................................. 24 4.1.3. Cration de fonction............................................................................................................................ 25

4.2. LES FONCTIONS DANS SQL*PLUS ............................................................................................................... 25 4.2.1. Cration de fonctions stockes............................................................................................................ 25 4.2.2. Excuter des fonctions......................................................................................................................... 25

4.3. LES FONCTIONS DANS PROCEDURE BUILDER .............................................................................................. 26 4.3.1. Cration de fonction............................................................................................................................ 26 4.3.2. Exemple de cration de fonction ......................................................................................................... 26 4.3.3. Excuter des fonctions......................................................................................................................... 26

4.4. LES FONCTIONS DEFINIES PAR LUTILISATEUR DANS DU SQL ..................................................................... 27 4.4.1. Avantages des fonctions dans des expressions SQL............................................................................ 27 4.4.2. Emplacements do appeler les fonctions ........................................................................................... 27 4.4.3. Appel de fonctions : restrictions.......................................................................................................... 27

4.5. SUPPRIMER DES FONCTIONS ........................................................................................................................ 28 4.5.1. Supprimer des fonctions serveur ......................................................................................................... 28 4.5.2. Supprimer des fonctions client ............................................................................................................ 28

4.6. PROCEDURE OU FONCTION ? ....................................................................................................................... 29 4.6.1. Rcapitulatif ........................................................................................................................................ 29 4.6.2. Comparaison entre procdures et fonctions........................................................................................ 29 4.6.3. Les avantages des procdures et fonctions stockes ........................................................................... 29

5. CREATION DE PACKAGES........................................................................................................................ 30 5.1. LES PACKAGES ............................................................................................................................................ 30

5.1.1. Aperu des packages ........................................................................................................................... 30 5.1.2. Les composantes dun packages ......................................................................................................... 30 5.1.3. Rfrencer les objets dun package..................................................................................................... 31

5.2. CREER DES PACKAGES................................................................................................................................. 32 5.2.1. Dveloppement dun package ............................................................................................................. 32 5.2.2. Cration des spcifications du package .............................................................................................. 32 5.2.3. Dclaration dlments publics........................................................................................................... 32 5.2.4. Cration de spcification de package : exemple ................................................................................. 32 5.2.5. Cration du corps du package ............................................................................................................ 33 5.2.6. Elments publics et privs ................................................................................................................... 33 5.2.7. Cration de corps de package : exemple............................................................................................. 34 5.2.8. Directives pour dvelopper des packages ........................................................................................... 34 5.2.9. Les variables globales......................................................................................................................... 34

5.3. MANIPULER LES PACKAGES ........................................................................................................................ 35 5.3.1. Excuter une procdure publique dun package ................................................................................. 35 5.3.2. Invoquer des lments de packages..................................................................................................... 35 5.3.3. Rfrencer une variable publique partir dune procdure autonome .............................................. 36 5.3.4. Supprimer des packages...................................................................................................................... 37 5.3.5. Avantages des packages ...................................................................................................................... 37

6. COMPLEMENTS SUR LES PACKAGES................................................................................................... 39 6.1. LA SURCHARGE........................................................................................................................................... 39 6.2. LES DECLARATIONS ANTICIPEES ................................................................................................................. 40 6.3. CREATION DUNE PROCEDURE A USAGE UNIQUE ......................................................................................... 41 6.4. RESTRICTIONS SUR LES FONCTIONS DE PACKAGE EN SQL........................................................................... 42 6.5. INVOQUER UNE FONCTION DUN PACKAGE DEFINIT PAR LUTILISATEUR DANS UN ORDRE SQL .................. 42 6.6. LETAT PERSISTANT .................................................................................................................................... 43

6.6.1. Les packages de variables................................................................................................................... 43 6.6.2. Les packages de curseurs.................................................................................................................... 43 6.6.3. Les packages de tables et records PL/SQL ......................................................................................... 44

7. PACKAGES FOURNIS PAR ORACLE....................................................................................................... 46 7.1. LES PACKAGES FOURNIT PAR ORACLE ........................................................................................................ 46 7.2. LE PACKAGE DBMS_PIPE ......................................................................................................................... 46

7.2.1. La composition de DBMS_PIPE ......................................................................................................... 46 7.2.2. Les fonctions de DBMS_PIPE............................................................................................................. 46


7.2.3. Exemple dutilisation de DBMS_PIPE................................................................................................ 47


7.3. LE SQL DYNAMIQUE................................................................................................................................... 47 7.3.1. Dfinition ............................................................................................................................................ 47 7.3.2. Le flux dexcution .............................................................................................................................. 47 7.3.3. Le package DBMS_SQL...................................................................................................................... 48 7.3.4. Utilisation de DMBS_SQL .................................................................................................................. 48 7.3.5. EXECUTE IMMEDIATE..................................................................................................................... 49 7.3.6. Utilisation de EXECUTE IMMEDIATE.............................................................................................. 50

7.4. LES AUTRES PACKAGES DISPONIBLES.......................................................................................................... 50 7.4.1. Le package DBMS_DDL..................................................................................................................... 50 7.4.2. Le package DBMS_JOB...................................................................................................................... 50 7.4.3. Le package DBMS_OUTPUT. ............................................................................................................ 51 7.4.4. Dautres packages fournit par Oracle ................................................................................................ 51

8. CREATION DE TRIGGERS DE BASE DE DONNEES ............................................................................ 53 8.1. LES TRIGGERS DE BASE DE DONNEES........................................................................................................... 53

8.1.1. Aperu des triggers ............................................................................................................................. 53 8.1.2. Directives de conception des triggers ................................................................................................. 53 8.1.3. Exemple de trigger de base de donnes .............................................................................................. 54 8.1.4. Cration de triggers ............................................................................................................................ 54

8.2. LES COMPOSANTES DUN TRIGGER.............................................................................................................. 54 8.2.1. La synchronisation du trigger ............................................................................................................. 54 8.2.2. Lvnement dclenchant .................................................................................................................... 55 8.2.3. Le type de trigger ................................................................................................................................ 55 8.2.4. Le corps du trigger.............................................................................................................................. 55

8.3. LA SEQUENCE DE DECLENCHEMENT............................................................................................................ 55 8.4. CREATION DE STATEMENT TRIGGER........................................................................................................... 56

8.4.1. Syntaxe de cration de Statement triggers .......................................................................................... 56 8.4.2. Cration avec SQL*Plus ..................................................................................................................... 56 8.4.3. Cration avec Procedure Builder........................................................................................................ 57 8.4.4. Test de SECURE_EMP ....................................................................................................................... 57 8.4.5. Utilisation dattributs conditionnels ................................................................................................... 58

8.5. CREATION DE ROW TRIGGERS..................................................................................................................... 58 8.5.1. Syntaxe de cration dun Row Trigger................................................................................................ 58 8.5.2. Cration avec SQL*Plus ..................................................................................................................... 59 8.5.3. Cration avec Procedure Builder........................................................................................................ 60 8.5.4. Utilisation des qualificatifs OLD et NEW ........................................................................................... 60 8.5.5. Valeurs de OLD et NEW ..................................................................................................................... 60 8.5.6. Restreindre un trigger de ligne ........................................................................................................... 61

8.6. TRIGGER INSTEAD OF.............................................................................................................................. 61 8.6.1. Intrt des triggers INSTEAD OF....................................................................................................... 61 8.6.2. Cration dun trigger INSTEAD OF................................................................................................... 62

8.7. DIFFERENCE ENTRE LES TRIGGERS ET LES PROCEDURES STOCKEES............................................................. 62 8.8. GESTION DES TRIGGERS .............................................................................................................................. 63

8.8.1. Activation des triggers ........................................................................................................................ 63 8.8.2. Suppression de triggers....................................................................................................................... 63

8.9. TEST DE TRIGGERS ...................................................................................................................................... 63 8.9.1. Cas tester.......................................................................................................................................... 63 8.9.2. Modle dexcution de trigger et vrification de contrainte ............................................................... 64

8.10. INTERACTIONS ............................................................................................................................................ 64 8.10.1. Une dmonstration type ...................................................................................................................... 64 8.10.2. La table daudit ................................................................................................................................... 64 8.10.3. Les triggers ......................................................................................................................................... 65 8.10.4. Spcifications du package VAR_PACK............................................................................................... 65 8.10.5. Procdure............................................................................................................................................ 66

9. COMPLEMENTS SUR LES TRIGGERS.................................................................................................... 68 9.1. CREATION DE TRIGGERS SUR DES EVENEMENTS UTILISATEUR..................................................................... 68 9.2. CREATION DE TRIGGERS SUR DES EVENEMENTS SYSTEMES ......................................................................... 68 9.3. DES EXEMPLES DES TRIGGER LOG ON ET LOG OFF ..................................................................................... 69


9.4. LA DECLARATION CALL ............................................................................................................................ 69


9.5. LES TABLES EN COURS DE MODIFICATIONS ................................................................................................. 70 9.5.1. Lecture de donne dans une table en cours de modifications ............................................................. 70 9.5.2. Exemple de table en cours de modifications ....................................................................................... 70

9.6. FONCTIONS DES TRIGGERS .......................................................................................................................... 71 9.6.1. Scuriser le serveur............................................................................................................................. 71 9.6.2. Audit .................................................................................................................................................... 72 9.6.3. Garantir lintgrit des donnes ......................................................................................................... 73 9.6.4. Garantir lintgrit rfrentielle ......................................................................................................... 74 9.6.5. Dupliquer les tables ............................................................................................................................ 75 9.6.6. Utiliser des donnes drives.............................................................................................................. 76 9.6.7. Grer les logs dvnements avec les triggers .................................................................................... 77 9.6.8. Avantages des triggers de base de donnes ........................................................................................ 77

10. GERER LES SOUS PROGRAMMES ET LES TRIGGERS........................................................... 78 10.1. PRIVILEGES ................................................................................................................................................. 78

10.1.1. Privilges systmes.............................................................................................................................. 78 10.1.2. Privilges objets .................................................................................................................................. 78

10.2. ACCORDER DES ACCES AUX DONNEES......................................................................................................... 78 10.3. SPECIFIER LES DROITS DES UTILISATEURS ................................................................................................... 79 10.4. GERER LES OBJETS PL/SQL STOCKES ......................................................................................................... 79 10.5. INFORMATIONS SUR LOBJET....................................................................................................................... 80

10.5.1. USER_OBJECTS................................................................................................................................. 80 10.5.2. Lister toutes les procdures et fonctions ............................................................................................. 80

10.6. TEXTE DE LA PROCEDURE ........................................................................................................................... 81 10.6.1. La vue du dictionnaire de donnes USER_SOURCE.......................................................................... 81 10.6.2. Lister le code de toute les procdures et fonctions.............................................................................. 81 10.6.3. Lister le code des procdures stockes avec procdure builder.......................................................... 82

10.7. TEXTE DUN TRIGGER.................................................................................................................................. 82 10.7.1. USER_TRIGGERS .............................................................................................................................. 82 10.7.2. Lister le code des triggers ................................................................................................................... 83

10.8. LES PARAMETRES........................................................................................................................................ 83 10.8.1. DESCRIBE dans SQL*Plus ................................................................................................................ 83 10.8.2. La commande .DESCRIBE sous procdure builder............................................................................ 84

10.9. ERREURS DE COMPILATION ......................................................................................................................... 84 10.9.1. Dtecter les erreurs de compilation avec lditeur de programme stock .......................................... 84 10.9.2. USER_ERRORS .................................................................................................................................. 84 10.9.3. Dtecter les erreurs de compilation : exemple.................................................................................... 85

10.10. INFORMATIONS SUR LE DEBUGGAGE................................................................................................... 86 10.10.1. Dbugger en utilisant le package DBMS_OUTPUT........................................................................... 86 10.10.2. Dbugger les sous programmes en utilisant procedure builder.......................................................... 86 10.10.3. Crer des breakpoints ......................................................................................................................... 87 10.10.4. Utiliser les niveaux de dbuggages..................................................................................................... 87 10.10.5. Contrler lexcution des programmes............................................................................................... 88

11. GERER LES DEPENDANCES........................................................................................................... 89 11.1. OBJETS DEPENDANTS ET REFERENCES......................................................................................................... 89

11.1.1. Comprendre les dpendances.............................................................................................................. 89 11.1.2. Les dpendances directes et indirectes ............................................................................................... 89 11.1.3. Les dpendances locales ..................................................................................................................... 89 11.1.4. Les dpendances distantes .................................................................................................................. 89 11.1.5. Un scnario de dpendances locales................................................................................................... 90

11.2. VISUALISER LES DEPENDANCES .................................................................................................................. 90 11.2.1. Afficher les dpendances directes avec USER_DEPENDENCIES ..................................................... 90 11.2.2. Afficher les dpendances directes et indirectes................................................................................... 91 11.2.3. Afficher les dpendances..................................................................................................................... 91

11.3. UN SCENARIO DE DEPENDANCES DE NOM LOCALES..................................................................................... 91 11.4. DEPENDANCES DISTANTES .......................................................................................................................... 92

11.4.1. Recompilation des dpendances.......................................................................................................... 92 11.4.2. Concept de dpendances distantes ...................................................................................................... 92


11.4.3. Scnario de dpendance distante en mode Timestamp ....................................................................... 93


11.4.4. Le mode de signature .......................................................................................................................... 93 11.5. RECOMPILATION MANUELLE ....................................................................................................................... 94

11.5.1. Recompiler un programme PL/SQL.................................................................................................... 94 11.5.2. Echec de recompilation....................................................................................................................... 94 11.5.3. Recompilation russie ......................................................................................................................... 94 11.5.4. Recompiler les procdures .................................................................................................................. 94

11.6. PACKAGES ET DEPENDANCES ...................................................................................................................... 95 12. MANIPULER LES LARGES OBJECTS........................................................................................... 96 12.1. LES LOBS ................................................................................................................................................... 96

12.1.1. Quest-ce quun LOB .......................................................................................................................... 96 12.1.2. Opposition entre les types de donnes LONG et LOB......................................................................... 96 12.1.3. Anatomie dun LOB............................................................................................................................. 96

12.2. LOBS INTERNES ET EXTERNES .................................................................................................................... 97 12.2.1. Les LOBs internes ............................................................................................................................... 97 12.2.2. Grer les LOBs internes...................................................................................................................... 97 12.2.3. Les LOBs externes............................................................................................................................... 97 12.2.4. Dfinir les BFILEs .............................................................................................................................. 97

12.3. LE PACKAGE DBMS_LOB.......................................................................................................................... 98 12.3.1. Utilisation de DBMS_LOB.................................................................................................................. 98 12.3.2. Fonctions et procdures de DBMS_LOB ............................................................................................ 98 12.3.3. DBMS_LOB READ et WRITE............................................................................................................. 99 12.3.4. Exemple de cration de table avec des LOBs...................................................................................... 99

12.4. MANIPULER DES LOBS EN SQL.................................................................................................................. 99 12.4.1. Insertion en utilisant SQL ................................................................................................................... 99 12.4.2. Mise jour des LOBs en utilisant SQL ............................................................................................. 100 12.4.3. Mise jour en utilisant DBMS_LOB ................................................................................................ 100 12.4.4. Slectionner les valeurs CLOB ......................................................................................................... 101 12.4.5. Exemple de suppression de LOBs ..................................................................................................... 102

12.5. LES LOBS TEMPORAIRES .......................................................................................................................... 103



1. Aperu du PL/SQL 1.1. La solution complte dOracle

La solution Oracle est constitue de plusieurs outils reconnaissant et soumettant des ordres SQL et PL/SQL au serveur pour tre excutes. Ces outils possdent leur propre langage de commandes.

Figure 1 : Architecture de la solution complte Oracle

1.2. Les programmes en PL/SQL 1.2.1. Les modles de programme en PL/SQL

Les programmes crits en PL/SQL respectent tous une structure en blocs prdtermins (Cf. Module n4 Notion de base du PL/SQL $1.3 Les structures de programme PL/SQL ). Les diffrents modles de programme (blocs anonymes, procdures et fonctions stockes, trigger, package) sont donc construits suivant un mme modle. Tous les blocs dun programme PL/SQL peuvent tre spars et imbriqus les uns dans les autres. Donc un bloc peut reprsenter une petite partie dun autre bloc qui est lui-mme une partie du code du programme.

1.2.2. Structure dun bloc PL/SQL anonyme Un bloc anonyme est un bloc ne possdant pas de noms. Ces blocs sont dclars lendroit o ils vont tre excuts dans une application. Ils sont passs au moteur PL/SQL lors de lexcution du programme.

[DECLARE] [] BEGIN [EXCEPTION] ] END;


Les mots cls DECLARE, BEGIN et EXCEPTION ne sont pas suivis dun point virgule, seul END et les autres ordres PL/SQL ncessitent un point virgule.


1.2.3. Structure dun sous-programme PL/SQL Un sous programme PL/SQL est un bloc nomm qui peut prendre des paramtres et tre invoqu dans dautres blocs. Il existe deux types de sous programmes : les procdures et les fonctions.

Header IS|AS [] BEGIN [EXCEPTION] ] END;

La section Header dtermine la manire dont le sous programme va tre appele ou invoque. Cette section dtermine galement le type du sous programme (procdure ou fonction), la liste des paramtres si il y en a, la clause RETURN qui sapplique uniquement aux fonctions. Le mot cl IS est obligatoire. Il ne faut pas utiliser le mot cl DECLARE car la section dclarative se situe entre le IS et le BEGIN. Pour le reste du code, il se comporte de la mme manire que pour les blocs PL/SQL anonymes.

1.2.4. Avantages des sous-programmes Les procdures et fonctions stockes ont des avantages en plus du dveloppement modulaire des applications. Les sous programmes permettent damliorer :

la maintenance : Modification des routines on-line sans interfrer avec les autres utilisateurs Modification dune routine pour agir sur plusieurs applications Modification dune routine pour liminer les tests en double

lintgrit et la scurit des donnes : Contrle des accs indirects aux objets de la base de donnes par des utilisateurs ne possdant pas des privilges de scurit Sassure que les actions lies sont excutes ensemble, ou pas du tout, en centralisant lactivit des tables lies dans un seul rpertoire

les performances : Evite de re-parcourir les lignes pour diffrents utilisateurs en exploitant la zone SQL partage Evite de parcourir le bloc PL/SQL pendant lexcution en le parcourant lors de la compilation Rduit le nombre dappels la base de donnes et diminue le trafic rseau en envoyant les commandes par paquets

1.3. Les environnements de dveloppement 1.3.1. SQL*Plus et Procedure Builder

Le PL/SQL nest pas proprement parl un produit Oracle. Cest une technologie utilise par le serveur Oracle et par certains outils de dveloppement Oracle, les blocs de PL/SQL sont passs et traits par un moteur PL/SQL. Ce moteur peut tre inclus dans loutil de dveloppement ou dans le serveur Oracle. Les deux principaux outils de dveloppement sont SQL*Plus et Procedure Builder.


SQL*Plus utilise le moteur PL/SQL du serveur Oracle alors que Procedure Builder utilise le moteur PL/SQL de loutil client ou le moteur du serveur Oracle.


1.3.2. Dvelopper des fonctions et procdures avec SQL*Plus Il y a deux moyens pour crire des blocs PL/SQL dans SQL*Plus. On peut les stocker dans le buffer SQL*Plus et ensuite lexcuter partir de SQL*Plus ou bien les stocker dans un script SQL*Plus et ensuite excuter le fichier grce la commande EXECUTE.

1.3.3. Dvelopper en utilisant Oracle Procedure Builder Procedure Builder est un outil que lon peut utiliser pour crer, excuter et dbugger des programmes PL/SQL utiliss dans vos application ou sur le serveur Oracle par le biais de son interface graphique. Lenvironnement de dveloppement Procedure Builder possde un diteur intgr avec lequel il est possible de crer et dditer des sous programmes. Il est possible de compiler, tester et dbugger son code grce cet outil.

Figure 1 : Linterface de Procedure Builder

1.4. Appel de fonctions et de procdures Les procdures et fonctions stockes peuvent tre appeles depuis plusieurs environnements : SQL*Plus : Oracle Developer, Oracle Discoverer, WebDB , une autre procdure stocke et de nombreux outils Oracle et applications de prcompilation. Pour lancer une procdure ou fonction depuis SQL*Plus il faut utiliser la commande EXECUTE suivie du nom du fichier dans lequel elle est stocke. Avec Oracle discoverer et Oracle Developer il suffit de spcifier le nom du fichier script. Pour excuter une procdure lintrieur dune autre, il faut simplement donner le nom de la procdure au moment voulu. Exemple :

CREATE OR REPLACE PROCEDURE leave_emp (v_id IN emp.empno%TYPE) IS BEGIN DELETE FROM emp WHERE empno = v_id; exec_proc; END leave_emp;


-> Ce code cr une procdure qui efface les lignes dont le EMPNO corresponds au V_ID entr en paramtre. Aprs la suppression, on fait appel la procdure nomme EXEC_PROC. La structure de cration de procdure sera explique plus loin dans ce module.


2. Utilisation de Procedure Builder 2.1. Procedure Builder

2.1.1. Les composants de Procedure Builder Procedure Builder est un environnement de dveloppement intgr qui permet dditer, de compiler de tester et de dbugger des units de programmes PL/SQL client et serveur avec un seul et mme outil. Toutes ces fonctionnalits sont possibles grce aux diffrents composants intgrs dans Procedure Builder.

Composant Utilisation Explorateur dobjet Permet de grer les ensembles, et deffectuer

des oprations de dbuggage Interprteur PL/SQL Permet de dbugger du code PL/SQL, et

dvaluer du code PL/SQL en temps rel Editeur dunits de programmes

Permet de crer et dditer du code source PL/SQL

Editeur dunits de programmes stocks

Permet de crer et dditer du code source PL/SQL cot serveur

Editeur de trigger de base de donnes

Permet de crer et dditer des triggers de base de donnes

2.1.2. Dvelopper des units de programmes et des units de programmes stocks

Procedure Builder permet de dvelopper des sous programmes PL/SQL pouvant tre utiliss dans des applications clientes ou serveurs. Les units de programmes sont des sous programmes PL/SQL qui sont utilises avec des applications clientes, tel que Oracle Developer. Les units de programmes stockes sont des sous programmes PL/SQL que lon peut utiliser avec toutes les applications, clientes ou serveurs. Le code PL/SQL est perdu lorsque lon ferme Procedure Builder sauf si lon sauvegarde le code sur le serveur, dans la librairie PL/SQL ou si on lexporte dans un fichier. Il existe plusieurs faons de dvelopper du code PL/SQL dans Procedure Builder : Pour un code ct client, on peut crer lunit de programme en utilisant lditeur dunit de programme ou faire un glisser-dposer dune unit de programme ct serveur vers le client en utilisant lexplorateur dobjet. Pour un code ct serveur, on peut crer lunit de programme en utilisant lditeur dunits de programmes stocks ou faire un glisser-dposer dune unit de programme ct serveur vers le serveur en utilisant lexplorateur dobjet.

2.1.3. Le navigateur dobjets Lexplorateur dobjet est un navigateur qui permet de trouver et de travailler avec des units de programmes clients et serveurs ainsi que des librairies et des triggers. Il est possible de dvelopper et rduire larborescence, copier et coller, chercher un objet et glisser-dposer des units de programme PL/SQL entre les cts client et serveur.



Figure 1 : Aperu de lexplorateur dobjets

On peut distinguer plusieurs lments important dans la fentre du navigateur : Lindicateur demplacement (1) : il indique lemplacement actuel dans la hirarchie Lindicateur de sous-objet (2) : permet de dvelopper ou de rduire les nuds pour voir o cacher les informations sur les objets. Les diffrentes classes dobjets sont reprsentes par diffrentes icnes. Licne de type (3) : indique le type de lobjet, suivi du nom de lobjet. Dans lexemple, licne indique que LOG_EXECUTION est un bloc PL/SQL. Si on double-clique sur licne, Procedure Builder ouvre lditeur dunit de programme avec le code de cet objet. Le nom de lobjet (4) : affiche le nom de lobjet Le champs de recherche (5) : permet de chercher des objets

2.1.4. Lditeur dunits de programmes Lditeur dunits de programme permet dditer, de compiler et de parcourir les warning et les erreurs pendant le dveloppement de sous programmes PL/SQL clients.


Figure 2 : Aperu de lditeur dunit de programme


La zone (1) contient tous les diffrents boutons utiliss pour crer et dbugger des units de programmes (Compile, Apply, Revert, New, Delete, Close et Help). Le nom du programme est affich dans la zone (2) et le code source de la procdure est situ dans la zone (3). Pour amener le code dun sous programme dans le panneau de code source, il faut choisir le nom dans la liste droulante du champ Name.

2.1.5. Lditeur dunits de programmes stockes Lditeur dunits de programmes stocks se prsente comme lditeur dcrit prcdemment lexception que dans ce cas lopration de sauvegarde envoie le code source au compilateur PL/SQL du serveur.

2.2. Utilisation de Procedure Builder 2.2.1. Cration dune unit de programme cliente

Pour crer une unit de programme ct client, il faut slectionner lobjet Program Unit ou un sous objet dans lexplorateur dobjet. Ensuite clique sur Create pour faire apparatre la bote de dialogue New Program Unit. Dans celle-ci, on choisit le nom du programme ainsi que son type puis on valide pour afficher lditeur dunit de programme. Lditeur contient le squelette du modle PL/SQL. Le curseur est automatiquement positionn la ligne suivant le BEGIN. Une fois le code crit, on le compile en cliquant sur le bouton Compile. Les messages derreurs gnrs lors de la compilation sont affichs dans le panneau de messages de compilation. Lorsque lon slectionne une erreur, le curseur se dplace lendroit de lerreur dans la fentre du programme. Lorsque le programme sest bien compil, le message Successfully Compiled est affich dans la ligne de statut de lditeur. Les units de programmes rsidant dans larborescence sont perdues si lon quitte Procedure Builder. Il faut les exporter vers un fichier, les enregistrer dans une librairie PL/SQL ou les stocker dans la base de donnes pour ne pas les perdre.

2.2.2. Cration dune unit de programme serveur Pour crer une unit de programme ct serveur, la procdure est la mme que pour une unit de programme ct client, mais cette fois-ci, il faut slectionner lobjet Stored Program Unit dans le nud Database Objects de larborescence.

2.2.3. Transfrer les programmes entre le client et le serveur Avec Procedure Builder, il est galement possible de copier des units de programme crs sur le client en units de programme stockes sur le serveur (et vice et versa). On peut le faire en dplaant lunit de programme vers lunit de programme stocke de destination dans larborescence Le code PL/SQL stock sur le serveur est trait par le moteur PL/SQL du ct serveur, donc une requte SQL contenue dans une unit de programme na pas besoin dtre transfre entre une application client et le serveur. Les units de programmes stockes sur le serveur sont potentiellement accessibles toutes les applications mais en fonction des privilges de scurit de lutilisateur.

2.3. Linterprteur PL/SQL Linterprteur PL/SQL est un outil de Procedure Builder permettant dexcuter directement des units de programme PL/SQL.



Figure 3 : Linterprteur PL/SQL

Linterprteur est compos de trois fentres : la premire affiche le code source du programme, la seconde contient les mmes informations que lexplorateur dobjets et enfin la dernire permet dexcuter des sous programmes, des commandes de Procedure Builder et des requtes SQL. Pour excuter des sous programmes il faut entrer le nom du programme au prompt PL/SQL, spcifier des paramtres si besoin, et ajouter un point virgule.

PL/SQL> nom_programme [paramtre1|paramtre2,] ; Pour excuter un ordre SQL, il suffit dentrer cet ordre et de placer un point-virgule la fin.

2.4. Le package TEXT_IO TEXT_IO est un package, faisant partie de Procedure Builder et ne pouvant tre utilis que par des fonctions et procdures ct client. Il permet de grer les entres/sorties de texte. Ce package inclut une procdure PUT_LINE qui crit des informations dans la fentre de linterprteur PL/SQL. Cette procdure accepte un seul paramtre qui correspond au texte que lon veut afficher. Exemple :

PL/SQL> TEXT_IO.PUT_LINE(Ce texte sera affich) : Ce texte sera affich


Ce package est trs utile pour effectuer des dbuggages de procdures clientes. En revanche, pour dbugger un procdure du serveur il faut utiliser le package fournit par Oracle DBMS_OUTPUT, car TEXT_IO produira des erreurs de compilation sur le serveur. Le package DBMS_OUTPUT naffiche pas de messages dans la fentre de linterprteur PL/SQL si lon excute une procdure depuis Procedure Builder.


3. Cration de procedures 3.1. Aperu des procdures

Une procdure est un bloc PL/SQL nomm qui peut prendre des paramtres (quon appelle aussi arguments) et tre invoqu. Comme dcrit prcdemment une procdure est constitue dun en-tte, une section dclarative, une section excutable, et une section de gestion dexception optionnelle. Les procdures facilitent la rutilisation et la manipulation du code car une fois enregistre, une procdure peut tre utilise par plusieurs autres applications. Si la dfinition change, seule la procdure est affecte ce qui simplifie la maintenance.

3.2. Crer des procdures 3.2.1. La syntaxe de cration de procdures

Pour crer une procdure, on utilise lexpression CREATE PROCEDURE qui dfinit les actions qui seront excutes par le bloc PL/SQL. Cette expression peut dfinir une liste de paramtres.

CREATE [OR REPLACE] PROCEDURE procedure_name (parameter1 [mode1] datatype1, parameter2 [mode2] datatype2, ) IS|AS Bloc PL/SQL

Le bloc PL/SQL commence par un BEGIN ou la dclaration des variables locales et se termine par END ou END procedure_name. Il est impossible de faire rfrence des variables htes ou des variables de substitution. Loption REPLACE indique que si la procdure existe dj, elle sera supprime et remplace par celle cre par la requte. Dfinitions de la syntaxe :

Paramtre Description Procedure_name Nom de la procdure Parameter Nom de la variable PL/SQL qui est passe, retourne

lenvironnement appelant, ou les deux suivant le mode choisit

Mode Type de largument : IN (par dfaut) OUT IN OUT

Datatype Type de donne de largument Bloc PL/SQL Corps de la procdure dfinissant les actions effectuer

3.2.2. Les modes de paramtres de la procdure Les paramtres de la procdure permettent de transfrer des valeurs depuis et vers lenvironnement appelant. Les paramtres possdent chacun trois modes : IN, OUT et IN OUT.



Type de paramtre

Description

IN (par dfaut) Une valeur constante est passe de lenvironnement appelant vers la procdure

OUT Une valeur est passe de la procdure vers lenvironnement appelant

IN OUT Une valeur constante est passe de lenvironnement appelant vers la procdure et une valeur diffrente peut tre renvoye lenvironnement en utilisant le mme paramtre.

3.2.3. Dvelopper des procdures stockes Pour dvelopper une procdure stocke, il faut tout dabord choisir un environnement de dveloppement tel que Procedure Builder ou SQL*Plus. Ensuite il faut saisir le code en utilisant la syntaxe dfinie prcdemment. Sous Procedure Builder on utilise lditeur dunit de programme et sous SQL*Plus, on entre le texte dans un diteur de texte puis on le sauvegarde en fichier script.* Enfin il faut compiler le code en p-code (pseudo-code). Avec Procedure Builder il faut juste cliquer sur Save et sous SQL*Plus il faut excuter le fichier script.

3.2.4. Dvelopper une procdure en utilisant SQL*Plus Pour la cration de procdure avec SQL*Plus il faut dabord taper le texte de la requte CREATE PROCEDURE dans un diteur de texte puis lenregistrer en fichier script. Ensuite, pour le compiler en p-code, il suffit de lexcuter depuis SQL*Plus. Si le terminal renvoie une ou plusieurs erreurs de compilation, la commande SHOW ERRORS permet de les afficher. Lorsque le script est compil sans erreur, il peut tre excut depuis lenvironnement du serveur Oracle. Un fichier script avec la requte CREATE PROCEDURE (ou CREATE FUNCTION) permet de faire des changements directement dans le fichier si il y a des erreurs de compilation ou de faire des modifications ultrieures. Si une procdure a t compile et quil retourne des erreurs de compilation, elle ne pourra pas tre invoque correctement. Il faut donc sassurer du bon droulement de la compilation avant de linvoquer. Lors de lexcution, la commande CREATE PROCEDURE (ou CREATE FUNCTION) stocke le code source dans le dictionnaire de donne mme si la procdure contient des erreurs de compilation. Si lon veut effectuer des changements, le mieux est donc dutiliser loption OR REPLACE ou bien il faut faire un DROP de la procdure.

3.2.5. Dvelopper une procdure en utilisant procedure builder

Cration dune procdure client Grce au moteur PL/SQL intgr dans lapplication Procedure Builder, il est possible de dvelopper des procdures ct client. Pour cela il faut choisir le nud Program Units dans larborescence de lexplorateur dobjet puis cliquer sur Create pour faire apparatre la bote de dialogue de cration dune nouvelle unit de programme. On entre le nom de la procdure en slectionnant le type Procedure (qui est celui slectionn par dfaut). Aprs validation, la fentre de lditeur de programme apparat avec le nom de la procdure et les mots cls IS, BEGIN et END. Le curseur est positionn automatiquement la ligne suivant le BEGIN. Une fois le code source entr, on clique sur Compile. Les messages derreurs gnrs durant la compilation sont affichs dans la fentre de messages de compilation. Lorsque lon slectionne un message derreur dans la fentre, le curseur se positionne automatiquement lendroit de lerreur dans le code source. Si la compilation seffectue correctement, un message le prcisant est affich dans la fentre de lditeur de programme. On peut ensuite sauvegarder le code dans un fichier en slectionnant Export dans le menu File.


Dans Procedure Builder, les mots cls CREATE et CREATE OR REPLACE ne peuvent pas tre utiliss.


Cration dune procdure serveur On peut galement utiliser le moteur PL/SQL du serveur pour dvelopper des applications ct serveur. Pour cela il faut tout dabord se connecter (File Connect) la base de donne en utilisant son nom dutilisateur et son mot de passe. Ensuite on dveloppe le nud Database Objects dans lexplorateur dobjets afin de faire apparatre le nom de notre schma pour le dvelopper son tour. On slectionne ensuite le nud Stored Program Units de ce schma et on clique sur Create pour pouvoir saisir le code source de cette procdure. Le reste de la cration de procdures stockes se droulent comme dcrit prcdemment pour les procdures. Une fois le code source compil, on clique sur Save pour sauvegarder la procdure sur le serveur.

Naviguer dans les erreurs de compilation Procedure Builder affiche les erreurs de compilation dans un panneau spar qui permet au dveloppeur de dbugger facilement son code. Lorsque lon slectionne une erreur dans ce panneau, le curseur se place automatiquement lendroit de lerreur dans le code source. Une fois lerreur rsolue, on recompile la procdure pour sassurer de la russite de la correction.

3.3. Procdures et paramtres 3.3.1. Cration de procdures avec des paramtres

Les procdures peuvent prendre en compte des paramtres extrieurs lors de leur excution. Ces paramtres peuvent tre passs en entre (la valeur est utilise dans la procdure mme), en sortie (la valeur est envoye lenvironnement appelant) ou les deux.

IN OUT IN OUT Par dfaut Doit tre spcifi Doit tre spcifi La valeur est passe dans le sous-programme

La valeur est renvoye lenvironnement appelant

La valeur est passe au sous programme puis une valeur diffrente est retourne lenvironnement appelant

Le paramtre formel agit comme une constante

Cest une variable non initialise

Cest une variable initialise

Le paramtre actuel peut tre une expression littrale, constante ou une variable initialise

Doit tre une variable

Doit tre une variable

3.3.2. Le paramtre IN Exemple:

SQL> CREATE OR REPLACE PROCEDURE raise_salary 2 (v_id in emp.empno%TYPE) 3 IS 4 BEGIN 5 UPDATE emp 6 SET sal = sal * 1.10 7 WHERE empno = v_id; 8 END raise_salary; 9 / Procedure created. SQL> EXECUTE raise_salary (7369)


PL/SQL procedure successfully completed.


Lexemple montre une procdure utilisant un paramtre IN. Lorsque la procdure RAISE_SALARY est appele, le paramtre est utilis en tant que numro demploy pour excuter lordre UPDATE. Pour appeler une procdure avec un paramtre dans SQL*Plus, on utilise la commande EXECUTE :

SQL> EXECUTE raise_salary (7569) Pour appeler une procdure depuis Procedure Builder on utilise un appel direct. Pour cela, on entre le nom de la procdure et le paramtre actuel au prompt de linterprteur de Procdure Builder :

PL/SQL> raise_salary (7369) Les paramtres IN sont passs en tant que constantes donc si lon essaye de modifier la valeur dun paramtre IN, il se produira une erreur.

3.3.3. Le paramtre OUT

Utilisation du paramtre OUT Le paramtre OUT permet de retourner des valeurs obtenues lintrieur de la procdure vers lenvironnement appelant. Comme la valeur par dfaut pour les paramtres est IN, il faut prciser explicitement OUT lorsque lon veut retourner une valeur. Exemple :

SQL> CREATE OR REPLACE PROCEDURE query_emp 1 (v_id IN emp.empno%TYPE, 2 v_name OUT emp.ename%TYPE, 3 v_salary OUT emp.sal%TYPE, 4 v_comm OUT emp.comm%TYPE) 5 IS 6 BEGIN 7 SELECT ename, sal, comm 8 INTO v_name, v_salary, v_comm 9 FROM emp 10 WHERE empno = v_id; 11 END query_emp; 12 / Ce script cr une procdure acceptant un paramtre externe et renvoyant trois paramtres

Pour quune procdure avec un ou plusieurs paramtres OUT fonctionne il faut dclarer autant de variables htes que de valeurs retournes par la requte. Ces variables devront tre du mme type que les valeurs retournes. Ensuite ces variables prcdes de deux points (:) seront passes en paramtres de la procdure.

Le paramtre OUT et SQL*Plus Pour excuter la procdure query_emp dans SQL*Plus, on cre dabord trois variables en utilisant la commande VARIABLE. On appelle ensuite la procdure en indiquant une valeur en entre et les trois variables prcdes de deux points (:) pour les paramtres OUT. Pour voir les valeurs renvoyes dans les variables on utilise la commande PRINT.

SQL> VARIABLE g_name VARCHAR2(15) SQL> VARIABLE g_sal NUMBER SQL> VARIABLE g_comm NUMBER SQL> EXECUTE query_emp(7654,:g_name,:g_sal,:g_comm) Procdure PL/SQL termine avec succs. SQL> PRINT g_name G_NAME ---------------


MARTIN


Cet exemple affiche la valeur de la variable g_name renvoye lenvironnement appelant par la procdure query_emp.

Pour afficher plusieurs variables en mme temps il suffit de spcifier tous les noms la suite dans la liste du PRINT. La commande PRINT ainsi que la commande VARIABLE sont des commandes spcifiques SQL*Plus. Lors de lutilisation de la commande VARIABLE pour dfinir des variables htes, il nest pas ncessaire de spcifier une taille pour les variables de type NUMBER. Une variable hte de type CHAR ou VARCHAR2 a une taille par dfaut de un, moins quune valeur soit spcifie entre parenthses. Afin de ne pas crer derreurs il faut sassurer que les variables peuvent contenir les valeurs renvoyes.

Le paramtre OUT et procdure builder Avec Procedure Builder, il faut galement dclarer des variables. La commande qui permet de les dclarer est .CREATE. Pour cette commande, il faut spcifier le type de donnes, le nom de la variable et la taille de celle-ci. On appelle ensuite la procdure comme dans SQL*Plus afin de stocker les valeurs retournes dans les variables dfinies. Pour ensuite afficher ces valeurs, on utilise la procdure PUT_LINE du packageTEXT_IO. Exemple :

PL/SQL> .CREATE CHAR g_name LENGTH 10 PL/SQL> .CREATE NUMBER g_sal PRECISION 4 PL/SQL> .CREATE NUMBER g_comm PRECISION 4 PL/SQL> QUERY_EMP (7654, :g_name, :g_sal, +> :g_comm); PL/SQL> TEXT_IO.PUT_LINE (:g_name || gagne || +> TO_CHAR(:g_sal) || et une commission de +> || TO_CHAR(:g_comm)); MARTIN gagne 1250 et une commission de 1400 Cet exemple affiche les valeurs des variables modifies par la procdure query_emp

3.3.4. Le paramtre IN OUT

Crer une procdure utilisant IN OUT Le paramtre IN OUT permet de passer une valeur la procdure et de retourner une valeur diffrente lenvironnement appelant. La valeur renvoye peut tre soit loriginale, si la valeur nest pas modifie par la procdure, soit une toute autre valeur dfinie dans la procdure. Un paramtre IN OUT se comporte comme une variable initialise. Exemple :

SQL> CREATE OR REPLACE PROCEDURE format_phone 2 (v_phone_no IN OUT VARCHAR2) 3 IS 4 BEGIN 5 v_phone_no := ( || SUBSTR(v_phone_no,1,3) || 6 ) || SUBSTR(v_phone_no,4,3) || 7 - || SUBSTR(v_phone_no,7); 8 END format_phone; 9 /

Lexemple montre la cration de la procdure FORMAT_PHONE qui utilise un paramtre IN OUT pour faire une conversion de format sur ce paramtre.


Pour faire fonctionner une procdure avec un paramtre IN OUT il faut pralablement crer et initialiser une variable hte.


Utilisation avec SQL*Plus Pour invoquer la procdure FORMAT_PHONE, cre prcdemment, dans SQL*Plus on va crer une variable hte par la commande VARIABLE puis initialise celle-ci grce un script PL/SQL. Exemple :

SQL> VARIABLE g_phone_no VARCHAR2(15) SQL> BEGIN :g_phone_no := '8006330575'; END; 2 / Procdure PL/SQL termine avec succs. SQL> PRINT g_phone_no G_PHONE_NO -------------------------------- 8006330575 SQL> EXECUTE format_phone (:g_phone_no) Procdure PL/SQL termine avec succs. SQL> PRINT g_phone_no G_PHONE_NO -------------------------------- (800)633-0575 La procdure FORMAT_PHONE effectue la modification de format sur la variable g_phone_no

Utilisation avec Procedure Builder Dans Procedure Builder, la mthode pour invoquer la procdure FORMAT_PHONE est semblable celle de SQL*Plus mais la syntaxe est lgrement diffrente. Exemple :

PL/SQL> .CREATE CHAR g_phone_no LENGTH 15 PL/SQL> BEGIN +> :g_phone_no := 8006330575; +> END; PL/SQL> FORMAT_PHONE (:g_phone_no); PL/SQL> TEXT_IO.PUT_LINE (:g_phone_no); (800)633-0575

3.3.5. Passer des paramtres

Mthodes pour passer des paramtres Lorsquune procdure possde plusieurs arguments, on dispose de plusieurs mthodes pour spcifier la valeurs des paramtres : par position, par association de nom et par combinaison.


Mthode Description Par position Les valeurs sont listes dans lordre dans lequel sont dclars

les paramtres. Par association de nom

Les valeurs sont listes dans un ordre arbitraire en associant chacune avec le nom de paramtre correspondant en utilisant une syntaxe spciale (=>).

Par combinaison

Cest une combinaison des deux mthodes prcdentes : les premires valeurs sont listes par position et le reste utilise la


syntaxe spciale de la mthode par association de nom.

Loption DEFAULT pour les paramtres Lors de la dclaration des paramtres, on peut spcifier une option DEFAULT la suite du type de donnes.

Nom_variable [IN|OUT|IN OUT] type de donne [DEFAULT valeur] Cette option permet lutilisateur de ne pas spcifier de paramtres quand une procdure en rclame. Si les paramtres ne sont pas spcifis, la procdure sexcutera avec la valeur dfinie dans loption DEFAULT. Exemple :

SQL> CREATE OR REPLACE PROCEDURE add_dept 1 (v_name IN dept.dname%TYPE DEFAULT unknown, 2 v_loc IN dept.loc%TYPE DEFAULT unknown) 3 IS 4 BEGIN 5 INSERT INTO dept 6 VALUES (dept_deptno.NEXTVAL, v_name, v_loc); 7 END add_dept; 8 / Cette requte cre une procdure ADD_DEPT qui permet dajouter un nouveau departement la table DEPT sans forcment prciser un nom et une localisation.

Exemple dutilisation de paramtres Exemple :

SQL> BEGIN 2 add_dept; 3 add_dept ( TRAINING, NEW YORK); 4 add_dept ( v_loc => DALLAS, v_name =>EDUCATION); 5 add_dept ( v_loc => BOSTON) ; 6 END; 7 / Procdure PL/SQL termine avec succs. SQL> SELECT * FROM dept; DEPTNO DNAME LOC ------ -------------- ------------- ... ... ... 41 unknown unknown 42 TRAINING NEW YORK 43 EDUCATION DALLAS 44 unknown BOSTON Ce bloc anonyme illustre les diffrents moyens dappeler une fonction contenant des paramtres. On voit que lorsque quun paramtre est manquant, celui-ci est remplac par la valeur dfinie dans le DEFAULT : unknown .

Le premier appel de la procdure fonctionne car une valeur DEFAULT a t dfinie

3.4. Les sous programmes 3.4.1. Dclarer des sous-programmes


Un sous programme peut tre dclar dans nimporte quel bloc PL/SQL. Cest une alternative la cration de procdures usage unique pour les appeler depuis dautres procdures.


Le sous programme doit tre dclar dans la section dclarative du bloc et doit tre le dernier lment de cette section, aprs tous les autres lments du programme. Si une variable est dclare aprs la fin du sous programme, cela crera une erreur de compilation. Exemple :

CREATE OR REPLACE PROCEDURE LEAVE_EMP2 (v_id IN emp.empno%TYPE) IS PROCEDURE log_exec IS BEGIN INSERT INTO log_table (user_id, log_date) VALUES (user,sysdate); END log_exec; BEGIN DELETE FROM emp WHERE empno = v_id; log_exec; END leave_emp2; Cette requte cre une procdure acceptant un paramtre. Cette procdure comporte un sous programme qui est appel dans la section excutable du bloc.

3.4.2. Invoquer une procdure depuis un bloc anonyme Les procdures peuvent tre appeles depuis nimporte quel outil ou langage prenant en compte le PL/SQL. Pour appeler une procdure depuis un bloc anonyme il faut indiquer son nom, en passant les paramtres ventuels entre parenthses, suivi dun point virgule. Exemple :

DECLARE v_id NUMBER := 7900; BEGIN raise_salary(v_id); --appel la procdure COMMIT; ... END; Ce bloc anonyme appelle la procdure RAISE_SALARY dfinie prcdemment en lui donnant le paramtre v_id initialis dans la section dclarative.

3.4.3. Invoquer une procdure depuis une procdure stocke Les procdures peuvent tre galement appeles partir de procdures stockes. Pour ce faire, il faut utiliser le nom de la procdure comme pour lappel partir de blocs anonymes. Exemple :

SQL> CREATE OR REPLACE PROCEDURE process_emps 2 IS 3 CURSOR emp_cursor IS 4 SELECT empno 5 FROM emp; 6 BEGIN 7 FOR emp_rec IN emp_cursor 8 LOOP 9 raise_salary(emp_rec.empno); --appel de la procdure 10 END LOOP; 11 COMMIT; 12 END process_emps; 13 /


La procdure PROCESS_EMPS utilise un curseur pour traiter toutes les donnes de la table EMP et passer le numro de chaque employ la procdure RAISE_SALARY, qui incrmente le salaire de 10 %.


3.5. Gestion des exceptions 3.5.1. Exceptions traites

Lorsque lon dveloppe des procdures qui seront appeles depuis dautres procdures, il faut prendre en compte les effets que peuvent avoir les exceptions traites et non traites sur la transaction et sur la procdure appelante. Une transaction regroupe lensemble des ordres de manipulation de donnes effectus depuis le dernier COMMIT. Pour la contrler on peut utiliser les commandes de contrle de transaction, COMMIT, ROLLBACK et SAVEPOINT. Dans une procdure appelant une autre procdure, il faut faire attention la manire dont les exceptions leves affectent la transaction et dont lexception est propage. Quand une exception est leve dans un programme appel, la section de gestion des exceptions prend automatiquement le contrle du bloc. Si lexception est traite dans cette section, le bloc se termine correctement et le contrle est rendu au programme appelant. Tout ordre DML effectu avant que lexception ne soit leve reste dans la transaction.

3.5.2. Exceptions non traites Lorsque lexception nest pas traite par la section de gestion des exceptions, tout ordre DML effectu dans le bloc du programme appel est implicitement annul (ROLLBACK), le bloc se termine et le contrle est rendu la section de gestion des exceptions du programme appelant. Si lexception est traite par la procdure appelante, tous les ordres DML effectus dans ce bloc sont conservs dans la transaction. Si lexception nest pas traite par la procdure appelante, tous les ordres DML effectus dans ce bloc sont implicitement annuls (ROLLBACK), le bloc se termine et lexception est propage lenvironnement appelant.

3.6. Supprimer des procdures Lorsquune procdure nest plus utilise, on peut utiliser un ordre SQL dans SQL*Plus ou dans linterprteur de Procedure Builder pour la supprimer (DROP). La mthode de suppression diffre lgrement selon le type de la procdure (cliente ou serveur). Sous SQL*Plus, on ne peut supprimer que des procdures serveurs alors que sous Procedure Builder les procdures serveurs et clientes peuvent tre supprimes.

3.7. Supprimer des procdures serveur

Avec SQL*Plus Sous SQL*Plus, on utilise la commande DROP PROCEDURE pour supprimer la procdure serveur souhaite.

DROP PROCEDURE procedure_name Exemple :

SQL> DROP PROCEDURE raise_salary; Procdure supprime. Cet ordre permet de supprimer la procdure RAISE_SALARY cre prcdemment.


Il est impossible deffectuer un ROLLBACK aprs avoir supprimer une procdure car une commande de dfinition de donne (DDL) ne peut pas tre annule.


Avec Procedure Builder Pour supprimer une procdure serveur sous Procedure Builder, il faut tout dabord se connecter la base de donnes. Dans lexplorateur dobjet, on dveloppe le nud Database Object pour faire apparatre les diffrents schmas disponibles. On dveloppe ensuite le schma du propritaire de la procdure puis le nud Stored Progam Units (Units de programme stocks) pour faire apparatre toutes les procdures existantes. On slectionne ensuite la procdure supprimer puis on clique sur Delete dans lexplorateur dobjet. Un message de confirmation apparat alors, on clique ensuite sur Yes pour la supprimer dfinitivement. Pour supprimer une procdure du serveur, on peut galement cliquer sur Drop dans lditeur de programmes stocks.

3.8. Supprimer des procdures client Pour supprimer une procdure client avec Procedure Builder, on dveloppe le nud Program Units, puis on slectionne la procdure que lon souhaite supprimer. On clique ensuite sur Delete dans lexplorateur dobjet et on clique sur Yes lapparition de la bote de dialogue de confirmation.


Si le code de la procdure a t export dans un fichier texte et que lon veut le supprimer, il faut passer par le systme dexploitation.


4. Creation de fonctions 4.1. Les fonctions

4.1.1. Aperu des fonctions stockes Une fonction stocke est un bloc PL/SQL nomm pouvant accepter des paramtres et tre appele de la mme faon que les procdures. Gnralement, on utilise une fonction pour calculer une valeur. Les procdures et les fonctions possdent une structure semblable sauf quune fonction doit retourner une valeur lenvironnement appelant. Comme les procdures, les fonctions sont composes de quatre parties : un en-tte, une section dclarative, une partie excutable et une partie optionnelle de gestion derreur. Une fonction doit avoir une clause RETURN dans len-tte et au moins un RETURN dans la partie excutable. Les fonctions facilitent la rutilisation et la maintenance. Une fois valide, les fonctions sont stockes dans la base de donnes en tant quobjet de base de donnes et peuvent ainsi tre rutilises dans de nombreuses applications. Si la dfinition change, seule la fonction est affecte ce qui permet une maintenance simple. Les fonctions peuvent tre appeles dans une expression SQL ou dans une expression PL/SQL. Dans une expression SQL, la fonction doit obir certaines rgles syntaxiques pour contrler les effets secondaires. Dans une expression PL/SQL, lidentifiant de la fonction se comporte comme une variable dont la valeur dpend du paramtre quon lui passe.

4.1.2. Syntaxe pour la cration de fonctions Pour crer une fonction, on utilise la commande CREATE FUNCTION, dans laquelle on peut spcifier une liste de paramtres. Dans cette commande on doit dfinir la valeur qui sera retourne lenvironnement appelant et dfinir les actions effectues par le bloc PL/SQL standard.

CREATE [OR REPLACE] FUNCTION function_name ( parameter1 [ mode1] datatype1, parameter2 [ mode2] datatype2, . . .) RETURN datatype IS|AS PL/SQL Block;

Paramtre Description Function_name Nom de la fonction Argument Nom de la variable PL/SQL dont la valeur est passe la

fonction Mode Le type de paramtre ; seul le paramtre IN doit tre

dclar Datatype Type de donne du paramtre RETURN datatype

Type de donne de la valeur RETURN qui doit tre renvoye par la fonction

PL/SQL Block Corps de la procdure dfinissant les actions effectues par la fonction

Loption REPLACE indique que si la fonction existe dj, elle sera remplace par la nouvelle version cre par la requte. Le type de donne du RETURN ne doit avoir de taille spcifie.


Le bloc PL/SQL commence soit par un BEGIN soit par une section de dclaration de variables locales et se termine par END ou END function_name. Il doit obligatoirement y avoir au moins une expression RETURN (variable). Il est impossible de faire rfrence des variables htes ou des variables de substitution dans le bloc PL/SQL dune fonction stocke.


4.1.3. Cration de fonction La mthode de cration dune fonction est semblable celle de cration de procdure. On choisit dabord un environnement de dveloppement (Procedure Builder ou SQL*Plus) dans lequel on entre la syntaxe de cration. Ensuite on compile le code pour obtenir du p-code. Lutilisation de plusieurs expressions RETURN dans un bloc PL/SQL est autorise mais lors de la compilation une seule sera prise en compte et donc une seule valeur sera retourne lors de lexcution. On utilise habituellement plusieurs RETURN lorsque le bloc contient une condition IF.

4.2. Les fonctions dans SQL*Plus 4.2.1. Cration de fonctions stockes

Pour crer une fonction stocke partir de SQL*Plus on tape lexpression CREATE FUNCTION dans un diteur de texte, puis on sauvegarde ce fichier en tant que fichier script (*.sql). Ce fichier script doit ensuite tre excut dans SQL*Plus afin de le compiler en p-code. Si la compilation produit des erreurs, on utilise la commande SHOW ERRORS pour les corriger. Une fois la compilation effectue sans erreurs, on appelle la fonction depuis un environnement Oracle Server. Un fichier script contenant lexpression CREATE FUNCTION nous permet de modifier la requte si il y a des erreurs de compilation ou dexcution ou de faire des changements ultrieurs. Il est impossible dappeler une fonction contenant des erreurs de compilation ou dexcution. Lexcution de la commande CREATE FUNCTION stocke le code source dans le dictionnaire de donnes mme si la fonction contient des erreurs de compilation. Il faut donc supprimer la fonction (DROP) ou bien utiliser la syntaxe OR REPLACE si lon veut effectuer des changements dans une fonction. Exemple :

SQL> CREATE OR REPLACE FUNCTION get_sal 2 (v_id IN emp.empno%TYPE) 3 RETURN NUMBER 4 IS 5 v_salary emp.sal%TYPE :=0; 6 BEGIN 7 SELECT sal 8 INTO v_salary 9 FROM emp 10 WHERE empno = v_id; 11 RETURN (v_salary); 12 END get_sal; 13 / Fonction cre. Cette requte cre une fonction acceptant un paramtre IN et retournant une valeur de type NUMBER correspondant au salaire de lemploy dont le numro a t fournit en paramtre.

4.2.2. Excuter des fonctions Les fonctions sont appeles lintrieur dexpression PL/SQL. Pour que la fonction sexcute convenablement il faut crer une variable hte pour y stocker la valeur retourne. Lors de lexcution, la variable hte est initialise avec la valeur renvoye par le RETURN.


Une fonction peut accepter plusieurs paramtres IN mais elle ne doit retourner quune seule valeur.


Exemple :

SQL> START get_salary.sql Fonction cre. SQL> VARIABLE g_salary number SQL> EXECUTE :g_salary := get_sal(7934) Procdure PL/SQL termine avec succs. SQL> PRINT g_salary G_SALARY ---------- 1300 Cet exemple cre une variable hte dans laquelle est stocke la valeur renvoye par la fonction utilisant le paramtre (numro demploy). La commande EXECUTE permet ici de faire excuter SQL*Plus une expression PL/SQL

4.3. Les fonctions dans Procedure Builder 4.3.1. Cration de fonction

Comme il y a un moteur PL/SQL dans loutil client de Procedure Builder, il est possible de dvelopper des fonctions ct client. Avec Procedure Builder, on peut aussi utiliser le moteur PL/SQL du serveur pour dvelopper des fonctions ct serveur. La fonctionnalit glisser-dposer de Procedure Builder permet de dplacer facilement des fonctions entre le client et le serveur.

4.3.2. Exemple de cration de fonction Pour crer une fonction avec Procedure Builder on slectionne le nud Program Units dans lexplorateur dobjet puis on clique sur Create. On choisit un nom pour la fonction dans la bote de dialogue de cration dune nouvelle unit de programme. Dans lexemple on choisit Tax. On choisit ensuite le type Function puis on clique sur OK pour faire apparatre la fentre de lditeur de programme. On tape ensuite le code avant de cliquer sur Compile.

FUNCTION tax (v_value IN NUMBER) RETURN NUMBER IS BEGIN RETURN (v_value * .08); END tax; Ce code cre une fonction calculant la taxe sur un salaire donn en argument.

Si la compilation seffectue sans erreurs le message Successfully Compiled est affich. Sinon les erreurs sont signales dans le panneau daffichage des erreurs. Il faut viter dutiliser les paramtres OUT et IN OUT avec les fonctions car elles sont conues pour retourner une valeur unique.

4.3.3. Excuter des fonctions Pour excuter une fonction dans Procedure Builder il faut tout dabord crer une variable hte pour y stocker la valeur retourne. Pour cela on utilise la syntaxe CREATE au prompt de linterprteur PL/SQL.


On cre ensuite une expression PL/SQL appelant la fonction TAX en lui passant en argument une valeur numrique. Les deux points (:) indiquent que lon fait rfrence une variable hte.


On observe le rsultat de la fonction en utilisant la procdure PUT_LINE du package TEXT_IO. Exemple :

PL/SQL> .CREATE NUMBER x PRECISION 4 PL/SQL> :x := tax(1000); PL/SQL> TEXT_IO.PUT_LINE (TO_CHAR(:x)); 80

4.4. Les fonctions dfinies par lutilisateur dans du SQL 4.4.1. Avantages des fonctions dans des expressions SQL

Les expressions SQL peuvent faire rfrence des fonctions PL/SQL dfinies par lutilisateur. Les fonctions dfinies par lutilisateur peuvent tre utilises partout o une fonction SQL peut tre utilise. Les fonctions dfinies par lutilisateur permettent deffectuer des calculs complexes, maladroit ou non disponibles dans SQL plus facilement. Elles augmentent galement lindpendance des donnes en effectuant des analyses de donnes complexe au niveau du serveur Oracle plutt que de la faire faire par les applications. Elles augmentent lefficacit des requtes en excutant les fonctions dans la requte plutt que dans lapplication. Elles permettent galement de manipuler des nouveaux types de donnes (par exemple des latitudes et des longitudes) en encodant les chanes de caractres et en utilisant des fonctions pour agir sur ces chanes. Exemple :

SQL> SELECT empno, ename, sal, tax(sal) 2 FROM emp; EMPNO ENAME SAL TAX(SAL) ---------- ---------- ---------- ---------- 7369 SMITH 800 64 7499 ALLEN 1600 128 7521 WARD 1250 100 7902 FORD 3000 240 7934 MILLER 1300 104 14 ligne(s) slectionne(s). Cet ordre SQL utilise la fonction TAX dans sa liste de SELECT

4.4.2. Emplacements do appeler les fonctions Les fonctions PL/SQL dfinies par lutilisateur peuvent tre appeles depuis toute expression SQL dans laquelle on peut utiliser une fonction prdfinie. C'est--dire que lon peut utiliser une fonction PL/SQL dans la liste dun ordre SELECT, dans les conditions des clauses WHERE et HAVING, dans les clauses CONNECT BY, START WITH, ORDER BY et GROUP BY, dans la clause VALUES dun ordre INSERT et dans la clause SET dun ordre UPDATE.

4.4.3. Appel de fonctions : restrictions Pour pouvoir tre appele depuis une expression SQL, une fonction dfinie par lutilisateur doit respecter certaines conditions :


Seules les fonctions stockes peuvent tre utilise. Les procdures stockes ne peuvent pas tre appeles.


Une fonction dfinie par lutilisateur utilise en SQL doit tre une fonction SINGLE-ROW et pas une fonction de groupe.

Ces fonctions nacceptent que des paramtres IN, pas OUT ou IN OUT. Les types de donnes retourns doivent tre des types de donnes SQL valides : CHAR,

VARCHAR2, DATE ou NUMBER. Les types de donnes spcifiques au PL/SQL (BOOLEAN, RECORD, TABLE) ne peuvent pas tre utiliss.

La fonction ne doit pas modifier la base de donne, par consquent les ordres INSERT, UPDATE ou DELETE sont interdits dans une fonction appele depuis du SQL.

Les paramtres dune fonction PL/SQL appele depuis une expression SQL doit utiliser la notation par position. La position par nom nest pas supporte dans le SQL.

On doit possder la fonction ou bien avoir le privilge EXECUTE sur celle-ci pour pouvoir lappeler depuis un ordre SQL.

Les fonctions PL/SQL stockes ne peuvent pas tre appeles depuis la clause CHECK dune commande CREATE ou ALTER TABLE ni tre utilise pour spcifier une valeur par dfaut pour une colonne.

Les fonctions appeles ne doivent pas faire appel un autre sous programme ne respectant pas ces rgles.

Lutilisation de fonction PL/SQL dans des ordres SQL est disponible depuis PL/SQL 2.1. Les outils utilisant une version plus ancienne de PL/SQL ne supportent pas cette fonctionnalit.

4.5. Supprimer des fonctions 4.5.1. Supprimer des fonctions serveur

Lorsquune fonction stocke nest plus utilise, on peut la supprimer en utilisant un ordre SQL dans SQL*Plus ou en utilisant le panneau de linterprteur Procedure Builder pour faire un DROP. Pour supprimer une fonction ct serveur sous SQL*Plus on utilise la commande DROP FUNCTION.

DROP FUNCTION function_name Exemple :

SQL> DROP FUNCTION get_sal; Fonction supprime. Cette requte supprime la fonction get_sal.

DROP FUNCTION est un ordre DDL, il est donc auto-commit et ne peut pas tre annul par un ROLLBACK. Pour supprimer une

Documents

57041482-DRAFTPLSQLA-MODULE-1-2003-08-07-0