Scheda di revisione: Introduction à la Programmation PL/SQL Oracle

📋 Plan du Cours

1. Introduction à PL/SQL
2. Variables et types
3. Structures de contrôle
4. Blocs de programmes
5. Types de données
6. Déclaration et affectation
7. Structures conditionnelles
8. Structures itératives
9. Gestion des exceptions
10. Utilisation des curseurs
11. Fonctions et procédures

📖 1. Introduction à PL/SQL

🔑 Notions clés & Définitions

• PL/SQL (Procedural Language/Structured Query Language) : Langage de programmation procédural propriétaire d'Oracle, permettant de combiner SQL et structures de contrôle pour le développement d'applications autour de bases de données relationnelles.
• Bloc PL/SQL : Ensemble d'instructions structuré comprenant généralement une déclaration de variables, un corps d'exécution, et une gestion des exceptions, délimité par BEGIN et END.
• Variables : Espaces mémoire pour stocker des données temporaires, déclarées avec un nom, un type, et éventuellement une valeur initiale. Types courants : NUMBER, VARCHAR2, %TYPE, %ROWTYPE.
• Types de données : Classification des données manipulées (scalaires, composites, structurés). Exemples : NUMBER, CHAR, BOOLEAN, RECORD, TABLE.
• Structures de contrôle : Outils permettant la logique conditionnelle et répétitive, telles que IF, CASE, LOOP, WHILE, FOR, EXIT.

📝 Points essentiels

• PL/SQL est une extension d'Oracle permettant d'écrire des programmes procéduraux intégrés aux requêtes SQL, facilitant la gestion complexe des données et des erreurs.
• La structure d’un programme est généralement composée d’un ou plusieurs blocs, avec déclaration de variables (DECLARE), instructions (BEGIN ... END), et gestion des exceptions (EXCEPTIONS).
• Les variables doivent être déclarées avant utilisation, avec des types adaptés, notamment %TYPE et %ROWTYPE pour une compatibilité automatique avec les colonnes ou lignes de tables.
• Les principales structures de contrôle incluent : IF-THEN-ELSE, CASE, LOOP, WHILE, FOR, avec la possibilité d’utiliser EXIT pour sortir d’une boucle.
• La syntaxe est proche du langage Ada, avec une gestion stricte des blocs et des terminators (;).

💡 À retenir

PL/SQL est un langage procédural intégré à Oracle, essentiel pour développer des applications robustes, modulaires et efficaces en combinant SQL et structures de contrôle, tout en permettant une gestion avancée des erreurs et des traitements complexes.

📖 2. Variables et types

🔑 Notions clés & Définitions

• Variable : Espace mémoire nommé permettant de stocker une valeur modifiable durant l'exécution du programme.
• Type de données : Catégorie définissant la nature des valeurs qu'une variable peut contenir (ex : NUMBER, VARCHAR, BOOLEAN).
• %TYPE : Déclaration d'une variable prenant le même type que la colonne d'une table ou d'une vue, assurant la cohérence avec la structure de la base.
• %ROWTYPE : Déclaration d'une variable pouvant contenir une ligne entière d'une table ou vue.
• Constante : Variable dont la valeur ne peut pas être modifiée après déclaration, utilisée pour des valeurs fixes.
• Types structurés : Types définis par l'utilisateur, tels que RECORD (struct) ou TABLE (tableau indexé).

📝 Points essentiels

• Déclaration de variables : Syntaxe nom_variable type [:= valeur]; ; ne pas déclarer plusieurs variables en une seule ligne.
• Affectation : Par := ou via SELECT ... INTO pour récupérer une valeur d'une requête.
• Conflit de noms : Si une variable a le même nom qu'une colonne, c'est la colonne qui prévaut ; il est conseillé d’éviter cette confusion.
• Types de données :
  • Prédéfinis : NUMBER, VARCHAR2, DATE, BOOLEAN, etc.
  • Structurés : RECORD, TABLE (tableau indexé).
• Types de collection :
  • TABLE OF <type> INDEXED BY BINARY_INTEGER ; permet de gérer des tableaux dynamiques.
• Utilisation de %TYPE et %ROWTYPE : Garantissent la cohérence avec la structure de la base, facilitant la maintenance.
• Blocs PL/SQL : Composés de sections DECLARE, BEGIN, EXCEPTIONS, END ; seuls BEGIN et END sont obligatoires.
• Structures de contrôle : IF (condition), CASE (plusieurs valeurs), LOOP, WHILE, FOR, EXIT pour gérer la logique conditionnelle et itérative.

💡 À retenir

Les variables en PL/SQL, avec leurs types et structures, permettent de manipuler efficacement les données, d’assurer la cohérence avec la base, et de structurer la logique de programmation pour des traitements complexes et sécurisés.

📖 3. Structures de contrôle

🔑 Notions clés & Définitions

• Structure conditionnelle (IF, CASE) : Permet d'exécuter différentes instructions selon que la condition est vraie ou fausse.
• IF THEN ELSE : Structure conditionnelle permettant de choisir entre deux blocs d'instructions.
• CASE : Structure permettant de tester une variable contre plusieurs valeurs possibles, équivalent à plusieurs IF imbriqués.
• Structures itératives (LOOP, WHILE, FOR) : Permettent de répéter un bloc d'instructions plusieurs fois.
• EXIT : Instruction pour sortir prématurément d'une boucle.
• Variables %TYPE et %ROWTYPE : Définissent des variables en fonction du type d'une colonne ou d'une ligne entière d'une table.

📝 Points essentiels

• Structures conditionnelles :
  • IF simple : IF <condition> THEN ... END IF;
  • IF avec ELSE : IF <condition> THEN ... ELSE ... END IF;
  • IF avec ELSIF : permet de tester plusieurs conditions successives.
  • CASE : test de plusieurs valeurs pour une variable, plus lisible que plusieurs IF.
• Structures itératives :
  • LOOP : répète indéfiniment jusqu'à un EXIT.
  • WHILE : répète tant que la condition est vraie.
  • FOR : boucle avec un compteur, itère sur une plage ou en ordre inverse.
• Affectation de variables :
  • Par := ou SELECT INTO.
  • Conflit de noms : si une variable a le même nom qu'une colonne, la colonne prévaut.
• Gestion des erreurs :
  • Bloc EXCEPTIONS pour traiter les erreurs.
• Utilisation des boucles avec EXIT :
  • Permet de sortir d'une boucle conditionnellement.

💡 À retenir

Les structures de contrôle en PL/SQL permettent d'écrire des programmes procéduraux complexes, combinant conditions et répétitions, indispensables pour la logique métier et la gestion des flux dans les applications de bases de données.

📖 4. Blocs de programmes

🔑 Notions clés & Définitions

• Bloc de programme : unité structurée de code en PL/SQL comprenant généralement une déclaration, un corps d'exécution, et une gestion des exceptions, délimité par BEGIN et END.
• Variables : espaces mémoire pour stocker des données temporaires, déclarées avec un type précis, accessibles uniquement dans le bloc où elles sont déclarées.
• Types de données : classifications des données (ex : NUMBER, VARCHAR2, DATE, BOOLEAN, RECORD, TABLE) permettant de définir la nature des valeurs stockées.
• %TYPE et %ROWTYPE : mécanismes de déclaration de variables héritant du type d'une colonne ou d'une ligne entière d'une table ou vue.
• Structures de contrôle : instructions conditionnelles (IF, CASE) et itératives (LOOP, WHILE, FOR) permettant la logique procédurale dans les blocs.

📝 Points essentiels

• Un bloc PL/SQL se compose généralement de trois parties : déclaration (DECLARE), exécution (BEGIN ... END), et gestion des exceptions (EXCEPTIONS).
• La déclaration des variables doit précéder leur utilisation ; leur portée est limitée au bloc où elles sont déclarées.
• Les types de données supportent aussi bien des types simples que des types structurés comme RECORD ou TABLE.
• Les structures conditionnelles permettent de réaliser des tests complexes avec IF, ELSIF, CASE.
• Les structures itératives (LOOP, WHILE, FOR) facilitent la répétition de blocs d'instructions avec ou sans condition d'arrêt.
• La gestion des erreurs s'effectue via la section EXCEPTIONS, permettant de traiter les exceptions levées lors de l'exécution.

💡 À retenir

Les blocs de programmes en PL/SQL sont la base de la programmation procédurale dans Oracle, combinant déclarations, logique conditionnelle et itérative, pour créer des applications robustes et modulaires autour des bases de données relationnelles.

📖 5. Types de données

🔑 Notions clés & Définitions

• Type de données : Classification des valeurs que peuvent prendre les variables dans un langage de programmation ou une base de données. Elle détermine la nature et le format des données stockées.
• Types primitifs : Types de base supportés nativement par le langage ou le SGBD, tels que NUMBER, VARCHAR2, DATE, BOOLEAN.
• Types structurés : Types complexes regroupant plusieurs valeurs, comme RECORD (struct) ou TABLE (tableau indexé).
• %TYPE : Attribut permettant de déclarer une variable avec le même type qu'une colonne d'une table ou d'une vue, assurant la cohérence.
• %ROWTYPE : Attribut permettant de déclarer une variable correspondant à une ligne entière d'une table ou vue.
• Types utilisateur : Types définis par l'utilisateur pour créer des structures de données spécifiques, comme des enregistrements ou des tableaux.

📝 Points essentiels

• Types standards SQL : char, varchar, number, date, etc., utilisés pour la manipulation de données.
• Types intégrés dans PL/SQL : boolean, binary, integer, etc., permettant des traitements spécifiques.
• Types structurés :
  • Record : regroupement de plusieurs champs (équivalent struct en C).
  • Table : tableau de données, pouvant être associatif (indexé par BINARY_INTEGER).
• Déclaration de variables : syntaxe nom_variable type [:= valeur];. Utilisation de %TYPE et %ROWTYPE pour garantir la compatibilité avec la structure des tables.
• Types de données utilisateur : création de types personnalisés pour répondre à des besoins spécifiques.
• Affectation : opérateur := ou INTO dans une requête SELECT.
• Conflit de noms : éviter de nommer une variable identiquement à une colonne pour ne pas masquer cette dernière.

💡 À retenir

Les types de données en PL/SQL permettent de structurer et de manipuler efficacement les informations, en assurant cohérence et précision dans le traitement des données. La maîtrise des types, notamment avec %TYPE et %ROWTYPE, facilite la compatibilité avec la structure des tables et optimise la gestion des données.

📖 6. Déclaration et affectation

🔑 Notions clés & Définitions

• Déclaration de variable : Instruction permettant de réserver un espace mémoire pour stocker une valeur, en précisant son nom, son type, et éventuellement une valeur initiale.
• Affectation : Opération qui consiste à donner une valeur à une variable déclarée, généralement avec l’opérateur := ou via une requête SELECT INTO.
• Types de variables : Catégories de données qu’une variable peut contenir, telles que NUMBER, VARCHAR2, %TYPE, %ROWTYPE, BOOLEAN, RECORD, TABLE.
• %TYPE : Attribut permettant de déclarer une variable du même type qu’une colonne ou une variable existante, assurant la cohérence.
• %ROWTYPE : Attribut permettant de déclarer une variable capable de contenir une ligne entière d’une table ou d’une vue.
• Conflit de noms : Situation où une variable porte le même nom qu’une colonne, la colonne ayant priorité dans l’interprétation.

📝 Points essentiels

• La déclaration de variables doit précéder leur utilisation et se fait généralement dans la section DECLARE d’un bloc PL/SQL.
• La syntaxe d’affectation est variable := valeur;.
• La déclaration multiple de variables sur une seule ligne est interdite.
• Les types de variables peuvent être simples (ex : integer, varchar) ou complexes (%TYPE, %ROWTYPE, RECORD, TABLE).
• Pour éviter les conflits, il est conseillé de ne pas nommer une variable identiquement à une colonne d’une table.
• La portée d’une variable est limitée à le bloc où elle est déclarée, sauf si elle est déclarée dans un bloc supérieur.

💡 À retenir

L’affectation et la déclaration de variables dans PL/SQL permettent de manipuler efficacement des données en assurant la cohérence des types et en évitant les conflits de noms, ce qui est essentiel pour la programmation structurée et la gestion des données dans les blocs PL/SQL.

📖 7. Structures conditionnelles

🔑 Notions clés & Définitions

• Structure conditionnelle (IF) : Permet d'exécuter des blocs d'instructions en fonction de la véracité d'une condition.
• IF THEN ELSE : Structure qui exécute un bloc si la condition est vraie, sinon un autre bloc.
• IF THEN ELSIF : Permet de tester plusieurs conditions successives.
• CASE : Structure permettant de tester une variable contre plusieurs valeurs ou expressions, facilitant la gestion de plusieurs cas.
• Points essentiels :
  • La syntaxe est spécifique à PL/SQL, avec des mots-clés comme IF, THEN, ELSE, ELSIF, END IF, CASE.
  • Les conditions peuvent être imbriquées pour gérer des scénarios complexes.
  • La structure CASE peut être utilisée pour simplifier plusieurs tests de valeurs.
  • Les structures conditionnelles sont souvent combinées avec des structures itératives pour la logique de contrôle avancée.

📝 Points essentiels

• La syntaxe de base de IF :

  IF <condition> THEN
    <instructions>
  END IF;
  

• Imbrication de conditions avec ELSE et ELSIF :

  IF <condition1> THEN
    <instructions1>
  ELSIF <condition2> THEN
    <instructions2>
  ELSE
    <instructions3>
  END IF;
  

• La structure CASE est utilisée pour tester une variable contre plusieurs valeurs :

  val := CASE <variable>
           WHEN <valeur1> THEN <résultat1>
           WHEN <valeur2> THEN <résultat2>
           ELSE <résultat par défaut>
         END;
  

• La structure LOOP et ses variantes (WHILE, FOR) permettent d'exécuter des blocs de façon répétée, souvent combinés avec des conditions pour contrôler la boucle (EXIT WHEN).

💡 À retenir

Les structures conditionnelles en PL/SQL permettent de diriger le flux d'exécution selon des critères précis, rendant la programmation plus flexible et adaptée à des scénarios complexes. La maîtrise de IF, ELSE, ELSIF, et CASE est essentielle pour écrire des programmes structurés et efficaces.

📖 8. Structures itératives

🔑 Notions clés & Définitions

• Boucle (loop) : Structure permettant de répéter un groupe d'instructions plusieurs fois.
• WHILE : Structure de boucle qui s'exécute tant qu'une condition est vraie.
• FOR : Boucle qui s'exécute un nombre déterminé de fois, avec une variable d'itération.
• EXIT : Instruction permettant de sortir prématurément d'une boucle.
• Imbrication : Possibilité d'imbriquer des structures de contrôle à l’intérieur d’autres pour gérer des cas complexes.

📝 Points essentiels

• Les structures itératives permettent d'automatiser la répétition d'instructions dans un programme PL/SQL.
• La boucle LOOP s'exécute indéfiniment sauf si un EXIT est rencontré.
• La boucle WHILE vérifie une condition avant chaque itération, s’arrêtant si la condition devient fausse.
• La boucle FOR est idéale pour un nombre fixe d’itérations, avec une variable d’itération qui change automatiquement.
• La commande EXIT WHEN permet de sortir d’une boucle en fonction d’une condition spécifique.
• La syntaxe précise et la gestion des conditions sont essentielles pour éviter les boucles infinies ou les erreurs logiques.
• La structure CASE permet de gérer plusieurs cas en une seule instruction, souvent utilisée pour le traitement conditionnel.

💡 À retenir

Les structures itératives en PL/SQL offrent une flexibilité essentielle pour répéter ou contrôler l’exécution de blocs d’instructions, facilitant la programmation procédurale dans le contexte des bases de données relationnelles. La maîtrise de ces boucles et de leur sortie conditionnelle est cruciale pour écrire des programmes efficaces et sûrs.

📖 9. Gestion des exceptions

🔑 Notions clés & Définitions

• Exception : Événement anormal ou erreur survenant lors de l'exécution d’un programme PL/SQL, nécessitant une gestion spécifique.
• Gestion des exceptions : Mécanisme permettant de capturer et traiter les erreurs pour éviter l’arrêt brutal du programme.
• Exceptions prédéfinies : Exceptions standard fournies par Oracle (ex : NO_DATA_FOUND, ZERO_DIVIDE).
• Exceptions utilisateur : Exceptions personnalisées déclarées par le programmeur pour gérer des erreurs spécifiques.
• Bloc EXCEPTION : Partie du programme où sont traitées les exceptions capturées.
• Raisons de gestion : Garantir la cohérence des données, assurer la robustesse du programme, fournir des messages d’erreur compréhensibles.

📝 Points essentiels

• La gestion des exceptions se fait dans la section EXCEPTION d’un bloc PL/SQL.
• Utilisation du mot-clé WHEN pour associer une exception à un traitement spécifique.
• Exemples d’exceptions prédéfinies :
  • NO_DATA_FOUND : aucune ligne trouvée lors d’un SELECT INTO.
  • ZERO_DIVIDE : division par zéro.
  • OTHERS : capture toutes les autres exceptions non spécifiées.
• La clause WHEN OTHERS doit être placée en dernier pour capturer toutes les autres erreurs.
• La levée d’une exception se fait avec RAISE ou implicitement lors d’une erreur.
• La gestion efficace des exceptions permet de maintenir l’intégrité des données et d’éviter l’arrêt brutal du programme.

💡 À retenir

La gestion des exceptions en PL/SQL consiste à anticiper et traiter les erreurs pour assurer la stabilité et la fiabilité des applications, en utilisant des blocs EXCEPTION et des exceptions prédéfinies ou utilisateur.

📖 10. Utilisation des curseurs

🔑 Notions clés & Définitions

• Curseur : Un mécanisme permettant de manipuler et de parcourir les résultats d'une requête SQL ligne par ligne dans PL/SQL.
• Curseur implicite : Géré automatiquement par PL/SQL lors de l'exécution d'une requête SELECT INTO.
• Curseur explicite : Déclaré et contrôlé manuellement par le programmeur pour gérer plusieurs lignes de résultats.
• OPEN : Instruction pour ouvrir un curseur explicite et lancer la requête associée.
• FETCH : Instruction pour récupérer la ligne suivante du curseur dans une variable.
• CLOSE : Instruction pour fermer un curseur et libérer ses ressources.

📝 Points essentiels

• Utilisation des curseurs explicites : Nécessitent leur déclaration, ouverture, récupération des lignes (FETCH), puis fermeture.
• Syntaxe d’un curseur explicite :

  DECLARE
    CURSOR nom_curseur IS requête;
    variable(s) pour stocker les résultats;
  BEGIN
    OPEN nom_curseur;
    LOOP
      FETCH nom_curseur INTO variables;
      EXIT WHEN nom_curseur%NOTFOUND;
      -- traitement sur les données récupérées
    END LOOP;
    CLOSE nom_curseur;
  END;
  

• Gestion des erreurs : Utilisation de blocs EXCEPTION pour traiter les erreurs liées aux curseurs.
• Curseurs pour traitement multi-lignes : Indispensables pour parcourir et manipuler plusieurs résultats d’une requête SELECT.
• Différence avec SELECT INTO : SELECT INTO récupère une seule ligne, tandis que FETCH avec curseur permet de traiter plusieurs lignes.

💡 À retenir

Les curseurs en PL/SQL sont essentiels pour parcourir et traiter efficacement plusieurs lignes de résultats d'une requête, en contrôlant manuellement leur ouverture, récupération et fermeture pour une gestion précise des données.

📖 11. Fonctions et procédures

🔑 Notions clés & Définitions

• Fonction : Un sous-programme qui retourne une valeur et peut prendre des paramètres en entrée. Elle est utilisée pour effectuer un calcul ou une opération spécifique et renvoyer un résultat.
• Procédure : Un sous-programme qui exécute une série d'instructions sans forcément retourner une valeur. Elle peut modifier des variables ou effectuer des opérations sur la base de données.
• Bloc PL/SQL : Un ensemble d'instructions regroupées entre BEGIN et END, pouvant contenir déclarations, instructions, et gestion des exceptions.
• Variables : Espaces mémoire déclarés pour stocker des données temporaires, déclarées avec un type précis.
• Types de données : Définitions des formats de données (ex : NUMBER, VARCHAR2, DATE, BOOLEAN) utilisés dans les variables, paramètres, et constantes.
• Gestion des exceptions : Mécanisme pour traiter les erreurs ou situations exceptionnelles dans un bloc PL/SQL avec la section EXCEPTIONS.

📝 Points essentiels

• Structure d’un programme PL/SQL : Composé d’un ou plusieurs blocs, chaque bloc pouvant contenir des déclarations, instructions, et gestion des erreurs.
• Déclaration de variables : Avant utilisation, déclarer dans la section DECLARE avec un type précis ou en utilisant %TYPE et %ROWTYPE pour assurer la compatibilité avec les colonnes ou lignes de table.
• Appel de fonctions et procédures :
  • Procédures : EXECUTE nom_proc; ou BEGIN nom_proc; END;
  • Fonctions : résultat := nom_fonction(paramètres);
• Utilisation des paramètres :
  • IN (entrée), OUT (sortie), IN OUT (entrée/sortie).
  • Les paramètres permettent de transmettre des valeurs à une procédure ou une fonction.
• Types de données structurés :
  • RECORD : regroupement de plusieurs champs.
  • TABLE (table indexée) : collection de données pouvant contenir plusieurs éléments.
• Contrôles de flux : Structures conditionnelles (IF, CASE) et itératives (LOOP, WHILE, FOR) pour contrôler l'exécution des instructions.
• Gestion des exceptions : EXCEPTION pour capturer et traiter les erreurs, évitant l'arrêt brutal du programme.
• Conflit de noms : Éviter de nommer une variable identique à une colonne pour ne pas masquer la colonne dans les requêtes.

💡 À retenir

Les fonctions et procédures en PL/SQL permettent de modulariser, réutiliser et structurer le code, facilitant la maintenance et la gestion des opérations complexes dans la programmation de bases de données relationnelles.

📊 Tableaux de Synthèse

Aspect	Introduction à PL/SQL	Variables et Types	Structures de Contrôle	Blocs de Programmes
Définition	Langage procédural Oracle combinant SQL et contrôle	Espaces mémoire pour stocker données, déclarées avec types	Outils pour logique conditionnelle et répétitive	Unité structurée comprenant déclaration, exécution, gestion erreurs
Syntaxe clé	BEGIN ... END, DECLARE, EXCEPTIONS	nom_variable type [:= valeur];, %TYPE, %ROWTYPE	IF, CASE, LOOP, WHILE, FOR, EXIT	Sections : DECLARE, BEGIN, EXCEPTIONS, END
Utilité	Développer applications robustes, gestion erreurs	Manipuler données, assurer cohérence avec la base	Contrôler flux d'exécution, répétitions	Structurer code, modulariser, gérer erreurs
Types principaux	NUMBER, VARCHAR2, DATE, BOOLEAN, RECORD, TABLE	Types simples et structurés, constantes	Conditions, boucles, sorties précoces	Variables locales, portée limitée, gestion d'exceptions

⚠️ Pièges & Confusions Fréquentes

1. Confusion entre %TYPE et déclaration explicite de types.
2. Oublier le ; à la fin des instructions.
3. Utiliser des noms de variables identiques à des noms de colonnes, provoquant des ambiguïtés.
4. Confondre LOOP infini sans EXIT ou boucle WHILE mal conditionnée.
5. Ne pas gérer les exceptions, entraînant des erreurs non traitées.
6. Déclarer plusieurs variables en une seule ligne, ce qui n’est pas recommandé.
7. Utiliser des types structurés sans bien maîtriser leur déclaration et manipulation.
8. Confusion entre BEGIN ... END et DECLARE (qui est optionnel).
9. Oublier la portée limitée des variables déclarées dans un bloc.
10. Mal utiliser SELECT INTO sans vérifier la présence de résultats, menant à des exceptions.
11. Ne pas utiliser %ROWTYPE pour manipuler des lignes entières, entraînant des incohérences.

✅ Checklist Examen

• Définir ce qu’est un bloc PL/SQL et ses composants.
• Expliquer la différence entre variables déclarées avec types simples et %TYPE.
• Illustrer l’usage de IF, CASE dans une structure conditionnelle.
• Décrire le fonctionnement d’une boucle FOR et WHILE.
• Expliquer comment gérer les exceptions dans un bloc PL/SQL.
• Définir l’usage des curseurs et leur rôle dans la récupération de données.
• Illustrer la déclaration et l’utilisation d’une procédure et d’une fonction.
• Expliquer la différence entre DECLARE et BEGIN.
• Décrire comment déclarer et utiliser un type RECORD.
• Expliquer la syntaxe pour affecter une valeur à une variable.
• Définir ce qu’est un curseur explicite et comment l’utiliser.
• Vérifier la compréhension de la gestion des erreurs avec EXCEPTIONS.
• Savoir comment utiliser %ROWTYPE pour manipuler une ligne entière.
• Connaître la structure d’un programme modulaire en PL/SQL.
• Identifier les pièges courants liés à la portée des variables.
• Expliquer le rôle des blocs EXCEPTION dans la gestion des erreurs.
• Décrire la différence entre une procédure et une fonction.
• Savoir utiliser EXIT pour sortir d’une boucle.
• Comprendre la syntaxe de déclaration d’une variable constante.
• Savoir comment utiliser un curseur pour parcourir des résultats.
• Vérifier la syntaxe correcte pour une boucle LOOP.
• Connaître la différence entre BOOLEAN et autres types de données.
• Savoir comment déclarer une collection (TABLE ou VARRAY).
• Identifier les erreurs fréquentes lors de la déclaration ou de l’affectation.