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.
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. |
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.
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.
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 ?
Comment fonctionne SQL%NOTFOUND ?
Quel est l'avantage de SQL%ROWCOUNT ?
Quand utiliser la clause SQL RETURNING ?
Comment utiliser SQL%ROWCOUNT pour suivre des opérations ?
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?