Tutoriel PL/SQL :Tout ce que vous devez savoir sur PL/SQL

PL/SQL est un langage procédural qui surmonte les lacunes rencontrées par le langage de requête structuré. C'est une extension de SQL et nous pouvons même utiliser des requêtes SQL sans aucun problème dans n'importe quelle application ou programme PL/SQL. Dans ce tutoriel PL/SQL, nous allons détailler les concepts de base de PL/SQL. Les sujets suivants sont traités dans cet article.

• Qu'est-ce que PL/SQL ?
  • Fonctionnalités
  • PL/SQL contre SQL
• Structures de blocs en PL/SQL
• Variables PL/SQL
• Fonction en PL/SQL
• Procédure PL/SQL
• Bloc imbriqué
• Instruction IF
• Déclaration CASE
• Instruction de boucle
  • Instruction de boucle While
  • Instruction de boucle For
• Manipulation exceptionnelle

Qu'est-ce que PL/SQL ?

Il représente l'extension du langage procédural au langage de requête structuré. Oracle a créé PL/SQL qui étend certaines limitations de SQL pour fournir une solution plus complète pour la création d'applications critiques exécutées sur la base de données Oracle.

Fonctionnalités

• PL/SQL fournit les fonctionnalités d'un langage procédural tel que la prise de décision, l'itération, etc.

• À l'aide d'une seule commande, PL/SQL peut exécuter un certain nombre de requêtes.

• Nous pouvons également réutiliser des unités PL/SQL telles que des fonctions, des déclencheurs, des procédures, etc. qui sont stockées dans la base de données après la création.

• PL/SQL dispose également d'un bloc de gestion des exceptions qui gère les exceptions dans PL/SQL.

• Une vérification approfondie des erreurs est également possible à l'aide de PL/SQL

• Les applications écrites en PL/SQL sont portables vers d'autres matériels et systèmes d'exploitation à condition qu'Oracle soit opérationnel.

PL/SQL contre SQL

Structures de blocs en PL/SQL

PL/SQL organise généralement le code en blocs. Le bloc de code sans nom est appelé bloc anonyme. Il est connu sous le nom de bloc anonyme car il n'est pas enregistré dans la base de données Oracle. Examinons un bloc anonyme en PL/SQL.

[DECLARE]
   declaration statements;
[BEGIN]
   execution statements;
   [EXCEPTION]
      exception statements;
END;
/

En regardant le diagramme ci-dessus, nous pouvons voir que la structure du bloc est divisée en quatre parties, c'est-à-dire la déclaration, le début, l'exception et la fin. Essayons de comprendre comment fonctionne la structure des blocs en PL/SQL. Parmi toutes ces sections, la section d'exécution est obligatoire et les autres sont facultatives.

• DÉCLARER mot-clé est utilisé pour la section de déclaration est utilisé pour déclarer des types de données et des structures telles que des variables, des fonctions, etc.

• COMMENCER mot-clé est utilisé pour la section d'exécution. Il est obligatoire et contient toutes les instructions qui doivent être exécutées. Ce bloc est l'endroit où la logique métier est définie, nous pouvons utiliser à la fois des instructions procédurales ou SQL dans ce bloc.

• L'EXCEPTION mot-clé est utilisé pour la section d'exception. Il contient toutes les déclarations d'exception.

• FIN Le mot-clé marque la fin du bloc et la barre oblique inverse "/" indique à l'outil que vous utilisez (Oracle Database Tool) pour exécuter le bloc PL/SQL.

Voici un exemple simple pour montrer comment nous pouvons utiliser le code PL/SQL.

BEGIN
       NULL;
END;
/

Maintenant que nous savons comment fonctionne la structure de blocs en PL/SQL, comprenons les différents aspects de PL/SQL comme déclarer, nommer et attribuer des valeurs aux variables.

Variables PL/SQL

La variable en PL/SQL est essentiellement un nom qui varie ou un emplacement de stockage temporaire qui prend en charge un type de données particulier. Voyons comment nous pouvons utiliser les variables dans un programme PL/SQL.

Règles de dénomination des variables

PL/SQL suit les règles suivantes pour nommer les variables.

• La variable ne peut pas dépasser 31 caractères

• Le nom de la variable doit commencer par un caractère ASCII. Étant donné que PL/SQL est sensible à la casse, une lettre majuscule et une lettre minuscule seront des variables différentes.

• Après le premier caractère, il doit y avoir un caractère spécial ($,_ ) ou n'importe quel nombre.

Conventions de dénomination

Utilisez les conventions de dénomination suivantes répertoriées ci-dessous pour utiliser les variables.

Déclaration

Essayons de comprendre comment se fait la déclaration des variables en PL/SQL

La déclaration inclut le nom de la variable suivi du type de données et séparé par un point-virgule. Voici un exemple pour montrer comment vous pouvez déclarer une variable en PL/SQL.

DECLARE
   v_name VARCHAR(25);
   n_age NUMBER(3);
BEGIN
  NULL;
END;

Vous pouvez également ajouter la longueur du type de données comme nous l'avons fait dans l'exemple ci-dessus.

Ancres

L'ancre fait essentiellement référence à l'utilisation du mot-clé %TYPE pour déclarer une variable avec le type de données associé au type de données d'une colonne d'une colonne particulière dans une table.

Jetez un oeil à un exemple pour comprendre cela. Supposons que nous ayons une table EMPLOYEES, nous pouvons utiliser les ancres de la manière suivante.

DECLARE
    v_name EMPLOYEE.NAME%TYPE;
    n_age    EMPLOYEE.AGE%TYPE;
BEGIN
   NULL;
END;
/

Devoir

L'affectation de variables est assez simple, nous pouvons utiliser l'opérateur d'affectation pour affecter des valeurs à une variable. L'exemple suivant montre comment nous pouvons attribuer des valeurs à une variable.

DECLARE
   v_name VARCHAR(20);
   n_course VARCHAR(10);
BEGIN
  v_name = "edureka";
  v_course = "sql";
END;
/

Initialisation

Nous pouvons également initialiser une valeur pour la variable dans la section de déclaration. L'exemple suivant montre comment nous pouvons initialiser les valeurs d'une variable.

DECLARE
v_name VARCHAR(20) = "edureka";
n_course VARCHAR(10) = "sql";
BEGIN
 NULL;
END;
/

Maintenant que nous savons comment nous pouvons travailler avec les variables, essayons de comprendre comment nous allons utiliser les fonctions en PL/SQL.

Fonction en PL/SQL

Une fonction en PL/SQL est essentiellement un bloc nommé qui renvoie une valeur. Il est également connu sous le nom de sous-programme ou de sous-programme, la syntaxe suivante montre comment nous pouvons utiliser les fonctions en PL/SQL.

CREATE [OR REPLACE] FUNCTION function_name [(
   parameter_1 [IN] [OUT] data_type,
   parameter_2 [IN] [OUT] data_type,
   parameter_N [IN] [OUT] data_type]
    RETURN return_data_type IS
 
BEGIN
   statements
   return return_data_type;
   EXCEPTION
     
END;
/

Tout d'abord, vous devez spécifier un nom de fonction après le mot-clé. Le nom de la fonction doit commencer par un verbe. Une fonction peut n'en avoir aucun, un ou plusieurs paramètres que nous spécifions dans parameters. Nous devons spécifier explicitement le type de données de chaque paramètre, puis vient le mode qui peut être l'un des suivants.

• EN – Le paramètre IN est un paramètre en lecture seule.

• OUT – C'est un paramètre en écriture seule

• IN OUT – Le paramètre IN OUT est à la fois un paramètre de lecture-écriture.

Voici un exemple simple pour montrer comment nous utilisons les fonctions en PL/SQL.

CREATE OR REPLACE FUNCTION try_parse(
    iv_number IN VARCHAR2)
  RETURN NUMBER IS
BEGIN
   RETURN to_number(iv_number);
   EXCEPTION
     WHEN others THEN
        RETURN NULL;
END;

Appeler une fonction

Essayons d'appeler la fonction que nous avons créée dans un bloc anonyme dans l'exemple suivant.

SET SERVEROUTPUT ON SIZE 1000000;
DECLARE
  n_x number;
  n_y number;
   n_z number;
BEGIN
   n_x := try_parse('256');
   n_y := try_parse('29.72');
   n_z := try_parse('pqrs');
 
   DBMS_OUTPUT.PUT_LINE(n_x);
   DBMS_OUTPUT.PUT_LINE(n_y);
   DBMS_OUTPUT.PUT_LINE(n_z);
END;
/

Nous pouvons également appeler la fonction dans une instruction SELECT. Maintenant que nous savons comment utiliser les fonctions en PL/SQL, essayons de comprendre comment nous travaillons avec les procédures en PL/SQL.

Procédure PL/SQL

Une procédure est essentiellement un bloc qui effectue une tâche spécifique. À l'aide d'une procédure, nous pouvons envelopper ou encapsuler une logique métier complexe et la réutiliser à la fois dans la couche application et dans la couche base de données.

Regardons un exemple simple pour comprendre le fonctionnement de la procédure en PL/SQL

CREATE OR REPLACE PROCEDURE adjust_salary(
    in_employee_id IN EMPLOYEES.EMPLOYEE_ID%TYPE,
    in_percent IN NUMBER
) IS
BEGIN
   -- update employee's salary
   UPDATE employees
   SET salary = salary + salary * in_percent / 100
   WHERE employee_id = in_employee_id;
END;

Dans l'exemple ci-dessus, nous avons deux paramètres, la procédure ajuste le salaire d'un pourcentage donné et le mot-clé UPDATE met à jour la valeur dans les informations sur le salaire.

En-tête de procédure

La section avant le mot-clé IS est appelée l'en-tête de la procédure. Voici quelques conseils avec lesquels vous devez vous familiariser lorsque vous travaillez avec des procédures.

• schéma – C'est le nom optionnel du schéma auquel appartient la procédure.

• nom – Le nom de la procédure qui doit commencer par un verbe.

• paramètres – C'est la liste facultative des paramètres.

• AUTHID – Il détermine si la procédure s'exécutera avec le privilège de l'utilisateur actuel ou du propriétaire d'origine de la procédure.

Organe de procédure

Tout ce qui vient après le mot-clé IS est appelé le corps de la procédure. Nous avons les instructions de déclaration, d'exception et d'exécution dans le corps de la procédure. Contrairement à la fonction, le mot-clé RETURN dans une procédure permet d'arrêter l'exécution et de rendre le contrôle à l'appelant.

Appeler une procédure

Voyons comment appeler une procédure en PL/SQL.

	
EXEC procedure_name(param1,param2…paramN);

Nous pouvons appeler les procédures sans paramètres en utilisant simplement le mot-clé EXEC et le nom de la procédure. Maintenant que nous savons comment utiliser les procédures, essayons de comprendre comment les blocs imbriqués sont utilisés en PL/SQL.

Bloc imbriqué

Un bloc imbriqué n'est rien d'autre qu'une combinaison d'un ou plusieurs blocs PL/SQL pour obtenir un meilleur contrôle sur l'exécution et une gestion exceptionnelle du programme.

Voici un exemple simple de bloc imbriqué.

SET SERVEROUTPUT ON SIZE 1000000;
DECLARE
  n_emp_id EMPLOYEES.EMPLOYEE_ID%TYPE := &emp_id1;
BEGIN
  DECLARE
    n_emp_id employees.employee_id%TYPE := &emp_id2;
    v_name   employees.first_name%TYPE;
  BEGIN
    SELECT first_name
    INTO v_name
    FROM employees
    WHERE employee_id = n_emp_id;
 
    DBMS_OUTPUT.PUT_LINE('First name of employee ' || n_emp_id || 
                                       ' is ' || v_name);
    EXCEPTION
      WHEN no_data_found THEN
        DBMS_OUTPUT.PUT_LINE('Employee ' || n_emp_id || ' not found');
  END;
END;
/

Le bloc PL/SQL externe dans l'exemple ci-dessus est appelé bloc parent ou bloc englobant, le bloc interne, quant à lui, est appelé bloc enfant ou bloc bloc fermé.

Ce n'est pas une bonne idée d'utiliser les variables avec les mêmes noms dans les deux blocs car pendant l'exécution, la variable de bloc enfant remplacera la variable de bloc parent. Cela se produit parce que PL/SQL donne la priorité à la variable à l'intérieur de son propre bloc.

Bloquer le libellé

Nous pouvons surmonter ce problème avec l'étiquette de bloc qui nous aide à faire des références aux variables à l'intérieur des blocs à l'aide d'une étiquette.

Voici un exemple simple pour montrer comment nous pouvons utiliser une étiquette de bloc.

<<block_label>>
DECLARE
...
BEGIN
...
END;

L'utilisation d'une étiquette de bloc permet d'améliorer la lisibilité du code, d'obtenir un meilleur contrôle et de faire des références aux blocs. Maintenant que nous savons comment travailler avec des blocs imbriqués, essayons de comprendre comment fonctionne IF STATEMENT en PL/SQL.

Instruction IF

PL/SQL a trois IF STATEMENTS

• SI-ALORS – C'est la plus simple IF STATEMENT si la condition est vraie les instructions s'exécuteront, si la condition est fausse, cela ne fait rien.

• SI-ALORS-SINON – Dans celui-ci, la clause ELSE est ajoutée pour une séquence alternative d'instructions.

• SI-ALORS-SINON – Cela nous permet d'exécuter plusieurs conditions de test dans une séquence.

Syntaxe SI-ALORS

IF condition THEN
   sequence_of_statements;
END IF;

Syntaxe SI-ALORS-SINON

IF condition THEN
   sequence_of_if_statements;
ELSE
   sequence_of_else_statements;
END IF;

Syntaxe SI-ALORS-ELSEIF

IF condition1  THEN
   sequence_of_statements1
ELSIF condition2 THEN
   sequence_of_statements2
ELSE
   sequence_of_statements3
END IF;

Maintenant que nous en avons fini avec IF STATEMENT, regardons l'instruction CASE en PL/SQL.

Énoncé de CAS

L'instruction CASE aide essentiellement à exécuter une séquence d'instructions basée sur un sélecteur. Un sélecteur, dans ce cas, peut être n'importe quoi, il peut s'agir d'une variable, d'une fonction ou d'une simple expression. Voici un exemple simple pour montrer la syntaxe de l'instruction CASE en PL/SQL.

[<<label_name>>]
CASE [TRUE | selector]
   WHEN expression1 THEN
 sequence_of_statements1;
   WHEN expression2 THEN
 sequence_of_statements2;
   ...
   WHEN expressionN THEN
 sequence_of_statementsN;
  [ELSE sequence_of_statementsN+1;]
END CASE [label_name];

Dans la syntaxe ci-dessus, après le mot-clé CASE vient le sélecteur. PL/SQL évaluera le sélecteur une seule fois pour déterminer quelle instruction doit être exécutée.

Suivi du sélecteur se trouve le mot-clé WHEN. Si l'expression satisfait le sélecteur, l'instruction correspondante après le mot-clé THEN est exécutée.

Maintenant que nous savons comment utiliser une instruction CASE, essayons de comprendre comment nous utiliserons les instructions de boucle dans le PL/SQL.

Instruction de boucle

Une instruction de boucle en PL/SQL est une instruction itérative qui vous permet d'exécuter plusieurs fois une séquence d'instructions. Voici un exemple simple pour montrer la syntaxe d'une instruction de boucle en PL/SQL.

LOOP
   sequence_of_statements;
END LOOP;

Il doit y avoir au moins une instruction exécutable entre les mots-clés LOOP et END LOOP.

Boucle avec instruction EXIT

Les instructions EXIT et EXIT when vous permettent de sortir de la boucle. L'instruction EXIT WHEN termine la boucle de manière conditionnelle tandis que EXIT termine l'exécution de manière inconditionnelle.

LOOP
   ...
   EXIT WHEN condition;
END LOOP;

Étiquette de boucle

Une étiquette de boucle est utilisée pour qualifier le nom de la variable de compteur de boucle lorsqu'elle est utilisée dans une boucle imbriquée. Voici la syntaxe d'une étiquette de boucle.

<<label>>
LOOP
   sequence_of_statements;
END LOOP label;

Maintenant que nous savons comment utiliser les instructions de boucle, examinons les instructions de boucle while pour une meilleure compréhension.

Instruction de boucle While

Nous pouvons utiliser l'instruction de boucle WHILE lorsque le nombre d'exécutions n'est pas défini avant le démarrage de l'exécution. La syntaxe suivante est utilisée pour une instruction de boucle WHILE en PL/SQL.

WHILE condition
LOOP
   sequence_of_statements;
END LOOP;

La condition dans la syntaxe est une valeur booléenne ou une expression qui est évaluée comme étant TRUE, FALSE ou NULL. Si la condition est VRAIE, les instructions seront exécutées, si elle est FAUX, l'exécution s'arrête et le contrôle passe à l'instruction exécutable suivante.

Maintenant que nous savons comment utiliser une instruction de boucle WHILE, examinons l'instruction de boucle FOR.

Instruction de boucle For

Une instruction de boucle FOR en PL/SQL nous permet d'exécuter une séquence d'instructions un nombre défini de fois. Voici la syntaxe pour utiliser l'instruction de boucle FOR en PL/SQL

FOR loop_counter IN [REVERSE] lower_bound .. higher_bound
LOOP
   sequence_of_statements;
END LOOP;

PL/SQL crée automatiquement une variable locale loop_counter avec un type de données INTEGER pour la boucle afin que vous n'ayez pas à la déclarer explicitement. La limite inférieure..la limite supérieure est la plage sur laquelle la boucle itère. De plus, vous devez avoir au moins une instruction exécutable entre les mots-clés LOOP et END LOOP.

Maintenant que nous savons comment utiliser les instructions de boucle en PL/SQL, examinons la gestion exceptionnelle en PL/SQL.

Manipulation exceptionnelle

En PL/SQL, tout type d'erreur est traité comme une exception. Une exception peut être traitée comme une condition spéciale qui peut changer ou altérer le flux d'exécution. En PL/SQL, il existe deux types d'exceptions.

• Exception système – Il est déclenché par l'environnement d'exécution PL/SQL lorsqu'il détecte une erreur.

• Exception définie par le programmeur – Ces exceptions sont définies par le programmeur dans une application spécifique.

Définir une exception

Une exception en PL/SQL doit être déclarée avant de pouvoir être déclenchée. Nous pouvons définir l'exception en utilisant le mot-clé EXCEPTION comme nous l'avons fait dans l'exemple ci-dessous.

EXCEPTION_NAME EXCEPTION;

Pour lever une exception, nous utilisons le mot-clé RAISE.

RAISE EXCEPTION_NAME;

C'était donc tout à propos de PL/SQL, j'espère que cet article vous a aidé à ajouter de la valeur à vos connaissances. Pour plus d'informations sur SQL ou les bases de données, vous pouvez vous référer à notre liste de lecture complète ici :Bases de données Edureka .

Si vous souhaitez obtenir une formation structurée sur MySQL, consultez notre Formation de certification MySQL DBA qui vient avec une formation en direct dirigée par un instructeur et une expérience de projet réelle. Cette formation vous aidera à comprendre MySQL en profondeur et vous aidera à maîtriser le sujet.

Vous avez une question pour nous ? Veuillez le mentionner dans la section des commentaires du ”tutoriel PL/SQL ” et je vous répondrai.