Comprendre la gestion des données en PL/SQL peut être complexe, surtout avec les divers types disponibles.
Sans une bonne connaissance des types de données, structurer et manipuler des informations complexes devient difficile, entraînant des erreurs et des inefficacités.
Cet article vous guide à travers les types de données en PL/SQL, y compris les types composés, pour vous aider à structurer vos données efficacement.
Maîtriser le langage SQL en environnement SGBDR. SQL n'aura plus de secrets pour vous !
Dans ce chapitre, nous allons explorer les différents types de données disponibles en PL/SQL, au-delà des types de base comme VARCHAR2, NUMBER, etc. Nous aborderons :
- Les types définis par les utilisateurs.
- Les types composés comme les enregistrements et les tableaux.
- Les variables basées sur d’autres objets.
Types de données définis par l'utilisateur PL/SQL
PL/SQL vous permet de définir vos propres types de données afin de structurer et manipuler des informations complexes.
Deux types dérivés possibles :
- Les types bornés :Définis avec des contraintes spécifiques comme des plages de valeurs autorisées.
- Les types non bornés :Alias ou synonymes d’un type de base, sans contrainte particulière.
SUBTYPE <nom_type> IS TYPE [ (CONSTRAINT) ] [NOT NULL];
Exemple
SUBTYPE age_type IS NUMBER(3);
Enregistrements et structures PL/SQL
Une structure, aussi appelée enregistrement en PL/SQL, est un type composé qui permet de regrouper plusieurs champs de données, chacun pouvant avoir un type différent. C’est une façon d’organiser des données complexes de manière logique.
Syntaxe de déclaration d’une structure
TYPE <nom_type_structure> IS RECORD (
<nom_champ1> TYPE [NOT NULL] [:= EXPRESSION1],
<nom_champ2> TYPE [NOT NULL] [:= EXPRESSION2],
...
);
- Exemple
Déclaration d’une structure de type RECORD pour représenter un client :
-- Déclaration d'une structure de type RECORD pour représenter un client
TYPE ClientRecord IS RECORD (
numero_cli NUMBER(38,0),
nom VARCHAR2(50),
prenom VARCHAR2(50),
adresse VARCHAR2(100),
code_postal NUMBER(5,0),
ville VARCHAR2(50),
pays VARCHAR2(50),
telephone NUMBER(11,0),
fax NUMBER(11,0)
);
Syntaxe d’utilisation d’une structure
Après avoir déclaré une structure, vous pouvez l’utiliser pour créer des variables qui contiendront les enregistrements des données. Voici comment cela se fait :
<nom_enregistrement> <nom_type_structure>;
- Exemple complet
Cet exemple illustre comment déclarer et utiliser une structure de type RECORD en PL/SQL pour représenter les détails d’un client. Vous verrez également comment initialiser ses valeurs et les afficher à l’aide de la procédure DBMS_OUTPUT.PUT_LINE.
DECLARE
-- Déclaration d'une structure de type RECORD pour représenter un client
TYPE ClientRecord IS RECORD (
numero_cli NUMBER(38,0),
nom VARCHAR2(50),
prenom VARCHAR2(50),
adresse VARCHAR2(100),
code_postal NUMBER(5,0),
ville VARCHAR2(50),
pays VARCHAR2(50),
telephone NUMBER(11,0),
fax NUMBER(11,0)
);
-- Déclaration d'une variable de type ClientRecord
v_client ClientRecord;
BEGIN
-- Exemple d'initialisation des valeurs de l'enregistrement
v_client.numero_cli := 1001;
v_client.nom := 'Durand';
v_client.prenom := 'Sophie';
v_client.adresse := '25 Rue des Lilas';
v_client.code_postal := 75001;
v_client.ville := 'Paris';
v_client.pays := 'France';
v_client.telephone := 12345678901;
v_client.fax := 98765432101;
-- Affichage des valeurs (juste à titre d'exemple)
DBMS_OUTPUT.PUT_LINE('Numéro Client: ' || v_client.numero_cli);
DBMS_OUTPUT.PUT_LINE('Nom: ' || v_client.nom);
DBMS_OUTPUT.PUT_LINE('Prénom: ' || v_client.prenom);
DBMS_OUTPUT.PUT_LINE('Adresse: ' || v_client.adresse);
DBMS_OUTPUT.PUT_LINE('Téléphone: ' || v_client.telephone);
DBMS_OUTPUT.PUT_LINE('Fax: ' || v_client.fax);
END;
Explication
- TYPE ClientRecord IS RECORD :Cette structure correspond à la table CLIENT, où chaque champ est associé à son type de données respectif (comme NUMBER, VARCHAR2, etc.).
- v_client :Une variable de type ClientRecord qui contient un enregistrement avec toutes les colonnes.
- Le bloc BEGIN initialise les champs de l’enregistrement avec des valeurs d’exemple (comme un numéro de client, un nom, un prénom, etc.), et affiche ces valeurs via DBMS_OUTPUT.PUT_LINE.
Ce bloc PL/SQL permet de manipuler un enregistrement de la table CLIENT en utilisant une structure composite.
Résultat d’affichage :
Ce résultat montre les valeurs des champs initialisés dans l’enregistrement v_client.
Tableaux composés PL/SQL
Les tableaux en PL/SQL sont utilisés pour stocker plusieurs éléments du même type, et ils sont souvent utilisés pour manipuler des ensembles de données de manière efficace.
Les tableaux associatifs
Les tableaux associatifs en PL/SQL sont des collections indexées par un type spécifique (comme un entier ou une chaîne de caractères). Ces tableaux n’ont pas de taille prédéfinie et peuvent être modifiés dynamiquement.
Pour déclarer une tableau associatif , voici la syntaxe à respecter :
TYPE <nom_type_tableau> IS TABLE OF <type_valeur> [NOT NULL]
INDEX BY {PLS_INTEGER | BINARY_INTEGER | VARCHAR2(TAILLE)};
Voilà un exemple de déclaration :
TYPE tableau_salaire IS TABLE OF NUMBER INDEX BY PLS_INTEGER;
Pour déclarer une variable de type tableau associatif, utilisez la syntaxe suivante :
<nom_variable> <nom_type_tableau>;
Voici un exemple illustrant comment utiliser un tableau associatif en PL/ :
DECLARE
-- Déclaration d'un tableau associatif pour stocker les noms de clients
TYPE ClientNamesTable IS TABLE OF VARCHAR2(50) INDEX BY PLS_INTEGER;
-- Déclaration d'une variable de type ClientNamesTable
client_names ClientNamesTable;
BEGIN
-- Initialisation des valeurs dans le tableau associatif
client_names(1001) := 'Dupont';
client_names(1002) := 'Martin';
client_names(1003) := 'Durand';
-- Affichage des noms des clients à partir de leur numéro
DBMS_OUTPUT.PUT_LINE('Nom du client 1001: ' || client_names(1001));
DBMS_OUTPUT.PUT_LINE('Nom du client 1002: ' || client_names(1002));
DBMS_OUTPUT.PUT_LINE('Nom du client 1003: ' || client_names(1003));
END;
Explication
- TYPE ClientNamesTable IS TABLE OF VARCHAR2(50) INDEX BY NUMBER :Déclare un tableau associatif qui contient des noms de clients (de type VARCHAR2), indexés par leur numéro de client (NUMBER).
- client_names(1001) := ‘Dupont’;: Initialise le nom du client avec le numéro 1001.
- DBMS_OUTPUT.PUT_LINE :Affiche les noms des clients en utilisant leur clé NUMERO_CLI.
Ce tableau associatif vous permet de stocker et accéder aux noms des clients via leur numéro de client, sans utiliser de structures complexes.
Et voici son résultat lors de son exécution :
Tableaux pré-dimensionnés PL/SQL
Les tableaux pré-dimensionnés sont des collections dont la taille est fixe, c’est-à-dire qu’ils contiennent un nombre déterminé d’éléments.
Voici la syntaxe de déclaration d’un tableau pré-dimensionné
TYPE <nom_type_tableau> IS VARRAY(TAILLE) OF <type_valeur> [NOT NULL];
Voilà un exemple de déclaration :
TYPE tableau_age IS VARRAY(10) OF NUMBER(3);
Pour déclarer une variable de type tableau pré-dimensionné, utilisez la syntaxe suivante :
<nom_variable> <nom_type_tableau>;
Voici un exemple illustrant comment utiliser un tableau pré-dimensionné pour stocker des numéros de téléphone :
DECLARE
-- Déclaration d'un VARRAY pour stocker 5 numéros de téléphone maximum
TYPE PhoneNumbersArray IS VARRAY(5) OF NUMBER(11);
-- Déclaration d'une variable de type PhoneNumbersArray
client_phones PhoneNumbersArray;
BEGIN
-- Initialisation des valeurs dans le VARRAY
client_phones := PhoneNumbersArray(12345678901, 23456789012, 34567890123);
-- Affichage des numéros de téléphone
FOR i IN 1..client_phones.COUNT LOOP
DBMS_OUTPUT.PUT_LINE('Numéro de téléphone ' || i || ': ' || client_phones(i));
END LOOP;
END;
Explication
- TYPE PhoneNumbersArray IS VARRAY(5) OF NUMBER(11) :Déclare un tableau pré-dimensionné (VARRAY) qui peut contenir jusqu’à 5 éléments de type NUMBER(11), chaque élément correspondant à un numéro de téléphone.
- client_phones := PhoneNumbersArray(…): Initialise le tableau avec trois numéros de téléphone.
- client_phones.COUNT :Cette méthode retourne le nombre d’éléments actuellement stockés dans le tableau.
- FOR i IN 1..client_phones.COUNT LOOP :Boucle pour afficher chaque numéro de téléphone stocké dans le tableau.
Résultat d’affichage :
Lorsque vous exécutez le code PL/SQL fourni, le résultat affiché dans la console sera :
Caractéristique | VARRAY (Tableau pré-dimensionné) | Tableau Associatif |
|---|---|---|
Taille | Taille maximale définie lors de la déclaration (fixe). | Taille dynamique, sans limite prédéfinie. |
Indexation | Indexé par des entiers séquentiels commençant à 1. | Indexé par des entiers (PLS_INTEGER ou BINARY_INTEGER), ou par des chaînes. |
Mémoire | Allocation de mémoire pour tous les éléments, même si non utilisés. | Mémoire allouée au fur et à mesure que des éléments sont ajoutés. |
Accès aux éléments | Accès par position (numéro de l’index). | Accès par clé (entier ou chaîne). |
Taille limite | La taille maximale est définie à l’avance et ne peut être dépassée. | Aucune limite de taille prédéfinie. |
Utilisation fréquente | Idéal pour les tableaux de petite taille et les données à accès séquentiel. | Idéal pour les associations clé-valeur dynamiques. |
Modifiable dynamiquement | Peut être étendu ou raccourci dans les limites définies. | Peut ajouter ou supprimer des éléments sans limite prédéfinie. |
Méthodes disponibles | COUNT, EXTEND, LIMIT, etc. | COUNT, pas de limite (pas de LIMIT). |
Ordre de parcours | Parcours dans l’ordre des index. | Parcours dans l’ordre des clés, non garanti pour les clés non numériques. |
Contrainte d’index | Doit être indexé par des entiers naturels (1, 2, 3, …). | Peut être indexé par des entiers ou des chaînes. |
Utilisation | Convient pour des collections de petite taille avec un nombre connu d’éléments. | Utilisé pour des collections flexibles et dynamiques, comme des tables de hachage. |
En résumé :
- VARRAY :Utilisé lorsque vous avez une taille fixe et que vous voulez limiter le nombre d’éléments. Il est utile lorsque les données sont accédées de manière séquentielle.
- Tableau associatif :Plus flexible, il est utilisé pour gérer des ensembles de données dynamiques indexés par des valeurs scalaires (comme des entiers ou des chaînes).
Actions sur tableaux PL/SQL
Voici les actions courantes que vous pouvez effectuer sur des tableaux en PL/SQL :
- EXISTS(n) :Vérifie si l’élément à l’index n existe dans le tableau.
- COUNT :Retourne le nombre d’éléments dans le tableau.
- FIRST et LAST :Retourne respectivement le premier et le dernier index du tableau.
- PRIOR(n) et NEXT(n) :Retourne l’index précédent ou suivant par rapport à n.
- TRIM(n) :Supprime les n derniers éléments du tableau.
- DELETE(n) :Supprime l’élément à l’index n.
Variables basées et types PL/SQL
PL/SQL propose deux attributs spéciaux qui permettent de créer des variables basées sur la définition de colonnes ou de lignes de tables.
Attribut %TYPE
Cet attribut permet de définir une variable ayant le même type qu’une colonne d’une table ou une autre variable déjà définie.
Voilà une syntaxe de déclaration avec %TYPE
<nom_variable> <nom_table.colonne>%TYPE;
Supposons que vous souhaitez créer une variable pour stocker le salaire d’un employé en utilisant le type exact de la colonne SALAIRE dans la table SALARIES. Voici comment vous pourriez procéder :
DECLARE
-- Déclaration de la variable avec le même type que la colonne SALAIRE
emp_salaire SALARIES.SALAIRE%TYPE;
BEGIN
-- Affectation d'une valeur à la variable emp_salaire
emp_salaire := 3000.50;
-- Affichage du salaire de l'employé
DBMS_OUTPUT.PUT_LINE('Salaire de l employé : ' || emp_salaire);
END;
Explication
- emp_salaire SALARIES.SALAIRE%TYPE; :Cette déclaration crée la variable emp_salaire et l’associe au type de la colonne SALAIRE de la table SALARIES. Cela garantit que emp_salaire a le même type de données et les mêmes contraintes que SALAIRE, qui est NUMBER(10,2) dans ce cas.
- emp_salaire := 3000.50;: On assigne la valeur 3000.50 à emp_salaire.
- DBMS_OUTPUT.PUT_LINE :Affiche la valeur de emp_salaire.
Attribut %ROWTYPE
Cet attribut permet à une variable d’hériter de toutes les caractéristiques d’une ligne de table. Cela signifie qu’une variable définie avec %ROWTYPE peut contenir une ligne complète de données d’une table.
Syntaxe de déclaration avec %ROWTYPE
<nom_variable> <nom_table>%ROWTYPE;
Voici un exemple pour %ROWTYPE
DECLARE
-- Déclaration d'une variable de type enregistrement pour une ligne de la table SALARIES
employe_record SALARIES%ROWTYPE;
BEGIN
-- Affectation de valeurs aux champs de l'enregistrement
employe_record.NUMERO_SAL := 1001;
employe_record.NOM_SAL := 'Dupont';
employe_record.PRENOM_SAL := 'Jean';
employe_record.FONCTION := 'Analyste';
employe_record.SALAIRE := 3500.00;
employe_record.COMISSION := 500.00;
-- Affichage des informations de l'employé
DBMS_OUTPUT.PUT_LINE('Numéro d\'employé : ' || employe_record.NUMERO_SAL);
DBMS_OUTPUT.PUT_LINE('Nom : ' || employe_record.NOM_SAL);
DBMS_OUTPUT.PUT_LINE('Prénom : ' || employe_record.PRENOM_SAL);
DBMS_OUTPUT.PUT_LINE('Fonction : ' || employe_record.FONCTION);
DBMS_OUTPUT.PUT_LINE('Salaire : ' || employe_record.SALAIRE);
DBMS_OUTPUT.PUT_LINE('Commission : ' || employe_record.COMISSION);
END;
Explication
- employe_record SALARIES%ROWTYPE; :Cette déclaration crée une variable employe_record qui a la même structure qu’une ligne de la table SALARIES. Cela signifie que employe_record contient tous les champs de la table SALARIES (NUMERO_SAL, NOM_SAL, PRENOM_SAL, FONCTION, SALAIRE, et COMISSION) avec leurs types respectifs.
- Affectation des valeurs :Chaque champ de employe_record est rempli individuellement avec une valeur spécifique.
- Affichage des informations :Les valeurs de chaque champ de employe_record sont affichées avec DBMS_OUTPUT.PUT_LINE.
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
Quels sont les types de données en PL/SQL ?
Comment créer un type d'enregistrement en PL/SQL ?
Qu'est-ce qu'un tableau associatif en PL/SQL ?
Comment utiliser l'attribut %TYPE en PL/SQL ?
À quoi sert l'attribut %ROWTYPE en PL/SQL ?
Conclusion
En maîtrisant les types de données et les structures en PL/SQL, vous pouvez optimiser la gestion de vos informations complexes. Quelle structure aimeriez-vous explorer davantage pour améliorer vos applications PL/SQL ?
