SQL Server permet aux développeurs de stocker, récupérer et manipuler des données à l’aide du langage SQL. Cependant, à mesure que les scripts et les procédures stockées deviennent plus complexes, il peut être difficile de gérer et de manipuler les données sans variables.

Sans variables, les développeurs peuvent être amenés à répéter plusieurs fois des requêtes complexes ou des calculs au sein d’un script, ce qui entraîne un code volumineux et difficile à lire, sujet aux erreurs. De plus, ne pas utiliser de variables peut rendre difficile la gestion efficace des erreurs, car les développeurs peuvent être amenés à répéter plusieurs fois le même code de gestion des erreurs dans un script. Cela peut entraîner un code difficile à maintenir et rendre plus difficile l’identification et la correction des erreurs lorsqu’elles se produisent.

Dans ce tutoriel, nous aborderons le concept d’utilisation des variables dans SQL Server, ainsi que divers exemples pour illustrer leur utilisation.

Déclaration d’une seule variable SQL

La syntaxe T-SQL pour déclarer une variable dans SQL Server est la suivante :

DECLARE @nom_variable type_de_données [= valeur];

Par exemple, déclarons une variable nommée @ProductID de type entier et attribuons-lui une valeur statique de 778 :

DECLARE @ProductID int = 778;

SELECT [SalesOrderID], [CarrierTrackingNumber], [OrderQty], [ProductID], [SpecialOfferID], [UnitPrice], [LineTotal]
FROM [AdventureWorks2019].[Sales].[SalesOrderDetail]
WHERE ProductID = @ProductID;

Vous pouvez également attribuer la valeur ultérieurement à l’aide du mot-clé SET :

DECLARE @ProductID int;

SET @ProductID = 778;

SELECT [SalesOrderID], [CarrierTrackingNumber], [OrderQty], [ProductID], [SpecialOfferID], [UnitPrice], [LineTotal]
FROM [AdventureWorks2019].[Sales].[SalesOrderDetail]
WHERE ProductID = @ProductID;

Vous pouvez utiliser des variables avec différents types de données, tels que des caractères, des dates et des décimales :

DECLARE @employee_name VARCHAR(50);
SET @employee_name = 'Rajendra';

DECLARE @current_date DATE = GETDATE();

DECLARE @tax_rate DECIMAL(4,2);
SET @tax_rate = 0.04;

Déclaration de plusieurs variables SQL Server

Pour déclarer plusieurs variables, vous pouvez utiliser différents mots-clés DECLARE :

DECLARE @Nom varchar(50);
DECLARE @Age tinyint;
DECLARE @DOJ int;

Alternativement, vous pouvez utiliser un seul mot-clé DECLARE et séparer plusieurs variables par une virgule :

DECLARE @Nom varchar(50), @Age tinyint, @DOJ int;

Attribution de valeurs dynamiques aux variables

Vous pouvez définir la valeur d’une variable de manière dynamique. Par exemple, le code suivant déclare trois variables, @AvgUnitPrice, @AvgOrderQty et @AvgLineTotal. L’instruction SELECT calcule le prix unitaire moyen, la quantité de commande moyenne et le total de ligne moyen, et attribue ces valeurs calculées aux variables :

DECLARE @AvgUnitPrice int, @AvgOrderQty int, @AvgLineTotal int;

SELECT @AvgUnitPrice = Avg(UnitPrice), @AvgOrderQty = Avg(OrderQty), @AvgLineTotal = Avg(LineTotal)
FROM [AdventureWorks2019].[Sales].[SalesOrderDetail];

SELECT @AvgUnitPrice as AvgLineTotal, @AvgOrderQty as AvgOrderQty, @AvgLineTotal as AvgLineTotal;

Utilisation des variables dans les procédures stockées

Les variables dans les procédures stockées offrent une flexibilité et un contrôle sur la manipulation des données. Par exemple, la procédure stockée suivante utilise deux variables, @JobTitle et @BirthDate. La procédure stockée attribue des valeurs à ces variables et affiche les informations requises à l’aide de ces variables :

CREATE PROCEDURE dbo.GetPersonInfo
    @NationalIDNumber INT
AS
BEGIN
    DECLARE @JobTitle VARCHAR(50);
    DECLARE @BirthDate date;
 
    SELECT @JobTitle = JobTitle, @BirthDate = BirthDate
    FROM [AdventureWorks2019].[HumanResources].[Employee]
    WHERE [NationalIDNumber] = @NationalIDNumber;
 
    -- Utilisez les variables pour un traitement ultérieur
    PRINT 'Titre du poste : ' + @JobTitle;
    PRINT 'Date de naissance : ' + CAST(@BirthDate AS VARCHAR(10));
END;

EXEC GetPersonInfo 295847284;

Utilisation des variables dans les curseurs

Les variables peuvent être utilisées dans les curseurs pour stocker et manipuler des données. Par exemple, la requête suivante déclare un curseur, SalesOrder_Cursor, et récupère le numéro de commande, le total dû et l’ID du vendeur à partir de la base de données AdventureWorks2019. Le curseur itère à travers les ID de commande, attribue les informations récupérées aux variables @SalesOrderNumber, @TotalDue et @SalesPersonID, et affiche ces informations avec des messages spécifiques :

DECLARE @SalesOrderID int = 71951;
DECLARE @SalesOrderNumber varchar(20);
DECLARE @TotalDue DECIMAL(10, 2);
DECLARE @SalesPersonID varchar(20);

DECLARE SalesOrder_Cursor CURSOR FOR
SELECT SalesOrderNumber, TotalDue, SalesPersonID
FROM [AdventureWorks2019].[Sales].[SalesOrderHeader]
WHERE SalesOrderID >= @SalesOrderID AND SalesPersonID IS NOT NULL;

OPEN SalesOrder_Cursor;

FETCH NEXT FROM SalesOrder_Cursor INTO @SalesOrderNumber, @TotalDue, @SalesPersonID;

WHILE @@FETCH_STATUS = 0
BEGIN
    -- Effectuer des opérations à l'aide des variables
    PRINT 'ID du vendeur : ' + @SalesPersonID;
    PRINT 'Commande : ' + CAST(@SalesOrderNumber AS VARCHAR(10));
    PRINT 'Montant total dû : ' + CAST(@TotalDue AS VARCHAR(10));

    -- Obtenir le prochain ensemble de données du curseur
    FETCH NEXT FROM SalesOrder_Cursor INTO @SalesOrderNumber, @TotalDue, @SalesPersonID;
END;

CLOSE SalesOrder_Cursor;
DEALLOCATE SalesOrder_Cursor;

Utilisation des variables pour créer des instructions SQL dynamiques

Les variables peuvent être utilisées pour créer des instructions SQL dynamiques en combinant plusieurs parties des requêtes, telles que les noms de table, les paramètres et les arguments. Par exemple, le code suivant crée et exécute dynamiquement une instruction SQL à l’aide de la procédure stockée sp_executesql :

DECLARE @table_name VARCHAR(50) = 'SalesOrderHeader';
DECLARE @schema varchar(20) = 'Sales';
DECLARE @SalesOrderID varchar(20) = 71951;
DECLARE @sql_stmt NVARCHAR(MAX);

SET @sql_stmt = 'SELECT * FROM ' + @schema + '.' + QUOTENAME(@table_name) + ' WHERE SalesOrderID =' + @SalesOrderID;

EXEC sp_executesql @sql_stmt;

Utilisation des variables pour contrôler l’exécution d’une boucle

Les variables peuvent aider à contrôler l’exécution des boucles en définissant des conditions, en contrôlant le compteur de boucle et en déterminant quand la boucle doit se poursuivre ou se terminer. Par exemple, le code suivant montre une boucle contenant des informations sur une plage d’ID de commande. La boucle commence à partir de @SalesOrderIDStart et se termine une fois que la valeur de l’ID de commande est égale à @SalesOrderIDEnd. L’instruction SET dans la boucle while incrémente l’ID de commande de 1 :

DECLARE @SalesOrderIDStart INT = 43659, @SalesOrderIDEnd INT = 43759;

WHILE @SalesOrderIDStart <= @SalesOrderIDEnd
BEGIN
    SELECT [AccountNumber], [CustomerID], [SalesPersonID], [TerritoryID], [BillToAddressID], [ShipToAddressID], [ShipMethodID], [CreditCardID], [CreditCardApprovalCode], [TaxAmt], [Freight], [TotalDue]
    FROM [AdventureWorks2019].[Sales].[SalesOrderHeader]
    WHERE SalesOrderID = @SalesOrderIDStart;
    
    SET @SalesOrderIDStart = @SalesOrderIDStart + 1;
END;

Gestion des erreurs à l’aide de variables

La gestion des erreurs est nécessaire pour capturer les erreurs lors de l’exécution du code. Par exemple, si vous avez défini une clé primaire sur la colonne ID et que quelqu’un essaie d’insérer une valeur en double, cela entraînerait une violation de la clé primaire. Le code suivant utilise le bloc TRY CATCH pour capturer l’erreur due à la violation de la clé primaire. Le bloc CATCH attribue le message d’erreur à la variable @ErrorMessage et affiche le message :

CREATE TABLE Employee
(
   ID int PRIMARY KEY,
   First_name varchar(50),
   Country varchar(20)
);

BEGIN TRY
    INSERT INTO Employee Values(1, 'Rajendra', 'India');

    -- Insertion d'un enregistrement en double qui générera une erreur de CLÉ PRIMAIRE
    INSERT INTO Employee Values(1, 'Rajendra', 'India');
END TRY

BEGIN CATCH
    -- Déclarer des variables pour stocker les informations sur l'erreur
    DECLARE @ErrorMessage NVARCHAR(MAX);
    SELECT @ErrorMessage = ERROR_MESSAGE();
    PRINT 'Une erreur s'est produite : ' + @ErrorMessage; 
END CATCH;

En utilisant des variables, vous pouvez gérer efficacement les erreurs et fournir des messages d’erreur appropriés.

Conclusion

La déclaration de variables dans SQL Server permet aux développeurs de stocker et de manipuler des données lors de l’exécution d’un script ou d’une procédure stockée. Les variables sont utiles pour conserver des ensembles de résultats intermédiaires, contrôler le flux de travail, préparer des instructions SQL dynamiques et gérer les erreurs. En utilisant efficacement les variables, les développeurs peuvent écrire un code plus efficace et plus facile à maintenir.

Article mis à jour pour la dernière fois le : 2023-08-16