Les avantages des packages PL/SQL

Les avantages des packages PL/SQL sont :

Gain de performance :

Le moteur PL/SQL charge le package entier en mémoire dès que l’on fait appel à une de ses procédures. L’exécution des autres procédures se fera directement, sans lecture préalable du moteur PL/SQL.

Gestion de sécurité :

En effet en enregistrant les procédures à travers un package, on peut définir des droits d’accès publique ou privée.

Un structuration plus cohérente :

Les objets peuvent être reliés entre eux par le biais d’utilisation de variable Globale. Le relecture et la compréhension des fonctionnalités des procédures du package se fait plus facilement.

Composition des packages PL/SQL

Les packages PL/SQL se divisent en 2 parties :

la spécification : Partie déclarative du package qui liste les entêtes de procédures et fonctions (contenues dans le package PL/SQL).

le corps du package : possède le code PL/SQL des procédures et fonctions définies dans la spécification.

Syntaxe

CREATE [OR REPLACE] PACKAGE BODY nompackage
{ IS | AS }
Déclarations de variables locales
Corps des sous-programmes publics et privés
BEGIN
…
END [nompackage] ;

Exemple en code

-- 1) Installation d'un package
CREATE or replace PACKAGE pacRH
AS
-- =====================
/*
 Fonction de conversion en FF (arrondir aux centimes) d'un montant transmis en EURO.
*/
 FUNCTION ConvFF (pMontant NUMBER) RETURN NUMBER ;

END pacRH ;

-- 2) Implémentation du corps de package
CREATE or replace PACKAGE BODY pacRH
AS

-- =====================
FUNCTION ConvFF (pMontant NUMBER)
RETURN NUMBER
IS
 vTaux  CONSTANT NUMBER := 6.55957 ;
BEGIN
 RETURN ( ROUND( pMontant * vTaux, 2) ) ;
EXCEPTION
 WHEN others THEN RETURN (null) ;
END ConvFF ;

END pacRH ;

-- =======================================
-- Test
select * from salarie
where pacRH.ConvFF(sal) > 12000 ;

-- =======================================

Traitement du curseur par une boucle FOR :

BEGIN
FOR indice IN requete sql LOOP
/* traitement */
END LOOP;
END;

En PL/SQL cela donne :

CREATE OR REPLACE
PROCEDURE BOUCLE_FOR AS
BEGIN
FOR vSegment IN (select  TABLE_NAME  from USER_TABLES)
LOOP
 DBMS_OUTPUT.PUT_LINE(vSegment.TABLE_NAME);
END LOOP;
END BOUCLE_FOR;

Nous nous allons voir comment définir, déclencher et traiter les exceptions en PL/SQL.

Le bloc PL/SQL possède comme structure type, celle-ci :

[DECLARE]
déclarations et initialisation
BEGIN
instructions exécutables
[EXCEPTION]
interception des erreurs
END;

Dans un premier temps nous allons créer un bloc PL/SQL avec une erreur sans la gestion exception.
Puis allons capturer l’erreur avec un la gestion d’exception.

DECLARE
sName USERS.NAME%TYPE;
BEGIN
  BEGIN
    SELECT NAME INTO sName FROM USERS WHERE 0 = 1;
    DBMS_OUTPUT.PUT_LINE( sName ) ;
  END;
  DBMS_OUTPUT.PUT_LINE( 'Le script continue.' ) ;
END;
/

eh la ! Oracle nous envoi une belle erreur !

On voit que le script s’est arrête dès l’apparition de l’erreur.

error 01403 pl sql

On va capturer l’erreur en déclarant une exception.

Voici ce que cella va donnée :

DECLARE
sName USERS.NAME%TYPE;
BEGIN
  BEGIN
    SELECT NAME INTO sName FROM USERS WHERE 0 = 1;
    DBMS_OUTPUT.PUT_LINE( sName ) ;
  EXCEPTION
  WHEN NO_DATA_FOUND then
      DBMS_OUTPUT.PUT_LINE( 'Il n''y a aucun utilisateur.' ) ;
  END;
  DBMS_OUTPUT.PUT_LINE( 'Le script continue.' ) ;
END;
/

note à part : pour mettre échapper un caractère en PL/SQL, il faut simplement le doubler . ex :
(‘ =>  »)
( » => »")
( =>\)

Après exécution du bloc, on voit que l’erreur n’apparait pas (elle est capturée) et que le script continu à tourner

exception-data-not-found

La syntaxe est très simple :
SELECT attribut INTO variable
FROM entité
WHERE condition;

Donc nous allons utiliser la commande SELECT INTO pour affecter le nombre d’utilisateur à une variable.

DECLARE
iNbUser INTEGER;
BEGIN
SELECT COUNT(*) INTO iNbUser FROM USERS;
   DBMS_OUTPUT.PUT_LINE( iNbUser ) ;
END;
/

Attention, il faut s’assurer que le SELECT INTO renvoi bien qu’un seul enregistrement ! Sinon le PL/SQL va générer une erreur.

Les types de curseurs

· Le curseur explicite
Le curseur explicite est géré pas l’utilisateur (sur un SELECT).

· Le curseur implicite
Le curseur implicite est généré et géré par le noyau.

l’utilisation du curseur pl/sql

On peut diviser le vie d’un curseur en 4 parties

• déclaration (DECLARE)
• ouverture (OPEN)
• utilisation (FETCH)
• fermeture (CLOSE)

Déclaration d’un curseur

CURSOR nom_curseur IS ordre_select

Exemple:

DECLARE
CURSOR cUtilisateur IS SELECT NOM, PRENOM FROM UTILISATEUR;

Ouverture d’un curseur

OPEN nom_curseur

L’ouverture du curseur engendre l’exécution de la requête.
Il faut savoir aussi que le curseur se place automatiquement à la première ligne du tableau.

exemple-curseur-pl-sql

Dans cet illustration on voit que le curseur est positionné dans le premier enregistrement qui est « dupond jean ».

Voici comment on ouvre un curseur en pl/sql :

DECLARE
CURSOR cUtilisateur IS SELECT NOM, PRENOM FROM UTILISATEUR;
BEGIN
OPEN cUtilisateur;
...
CLOSE cUtilisateur;
END;
/

Fetch

La commande Fetch permet de lire la ligne en cours (la ligne ou est positionné le curseur).
Après la lecture de la ligne, il positionne automatiquement le curseur à la ligne suivante.
Attention, si le curseur est en fin de tableau, la commande Fetch ne quitte pas automatiquement le tableau,
il reste « bloqué » sur le dernier enregistrement.

Voici la syntaxe :

Pour parcourir un tableau il faut ainsi utiliser une boucle sur la commande fetch
FETCH nom_curseur INTO ligne_tableau;

ligne_tableau doit être une variable dynamique à partir du curseur:
voici la syntaxe :

ligne_tableau nom_curseur%ROWTYPE;

DECLARE
CURSOR cUtilisateur IS SELECT NOM, PRENOM FROM UTILISATEUR;
  lUtilisateur cUtilisateur%ROWTYPE;
BEGIN
OPEN cUtilisateur;
  LOOP
  FETCH cUtilisateur INTO lUtilisateur;
  EXIT WHEN cUtilisateur%NOTFOUND;
   DBMS_OUTPUT.PUT_LINE( lUtilisateur.NAME ) ;
  END LOOP;
CLOSE cUtilisateur;
END;
/

Attributs

On peux vérifier l’état d’un curseur grasse à ces attributs :

%FOUND
vérifie si le fetch renvoi bien une ligne
%NOTFOUND
vérifie si le fetch ne renvoi aucune une ligne
%ROWCOUNT
compte le nombre de ligne que le curseur à lu
%ISOPEN
vérifie si le curseur est ouvert

Boucle WHILE en PL/SQL

La boucle WHILE répète une séquence d’instructions tant que la condition est respectée.
A chaque itération la condition est vérifiée.

WHILE condition
LOOP
commandes
END LOOP;

  DECLARE
  iCompteur INTEGER := 0 ;
  BEGIN
	WHILE iCompteur < 3
	LOOP
		iCompteur := iCompteur + 1;
		DBMS_OUTPUT.PUT_LINE( iCompteur ) ;
	END LOOP;
 END ;
 /

Boucle FOR en PL/SQL

La structure de contrôle for est sans doute l’une des plus importantes. Elle permet de réaliser toutes sortes de boucles et, en particulier, les boucles itérant sur les valeurs d’une variable de contrôle. Sa syntaxe est la suivante :

FOR indice IN [REVERSE] borne_début..borne_fin
LOOP
commandes;
END LOOP;

BEGIN
FOR iCompteur IN  1..3
LOOP
    DBMS_OUTPUT.PUT_LINE( iCompteur ) ;
END LOOP;
END ;
/

Chaque structure est composée de sous catégories, en voici l’architecture :

• Les types scalaires
• booléen
• numérique
• caractère
• date
• rowid
• grand objet
• Les types composés
• enregistrement
• tableau

Voici la liste complète de tous les types classé hiérarchiquement :

oracle pl/sql variable

Structure du bloc PL/SQL

Le bloc PL/SQL possède comme structure type, celle-ci :

[DECLARE]
déclarations et initialisation
BEGIN
instructions exécutables
[EXCEPTION]
interception des erreurs
END;

En enlevant les sections facultatives, un bloc PL/SQL peut ressembler à ça :

BEGIN
   Null;
END;

La section BEGIN contient les instructions du programme. Elle est obligatoire et doit se terminer par le mot clé END.
L’instruction Null; ne génère aucun code.

Afficher un Message en PL/SQL

Nous allons afficher une message. Pour ce ci nous allons utiliser la commande DBMS_OUTPUT.
Voici comment on l’utilise :

BEGIN
   DBMS_OUTPUT.PUT_LINE( 'Salut tilkc');
END;
   /

Attention, si rien ne s’affiche dans la console de sortit de script, c’est que vous n’avez pas
activer le DBMS OUTPUT. Pour faire ceci, rien de plus simple, allez dans l’onglet DBMS OUTPUT, puis cliquer sur l’icône en haut à gauche comme ci dessous :

oracle DBMS_OUTPUT PUT_LINE

Utilisation de variable en PL/SQL

Nous allons voir comment utiliser une variable.

Il faut utiliser la section déclarative avec l’utilisation du mot clé DECLARE.
On va pouvoir déclarer et initier toutes les variables utiles pour l’exécution du BLOC PL/SQL.
Voici la commande pour déclarer une variable du type chaine, et initier une valeur à celle-ci.

sMessage VARCHAR2(15) := ‘Salut tilkc’ ;

sMessage est déclarée de type VARCHAR2(15)

ce qui donne :

DECLARE
   LC$Chaine	  VARCHAR2(15) := 'Salut Tilkc' ;
BEGIN
   DBMS_OUTPUT.PUT_LINE( LC$Chaine ) ;
END ;
 /

comme vous le voyez, pour affecter une valeur à une variable, il faut utiliser l’opérateur :=

Pour connaitre les différents types de variable que propose oracle cliquez ici

Structure conditionnel IF en PL/SQL

Pendant l’écriture de vos blocs pl/sql, il est fort probable que vous deviez faire des test.
Le PL/SQL nous permet d’évaluer ces tests en utilisant la syntaxe suivante :

IF condition THEN
commandes ;
[ELSEIF condition THEN
commandes ;]
[ELSE
commandes ;]
END IF

Seuls les mots clé IF et END IF; sont obligatoires. Les clauses ELSIF et ELSE sont facultatives

Nous allons effectuer un test simple.

 DECLARE
      iPanier INTEGER := 0 ;
    BEGIN
          IF iPanier = 0 THEN
            DBMS_OUTPUT.PUT_LINE( 'votre panier est vide' ) ;
         ELSE
            DBMS_OUTPUT.PUT_LINE( 'votre panier possède un objet' ) ;
         END IF ;
   END ;
   /

Les opérateurs utilisés dans les expressions conditionnelles sont :

• =
• <
• >
• <=
• >=
• <>
• !=
• ~=
• ^=
• IS NULL
• BETWEEN
• LIKE
• IN
• NOT
• AND
• OR

L’utilité du PL/SQL

Pourquoi utiliser le PL/SQL ?
Principalement pour l’optimisation du traitement des données en BDD (base de données).

En effet le traitement des données par le PL/SQL est interne. C’est à dire que c’est la base de donnée Oracle qui gère tout le traitement des données sans passer par des logiciels tiers. Cela limite donc le temps de communication entre ces logiciels tiers et Oracle.

Le PL/SQL assure aussi beaucoup plus de sécurité. Enfin l’intérêt du langage PL/SQL est qu’il soit portable sur toute sorte d’application.

Fonctionnement du PL/SQL

Le PL/SQL est un langage procédural structuré en blocs.
Principalement le PL/SQL manipule des structures de contrôle (tests, boucles), des variables (ainsi que leur type). Il peut aussi gérer les curseurs et les erreurs.

Dans cet article on va parler de bloc SQL. Ces blocs PL/SQL sont la plupart du temps stockés dans la base de données sous forme de procédure stockée, fonction ou trigger.
Le bloc PL/SQL est composé de SQL et de PL/SQL. Le SQL est traité pas le moteur SQL et le PL/SQL est géré par le moteur PL/SQL.

PL/SQL architecture