CASE (Transact-SQL)CASE (Transact-SQL)

S’APPLIQUE À : ouiSQL Server ouiAzure SQL Database ouiAzure Synapse Analytics (SQL DW) ouiParallel Data Warehouse APPLIES TO: yesSQL Server yesAzure SQL Database yesAzure Synapse Analytics (SQL DW) yesParallel Data Warehouse

Évalue une liste de conditions et retourne une expression de résultat parmi plusieurs possibilités.Evaluates a list of conditions and returns one of multiple possible result expressions.

L'expression CASE a deux formats :The CASE expression has two formats:

  • l'expression CASE simple détermine le résultat en comparant une expression à un jeu d'expressions simples ;The simple CASE expression compares an expression to a set of simple expressions to determine the result.

  • l'expression CASE élaborée évalue un ensemble d'expressions booléennes pour déterminer le résultat.The searched CASE expression evaluates a set of Boolean expressions to determine the result.

Les deux formats prennent en charge un argument ELSE facultatif.Both formats support an optional ELSE argument.

CASE peut être utilisé dans n'importe quelle instruction ou clause qui autorise une expression valide.CASE can be used in any statement or clause that allows a valid expression. Par exemple, vous pouvez utiliser CASE dans les instructions telles que SELECT, UPDATE, DELETE et SET, ainsi que dans les clauses telles que select_list, IN, WHERE, ORDER BY et HAVING.For example, you can use CASE in statements such as SELECT, UPDATE, DELETE and SET, and in clauses such as select_list, IN, WHERE, ORDER BY, and HAVING.

Icône de lien de rubrique Conventions de la syntaxe Transact-SQLTopic link icon Transact-SQL Syntax Conventions

SyntaxeSyntax

-- Syntax for SQL Server and Azure SQL Database  
  
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  
-- Syntax for Azure SQL Data Warehouse and Parallel Data Warehouse  
  
CASE  
     WHEN when_expression THEN result_expression [ ...n ]   
     [ ELSE else_result_expression ]   
END  

ArgumentsArguments

input_expressioninput_expression
Expression évaluée à l'aide du format CASE simple.Is the expression evaluated when the simple CASE format is used. input_expression correspond à toute expression valide.input_expression is any valid expression.

WHEN when_expressionWHEN when_expression
Expression simple à laquelle input_expression est comparée quand le format CASE simple est utilisé.Is a simple expression to which input_expression is compared when the simple CASE format is used. when_expression correspond à toute expression valide.when_expression is any valid expression. Les types de données de input_expression et de chaque when_expression doivent être identiques ou correspondre à une conversion implicite.The data types of input_expression and each when_expression must be the same or must be an implicit conversion.

THEN result_expressionTHEN result_expression
Expression retournée quand input_expression égale à when_expression a la valeur TRUE, ou quand Boolean_expression a la valeur TRUE.Is the expression returned when input_expression equals when_expression evaluates to TRUE, or Boolean_expression evaluates to TRUE. result_expression correspond à toute expression valide.result expression is any valid expression.

ELSE else_result_expressionELSE else_result_expression
Expression retournée si aucune opération de comparaison n'a la valeur TRUE.Is the expression returned if no comparison operation evaluates to TRUE. Si cet argument est omis et si aucune opération de comparaison n'a la valeur TRUE, CASE retourne la valeur NULL.If this argument is omitted and no comparison operation evaluates to TRUE, CASE returns NULL. else_result_expression correspond à toute expression valide.else_result_expression is any valid expression. Les types de données de else_result_expression et de toute result_expression doivent être identiques ou correspondre à une conversion implicite.The data types of else_result_expression and any result_expression must be the same or must be an implicit conversion.

WHEN Boolean_expressionWHEN Boolean_expression
Expression booléenne évaluée lorsque la fonction CASE élaborée est utilisée.Is the Boolean expression evaluated when using the searched CASE format. Boolean_expression correspond à toute expression booléenne valide.Boolean_expression is any valid Boolean expression.

Types de retourReturn Types

Retourne le type de priorité la plus élevé de l’ensemble des types dans result_expressions et le paramètre facultatif else_result_expression.Returns the highest precedence type from the set of types in result_expressions and the optional else_result_expression. Pour plus d’informations, consultez Priorités des types de données (Transact-SQL).For more information, see Data Type Precedence (Transact-SQL).

Valeurs de retourReturn Values

Expression CASE simple :Simple CASE expression:

L'expression CASE simple fonctionne en comparant la première expression à l'expression contenue dans chaque clause WHEN pour déterminer son équivalence.The simple CASE expression operates by comparing the first expression to the expression in each WHEN clause for equivalency. Si ces expressions sont équivalentes, l'expression contenue dans la clause THEN est retournée.If these expressions are equivalent, the expression in the THEN clause will be returned.

  • Autorise uniquement un contrôle d'égalité.Allows only an equality check.

  • Dans l’ordre spécifié, évalue input_expression = when_expression pour chaque clause WHEN.In the order specified, evaluates input_expression = when_expression for each WHEN clause.

  • Retourne la valeur result_expression de la première input_expression = when_expression qui a la valeur TRUE.Returns the result_expression of the first input_expression = when_expression that evaluates to TRUE.

  • Si aucune input_expression = when_expression a la valeur TRUE, Moteur de base de données SQL ServerSQL Server Database Engine retourne la valeur else_result_expression si une clause ELSE est spécifiée ou une valeur NULL si aucune clause ELSE n’est spécifiée.If no input_expression = when_expression evaluates to TRUE, the Moteur de base de données SQL ServerSQL Server Database Engine returns the else_result_expression if an ELSE clause is specified, or a NULL value if no ELSE clause is specified.

Expression CASE élaborée :Searched CASE expression:

  • Évalue, dans l’ordre spécifié, Boolean_expression pour chaque clause WHEN.Evaluates, in the order specified, Boolean_expression for each WHEN clause.

  • Retourne la valeur result_expression de la première Boolean_expression qui a la valeur TRUE.Returns result_expression of the first Boolean_expression that evaluates to TRUE.

  • Si aucune Boolean_expression n’a la valeur TRUE, Moteur de base de donnéesDatabase Engine retourne la valeur else_result_expression si une clause ELSE est spécifiée ou une valeur NULL si aucune clause ELSE n’est spécifiée.If no Boolean_expression evaluates to TRUE, the Moteur de base de donnéesDatabase Engine returns the else_result_expression if an ELSE clause is specified, or a NULL value if no ELSE clause is specified.

NotesRemarks

SQL ServerSQL Server autorise uniquement 10 niveaux d'imbrication dans les expressions CASE.allows for only 10 levels of nesting in CASE expressions.

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.The CASE expression cannot be used to control the flow of execution of Transact-SQL statements, statement blocks, user-defined functions, and stored procedures. Pour obtenir la liste des méthodes de contrôle de flux, consultez Langage de contrôle de flux (Transact-SQL).For a list of control-of-flow methods, see Control-of-Flow Language (Transact-SQL).

L’expression CASE évalue les conditions de manière séquentielle et s’arrête à la première condition remplie.The CASE expression evaluates its conditions sequentially and stops with the first condition whose condition is satisfied. 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.In some situations, an expression is evaluated before a CASE expression receives the results of the expression as its input. Des erreurs sont possibles lors de l'évaluation de ces expressions.Errors in evaluating these expressions are possible. Les expressions d’agrégation qui apparaissent dans les arguments WHEN d’une expression CASE sont évaluées en premier, puis fournies à l’expression CASE.Aggregate expressions that appear in WHEN arguments to a CASE expression are evaluated first, then provided to the CASE expression. 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.For example, the following query produces a divide by zero error when producing the value of the MAX aggregate. Cela se produit avant l'évaluation de l'expression CASE.This occurs prior to evaluating the CASE expression.

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 ;  

Vous devez uniquement dépendre de l'ordre d'évaluation des conditions WHEN pour les expressions scalaires (notamment les sous-requêtes non corrélées qui retournent des expressions scalaires), et non pas pour les expressions d'agrégation.You should only depend on order of evaluation of the WHEN conditions for scalar expressions (including non-correlated sub-queries that return scalars), not for aggregate expressions.

ExemplesExamples

A.A. Utilisation d'une instruction SELECT avec une expression CASE simpleUsing a SELECT statement with a simple CASE expression

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.Within a SELECT statement, a simple CASE expression allows for only an equality check; no other comparisons are made. L'exemple suivant utilise l'expression CASE pour modifier la présentation des catégories de gammes de produits pour en faciliter la lecture.The following example uses the CASE expression to change the display of product line categories to make them more understandable.

USE AdventureWorks2012;  
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.B. Utilisation d'une instruction SELECT avec une expression CASE élaboréeUsing a SELECT statement with a searched CASE expression

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.Within a SELECT statement, the searched CASE expression allows for values to be replaced in the result set based on comparison values. L'exemple suivant donne le prix sous la forme d'un texte de commentaire basé sur la fourchette de prix d'un produit.The following example displays the list price as a text comment based on the price range for a product.

USE AdventureWorks2012;  
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.C. Utilisation de CASE dans une clause ORDER BYUsing CASE in an ORDER BY clause

L'exemple suivant utilise l'expression CASE dans une clause ORDER BY pour déterminer l'ordre de tri des lignes d'après la valeur d'une colonne donnée.The following examples uses the CASE expression in an ORDER BY clause to determine the sort order of the rows based on a given column value. Dans le premier exemple, la valeur de la colonne SalariedFlag de la table HumanResources.Employee est évaluée.In the first example, the value in the SalariedFlag column of the HumanResources.Employee table is evaluated. Les employés pour lesquels SalariedFlag a la valeur 1 sont retournés par ordre décroissant d'BusinessEntityID.Employees that have the SalariedFlag set to 1 are returned in order by the BusinessEntityID in descending order. Les employés pour lesquels SalariedFlag a la valeur 0 sont retournés par ordre croissant d'BusinessEntityID.Employees that have the SalariedFlag set to 0 are returned in order by the BusinessEntityID in ascending order. 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.In the second example, the result set is ordered by the column TerritoryName when the column CountryRegionName is equal to 'United States' and by CountryRegionName for all other rows.

SELECT BusinessEntityID, SalariedFlag  
FROM HumanResources.Employee  
ORDER BY CASE SalariedFlag WHEN 1 THEN BusinessEntityID END DESC  
        ,CASE WHEN SalariedFlag = 0 THEN BusinessEntityID END;  
GO  
  
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;  
  

D.D. Utilisation de CASE dans une instruction UPDATEUsing CASE in an UPDATE statement

L'exemple suivant utilise l'expression CASE dans une instruction UPDATE afin de déterminer la valeur définie pour la colonne VacationHours des employés pour lesquels SalariedFlag a la valeur 0.The following example uses the CASE expression in an UPDATE statement to determine the value that is set for the column VacationHours for employees with SalariedFlag set to 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.When subtracting 10 hours from VacationHours results in a negative value, VacationHours is increased by 40 hours; otherwise, VacationHours is increased by 20 hours. La clause OUTPUT est utilisée pour afficher les valeurs antérieures et postérieures aux congés.The OUTPUT clause is used to display the before and after vacation values.

USE AdventureWorks2012;  
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;  
  

E.E. Utilisation de CASE dans une instruction SETUsing CASE in a SET statement

L'exemple suivant utilise l'expression CASE dans une instruction SET au sein de la fonction table dbo.GetContactInfo.The following example uses the CASE expression in a SET statement in the table-valued function dbo.GetContactInfo. Dans la base de données AdventureWorks2012AdventureWorks2012, toutes les données relatives aux personnes sont stockées dans la table Person.Person.In the AdventureWorks2012AdventureWorks2012 database, all data related to people is stored in the Person.Person table. Par exemple, la personne peut être un employé, un représentant du fournisseur ou un client.For example, the person may be an employee, vendor representative, or a customer. La fonction retourne le prénom et le nom d’un BusinessEntityID donné, ainsi que le type de contact correspondant à cette personne. L’expression CASE dans l’instruction SET détermine la valeur à afficher pour la colonne ContactType en fonction de l’existence de la colonne BusinessEntityID dans les tables Employee, Vendor ou Customer.The function returns the first and last name of a given BusinessEntityID and the contact type for that person.The CASE expression in the SET statement determines the value to display for the column ContactType based on the existence of the BusinessEntityID column in the Employee, Vendor, or Customer tables.

  
USE AdventureWorks2012;  
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);  
  

F.F. Utilisation de CASE dans une clause HAVINGUsing CASE in a HAVING clause

L'exemple suivant utilise l'expression CASE dans une clause HAVING pour restreindre les lignes retournées par l'instruction SELECT.The following example uses the CASE expression in a HAVING clause to restrict the rows returned by the SELECT statement. L’instruction retourne le taux horaire maximal de chaque poste indiqué dans la table HumanResources.Employee.The statement returns the maximum hourly rate for each job title in the HumanResources.Employee table. La clause HAVING restreint les fonctions aux hommes ayant un taux de salaire maximal supérieur à 40 dollars ou aux femmes ayant un taux de salaire maximal supérieur à 42 dollars.The HAVING clause restricts the titles to those that are held by men with a maximum pay rate greater than 40 dollars or women with a maximum pay rate greater than 42 dollars.

USE AdventureWorks2012;  
GO  
SELECT JobTitle, MAX(ph1.Rate)AS MaximumRate  
FROM HumanResources.Employee AS e  
JOIN HumanResources.EmployeePayHistory AS ph1 ON e.BusinessEntityID = ph1.BusinessEntityID  
GROUP BY JobTitle  
HAVING (MAX(CASE WHEN Gender = 'M'   
        THEN ph1.Rate   
        ELSE NULL END) > 40.00  
     OR MAX(CASE WHEN Gender  = 'F'   
        THEN ph1.Rate    
        ELSE NULL END) > 42.00)  
ORDER BY MaximumRate DESC;  
  

Exemples : Azure Synapse Analytics (SQL DW)Azure Synapse Analytics (SQL DW) et Parallel Data WarehouseParallel Data WarehouseExamples: Azure Synapse Analytics (SQL DW)Azure Synapse Analytics (SQL DW) and Parallel Data WarehouseParallel Data Warehouse

G.G. Utilisation d’une instruction SELECT avec une expression CASEUsing a SELECT statement with a CASE expression

Dans une instruction SELECT, l’expression CASE permet de remplacer des valeurs dans le jeu de résultats, en fonction de valeurs de comparaison.Within a SELECT statement, the CASE expression allows for values to be replaced in the result set based on comparison values. L’exemple suivant utilise l’expression CASE pour modifier la présentation des catégories de gammes de produits pour en faciliter la lecture.The following example uses the CASE expression to change the display of product line categories to make them more understandable. Quand une valeur n’existe pas, le texte « Not for sale » s’affiche.When a value does not exist, the text "Not for sale' is displayed.

-- Uses AdventureWorks  
  
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;  

H.H. Utilisation de CASE dans une instruction UPDATEUsing CASE in an UPDATE statement

L'exemple suivant utilise l'expression CASE dans une instruction UPDATE afin de déterminer la valeur définie pour la colonne VacationHours des employés pour lesquels SalariedFlag a la valeur 0.The following example uses the CASE expression in an UPDATE statement to determine the value that is set for the column VacationHours for employees with SalariedFlag set to 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.When subtracting 10 hours from VacationHours results in a negative value, VacationHours is increased by 40 hours; otherwise, VacationHours is increased by 20 hours.

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

Voir aussiSee Also

Expressions (Transact-SQL) Expressions (Transact-SQL)
SELECT (Transact-SQL) SELECT (Transact-SQL)
COALESCE (Transact-SQL) COALESCE (Transact-SQL)
IIF (Transact-SQL) IIF (Transact-SQL)
CHOOSE (Transact-SQL)CHOOSE (Transact-SQL)