Comprendre les Attributs SQL en PL/SQL

La manipulation efficace des données en SQL peut souvent être complexe.

Sans vérification adéquate, des erreurs peuvent survenir, affectant la fiabilité des données.

L’article explore des attributs comme SQL%FOUND et SQL%ROWCOUNT pour garantir une gestion précise des données.

Table de matière

Attributs SQL en PL/SQL Utilisation de SQL%FOUND en PL/SQL Utilisation de SQL%NOTFOUND en PL/SQL Utilisation de SQL%ROWCOUNT en PL/SQL Clause RETURNING en SQL RETURNING dans INSERT SQL RETURNING dans UPDATE SQL RETURNING dans DELETE SQL FAQ Conclusion

Formation Le langage PL/SQL : Le Guide Complet

Maîtriser le langage SQL en environnement SGBDR. SQL n'aura plus de secrets pour vous !

En SQL, les attributs SQL%FOUND , SQL%NOTFOUND , et SQL%ROWCOUNT permettent de gérer les résultats de commandes de manipulation de données ( INSERT , UPDATE , et DELETE ) en fournissant des informations sur l’exécution de la dernière instruction.

Attributs SQL en PL/SQL

Attribut	Type	Utilisation
SQL%FOUND	BOOLEAN	Renvoie TRUE si la dernière instruction (INSERT, UPDATE, ou DELETE) a modifié au moins un enregistrement.
SQL%NOTFOUND	BOOLEAN	Renvoie TRUE si la dernière instruction n’a modifié aucun enregistrement, utile pour détecter des modifications échouées.
SQL%ROWCOUNT	–	Renvoie le nombre de lignes affectées par la dernière instruction, utile pour vérifier l’impact d’une opération.

Question : Pourquoi utiliser SQL%FOUND ou SQL%NOTFOUND ?

Ces attributs sont essentiels pour vérifier l’impact d’une instruction et éviter d’afficher ou de manipuler des données non modifiées, améliorant ainsi la fiabilité du code.

Utilisation de SQL%FOUND en PL/SQL

Dans cet exemple, nous utilisons SQL%FOUND pour vérifier si un salarié a bien été mis à jour. Cependant, un problème courant consiste à supposer que l’opération a échoué si SQL%FOUND est FALSE, ce qui peut être trompeur dans certains contextes.

				
					
 SET SERVEROUTPUT ON;
DECLARE
var_salarie salaries.numero_sal%TYPE := 2;
valeur_salaire salaries.salaire%TYPE;
BEGIN
-- Affiche le salaire avant l'augmentation
SELECT salaire INTO valeur_salaire FROM salaries WHERE numero_sal = var_salarie;
DBMS_OUTPUT.PUT_LINE('Salaire avant augmentation : ' || valeur_salaire);
-- Augmente le salaire de 20%
UPDATE salaries SET salaire = salaire * 1.2 WHERE numero_sal = var_salarie;
-- Vérifie si la mise à jour a été effectuée
IF SQL%FOUND THEN
SELECT salaire INTO valeur_salaire FROM salaries WHERE numero_sal = var_salarie;
DBMS_OUTPUT.PUT_LINE('Salaire après augmentation : ' || valeur_salaire);
END IF;
END;

Cet exemple vérifie que l’UPDATE a bien modifié la ligne correspondant au salarié. Si la condition SQL%FOUND est TRUE, le nouveau salaire est récupéré et affiché. Cette vérification assure que l’instruction a bien été appliquée.

Infos : SQL%FOUND est particulièrement utile pour éviter des sélections inutiles, en vérifiant que des modifications ont bien été apportées avant de continuer.

Le programme affiche le salaire avant et après l’augmentation, confirmant ainsi que la mise à jour a bien été effectuée.

Utilisation de SQL%NOTFOUND en PL/SQL

Ici, nous utilisons SQL%NOTFOUND pour vérifier si un salarié avec un numéro spécifique existe avant d’appliquer une mise à jour. Si le salarié n’existe pas, un message est affiché.

				
					
 DECLARE
var_salarie salaries.numero_sal%TYPE := 12;
BEGIN
-- Tente de mettre à jour le salaire du salarié
UPDATE salaries SET salaire = salaire * 1.2 WHERE numero_sal = var_salarie;
-- Affiche un message si le salarié n'existe pas
IF SQL%NOTFOUND THEN
DBMS_OUTPUT.PUT_LINE('Le salarié numéro ' || var_salarie || ' n''existe pas');
END IF;
END;

Dans cet exemple, si l’instruction UPDATE ne trouve aucun salarié avec le numéro spécifié, SQL%NOTFOUND renvoie TRUE, ce qui déclenche l’affichage du message indiquant que le salarié n’existe pas.

Si aucun salarié n’est trouvé avec le numéro spécifié, le programme affiche un message informant que le salarié n’existe pas.

Utilisation de SQL%ROWCOUNT en PL/SQL

Cet exemple utilise SQL%ROWCOUNT pour compter le nombre de salariés dont la commission a été mise à jour dans la table salaries.

				
					
 DECLARE
var_fonction salaries.fonction%TYPE := 'Vendeur';
BEGIN
-- Met à jour la commission des salariés avec la fonction 'Vendeur'
UPDATE salaries SET comission = salaire / 2 WHERE fonction = var_fonction;
-- Affiche le nombre de lignes affectées par l'UPDATE
DBMS_OUTPUT.PUT_LINE('Nombre de salariés mis à jour : ' || SQL%ROWCOUNT);
END;

Ici , SQL%ROWCOUNT renvoie le nombre de lignes modifiées par l’instruction UPDATE. Ce nombre est affiché pour indiquer combien de salariés ont été affectés par la mise à jour.

Astuce Pratique : Utilisez SQL%ROWCOUNT pour suivre l’impact des mises à jour ou suppressions, ce qui permet de générer des rapports ou des messages de confirmation pour l’utilisateur.

Le programme affiche le nombre de salariés pour lesquels la commission a été mise à jour, ce qui permet de vérifier l’impact de l’instruction UPDATE.

Clause RETURNING en SQL

La clause SQL RETURNING est particulièrement utile pour récupérer des informations d’enregistrements immédiatement après une opération de modification (INSERT, UPDATE, ou DELETE). Elle permet d’obtenir les valeurs des champs affectés sans avoir à exécuter une requête supplémentaire. Voici un aperçu des attributs associés et leurs utilisations :

Aspect	Détails
Fonction	Permet de renvoyer les valeurs de champs des enregistrements affectés par les ordres INSERT, UPDATE ou DELETE.
Limites	– Inutilisable avec un INSERT qui insère plusieurs enregistrements à partir d’une sous-requête.- Impossible d’utiliser * pour retourner l’ensemble des champs insérés.

RETURNING dans INSERT SQL

Dans cet exemple, on insère un nouvel enregistrement dans la table salaries et utilise la clause RETURNING pour récupérer certains champs de l’enregistrement inséré.

Problème courant : RETURNING ne peut pas être utilisé avec une sous-requête dans un INSERT multiple, ce qui peut limiter son utilisation.

				
					
 DECLARE
var_nom salaries.nom_sal%TYPE;
var_prenom salaries.prenom_sal%TYPE;
var_fonction salaries.fonction%TYPE;
BEGIN
INSERT INTO salaries VALUES (17, 'Basso', 'Karter', 'vendeur', 1750, NULL)
RETURNING nom_sal, prenom_sal, fonction INTO var_nom, var_prenom, var_fonction;
DBMS_OUTPUT.PUT_LINE('Nom inséré : ' || var_nom);
DBMS_OUTPUT.PUT_LINE('Prénom inséré : ' || var_prenom);
DBMS_OUTPUT.PUT_LINE('Fonction inséré : ' || var_fonction);
END;

La clause RETURNING récupère ici les valeurs des champs nom_sal, prenom_sal, et fonction de l’enregistrement nouvellement inséré, permettant de les afficher immédiatement après l’insertion.

Le programme affiche le nom, le prénom et la fonction de l’enregistrement inséré, confirmant la réussite de l’opération.

RETURNING dans UPDATE SQL

Ce second exemple montre comment utiliser RETURNING avec UPDATE pour récupérer la nouvelle valeur de la commission après une mise à jour.

				
					
 DECLARE
var_comission salaries.comission%TYPE;
BEGIN
UPDATE salaries SET comission = salaire / 2
WHERE nom_sal = 'Andrieu'
RETURNING comission INTO var_comission;
DBMS_OUTPUT.PUT_LINE('Nouvelle valeur de commission pour Andrieu : ' || var_comission);
END;

Ici, RETURNING récupère la valeur de la commission nouvellement calculée pour le salarié nommé Andrieu. Cela permet de vérifier la mise à jour immédiatement après son exécution.

Le programme affiche la nouvelle commission du salarié, indiquant que la mise à jour a bien été appliquée.

RETURNING dans DELETE SQL

Cet exemple utilise RETURNING pour récupérer les informations d’un salarié supprimé.

				
					
 DECLARE
var_salarie salaries%ROWTYPE;
BEGIN
DELETE salaries WHERE numero_sal = 4
RETURNING numero_sal, nom_sal, prenom_sal, fonction, salaire, comission INTO var_salarie;
DBMS_OUTPUT.PUT_LINE('Numéro du salarié supprimé : ' || var_salarie.numero_sal);
DBMS_OUTPUT.PUT_LINE('Nom du salarié supprimé : ' || var_salarie.nom_sal);
DBMS_OUTPUT.PUT_LINE('Prénom du salarié supprimé : ' || var_salarie.prenom_sal);
END;

Le RETURNING récupère ici les informations du salarié supprimé pour confirmer que l’opération DELETE a bien supprimé l’enregistrement ciblé.

Le programme affiche le numéro, nom et prénom du salarié supprimé, permettant ainsi de vérifier les données avant et après suppression.

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 que SQL%FOUND et quand l'utiliser ?

SQL%FOUND est un attribut BOOLEAN en PL/SQL qui renvoie TRUE si la dernière instruction INSERT, UPDATE ou DELETE a modifié au moins un enregistrement. Il est essentiel pour vérifier que l’opération a été exécutée avec succès avant de procéder à d’autres actions. Cela permet d’éviter des erreurs dans la manipulation de données non modifiées, augmentant ainsi la fiabilité du code.

Comment fonctionne SQL%NOTFOUND ?

SQL%NOTFOUND est utilisé pour détecter l’absence de modification par une commande SQL. Cet attribut renvoie TRUE si aucune ligne n’a été affectée, ce qui est utile pour identifier les tentatives de mise à jour ou de suppression échouées. Son utilisation permet d’éviter d’afficher ou de manipuler des données incorrectes, assurant ainsi l’intégrité des processus de données.

Quel est l'avantage de SQL%ROWCOUNT ?

SQL%ROWCOUNT renvoie le nombre de lignes affectées par la dernière instruction SQL exécutée. Cet attribut est particulièrement utile pour évaluer l’impact d’opérations de manipulation de données et pour générer des rapports ou des messages de confirmation. Il offre un moyen efficace de suivre et de valider les modifications apportées par des commandes SQL.

Quand utiliser la clause SQL RETURNING ?

La clause SQL RETURNING est utilisée pour récupérer les valeurs des champs des enregistrements affectés par les commandes INSERT, UPDATE ou DELETE. Cela permet d’obtenir immédiatement les informations modifiées sans avoir à exécuter une requête supplémentaire. Cependant, elle n’est pas utilisable avec des INSERT multiples basés sur des sous-requêtes, ce qui peut limiter son application.

Comment utiliser SQL%ROWCOUNT pour suivre des opérations ?

SQL%ROWCOUNT est utilisé pour suivre le nombre de lignes affectées par une commande SQL. En affichant ce nombre, les développeurs peuvent rapidement vérifier l’impact des modifications apportées par une opération, facilitant ainsi la génération de rapports et le suivi des transactions dans les applications PL/SQL. Cela aide à garantir que les opérations ont l’effet escompté.

Conclusion

En comprenant l’utilisation des attributs SQL et de la clause RETURNING, vous pouvez optimiser vos scripts PL/SQL pour une meilleure gestion des données. Comment envisagez-vous d’intégrer ces outils dans vos projets SQL pour améliorer vos processus de données?