Organiser et structurer le code dans les bases de données peut être un défi complexe.
Sans une bonne structuration, le code devient difficile à maintenir, et la performance de l’application peut en souffrir.
Les packages PL/SQL offrent une solution efficace pour encapsuler et organiser le code, améliorant ainsi la gestion et la performance.
Maîtriser le langage SQL en environnement SGBDR. SQL n'aura plus de secrets pour vous !
Les packages sont des éléments essentiels pour organiser et structurer le code dans les bases de données, notamment en PL/SQL. Ils permettent de regrouper de manière cohérente les procédures , fonctions , variables , et autres composants nécessaires à la gestion des données et à l’exécution de traitements spécifiques. En utilisant des packages, vous pouvez encapsuler des fonctionnalités, protéger l’accès aux données sensibles, et améliorer les performances en réduisant le nombre d’opérations de chargement. Dans cette section, nous allons explorer la structure, les avantages, et la syntaxe de création des packages, ainsi que les bonnes pratiques pour en tirer le meilleur parti.
Un package est une structure de programmation utilisée pour regrouper logiquement des procédures, fonctions, variables, types de données et curseurs. Dans les systèmes de gestion de bases de données comme Oracle, il permet de mieux organiser et encapsuler le code afin de faciliter la maintenance et l’utilisation des éléments.
Regrouper avec Packages PL/SQL
Dans un package, vous pouvez regrouper des procédures et des fonctions pour organiser votre code et rendre l’application plus modulaire. Cela signifie que toutes les opérations liées à une certaine logique d’affaires peuvent être encapsulées au sein du même package. Par exemple, si vous avez plusieurs fonctions et procédures pour gérer les employés, vous pouvez les placer dans un package Gestion_Employes .
Un package est divisé en deux sections principales :
- Section de déclaration (spécification) :elle contient les déclarations d’éléments que l’on souhaite rendre accessibles à l’extérieur du package, comme des variables, des curseurs, des procédures et des fonctions.
- Section de traitement (corps) :elle contient les implémentations des éléments déclarés dans la spécification, mais peut aussi inclure des éléments privés non visibles à l’extérieur du package.
Avantages des Packages PL/SQL
L’utilisation des packages offre plusieurs avantages :
- Protection des données :le package permet de masquer l’implémentation interne et de ne rendre visibles que les éléments nécessaires.
- Amélioration des performances :les packages sont chargés en mémoire une seule fois par session, ce qui réduit les opérations d’E/S et améliore les performances lors de l’appel de plusieurs éléments du package.
- Persistance des objets :les objets tels que les variables peuvent conserver leurs valeurs au sein du package durant toute la session, ce qui permet de conserver des informations entre différents appels.
Structure de Package PL/SQL
Voici un schéma pour représenter la séparation entre la spécification et le corps du package :
Éléments du schéma :
- Éléments publics :déclarés dans la section de spécification, accessibles depuis l’extérieur du package.
- Éléments privés :déclarés dans le corps, non accessibles directement depuis l’extérieur.
- Spécification du package :Cette section contient les déclarations de toutes les procédures, fonctions, variables et curseurs qui seront accessibles publiquement.
- Corps du package :C’est ici que se trouvent les implémentations des procédures et fonctions. Vous pouvez également y inclure des variables ou procédures privées qui ne seront pas visibles à l’extérieur.
Créer un Package PL/SQL
Pour créer un package, vous pouvez utiliser la syntaxe suivante :
CREATE [ OR REPLACE ] PACKAGE nom_package
{ IS | AS }
-- Déclarations de variables et types
variable1 TYPE;
variable2 TYPE;
-- Déclaration de curseurs
CURSOR nom_curseur IS SELECT ...;
-- Déclaration des procédures et fonctions
PROCEDURE nom_procedure(paramètres);
FUNCTION nom_fonction(paramètres) RETURN type;
END nom_package;
Explication de la syntaxe :
- CREATE OR REPLACE PACKAGE :crée un nouveau package ou remplace un package existant.
- { IS | AS } :mots-clés utilisés pour définir le début de la spécification du package.
- variable TYPE :déclaration de variables utilisables dans le package.
- CURSOR :déclaration de curseurs pour les ensembles de données.
- PROCEDURE et FUNCTION :déclaration des procédures et fonctions.
Ces exemples vous aideront à mieux comprendre comment exploiter la puissance des packages pour simplifier la gestion des données et améliorer la lisibilité du code.
Exemple: Package variablesConstantes
Dans ce premier exemple, le package variablesConstantes est créé pour contenir des constantes et variables que l’on peut réutiliser dans différents blocs PL/SQL.
Voici le code pour créer le package :
CREATE OR REPLACE PACKAGE variablesConstantes
IS
datesysteme DATE := SYSDATE;
nomuser VARCHAR(50) := USER;
END variablesConstantes;
- datesysteme DATE := SYSDATE; : Cette variable contient ladate systèmeau moment où le package est exécuté.
- nomuser VARCHAR(50) := USER; : Cette variable contient lenom de l’utilisateuractuel.
Une fois ce package créé, il est stocké dans le dossier des packages de SQL Developer, où il peut être consulté et appelé depuis d’autres programmes.
Pour utiliser ce package, on peut écrire un bloc PL/SQL comme suit :
SET SERVEROUTPUT On;
BEGIN
DBMS_OUTPUT.PUT_LINE('Date système : ' || variablesConstantes.datesysteme);
DBMS_OUTPUT.PUT_LINE('Utilisateur : ' || variablesConstantes.nomuser);
END;
/
- DBMS_OUTPUT.PUT_LINE affiche les valeurs de datesysteme et nomuser.
- La syntaxe variablesConstantes.datesysteme et variablesConstantes.nomuser permet d’accéder aux variables du package.
Résultat attendu : Cela affichera quelque chose comme :
Utilisation du Préfixe : On accède aux variables du package en utilisant le nom du package suivi du point (variablesConstantes.datesysteme).
Portée des Variables : Les variables dans le package sont globales pour toute session et peuvent être utilisées dans d’autres blocs PL/SQL sans avoir besoin de les redéclarer.
Exemple: Package variableApp
Dans ce deuxième exemple, le package variableApp contient des constantes utilisées pour des opérations de requête.
Voici le code pour créer le package :
CREATE OR REPLACE PACKAGE variableApp
IS
ville clients.ville%TYPE := 'Toulouse';
pays CONSTANT clients.pays%TYPE := 'France';
END variableApp;
- ville clients.ville%TYPE := ‘Toulouse’; : Cette variable contient la ville « Toulouse », en utilisant le même type que la colonne ville de la table clients.
- pays CONSTANT clients.pays%TYPE := ‘France’; : Cette constante contient la valeur « France », avec le même type que la colonne pays de la table clients. Elle est déclarée comme constante, ce qui signifie qu’elle ne peut pas être modifiée.
Pour utiliser ce package, on peut écrire un bloc PL/SQL comme suit :
DECLARE
var_nbr NUMBER;
BEGIN
SELECT COUNT(*) INTO var_nbr
FROM clients
WHERE ville = variableApp.ville AND pays = variableApp.pays;
END;
/
- La requête SQL compte le nombre de clients dont la ville est Toulouse et le pays est la France , en utilisant les variables définies dans le package variableApp.
- DBMS_OUTPUT.PUT_LINE affiche le nombre de clients trouvé.
Et voici son résultat lors de son exécution :
Corps de Package PL/SQL
Une fois la spécification du package définie, le corps du package (ou package body ) contient l’implémentation des procédures et fonctions déclarées dans la spécification. Le corps permet d’encapsuler la logique des opérations, en ne laissant accessible que la signature de celles-ci dans la spécification, améliorant ainsi l’encapsulation et la modularité de l’application.
La syntaxe de création d’un corps de package est la suivante :
CREATE [ OR REPLACE ] PACKAGE BODY <nom_package>
{ IS | AS }
[ Déclaration des variables et des types ]
[ Déclaration des curseurs ]
[ Déclaration des procédures et des fonctions ]
[ BEGIN
<instructions_plsql>;
[ EXCEPTIONS
<gestion_exception>
END <nom_package>;
Explications :
- Déclaration des variables et types :Les variables et types peuvent être définis ici pour un usage interne au package.
- Déclaration des curseurs :Vous pouvez déclarer des curseurs pour parcourir des ensembles de résultats.
- Déclaration des procédures et fonctions :C’est ici que vous implémentez la logique de vos fonctions et procédures.
- Bloc BEGIN et gestion des exceptions :Vous pouvez définir un bloc BEGIN pour des instructions PL/SQL exécutées dès que le package est initialisé, et gérer les exceptions.
Exemple: Package verifData
Voici un exemple illustrant la création d’un package verifData qui contient deux fonctions :
- verifClient :retourne true si un client existe.
- verifSalarie :retourne true si un salarié existe.
- Création de la Spécification du Package
CREATE OR REPLACE PACKAGE verifData IS
function verifClient(arg_numcli clients.numero_cli%type) RETURN BOOLEAN;
function verifSalarie(arg_numsal salaries.numero_sal%type) RETURN BOOLEAN;
nbr_ligne NUMBER;
END verifData;
- Création du Corps du Package
CREATE OR REPLACE PACKAGE BODY verifData IS
FUNCTION verifClient(arg_numcli clients.numero_cli%type) RETURN BOOLEAN AS
BEGIN
verifData.nbr_ligne := 0;
SELECT COUNT(*) INTO verifData.nbr_ligne FROM clients
WHERE numero_cli = arg_numcli;
IF verifData.nbr_ligne > 0 THEN
RETURN TRUE;
ELSE
RETURN FALSE;
END IF;
END verifClient;
FUNCTION verifSalarie(arg_numsal salaries.numero_sal%type) RETURN BOOLEAN AS
BEGIN
verifData.nbr_ligne := 0;
SELECT COUNT(*) INTO verifData.nbr_ligne FROM salaries
WHERE numero_sal = arg_numsal;
IF verifData.nbr_ligne > 0 THEN
RETURN TRUE;
ELSE
RETURN FALSE;
END IF;
END verifSalarie;
END verifData;
Explications des Points Clés
- Variables Globales dans le Corps :Ici, nbr_ligne est une variable partagée entre les fonctions verifClient et verifSalarie.
- Fonctions de Vérification :Les fonctions verifClient et verifSalarie effectuent une vérification simple de l’existence d’un enregistrement dans les tables clients et salaries.
Une fois le package créé avec succès, vous pouvez tester les fonctions ainsi :
Tester Fonctions de Package
- Vérification d’un Salarié
DECLARE
var_bool BOOLEAN;
BEGIN
var_bool := verifData.verifSalarie(2000);
IF var_bool THEN
DBMS_OUTPUT.PUT_LINE('Le salarié existe');
ELSE
DBMS_OUTPUT.PUT_LINE('Le salarié n''existe pas');
END IF;
END;
Et voici son résultat lors de son exécution :
- Vérification d’un Client
DECLARE
var_bool BOOLEAN;
BEGIN
var_bool := verifData.verifClient(10);
IF var_bool THEN
DBMS_OUTPUT.PUT_LINE('Le client existe');
ELSE
DBMS_OUTPUT.PUT_LINE('Le client n''existe pas');
END IF;
END;
Et voici son résultat lors de son exécution :
Pour tester si notre programme fonctionne correctement, nous allons lister les clients existants dans la table clients avec la commande SELECT * FROM clients et obtenir le résultat suivant :
Oubli de RETURN dans la Fonction : Assurez-vous que chaque fonction renvoie bien une valeur (TRUE ou FALSE dans cet exemple).
Variable Non Initialisée : Si nbr_ligne n’est pas initialisé à 0, les résultats peuvent être imprévisibles.
Formez-vous gratuitement avec Alphorm !
Maîtrisez les compétences clés en IT grâce à nos formations gratuites et accélérez votre carrière dès aujourd'hui.
FAQ
Qu'est-ce qu'un package en PL/SQL ?
Quels sont les avantages des packages PL/SQL ?
Comment structurer un package PL/SQL ?
Comment créer un package en PL/SQL ?
Quels exemples de packages PL/SQL pouvez-vous fournir ?
Conclusion
Les packages PL/SQL sont des composants puissants pour gérer efficacement le code en bases de données. En exploitant leur structure, vous pouvez améliorer la performance et la lisibilité de vos applications. Quels autres aspects des packages PL/SQL aimeriez-vous explorer davantage ?
