SQL Server

Bonnes pratiques pour UPDATE et DELETE sûrs dans SQL Server

Suivez une méthode SQL Server pour prévisualiser les lignes, compter les cibles, utiliser une transaction, vérifier le résultat et choisir COMMIT ou ROLLBACK.

Par JaviPublié 15 min de lectureDébutant

Un UPDATE ou un DELETE peut toucher plus de lignes que prévu si la base ou le filtre est incorrect. Le bon réflexe consiste à suivre une séquence : confirmer la base, prévisualiser les lignes avec SELECT, les compter, effectuer la modification, inspecter le résultat, puis décider entre COMMIT et ROLLBACK. Les leçons sur UPDATE et DELETE présentaient chaque instruction ; ici, elles s’inscrivent dans une méthode répétable. Entraînez-vous uniquement dans la base synthétique JaviBuildsLab, jamais en production.

Confirmer le contexte de la base

Une fenêtre de requête SSMS peut rester connectée au serveur tandis que sa base sélectionnée change. Avant de modifier des données, demandez à SQL Server quelle base la session utilise :

Requête SQL: Confirmer le contexte de la baseT-SQL
SELECT DB_NAME() AS CurrentDatabase;
T-SQL1 ligneAffichage en lecture seule. Aucune connexion à une base de données.

Pour ces exercices, le résultat attendu est JaviBuildsLab. S’il diffère, ne continuez pas. Sélectionnez la bonne base dans SSMS ou, si cela convient, changez explicitement de contexte avec USE JaviBuildsLab;, puis vérifiez de nouveau. USE modifie le contexte de la connexion ; il ne crée pas la base et ne prouve pas que ses tables contiennent les données attendues. Dans Azure SQL Database, connectez-vous directement à la base nommée, car USE n’y est pas pris en charge.

Prévisualiser exactement les lignes visées

Écrivez d’abord le SELECT en utilisant la même table FROM et la même condition WHERE que l’UPDATE ou le DELETE à venir. Pour une seule ligne d’exercice, une clé primaire constitue généralement un choix clair :

Requête SQL: Prévisualiser exactement les lignes viséesT-SQL
SELECT CustomerId, FirstName, LastName, City, State
FROM dbo.Customers
WHERE CustomerId = 11;
T-SQL3 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Examinez les valeurs, et pas seulement la présence d’une ligne. Confirmez qu’il s’agit du client souhaité et que le nombre de lignes correspond à votre attente. Si la ligne manque, l’instruction suivante ne toucherait aucune ligne. Si des lignes supplémentaires apparaissent, précisez le filtre avant toute modification. Si vous ne comprenez pas les résultats, arrêtez-vous et demandez ce que signifient les données plutôt que de deviner.

Compter les lignes attendues

Un compte facilite la comparaison avec votre attente :

Requête SQL: Compter les lignes attenduesT-SQL
SELECT COUNT(*) AS RowsToChange
FROM dbo.Customers
WHERE CustomerId = 11;
T-SQL3 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Si vous en attendez une et obtenez 1, le nombre est cohérent. Si vous obtenez 0 ou 1 000, arrêtez-vous et vérifiez. Le compte est un deuxième contrôle utile, pas un remplacement de l’inspection des lignes. Pour une modification de groupe, exécutez SELECT sur le détail et COUNT avec exactement le même filtre. Vérifiez que chaque ligne affichée appartient à la modification.

Quand l’objectif est de modifier une ligne, privilégiez une clé primaire ou un autre identifiant unique. Un filtre comme State = 'FL' peut correspondre à plusieurs clients. Cela peut être voulu si toutes ces lignes doivent changer, mais ne supposez jamais quelle est l’étendue. Examinez les résultats, comparez le compte à votre attente et précisez la condition si nécessaire. Une condition WHERE valide en SQL peut tout de même exprimer une mauvaise intention.

Utiliser une transaction pendant l’exercice

Une transaction rassemble plusieurs instructions afin de pouvoir les valider ou les annuler. Pour apprendre, gardez-la ouverte pendant l’inspection du résultat modifié, puis utilisez ROLLBACK afin de restaurer l’état initial de la base :

Requête SQL: Utiliser une transaction pendant l’exerciceT-SQL
BEGIN TRANSACTION;

UPDATE dbo.Customers
SET City = N'Orlando'
WHERE CustomerId = 11;

SELECT @@ROWCOUNT AS RowsUpdated;
SELECT CustomerId, City FROM dbo.Customers WHERE CustomerId = 11;

ROLLBACK TRANSACTION;

SELECT CustomerId, City FROM dbo.Customers WHERE CustomerId = 11;
T-SQL12 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Le premier SELECT après UPDATE lit @@ROWCOUNT avant qu’une autre instruction ne remplace sa valeur. Le SELECT suivant affiche la valeur temporaire dans la transaction. ROLLBACK annule la modification non validée ; le dernier SELECT permet de confirmer le retour à l’ancienne valeur. Si la ligne cible n’existait pas, UPDATE touche zéro ligne ; il faut tout de même fermer la transaction.

ROLLBACK TRANSACTION n’annule que les changements effectués dans une transaction encore ouverte. Ce n’est pas une commande d’annulation générale après COMMIT. Une déconnexion ou une erreur suit les règles transactionnelles de SQL Server, mais ce n’est pas une stratégie d’exercice. Terminez l’opération consciemment et vérifiez l’état de la transaction.

Choisir entre COMMIT et ROLLBACK

COMMIT TRANSACTION rend les changements de la transaction permanents du point de vue de la session. N’utilisez COMMIT qu’après avoir confirmé la base, les lignes visées, le compte attendu, les valeurs obtenues et l’intention, et seulement si vous êtes autorisé à effectuer cette modification. ROLLBACK TRANSACTION abandonne le travail non validé. Pendant l’apprentissage, utilisez ROLLBACK par défaut. Le diagramme insiste sur cette décision : un résultat correct peut être validé ; un résultat incorrect ou incertain doit être annulé.

@@TRANCOUNT indique combien d’instructions BEGIN TRANSACTION sont actives dans la session. Après COMMIT ou ROLLBACK de la transaction externe, le compte doit revenir à zéro :

Requête SQL: Choisir entre COMMIT et ROLLBACKT-SQL
SELECT @@TRANCOUNT AS OpenTransactionCount;
T-SQL1 ligneAffichage en lecture seule. Aucune connexion à une base de données.

Un nombre supérieur à zéro indique qu’une transaction reste ouverte. Fermez-la explicitement avant de poursuivre. XACT_STATE() fournit un autre indicateur SQL Server : transaction active et validable, non validable, ou inexistante. Il peut aider au traitement d’erreurs, mais cette méthode pour débutants n’a pas besoin de logique avancée ; retenez qu’il faut vérifier et fermer la transaction.

Garder le filtre et la vérification précis

La condition WHERE du SELECT, du compte et de la modification doit être la même. Pour un seul enregistrement, préférez sa clé primaire. Après le changement, relisez la ligne et comparez-la au résultat attendu. Lisez @@ROWCOUNT immédiatement après UPDATE ou DELETE, puis lancez le SELECT de vérification. Un compte d’une ligne ne prouve pas que vous avez sélectionné le bon client, et une valeur correcte ne prouve pas que les autres lignes n’ont pas changé. Les deux vérifications sont utiles.

Les modifications importantes demandent davantage de préparation qu’un exemple de débutant. Ne transformez pas une modification de toute la table en exercice improvisé et ne choisissez pas une stratégie de lots au hasard. Avant une modification de grande ampleur, faites examiner la cible, le nombre attendu et le processus approuvé par la personne responsable. La performance et le découpage en lots sont des sujets avancés distincts ; cette leçon porte sur la justesse et la vérification.

Les transactions sont utiles, mais ne remplacent ni les sauvegardes, ni un plan de restauration, ni l’autorisation et le contrôle des changements. Une modification validée peut exiger une restauration ou une autre procédure examinée. En production, suivez les exigences de validation, de sauvegarde et de revue de votre organisation. Cette série utilise uniquement JaviBuildsLab et ses lignes synthétiques.

Que faire si les vérifications divergent ?

Traitez toute différence comme un signal d’arrêt. Si DB_NAME() indique une autre base, corrigez la connexion avant toute lecture ou modification. Si SELECT affiche un client inattendu, ne changez pas le WHERE de l’UPDATE puis ne l’exécutez pas aussitôt : corrigez l’aperçu et examinez son nouveau résultat. Si COUNT dépasse votre attente, identifiez les lignes supplémentaires. S’il vaut zéro, vérifiez que la ligne d’exercice existe. Si @@ROWCOUNT diffère du compte aperçu, arrêtez-vous avant toute suite et cherchez pourquoi l’ensemble cible a changé ou pourquoi les instructions diffèrent.

L’aperçu et la modification sont deux instructions distinctes ; une autre session pourrait modifier les données entre les deux. Pour un exercice de débutant dans une base locale, c’est peu probable, mais il est utile de comprendre que SELECT suivi d’UPDATE ne garantit pas dans tous les contextes que rien d’autre ne touche la cible. N’essayez pas de résoudre ici les sujets de concurrence ou d’isolation. Dans un environnement partagé ou de production, suivez une procédure relue pour ce système et consultez son responsable.

Pendant l’exercice, gardez la transaction courte et ciblée. Ouvrez-la juste avant la modification, inspectez le résultat et fermez-la par ROLLBACK. Ne laissez pas une fenêtre SSMS avec une transaction ouverte pendant que vous passez à une autre tâche. D’autres opérations de la session pourraient en faire partie, ce qui compliquerait la compréhension des changements. @@TRANCOUNT fournit une vérification simple avant de quitter l’exercice.

En cas d’erreur, lisez le message et inspectez l’état de la transaction avant d’agir. XACT_STATE() peut indiquer si une transaction active est validable ou doit être annulée, mais ne remplace pas la compréhension de l’erreur. Pour cette leçon, arrêtez-vous, utilisez ROLLBACK si SQL Server le permet, vérifiez @@TRANCOUNT et comparez les données à leur état attendu. Ne relancez pas à répétition une modification qui a échoué ou dont le résultat est incertain.

L’ordre des vérifications compte. Confirmer la base avant SELECT évite d’inspecter une table au nom similaire ailleurs. Réutiliser exactement le prédicat limite l’écart entre les lignes examinées et celles modifiées. Lire @@ROWCOUNT immédiatement conserve la preuve du nombre de lignes touchées par l’instruction. La relecture rend le résultat visible, et la fermeture de la transaction empêche les opérations suivantes de s’y ajouter par accident. Chaque contrôle est simple ; ensemble, ils rendent la modification plus facile à comprendre et à expliquer.

Pour les débutants, le résultat le plus sûr est souvent une modification d’exercice réussie puis annulée. Vous apprenez comment SQL Server exécute l’instruction, à quoi ressemble la ligne concernée et comment fonctionne la transaction, tout en restaurant les données locales. Si le résultat ne correspond pas à l’attendu, ne multipliez pas les modifications pour le rendre plausible. Annulez, inspectez de nouveau les données initiales et corrigez la requête lorsque la transaction d’essai est fermée.

Un modèle qui privilégie ROLLBACK

Utilisez ce modèle de relecture après avoir remplacé la table, les colonnes et le filtre par une instruction que vous comprenez. Exécutez SELECT et COUNT en premier. Ouvrez ensuite la transaction, effectuez une modification, lisez immédiatement le nombre et inspectez le résultat. Par défaut, le modèle termine par ROLLBACK. COMMIT n’apparaît que comme point de décision commenté ; ne le décommentez pas pour un exercice ordinaire.

Requête SQL: Un modèle qui privilégie ROLLBACKT-SQL
SELECT DB_NAME() AS CurrentDatabase;

SELECT CustomerId, FirstName, LastName, City
FROM dbo.Customers
WHERE CustomerId = 11;

SELECT COUNT(*) AS RowsToChange
FROM dbo.Customers
WHERE CustomerId = 11;

BEGIN TRANSACTION;

UPDATE dbo.Customers
SET City = N'Orlando'
WHERE CustomerId = 11;

SELECT @@ROWCOUNT AS RowsChanged;

SELECT CustomerId, FirstName, LastName, City
FROM dbo.Customers
WHERE CustomerId = 11;

-- COMMIT TRANSACTION;
ROLLBACK TRANSACTION;

SELECT @@TRANCOUNT AS OpenTransactionCount;
T-SQL26 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Pour un exercice DELETE, remplacez UPDATE par DELETE FROM dbo.Customers WHERE CustomerId = 11; et vérifiez avec SELECT pendant que la transaction est encore ouverte. Le ROLLBACK final doit restaurer la ligne. N’exécutez jamais un modèle copié sans comprendre chaque prédicat et la table ciblée.

Erreurs courantes et exercices

Les erreurs courantes sont de commencer une transaction puis de l’oublier, de valider avant vérification, de croire que ROLLBACK annule un COMMIT, d’utiliser un filtre large, de choisir la mauvaise base, de copier du SQL sans le comprendre ou de tester des suppressions sur un système de production. Rendez chaque étape visible : confirmer la base, inspecter les lignes, vérifier le compte, faire une seule modification, lire le résultat et le nombre, puis décider explicitement. Pendant l’apprentissage, la décision est normalement ROLLBACK.

  1. Que doit afficher DB_NAME() avant ces exercices ?
  2. Écrivez l’aperçu et le compte pour le client 11.
  3. Pourquoi COMMIT est-il commenté et ROLLBACK actif dans le modèle ?
  4. Que doit indiquer @@TRANCOUNT après l’annulation de la transaction ?
  5. Citez deux protections qu’une transaction ne remplace pas.

Réponses

Requête SQL: RéponsesT-SQL
-- 1
SELECT DB_NAME() AS CurrentDatabase;

-- 2
SELECT CustomerId, FirstName, LastName, City
FROM dbo.Customers WHERE CustomerId = 11;
SELECT COUNT(*) AS RowsToChange
FROM dbo.Customers WHERE CustomerId = 11;

-- 4
SELECT @@TRANCOUNT AS OpenTransactionCount;
T-SQL11 lignesAffichage en lecture seule. Aucune connexion à une base de données.

La base attendue est JaviBuildsLab. L’aperçu affiche les valeurs et COUNT contrôle le nombre de lignes correspondantes. ROLLBACK est actif pour que l’exercice soit annulé par défaut ; COMMIT exige une décision délibérée et revue. Une fois la transaction fermée, @@TRANCOUNT doit indiquer zéro. Les sauvegardes, la restauration, l’autorisation et le contrôle des changements restent nécessaires.

Cette leçon termine l’étape Modifier les données en toute sécurité. Continuez avec les erreurs SQL courantes chez les débutants, première leçon de la dernière étape, ou révisez le filtrage WHERE pour raisonner sur une condition cible.

  1. Confirmer la base avec DB_NAME()
  2. SELECT des lignes cibles
  3. COUNT des lignes attendues
  4. BEGIN TRANSACTION
  5. UPDATE ou DELETE
  6. Vérifier le résultat et @@ROWCOUNT
  7. Décision
    • COMMIT si le résultat est correct et autorisé
    • ROLLBACK si le résultat est incorrect ou incertain
Prévisualiser, modifier, vérifier, puis décider

Vérifiez ce que vous avez retenu

2 questions rapides

Question 1 sur 2Quelle précaution est utile avant une modification importante ?
Question 2 sur 2Pourquoi utiliser une transaction pour une modification risquée ?

Fondamentaux de SQL Server

Leçon 19 sur 25

Continuer vers la leçon suivante

Erreurs SQL courantes chez les débutants et comment les éviter

Continuer vers la leçon 20

Étiquettes

  • SQL Server
  • Fondamentaux SQL
  • SSMS
  • T-SQL