Gestion des Exceptions

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.

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

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 :

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 :

• 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.

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
  

  

  
  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 :
  

  

  
  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.

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..

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 :

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 :

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.

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 :

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

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.

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 :

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 :

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 :

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 :

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.

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 :

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().

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 :
   

   

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 :

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.

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 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.

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 :

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

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 :

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

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

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.

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)