Home

Gestion des Exceptions

 

Principes de Base des Exceptions

 

Introduction

Certains problèmes se produiront au cours de la durée de vie d'une application de base de données. Vous ne pouvez pas éliminer ce fait. Au lieu de cela, vous pouvez anticiper les problèmes autant que possible et mettre en place les actions appropriées. Normalement, Microsoft SQL Server fournit un moyen de prise en charge des problèmes.

En réalité, lorsqu'il s'agit d'une application de base de données de Microsoft SQL Server, vous pouvez prendre soin des problèmes sur le côté Microsoft SQL Server ou sur un environnement de programmation que vous utilisez pour créer une application graphique.

Practical LearningEtude d'apprentissage : Gestion des exceptions

  1. Démarrez Microsoft SQL Server et connectez-vous au serveur
  2. Dans la barre d'outils standard, cliquez sur le bouton Nouvelle requête
  3. Pour créer une nouvelle base de données, tapez ce qui suit
    CREATE DATABASE exercice ; 
    GO
  4. Appuyez sur F5 pour exécuter

Types d'erreurs : erreurs de syntaxe

Il existe différentes catégories dont vous pouvez traiter les erreurs. Une erreur de syntaxe se produit si vous essayez d'écrire le code qui n'autorise pas Transact-SQL. Exemples :

  • Si vous essayez de taper un opérateur ou un mot-clé où il ne devrait pas être, l'éditeur de code vous le montrerait . Voici un exemple :

Syntax Error

Cette erreur est causée par l'opérateur SET, bien qu'une partie de Transact-SQL, ait été utilisée à tort.

  • Si vous tapez à tord un mot-clé ou un opérateur probablement parce que vous ne vous rappelez pas, l'éditeur de code l'indiquerait. Voici un exemple :

Syntax Error

  • Si vous oubliez de taper quelque chose de nécessaire ou obligatoire, lorsque vous essayez d'exécuter le code, il produirait une erreur.

Les erreurs de syntaxe sont généralement faciles à détecter, car l'éditeur de code les souligne immédiatement. Par conséquent, ces erreurs sont faciles à résoudre.

Si vous utilisez une application basée sur la commande comme SQLCMD ou PowerShell, elle ne montre pas l'erreur droit moyen. Il serait affiché lorsque vous exécuterez le code.

Types d'erreurs : erreurs d'exécution

Une erreur d'exécution est le type qui se produit si votre application essaie d'effectuer une opération où Microsoft SQL Server ou le système d'exploitation ne permettent pas. Ces erreurs peuvent être difficiles à résoudre car parfois elles ne sont pas claires, ou ce qui arrive comme erreur n'est pas clairement identifiée ou est externe à la base de données. Le problème pourrait consister en ce que, en évaluant la base de données dans Microsoft SQL Server, il peut fonctionner, mais une fois que l'application a été distribuée et est utilisée, les problèmes commencent à se produire.

les exemples d'erreurs d'exécution sont les suivants :

  • Tentative d'exécution de code qui n'est pas disponible ou n'est pas clairement défini
  • Exécution d'un mauvais calcul tel qu'une division par 0

    Division by 0


    Notez que l'éditeur de code n'indique pas de problème, car il ne s'agit pas d'une erreur de syntaxe
  • Essayez d'utiliser une fonction, une procédure stockée ou un déclencheur qui n'est pas disponible
  • Utilisez ou accédez à la mémoire de l'ordinateur qui n'est pas ou assez disponible
  • Essayez d'effectuer une opération qu'une variable ou un objet ne peut pas gérer. Un exemple tente de stocker dans une variable une valeur qui est au-delà de sa plage autorisée. Voici un exemple :

    Overflow


    Notez que l'éditeur de code n'indique pas de problème, car il ne s'agit pas d'une erreur de syntaxe
  • Exécutez une opération sur les types incompatibles
  • Utilisez injustement une instruction conditionnelle, ou utilisez une instruction conditionnelle mi-construite

Les erreurs d'exécution peuvent être difficiles à localiser et à corriger.

Gestion d'une exception

 

Essai d'une exception

La gestion des exceptions est la capacité de traiter les erreurs qui se produisent ou peuvent se produire sur une base de données. L'erreur est appelée une exception. Pour vous aider avec la gestion des exceptions, Transact-SQL fournit une formule générale. Vous démarrez avec une section comme suit :

BEGIN TRY      
Normal Code 
 END TRY

Entre le BEGIN TRY et les lignes END TRY, écrivez le code normal que vous souhaitez exécuter. Voici un exemple.

BEGIN TRY 
DECLARE @Side decimal (6, 3), 
@Perimeter décimal (6, 3); 
 
 
SET @Side = 124.36 ; 
SET @Perimeter = @Side * 4; 
 
 
SELECT @Side AS Side, @Perimeter AS Perimeter ; 
END TRY

La section de code qui démarre à partir de BEGIN TRY à END TRY est appelée un bloc d'essai/try block ou une clause d'essai/catch clause..

Interception d'une exception

Après le try block, vous devez créer une autre section qui commence avec BEGIN CATCH et se termine par END CATCH :

BEGIN TRY 
Normal code 
END TRY 
BEGIN CATCH        
 
 
END CATCH

La section de code qui va de BEGIN CATCH à END CATCH est appelée un catch block ou catch clause.

Parmi les règles, vous devez observer :

  • Si vous créez un try block, vous devez également créer un catch block
  • Il ne doit y avoir aucun code Transact-SQL (sauf un commentaire, ce n'est pas un code SQL quand même) entre l' END TRY et les lignes BEGIN CATCH

Si aucune erreur ne se produit dans le try block, vous pouvez quitter le catch block vide. Voici un exemple :

USE exercice ; 
Go 
BEGIN TRY 
DECLARE @Side decimal (6, 3), 
        @Perimeter décimal (6, 3); 
 
 
SET @Side = 124.36 ; 
SET @Perimeter =  @Side * 4 ;
 
 
SELECT @Side AS Side, @Perimeter AS Perimeter ; 
END TRY 
BEGIN CATCH 
 
 
END CATCH

Cela donnerait :

Normal

Imaginez que vous écrivez le code qui pourrait produire une erreur :

USE Exercice ; 
GO 
 
 
DECLARE @Number tinyint, 
 @Result tinyint ; 
 
 
SET @Number = 252 ; 
SET @Result = @Number + 20 ; 
 
 
SELECT @Number AS Number, 
@Result AS Result ; 
GO

Cela donnerait :

Error

Pour répondre à ce type de problème, vous pouvez utiliser la gestion des exceptions et inclure le code normal dans un try block. Ensuite, si une erreur se produit dans le try block, vous pouvez utiliser le catch block pour afficher un message. Voici un exemple :

USE Exercice ; 
GO 
 
 
BEGIN TRY,
DECLARE @Number tinyint ;
        @Results tinyint ; 
 
 
SET @Number = 252 ; 
SET @Result = @Number + 20 ; 
 
 
SELECT @Number AS Number, @Result AS Result ; 
END TRY 
BEGIN CATCH 
    PRINT N'There was a problem with the program'; 
END CATCH

D'autre part, si aucune erreur ne se produit dans le try block, ce try block exécute mais dès qu'il se termine, l'exécution ignore le catch block et poursuit l'exécution avec code au-dessous de la ligne END CATCH, le cas échéant.

Practical LearningEtude pratique : Création d'une exception

  1. Sélectionnez l'intégralité du texte dans l'éditeur et tapez le texte suivant :
    USE Exercise  ; 
    GO 
    BEGIN TRY 
         DECLARE @Number tinyint, 
                 @Result tinyint ; 
     
     
    SET @Number = 252 ; 
    SET @Result = @Number + 20 ; 
     
     
    SELECT @Number AS Number, @Result AS result ;
    END TRY 
    BEGIN CATCH 
    PRINT N'There was a problem with the program'; 
    END CATCH 
    GO
  2. Appuyez sur la touche F5 pour l'exécuter.
    Cela donnerait :

Error

 
 
   

 

 

Identification d'une erreur

 

Introduction

Pour vous aider à identifier une erreur qui s'est produite, Transact-SQL fournit différentes fonctions.

La ligne d'erreur

Lorsqu'une erreur survient dans votre code, la première chose que vous voulez savoir est probablement où l'erreur s'est produite dans votre code. Pour vous aider à cela, Transact-SQL fournit une fonction nommée ERROR_LINE. Sa syntaxe est la suivante :

int ERROR_LINE() ;

Cette fonction ne prend pas d'argument. Elle renvoie un numéro qui représente le numéro de la ligne où l'erreur s'est produite.

À l'aide d'une instruction conditionnelle, vous pouvez mettre en question le moteur de base de données pour connaître la ligne où l'erreur s'est produite. Grâce à ces informations, vous pouvez prendre les mesures nécessaires.

Practical LearningEtude pratique : Obtention d'un numéro de ligne d'erreur

  1. Modifiez le code dans l'éditeur de texte comme suit :
    USE exercice ; 
    GO 
     
     
    BEGIN TRY 
    DECLARE @Number tinyint, 
            @Result tinyint ; 
     
     
    SET @Number = 252 ; 
    SET @Result = @Number + 20 ; 
     
     
    SELECT @Number AS Number, @Result AS Result ; 
    END TRY 
    BEGIN CATCH 
    PRINT  N'Error Line:' + CAST(ERROR_LINE() AS nvarchar(100)) ; 
    END CATCH 
    GO
  2. Appuyez sur la touche F5 pour l'exécuter.
    Cela donnerait :

Le nombre d'erreurs

Chaque type d'erreur est reconnu avec un nombre spécifique, qui est simplement un type d'identité (nous allons voir comment vous pouvez utiliser ce numéro ; mais, comme une valeur numérique, ce nombre n'indique rien pas). Pour connaître le nombre d'une erreur, vous pouvez appeler la fonction error_number(). Sa syntaxe est la suivante :

int error_number() ;

Cette fonction ne prend aucun argument et renvoie à un nombre entier. Voici un exemple d'appel :

USE Exercise ; GO
 
 
BEGIN TRY
DECLARE @Number tinyint, 
        @Result tinyint ; 
 
 
SET @Number = 252 ; 
SET @Result = @Number + 20 ; 
 
 
SELECT @Number AS Number, @Result AS Result ; 
END TRY 
BEGIN CATCH 
    ERROR_number() ; 
END CATCH

Vous pouvez ensuite obtenir le numéro de l'erreur et agir. Voici un exemple pour trouver le nombre :

Error Number

Pour savoir quel numéro d'erreur a été produit par votre code, vous pouvez vous renseigner sur la valeur produite par la fonction ERROR_NUMBER(). Pour le faire, vous pouvez écrire une instruction conditionnelle IF.

Si/une fois que vous connaissez le numéro de l'erreur, vous pouvez prendre une action appropriée. Au moins, vous pouvez afficher un message. Voici un exemple :

Error Number

Bien entendu, vous pouvez agir mieux que cela.

Dans les versions précédentes de Microsoft SQL Server, le moyen d'obtenir un numéro de l'erreur était d'appeler une fonction nommée @@ ERROR. Vous pouvez toujours utiliser cette fonction pour savoir quel est le numéro de l'erreur afin d'entreprendre une action appropriée. Sa syntaxe est la suivante :

int @@ ERROR() ;

Cette fonction peut être appelée pour obtenir le numéro de l'erreur produite par une exception. Voici un exemple ;

USE Exercise ; 
GO 
 
 
BEGIN TRY 
DECLARE @Number tinyint, 
        @Result tinyint ; 
 
 
SET @Number = 252 ; 
SET @Result = @Number + 20 ; 
 
 
SELECT @Number AS Number, @Result AS Result ; 
END TRY 
BEGIN CATCH 
    PRINT N'Error #:'+ CAST(@@ERROR AS NVARCHAR(50)); 
END CATCH

Cela donnerait :

Error

Tout comme fait pour la fonction ERROR_NUMBER(), vous pouvez vérifier la valeur de l'appel @@ERROR pour savoir quel est le numéro de l'erreur, et si c'est le bon nombre que vous cherchez, vous pouvez prendre des mesures appropriées.

Practical LearningEtude pratique : Vérifier un numéro de l'erreur

  1. Modifiez le code dans l'éditeur de texte comme suit :
    USE Exercise ; 
    GO 
     
     
    BEGIN TRY 
    DECLARE @Number tinyint, 
            @Result tinyint ; 
     
     
    SET @Number = 252 ; 
    SET @Result = @Number + 20 ; 
     
     
    SELECT @Number AS Number, @Result AS Result ; 
    END TRY 
    BEGIN CATCH 
    IF @@ERROR = 220 
    PRINT N'Something went wrong with your code' ; 
    END CATCH 
    GO
  2. Appuyez sur F5 pour exécuter

Le message d'erreur

Un numéro d'erreur est seulement un nombre construit dans le code de la fonction et connu par le moteur de base de données. Ce nombre ne donne aucune indication significative sur l'erreur. Pour vous donner un message lié à l'erreur, Transact-SQL fournit la fonction ERROR_MESSAGE(). Sa syntaxe est la suivante :

NVARCHAR ERROR_MESSAGE() ;

Cette fonction ne prend aucun argument et elle renvoie à une chaîne. Voici un exemple d'appel :

USE Exercise ; 
GO 
BEGIN TRY 
DECLARE @Number tinyint, 
        @Result tinyint ; 
 
 
SET @Number = 252 ; 
SET @Result = @Number + 20 ; 
 
 
SELECT @Number AS Number, @Result AS Result 
END TRY 
BEGIN CATCH 
PRINT ERROR_MESSAGE() ; 
END CATCH

Cela donnerait :

Error Message

Parce que vous êtes un programmeur, vous devez comprendre la signification des mots overflow, error et tinyint. Malheureusement, ce message peut ne pas être très clair pour un utilisateur normal. Pour cette raison, vous devez fournir un moyen facile de lire le message. Vous pouvez même combiner votre propre message d'erreur à la valeur de la fonction ERROR_MESSAGE().

Practical LearningEtude pratique : Réception d'un message d'erreur

  1. Modifiez le code dans l'éditeur de texte comme suit :
    USE exercise ; 
    GO 
    BEGIN TRY 
    DECLARE @Number tinyint, 
            @Result tinyint ; 
     
     
    SET @Number = 252 ; 
    SET @Result = @Number + 20 ; 
     
     
    SELECT @Number AS Number, @Result AS Result ; 
    END TRY 
    BEGIN CATCH 
    PRINT N'Error Message : ' + ERROR_MESSAGE() ; 
    END CATCH 
    GO
  2. Appuyez sur la touche F5 pour l'exécuter.
    Cela donnerait :

    Error Message

La priorité d'un message

Les erreurs ont différents niveaux de considération. Certaines doivent être traitées dans les plus brefs délais tandis que d'autres peuvent attendre. Pour vous aider à identifier la gravité d'une erreur, Transact-SQL fournit la fonction ERROR_SEVERITY(). Sa syntaxe est la suivante :

int ERROR_SEVERITY() ;

Cette fonction ne prend aucun argument et renvoie à un nombre entier. Voici un exemple d'appel pour identifier la gravité d'une erreur :

USE Exercise ; 
GO 
 
 
BEGIN TRY 
DECLARE @Number tinyint, 
        @Result ; 
 
 
SET @Number = 252 ; 
SET @Result = @Number + 20 ; 
 
 
SELECT @Number AS Number, @Result AS Result ; 
END TRY 
BEGIN CATCH 
PRINT N'Error Severity :' + CAST(ERROR_SEVERITY() AS nvarchar(100)); 
END CATCH

Cela donnerait :

Error Severity

La valeur de ce numéro n'est pas un niveau de gravité. C'est juste une indication de la gravité. Vous, en tant que développeur de base de données, devez savoir ce qu'est ce nombre, et prendre des mesures appropriées. Vous pouvez écrire une instruction conditionnelle IF pour découvrir la valeur produite par cette fonction et faire ce que vous jugez nécessaire.

Practical LearningEtude pratique : Obtention de la gravité d'une erreur

  1. Modifiez le code dans l'éditeur de texte comme suit :
    USE exercise ; 
    GO 
     
     
    BEGIN TRY 
    DECLARE @Number tinyint, 
            @Result tinyint ; 
     
     
    SET @Number = 252 ; 
    SET @Result = @Number + 20 ; 
     
     
    SELECT @Number AS Number, @Result AS Result ; 
    END TRY 
    BEGIN CATCH 
    IF ERROR_SEVERITY() = 16 
    PRINT N'An error has occurred on the database. '; 
    PRINT N '---------------------------------------------'; 
    PRINT N'The error severity number is 16.'; 
    PRINT N'Don"t panic at this time. Contact the'; 
    PRINT N'database administrator and specify this number.'; 
    END CATCH 
    GO.
  2. Appuyez sur la touche F5 pour l'exécuter.
    Cela donnerait :

L'état d'une erreur

L'état d'une erreur est un nombre qui indique la section du code où une erreur s'est produite. C'est parce que le même code peut produire des erreurs différentes aux différentes sections du code. Pour vous aider à identifier l'état d'une erreur, Transact-SQL fournit la fonction ERROR_STATE(). Sa syntaxe est la suivante :

int ERROR_STATE() ;

Cette fonction ne prend aucun argument. Elle renvoie à un nombre entier qui spécifie l'état de l'erreur. Cette fonction est utilisée avec la même approche que la gravité d'une erreur.

Autres caractéristiques de la gestion des exceptions

 

Introduction

Comme vous pouvez écrire des diverses déclarations dans votre code, vous pouvez également créer des différentes sections d'exception. Voici des exemples :

USE Exercise;  
GO    
 
 
BEGIN TRY      
DECLARE @Number tinyint,  	    
@Result tinyint;  	     
SET @Number = 252;   
SET @Result = @Number + 2;  	
 
 
PRINT N'Number = '+ CAST(@Number AS nvarchar(20));  
PRINT N'Result = ' + CAST(@Result AS nvarchar(20));
END TRY  
BEGIN CATCH  
PRINT N'Error: ' + ERROR_MESSAGE();  
END CATCH    
PRINT N'---------------------------------------';   
 
 
BEGIN TRY      
DECLARE @Value decimal(6,2),  	 
@Division decimal;  	
 
 
SET @Value = 15.50; 
SET @Division = @Value / 2;  	  
 
 
PRINT N'Number = ' + CAST(@Value AS nvarchar(20));  
PRINT N'Result = ' + CAST(@Division AS nvarchar(20));
END TRY 
BEGIN CATCH 
PRINT N'Error: ' + ERROR_MESSAGE();
END CATCH

Cela donnerait :

Excception Handling

Dans ce cas, chaque section va gérer sa propre exception.

Practical LearningEtude pratique : Exploration des exceptions

  1. Modifiez le code dans l'éditeur de texte comme suit :
    USE Exercice ; 
    GO 
     
     
    BEGIN TRY 
    DECLARE @Number tinyint, 
    @Result tinyint ; 
    SET @Number = 252 ; 
    SET @Result =  @Number + 42 ; 
     
     
    PRINT N'Number = ' + CAST (@Number AS nvarchar(20)) ; 
    PRINT N'Result = ' + CAST (@Result AS nvarchar(20)) ; 
    END TRY 
    BEGIN CATCH 
    PRINT N'Error: '+ ERROR_MESSAGE() ; 
    END CATCH 
    PRINT N'---------------------------------------'; 
     
     
    BEGIN TRY 
    DECLARE  @Value decimal(6,2),
             @Division décimal ; 
     
     
    SET @Value = 15.50 ; 
    SET @Division = @Value / 0; 
     
     
    PRINT N'Number = ' + CAST(@Value AS nvarchar(20)); 
    PRINT N'Result = ' + CAST(@Division AS nvarchar(20)); 
    END TRY 
    BEGIN CATCH 
    PRINT N'Error: ' + ERROR_MESSAGE(); 
    END CATCH 
    GO
  2. Appuyez sur la touche F5 pour l'exécuter.
    Cela donnerait :

Multiple Exceptions

Une exception d'imbrication

Vous pouvez créer un code à l'intérieur d'un autre pour la gestion des exceptions.Ceci est appelé imbrication (Nesting). La formule de base est la suivante :

BEGIN TRY      
BEGIN TRY
     --Nested try block      
END TRY 
BEGIN CATCH
--Nested catch block      
END CATCH 
END TRY 
BEGIN CATCH 
 
END CATCH

Practical LearningEtude pratique : Imbrication des exceptions

  1. Modifiez le code dans l'éditeur de texte comme suit :
    USE Exercise;  
    GO    
     
    BEGIN TRY      
    BEGIN TRY          
    DECLARE @Number tinyint,  	       
            @Result tinyint;  	      
     
     
    	SET @Number = 252;  
     SET @Result = @Number + 42;  	    
     
     
    PRINT N'Number = ' + CAST(@Number AS nvarchar(20)); 
    PRINT N'Result = ' + CAST(@Result AS nvarchar(20)); 
    END TRY    
    BEGIN CATCH  	
    PRINT N'Error: ' + ERROR_MESSAGE(); 
    END CATCH      
    PRINT N'---------------------------------------';    
     
     
    BEGIN TRY  	    
    DECLARE @Value decimal(6,2),  	
    @Division decimal;  	 
     
     
    SET @Value = 15.50;  	
    SET @Division = @Value / 0;  	
     
     
    PRINT N'Number = ' + CAST(@Value AS nvarchar(20));  
    PRINT N'Result = ' + CAST(@Division AS nvarchar(20));   
    END TRY      
    BEGIN CATCH  		P
    RINT N'Error: ' + ERROR_MESSAGE();  
    END CATCH 
    END TRY 
    BEGIN CATCH     
    PRINT N'There was a problem with your code'; 
    END CATCH 
    GO
  2. Appuyez sur F5 pour exécuter

Levée d'une erreur

Si une erreur survient dans votre code, vous pouvez prendre l' initiative pour cela, comme nous l'avons fait jusqu'à présent. Pour mieux personnaliser comment une exception est gérée lorsqu'elle survient, vous pouvez lever une erreur. Pour cela, Transact-SQL fournit la fonction RAISERROR(). Sa syntaxe est la suivante :

RAISERROR ({msg_id | msg_str | @local_variable}
       {,severity, state} 
       [, argument [,.. .n]]) 
       [WITH option [,.. .n]]

Cette fonction accepte trois arguments requis :

  • Le premier argument peut être une des trois choses :
    • L'argument peut être représenté sous la forme d'une constante entière. Pour commencer, créez un message, lui attribuer un numéro supérieur à 50000 et transmettre ce message à Transact-SQL en stockant dans la bibliothèque sys.messages. Si vous le faites, pour accéder au message, vous devez utiliser le numéro que vous avez spécifié
    • L'argument peut être représenté sous la forme d'un objet msg_str. Dans ce cas, l'argument est le message que vous souhaitez produire (ou afficher) si une erreur se produit. L'argument est créé et mis en forme comme la fonction printf() du langage C
    • Le premier argument peut être une variable locale déclarée basée sur la chaîne. Il est ensuite initialisé et formaté comme fait pour l'option msg_str
  • Le deuxième argument est un numéro qui représente le niveau de gravité de l'erreur. Vous pouvez indiquer ce numéro comme bon vous semble, tout en sachant que vous allez le gérer plus tard comme bon vous semble. Le nombre spécifié pour cet argument doit être compris entre 0 et 18. Si vous êtes un membre du groupe sysadmin, vous pouvez spécifier un nombre plus élevé que celui-là. Si vous utilisez un nombre compris entre 20 et 25, cela est considéré comme très élevé (ou une erreur dangereuse) et vous pouvez fermer la connexion à la base de données
  • Le troisième argument est un nombre qui représente l'état de l'erreur. Pour cet argument, vous pouvez spécifier tout nombre compris entre 1 et 127. Si vous créez des différentes sections d'exceptions, vous devez fournir un numéro public unique pour chacun.

Practical LearningEtude pratique : Fin de la leçon

  1. Fermez la fenêtre de requête
  2. Quand on demande si vous souhaitez enregistrer le fichier, cliquez sur non
  3. Dans l'Explorateur d'objets, sous le nœud de bases de données, cliquez avec le bouton droit de la souris sur exercice, puis cliquez sur Supprimer
  4. Dans la boîte de dialogue, cliquez sur OK (si vous ne réussissez pas lors de la suppression de la base de données, fermez Microsoft SQL Server, rouvrir et essayez à nouveau la suppression de la base de données)
 
 
   
 

Précédent Copyright © 2010 Yevol Suivant