Modèles et structure des blocs PL/SQL pour Oracle

Ce document porte sur les modèles et la structure des blocs PL/SQL dans l’environnement Oracle. Il s’adresse principalement aux étudiants et développeurs débutants en programmation PL/SQL, souhaitant comprendre comment organiser et écrire des programmes efficaces dans ce langage procédural étendu de SQL.

La question

Le travail aborde la question de la structuration des programmes en PL/SQL, un langage procédural propre à Oracle qui étend les capacités du SQL. Il est important de comprendre comment organiser un bloc PL/SQL, quelles sont ses composantes, et comment utiliser les différentes constructions du langage pour écrire des programmes clairs et fonctionnels. Cette compréhension est essentielle pour toute personne souhaitant développer des applications utilisant des bases de données Oracle de manière avancée.

Concepts de base

Avant d’entrer dans les détails de la programmation PL/SQL, il faut rappeler que SQL est un langage de gestion de bases de données structuré en plusieurs catégories :

• LID (Langage d’Interrogation de Données) : pour les requêtes (exemple : SELECT)
• LDD (Langage de Définition des Données) : pour définir ou modifier la structure des données (exemples : CREATE, ALTER, DROP)
• LMD (Langage de Manipulation des Données) : pour modifier les données (exemples : INSERT, UPDATE, DELETE)

PL/SQL est une extension procédurale de SQL, propre à Oracle, qui permet d’écrire des programmes plus complexes en combinant des instructions SQL avec des constructions de programmation classiques (variables, boucles, conditions, etc.).

Approche

Le document présente d’abord les différents modèles de programmes en PL/SQL :

• Blocs anonymes
• Sous-programmes (procédures et fonctions)
• Procédures et fonctions stockées
• Triggers (déclencheurs)
• Packages

Chaque programme PL/SQL suit une structure en blocs prédéterminés, composés principalement de deux sections :

• La section de déclaration (optionnelle) : commence par le mot-clé DECLARE et sert à déclarer variables, constantes, types, et enregistrements.
• La section exécutable : commence par BEGIN et contient les instructions à exécuter, se terminant par END;.

Un bloc PL/SQL anonyme est exécuté en terminant par un slash / après le point-virgule de fin.

La section de déclaration

Elle permet de déclarer :

• Des variables de différents types (INTEGER, NUMBER, CHAR, VARCHAR2, LONG, DATE, BOOLEAN, etc.)
• Des constantes, avec le mot-clé CONSTANT
• Des types composites comme les RECORD, qui regroupent plusieurs champs sous un même type utilisateur

Les variables peuvent être initialisées lors de leur déclaration avec l’opérateur := ou le mot-clé DEFAULT. Par exemple :

DECLARE
  v_integer INTEGER := 12345;
  v_bool BOOLEAN := TRUE;
  v_char VARCHAR2(30) NOT NULL := 'SGBD';
  v_date DATE DEFAULT '01-Janv.-2009';
  v_constant CONSTANT NUMBER := 10;

Les règles de nommage imposent que les noms ne dépassent pas 30 caractères, commencent par une lettre, et soient différents des noms de colonnes ou tables utilisées dans le bloc.

La section exécutable

Elle contient les instructions qui seront réellement exécutées, telles que :

• Instructions d’affectation de valeurs aux variables
• Instructions de contrôle de flux (conditions, boucles)
• Instructions SQL (requêtes, modifications)
• Utilisation de curseurs

Exemple d’affectation dans la section exécutable :

BEGIN
  v_integer := 12345;
  v_bool := TRUE;
  v_char := 'SGBD';
  v_date := '21-févr.-2008';
END;

Structures de contrôle

PL/SQL offre plusieurs structures pour contrôler le flux du programme :

• IF .. THEN .. END IF : exécution conditionnelle simple
• IF .. THEN .. ELSE .. END IF : condition avec alternative
• IF .. THEN .. ELSIF .. THEN .. ELSE .. END IF : plusieurs conditions en cascade
• CASE : sélection multiple selon la valeur d’une expression
• WHILE .. LOOP .. END LOOP : boucle tant qu’une condition est vraie
• LOOP .. EXIT WHEN .. END LOOP : boucle avec sortie conditionnelle
• FOR .. IN .. LOOP .. END LOOP : boucle avec compteur, possibilité de parcours inversé

Exemple d’une structure IF :

DECLARE
  v1 INTEGER := 1100;
  v2 INTEGER := 200;
BEGIN
  IF v1 < v2 THEN
    dbms_output.put_line('v1 < v2');
  ELSE
    dbms_output.put_line('v2 <= v1');
  END IF;
END;

Exemple d’une boucle FOR :

DECLARE
  v1 INTEGER;
BEGIN
  FOR v1 IN 1..10 LOOP
    dbms_output.put_line(v1);
  END LOOP;
END;

L’instruction SELECT

PL/SQL permet d’exécuter des requêtes SQL et de stocker les résultats dans des variables grâce à la clause INTO. La requête doit retourner une seule ligne.

Exemple :

DECLARE
  salaire_moy employees.salary%TYPE;
BEGIN
  SELECT AVG(salary) INTO salaire_moy FROM employees WHERE department_id = 10;
  dbms_output.put_line('Le salaire moyen des employés du département 10 est : ' ||
    TO_CHAR(salaire_moy, '99999.99'));
END;

Il est aussi possible de récupérer une ligne entière dans une variable de type %ROWTYPE :

DECLARE
  v_emp employees%ROWTYPE;
BEGIN
  SELECT * INTO v_emp FROM employees WHERE employee_id = 124;
  dbms_output.put_line('Nom employé : ' || v_emp.last_name || CHR(10) ||
    'Fonction : ' || v_emp.job_id || CHR(10) || 'Département : ' ||
    v_emp.department_id || CHR(10) || 'Date recrutement : ' ||
    TO_CHAR(v_emp.hire_date, 'dd/mm/yyyy') || CHR(10) || 'Salaire : ' ||
    v_emp.salary);
END;

Résultats

Le document établit clairement que la programmation PL/SQL repose sur une structure en blocs avec une section déclarative et une section exécutable. Il montre comment déclarer et initialiser les variables, utiliser les types standards et composites, et contrôler le flux d’exécution avec des structures conditionnelles et itératives. L’utilisation de l’instruction SELECT avec INTO permet d’intégrer les résultats des requêtes SQL dans les programmes PL/SQL.

Ces éléments permettent de construire des programmes modulaires, lisibles et efficaces pour manipuler les données dans une base Oracle.

Limitations et questions ouvertes

Le document ne traite pas des aspects avancés tels que la gestion des exceptions, les curseurs explicites, ni la programmation orientée objet en PL/SQL. Il ne présente pas non plus les performances ou les bonnes pratiques d’optimisation. Ces points restent à approfondir pour une maîtrise complète du langage.

Glossaire

• PL/SQL : Langage procédural étendu de SQL, propre à Oracle.
• Bloc anonyme : Bloc PL/SQL sans nom, exécuté directement.
• Section déclarative : Partie d’un bloc PL/SQL où sont déclarées variables, constantes, types.
• Section exécutable : Partie d’un bloc PL/SQL contenant les instructions à exécuter.
• Variable : Zone mémoire nommée pouvant contenir une valeur modifiable.
• Constante : Variable dont la valeur ne peut pas changer après initialisation.
• Type RECORD : Type composite utilisateur regroupant plusieurs champs.
• Instruction SELECT INTO : Requête SQL qui stocke le résultat dans des variables PL/SQL.
• Structure de contrôle : Instruction permettant de contrôler le flux d’exécution (IF, LOOP, CASE, etc.).
• dbms_output.put_line : Procédure Oracle pour afficher du texte en sortie.