AFFAIRE (Transact-SQL)

S’applique à :SQL Server Azure SQL Database Azure SQL Managed Instance Azure Synapse Analytics Analytics Platform System (PDW)Point de terminaison d’analytique SQL dans Microsoft Fabric Entrepôt dans Microsoft Fabric Base de données SQL dans Microsoft Fabric

Évalue une liste de conditions et retourne une expression de résultat parmi plusieurs possibilités.

L’expression CASE a deux formats :

L’expression simpleCASE compare une expression à un ensemble d’expressions simples pour déterminer le résultat.
L’expression recherchéeCASE évalue un ensemble d’expressions booléennes pour déterminer le résultat.

Les deux formats prennent en charge un argument facultatif ELSE .

CASE peut être utilisé dans toute instruction ou clause qui autorise une expression valide. Par exemple, vous pouvez utiliser CASE dans des instructions telles que SELECT, UPDATEDELETEet , et SETdans des clauses telles que <select_list>, , IN, WHEREORDER BYet HAVING.

Conventions de la syntaxe Transact-SQL

Syntax

Syntaxe pour SQL Server, Azure SQL Database et Azure Synapse Analytics.

-- Simple CASE expression:
CASE input_expression
     WHEN when_expression THEN result_expression [ ...n ]
     [ ELSE else_result_expression ]
END

-- Searched CASE expression:
CASE
     WHEN Boolean_expression THEN result_expression [ ...n ]
     [ ELSE else_result_expression ]
END

Syntaxe pour Parallel Data Warehouse.

CASE
     WHEN when_expression THEN result_expression [ ...n ]
     [ ELSE else_result_expression ]
END

Arguments

input_expression

Expression évaluée à l’aide quand le format CASE simple est utilisé. input_expression correspond à toute expression valide.

QUAND when_expression

Expression simple à laquelle input_expression est comparée quand le format CASE simple est utilisé. when_expression correspond à toute expression valide. Les types de données de input_expression et de chaque when_expression doivent être identiques ou correspondre à une conversion implicite.

PUIS result_expression

L’expression retournée lorsque input_expression est égale à when_expression est évaluée TRUEà , ou Boolean_expression est évaluée à TRUE. result_expression correspond à toute expression valide.

SINON else_result_expression

Expression retournée si aucune opération de comparaison n’est évaluée à TRUE. Si cet argument est omis TRUEet qu’aucune opération de comparaison n’est évaluée, CASE retourne NULL. else_result_expression correspond à toute expression valide. Les types de données de else_result_expression et de toute result_expression doivent être identiques ou correspondre à une conversion implicite.

QUAND Boolean_expression

Expression booléenne évaluée quand la fonction CASE élaborée est utilisée. Boolean_expression correspond à toute expression booléenne valide.

Types de retour

Retourne le type de priorité la plus élevé de l’ensemble des types dans result_expressions et le paramètre facultatif else_result_expression. Pour plus d’informations, consultez Priorité du type de données.

Valeurs de retour

Expression CASE simple

L’expression simple CASE fonctionne en comparant la première expression à l’expression dans chaque WHEN clause pour l’équivalence. Si ces expressions sont équivalentes, l’expression dans la THEN clause est retournée.

Autorise uniquement un contrôle d'égalité.
Dans l’ordre spécifié, évalue input_expression = when_expression pour chaque WHEN clause.
Retourne la result_expression du premier input_expression = when_expression qui prend TRUEla valeur .
Si aucune input_expression = when_expression est TRUEévaluée, le moteur de base de données SQL Server retourne l’else_result_expression si une ELSE clause est spécifiée, ou une NULL valeur si aucune clause n’est ELSE spécifiée.

Expression CASE recherchée

Évalue, dans l’ordre spécifié, Boolean_expression pour chaque WHEN clause.
Retourne result_expression du premier Boolean_expression qui prend la TRUEvaleur .
Si aucune Boolean_expression n’est évaluée TRUE, le moteur de base de données retourne l’else_result_expression si une ELSE clause est spécifiée, ou une NULL valeur si aucune clause n’est ELSE spécifiée.

Remarks

SQL Server autorise uniquement 10 niveaux d’imbrication dans les expressions CASE.

L’expression CASE ne peut pas être utilisée pour contrôler le flux d’exécution d’instructions, de blocs d’instructions, de fonctions définies par l’utilisateur et de procédures stockées Transact-SQL. Pour obtenir la liste des méthodes de contrôle de flux, consultez Contrôle de flux.

L’expression CASE évalue les conditions de manière séquentielle et s’arrête à la première condition remplie. Dans certains cas, une expression est évaluée avant qu’une expression CASE ne reçoive les résultats de l’expression en entrée. Des erreurs sont possibles lors de l'évaluation de ces expressions. Les expressions d’agrégation qui apparaissent dans WHEN les arguments d’une CASE expression sont évaluées en premier, puis fournies à l’expression CASE . Par exemple, la requête suivante génère une erreur de division par zéro lors de la production de la valeur de l’agrégat MAX . Cette étape se produit avant d’évaluer l’expression CASE .

WITH Data (value)
AS (
    SELECT 0
    UNION ALL
    SELECT 1
    )
SELECT CASE
        WHEN MIN(value) <= 0 THEN 0
        WHEN MAX(1 / value) >= 100 THEN 1
        END
FROM Data;
GO

Vous ne devez dépendre que de l’ordre d’évaluation des conditions pour les WHEN expressions scalaires (y compris les sous-requêtes non liées qui retournent des scalaires), et non pour les expressions d’agrégation.

Vous devez également vous assurer qu’au moins une des expressions dans le THEN ou ELSE les clauses n’est pas la NULL constante. Bien qu’elles NULL puissent être retournées à partir de plusieurs expressions de résultat, elles ne peuvent pas toutes être explicitement la NULL constante. Si toutes les expressions de résultat utilisent la NULL constante, l’erreur 8133 est retournée.

Examples

Les exemples de code de cet article utilisent les bases de données d'exemple AdventureWorks2025 ou AdventureWorksDW2025, que vous pouvez télécharger à partir de la page d'accueil Microsoft SQL Server Samples and Community Projects.

A. Utiliser une instruction SELECT avec une expression CASE simple

Dans une instruction SELECT, une expression CASE simple permet seulement de vérifier s'il y a égalité ; aucune autre comparaison n'est effectuée. L'exemple suivant utilise l'expression CASE pour modifier la présentation des catégories de gammes de produits pour en faciliter la lecture.

USE AdventureWorks2022;
GO

SELECT ProductNumber,
    Category = CASE ProductLine
        WHEN 'R' THEN 'Road'
        WHEN 'M' THEN 'Mountain'
        WHEN 'T' THEN 'Touring'
        WHEN 'S' THEN 'Other sale items'
        ELSE 'Not for sale'
        END,
    Name
FROM Production.Product
ORDER BY ProductNumber;
GO

B. Utiliser une instruction SELECT avec une expression CASE élaborée

Dans une instruction SELECT, l'expression CASE élaborée permet de remplacer des valeurs dans le jeu de résultats, en fonction des valeurs de comparaison. L'exemple suivant donne le prix sous la forme d'un texte de commentaire basé sur la fourchette de prix d'un produit.

USE AdventureWorks2022;
GO

SELECT ProductNumber,
    Name,
    "Price Range" = CASE
        WHEN ListPrice = 0 THEN 'Mfg item - not for resale'
        WHEN ListPrice < 50 THEN 'Under $50'
        WHEN ListPrice >= 50 AND ListPrice < 250 THEN 'Under $250'
        WHEN ListPrice >= 250 AND ListPrice < 1000 THEN 'Under $1000'
        ELSE 'Over $1000'
        END
FROM Production.Product
ORDER BY ProductNumber;
GO

C. Utiliser CASE dans une clause ORDER BY

Les exemples suivants utilisent l’expression CASE dans une ORDER BY clause pour déterminer l’ordre de tri des lignes en fonction d’une valeur de colonne donnée. Dans le premier exemple, la valeur de la colonne SalariedFlag de la table HumanResources.Employee est évaluée. Les employés pour lesquels SalariedFlag a la valeur 1 sont retournés par ordre décroissant d'BusinessEntityID. Les employés pour lesquels SalariedFlag a la valeur 0 sont retournés par ordre croissant d'BusinessEntityID.

SELECT BusinessEntityID,
    SalariedFlag
FROM HumanResources.Employee
ORDER BY CASE SalariedFlag
        WHEN 1 THEN BusinessEntityID
        END DESC,
    CASE
        WHEN SalariedFlag = 0 THEN BusinessEntityID
        END;
GO

Dans le deuxième exemple, le jeu de résultats est classé par la colonne TerritoryName lorsque la colonne CountryRegionName est égale à « United States » et par CountryRegionName pour toutes les autres lignes.

SELECT BusinessEntityID,
    LastName,
    TerritoryName,
    CountryRegionName
FROM Sales.vSalesPerson
WHERE TerritoryName IS NOT NULL
ORDER BY CASE CountryRegionName
        WHEN 'United States' THEN TerritoryName
        ELSE CountryRegionName
        END;
GO

D. Utiliser CASE dans une instruction UPDATE

L’exemple suivant utilise l’expression CASE dans une UPDATE instruction pour déterminer la valeur définie pour la colonne VacationHours pour les employés ayant SalariedFlag la valeur 0. En soustrayant 10 heures des résultats de VacationHours dans une valeur négative, VacationHours augmente de 40 heures ; sinon, VacationHours augmente de 20 heures. La OUTPUT clause est utilisée pour afficher les valeurs avant et après les vacances.

USE AdventureWorks2022;
GO

UPDATE HumanResources.Employee
SET VacationHours = (
        CASE
            WHEN ((VacationHours - 10.00) < 0) THEN VacationHours + 40
            ELSE (VacationHours + 20.00)
            END
        )
OUTPUT Deleted.BusinessEntityID,
    Deleted.VacationHours AS BeforeValue,
    Inserted.VacationHours AS AfterValue
WHERE SalariedFlag = 0;
GO

E. Utiliser CASE dans une instruction SET

L’exemple suivant utilise l’expression CASE dans une SET instruction dans la fonction dbo.GetContactInfotable . Dans la base de données AdventureWorks2025, toutes les données relatives aux personnes sont stockées dans la table Person.Person. Par exemple, la personne peut être un employé, un représentant du fournisseur ou un client. La fonction retourne le prénom (FirstName) et le nom de famille (LastName) d’un nom donné BusinessEntityID et le type de contact pour cette personne. L’expression CASE de l’instruction SET détermine la valeur à afficher pour la colonne ContactType en fonction de l’existence de la BusinessEntityID colonne dans la EmployeeVendorou Customer les tables.

USE AdventureWorks2022;
GO

CREATE FUNCTION dbo.GetContactInformation (
    @BusinessEntityID INT
)
RETURNS
    @retContactInformation TABLE (
        BusinessEntityID INT NOT NULL,
        FirstName NVARCHAR (50) NULL,
        LastName NVARCHAR (50) NULL,
        ContactType NVARCHAR (50) NULL,
        PRIMARY KEY CLUSTERED (BusinessEntityID ASC))
AS
-- Returns the first name, last name and contact type for the specified contact.
BEGIN
    DECLARE @FirstName NVARCHAR(50),
        @LastName NVARCHAR(50),
        @ContactType NVARCHAR(50);

    -- Get common contact information
    SELECT @BusinessEntityID = BusinessEntityID,
        @FirstName = FirstName,
        @LastName = LastName
    FROM Person.Person
    WHERE BusinessEntityID = @BusinessEntityID;

    SET @ContactType = CASE
            -- Check for employee
            WHEN EXISTS (
                    SELECT *
                    FROM HumanResources.Employee AS e
                    WHERE e.BusinessEntityID = @BusinessEntityID
                    )
                THEN 'Employee'
            -- Check for vendor
            WHEN EXISTS (
                    SELECT *
                    FROM Person.BusinessEntityContact AS bec
                    WHERE bec.BusinessEntityID = @BusinessEntityID
                    )
                THEN 'Vendor'
            -- Check for store
            WHEN EXISTS (
                    SELECT *
                    FROM Purchasing.Vendor AS v
                    WHERE v.BusinessEntityID = @BusinessEntityID
                    )
                THEN 'Store Contact'
            -- Check for individual consumer
            WHEN EXISTS (
                    SELECT *
                    FROM Sales.Customer AS c
                    WHERE c.PersonID = @BusinessEntityID
                    )
                THEN 'Consumer'
            END;

    -- Return the information to the caller
    IF @BusinessEntityID IS NOT NULL
        BEGIN
            INSERT @retContactInformation
            SELECT @BusinessEntityID,
                   @FirstName,
                   @LastName,
                   @ContactType;
        END
    RETURN;
END
GO

SELECT BusinessEntityID,
    FirstName,
    LastName,
    ContactType
FROM dbo.GetContactInformation(2200);
GO

SELECT BusinessEntityID,
    FirstName,
    LastName,
    ContactType
FROM dbo.GetContactInformation(5);
GO

F. Utiliser CASE dans une clause HAVING

L’exemple suivant utilise l’expression CASE dans une HAVING clause pour restreindre les lignes retournées par l’instruction SELECT . L’instruction retourne le taux horaire de chaque poste indiqué dans la table HumanResources.Employee. La HAVING clause limite les titres aux employés salariés dont le taux de rémunération est supérieur à 40 dollars, ou les employés non rémunérés dont le taux de rémunération est supérieur à 15 dollars.

USE AdventureWorks2022;
GO

SELECT JobTitle,
    MAX(ph1.Rate) AS MaximumRate
FROM HumanResources.Employee AS e
INNER JOIN HumanResources.EmployeePayHistory AS ph1
    ON e.BusinessEntityID = ph1.BusinessEntityID
GROUP BY JobTitle
HAVING (
    MAX(CASE
            WHEN SalariedFlag = 1 THEN ph1.Rate
            ELSE NULL
        END) > 40.00
    OR MAX(CASE
            WHEN SalariedFlag = 0 THEN ph1.Rate
            ELSE NULL
        END) > 15.00
)
ORDER BY MaximumRate DESC;
GO

G. Utiliser une expression CASE imbriquée pour catégoriser les résultats

L’exemple suivant utilise une expression imbriquée CASE pour catégoriser les produits en fonction ListPricede . Si un prix de liste de produits dépasse 1 000 dollars, il est considéré High-end. Les produits restants sont classés dans une expression imbriquée CASE basée sur ProductLine et ListPrice.

USE AdventureWorks2022;
GO

SELECT 
    ProductNumber,
    Name,
    ListPrice,
    PriceCategory = 
        CASE 
            WHEN ListPrice > 1000 THEN 'High-end'
            ELSE 
                CASE ProductLine
                    WHEN 'R' THEN
                        CASE 
                            WHEN ListPrice > 500 THEN 'Premium Road'
                            ELSE 'Standard Road'
                        END
                    WHEN 'M' THEN
                        CASE 
                            WHEN ListPrice > 500 THEN 'Premium Mountain'
                            ELSE 'Standard Mountain'
                        END
                    WHEN 'T' THEN 'Touring'
                    ELSE 'Other'
                END
        END
FROM Production.Product
ORDER BY ListPrice DESC;

Exemples : Azure Synapse Analytics et Analytics Platform System (PDW)

H. Utiliser une instruction SELECT avec une expression CASE

Dans une SELECT instruction, l’expression CASE permet de remplacer les valeurs dans le jeu de résultats en fonction des valeurs de comparaison. L'exemple suivant utilise l'expression CASE pour modifier la présentation des catégories de gammes de produits pour en faciliter la lecture. Lorsqu’une valeur n’existe pas, le texte Not for sale s’affiche.

SELECT ProductAlternateKey,
    Category = CASE ProductLine
        WHEN 'R' THEN 'Road'
        WHEN 'M' THEN 'Mountain'
        WHEN 'T' THEN 'Touring'
        WHEN 'S' THEN 'Other sale items'
        ELSE 'Not for sale'
        END,
    EnglishProductName
FROM dbo.DimProduct
ORDER BY ProductKey;
GO

I. Utiliser CASE dans une instruction UPDATE

UPDATE dbo.DimEmployee
SET VacationHours = (
        CASE
            WHEN ((VacationHours - 10.00) < 0) THEN VacationHours + 40
            ELSE (VacationHours + 20.00)
            END
        )
WHERE SalariedFlag = 0;
GO

Rétroaction

Cette page vous a-t-elle été utile ?

Last updated on 2025-11-18