Expressão CASE do SQL Server

No SQL Server, o T-SQL CASE expression é uma expressão escalar que retorna um valor com base na lógica condicional. Ele avalia uma lista de condições e retorna um valor, com base no resultado dessas condições.

De certa forma, o SQL Server CASE expressão é semelhante a IF...ELSE . No entanto, CASE permite que você verifique várias condições, enquanto IF...ELSE não.

Além disso, no SQL Server, IF...ELSE é uma palavra-chave de linguagem de controle de fluxo, enquanto CASE não é. O CASO expressão não pode ser usada para controlar o fluxo de execução de instruções T-SQL, blocos de instruções, funções definidas pelo usuário e procedimentos armazenados.

As 2 formas de expressão CASE

Existem duas formas de CASE expressão no SQL Server:

Simples CASE expressão
Pesquisou CASE expressão

Estes são explicados com exemplos abaixo.

Formulário 1 – A expressão CASE simples

O simples CASE expressão compara uma expressão a um conjunto de expressões simples para determinar o resultado.

Aqui está um exemplo básico para demonstrar como um CASE expressão funciona no SQL Server.

DECLARE @stock_ticker varchar(4) ='V';SELECT Company =CASE @stock_ticker QUANDO 'AAPL' THEN 'Apple' QUANDO 'FB' THEN 'Facebook' QUANDO 'V' THEN 'Visa' ELSE ' Não está no portfólio' END

Resultado:

+-----------+| Empresa ||-----------|| Visto |+-----------+

Neste exemplo, meu CASE expressão é parte de um SELECT demonstração. Ele verifica três condições e tem um ELSE para atender a qualquer coisa que não esteja coberta nas três condições.

Neste caso, o código de ações V corresponde ao terceiro WHEN expressão e a expressão fornecida por THEN é devolvido.

Para ser claro, o CASE real expressão é esta parte:

 CASE @stock_ticker QUANDO 'AAPL' DEPOIS 'Apple' QUANDO 'FB' DEPOIS 'Facebook' QUANDO 'MA' DEPOIS 'Mastercard' QUANDO 'V' DEPOIS 'Visa' ENTÃO 'Não está no portfólio' END

 
 O que CASE faz é, ele verifica o valor de cada WHEN expressão contra a expressão de entrada. No meu exemplo, o @stock_ticker variável é a expressão de entrada. Portanto, está verificando o valor de cada WHEN expressão contra o @stock_ticker variável. 
 
 Quando/se encontrar uma correspondência, retornará a expressão fornecida por THEN . 
 
 Meu exemplo usa três WHEN expressões, mas poderia ter sido mais e poderia ter sido menos, dependendo das minhas necessidades. 
 Formulário 2 – A expressão CASE pesquisada
 
 O CASE pesquisado expression avalia um conjunto de expressões booleanas para determinar o resultado. 
 
 Aqui está um exemplo de um CASE pesquisado expressão. 
 DECLARE @price int =1500;SELECT Acessibilidade =CASE WHEN @price <100 THEN 'Cheap' WHEN @price>=100 AND @price <500 THEN 'Affordable' ELSE 'Caro' END 
 
 Resultado:
 +-----------------+| Acessibilidade ||-----------------|| Caro |+-----------------+
 
 Um CASE pesquisado expressão não tem uma expressão de entrada como o simples CASE expressão. 
 
 Você se lembrará disso em nosso simples CASE expressão, começou com CASE @stock_ticker , e, portanto, sabíamos que o WHEN expressões foram todas avaliadas em relação ao valor de @stock_ticker . 
 
 Com o CASE pesquisado expressão, não fornecemos uma expressão de entrada no início assim. Em vez disso, cada QUANDO expressão inclui uma expressão booleana para a qual será avaliada. 
 Um exemplo de banco de dados
 
 Aqui está um exemplo que demonstra como o CASE expressão pode ser usada em uma consulta de banco de dados. 
 USE WideWorldImporters;SELECT CityName AS [City], LatestRecordedPopulation AS [Population], Size =CASE WHEN LatestRecordedPopulation <2000000 THEN 'Small City' WHEN LatestRecordedPopulation>=2000000 AND LatestRecordedPopulation <3000000 THEN 'Big City' ELSE ' Really Big City' END FROM Application.CitiesWHERE LatestRecordedPopulation> 1000000; 
 
 Resultado:
 +--------------+--------------+---------------- -+| Cidade | População | Tamanho ||--------------+--------------+----------------- || Brooklin | 2565635 | Cidade Grande || Chicago | 2695598 | Cidade Grande || Dallas | 1197816 | Cidade Pequena || Houston | 2099451 | Cidade Grande || Los Angeles | 3792621 | Cidade realmente grande || Manhattan | 1619090 | Cidade Pequena || Nova York | 8175133 | Cidade realmente grande || Filadélfia | 1526006 | Cidade Pequena || Fênix | 1445632 | Cidade Pequena || Rainhas | 2272771 | Cidade Grande || Santo Antonio | 1327407 | Cidade Pequena || São Diego | 1307402 | Cidade Pequena || O Bronx | 1408473 | Cidade Pequena |+--------------+--------------+---------------- -+
 
 Este exemplo usa um CASE pesquisado expressão para avaliar os resultados da LatestRecordedPopulation coluna do Application.Cities tabela. 
 Tipos de dados
 
 No SQL Server, o tipo de dados da expressão de entrada e o WHEN expressões devem ser iguais ou devem ser uma conversão implícita. 
 
 Veja o que acontece se não forem:
 DECLARE @stock_ticker varchar(4) ='V';SELECT Company =CASE @stock_ticker QUANDO 1 ENTÃO 'Apple' QUANDO 2 ENTÃO 'Facebook' QUANDO 3 ENTÃO 'Mastercard' QUANDO 4 ENTÃO 'Visa' ELSE ' Não está no portfólio' END 
 
 Resultado:
 Msg 245, Level 16, State 1, Line 3Falha na conversão ao converter o valor varchar 'V' para o tipo de dados int.
 Ordem de Avaliação
 
 O T-SQL CASE expressão avalia suas condições sequencialmente e para na primeira condição cuja condição é satisfeita. 
 
 Para demonstrar isso, vamos usar vários WHEN expressões que compartilham o mesmo valor:
 DECLARE @stock_ticker varchar(4) ='V';SELECT Company =CASE @stock_ticker QUANDO 'V' THEN 'Visa 1' QUANDO 'V' THEN 'Visa 2' QUANDO 'V' THEN 'Visa 3' ' ELSE 'Não está no portfólio' END 
 
 Resultado:
 +-----------+| Empresa ||-----------|| Visto 1 |+-----------+
 
 Neste caso, ele parou no primeiro WHEN expressão. 
 
 Pode haver o cenário ocasional em que uma expressão é avaliada antes de um CASE expressão recebe os resultados da expressão como sua entrada. Em tais cenários, você pode acabar com um erro. Isso pode acontecer se você incluir uma expressão agregada como WHEN expressão. 
 
 Por esse motivo, a Microsoft aconselha que:
  
 Você deve depender apenas da ordem de avaliação das condições WHEN para expressões escalares (incluindo subconsultas não correlacionadas que retornam escalares), não para expressões agregadas. 
 
 ELSE é opcional
 
 O ELSE argumento é opcional. Portanto, poderíamos reescrever nosso exemplo de “acessibilidade” da seguinte forma:
 DECLARE @price int =1500;SELECT Acessibilidade =CASE WHEN @price <100 THEN 'Cheap' WHEN @price>=100 AND @price <500 THEN 'Affordable' WHEN @price>=500 THEN 'Caro ' FIM  
 
 Resultado:
 +-----------------+| Acessibilidade ||-----------------|| Caro |+-----------------+
 
 Embora, esteja ciente de que você pode acabar com NULL se você omitir o ELSE argumento. 
 
 O exemplo a seguir resulta em NULL :
 DECLARE @price int =1500;SELECT Acessibilidade =CASE WHEN @price <100 THEN 'Cheap' WHEN @price>=100 AND @price <500 THEN 'Affordable' WHEN @price>=500 AND @price <1000 THEN 'Caro' END  
 
 Resultado:
 +-----------------+| Acessibilidade ||-----------------|| NULO |+-----------------+
 
 Nesses casos, sempre podemos adicionar um ELSE argumento, apenas no caso (desculpe o trocadilho!):
 DECLARE @price int =1500;SELECT Acessibilidade =CASE WHEN @price <100 THEN 'Cheap' WHEN @price>=100 AND @price <500 THEN 'Affordable' WHEN @price>=500 AND @price <1000 THEN 'Caro' ELSE 'Desconhecido' END  
 
 Resultado:
 +-----------------+| Acessibilidade ||-----------------|| Desconhecido |+-----------------+
 
 É certo que este exemplo é provavelmente um pouco artificial. Afinal, não há necessidade de limitar o “caro”. Se algo é caro por menos de US $ 1.000, também é caro se for superior a US $ 1.000. 
 
 Mas o ponto é que você pode usar ELSE para capturar qualquer coisa que não seja coberta pelo WHEN expressões. 
 Expressões CASE aninhadas
 
 Você pode aninhar CASE expressões, se necessário. 
 DECLARE @price int, @on_sale bit;SET @price =1500;SET @on_sale =1;SELECT Acessibilidade =CASE WHEN @price <100 THEN 'Cheap' WHEN @price>=100 THEN CASE @on_sale WHEN 0 THEN 'Caro (mas não está à venda no momento)' WHEN 1 THEN 'Caro (e já está à venda!)' END END 
 
 Resultado:
 +---------------------------------------+| Acessibilidade ||--------------------------------------------------|| Caro (e já está em promoção!) |+------------------------------------------------- +
 
 No entanto, é importante observar que apenas 10 níveis de aninhamento são permitidos para CASE expressões no SQL Server. Se você tentar aninhar mais de 10 níveis, receberá um erro. 
 CASO em uma cláusula ORDER BY
 
 Como mencionado, o T-SQL CASE expressão pode ser usada em qualquer instrução ou cláusula que permita uma expressão válida. Portanto, você pode usá-lo em instruções como SELECT , ATUALIZAR , EXCLUIR e SET , e em cláusulas como IN , ONDE , ORDER POR , GRUPAR POR , e TENDO . 
 
 Usando um CASE expressão no ORDER BY de uma instrução A cláusula pode ser útil quando você deseja fazer uma exceção especial para determinados valores ao ordenar seus resultados. 
 
 Suponha que executemos a seguinte consulta em uma tabela contendo gêneros musicais. 
 SELECT Genre FROM MusicGenresORDER BY Gênero ASC; 
 
 Resultado:
 +---------+| Gênero ||---------|| Azuis || País || Hip Hop || Jazz || Metais || Outros || Pop || Rap || Rocha |+---------+
 
 Aqui, ordenamos os resultados pelo Genre coluna, em ordem crescente. 
 
 Isso é bom, exceto por uma coisa. O gênero chamado Outro . Não seria bom se pudéssemos mover Outro ao fundo? 
 
 Podemos conseguir isso com o CASE expressão pegando a consulta acima e modificando-a da seguinte maneira. 
 SELECT GenreFROM MusicGenresORDER BY CASE Gênero WHEN 'Other' THEN 1 ELSE 0 END ASC, Gênero ASC; 
 
 Resultado:
 +---------+| Gênero ||---------|| Azuis || País || Hip Hop || Jazz || Metais || Pop || Rap || Rocha || Outros |+---------+
 CASE em uma declaração UPDATE
 
 Aqui está um exemplo de como usar um CASE expressão em um UPDATE demonstração. 
 
 Suponha que temos a seguinte tabela:
 +---------+-----------+-----------+----------+| DogId | DogName | GoodDog | Jantar ||---------+-----------+-----------+----------|| 1 | Buscar | 1 | NULO || 2 | Fofo | 0 | NULO || 3 | Wag | 0 | NULO || 1001 | Brian | 1 | NULO || 1002 | Rambo | 0 | NULO || 1003 | BamBam | 1 | NULL |+---------+-----------+-----------+----------+ 
 Recentemente adicionamos o Jantar coluna, e ainda é NULL , aguardando a inserção de valores. 
 
 Mas os valores a serem inseridos dependerão do valor do GoodDog coluna. 
 
 Poderíamos usar um CASE expressão em tal cenário. 
 UPDATE Dogs SET Dinner =CASE GoodDog WHEN 1 THEN 'Sunday Roast' ELSE 'Airline food' ENDSELECT * FROM Dogs; 
 
 Resultado:
 +---------+-----------+-----------+------------ --+| DogId | DogName | GoodDog | Jantar ||---------+-----------+-----------+------------- -|| 1 | Buscar | 1 | Assado de Domingo || 2 | Fofo | 0 | Comida de avião || 3 | Wag | 0 | Comida de avião || 1001 | Brian | 1 | Assado de Domingo || 1002 | Rambo | 0 | Comida de avião || 1003 | BamBam | 1 | Assado de Domingo |+---------+-----------+-----------+------------ --+
 CASE em uma instrução INSERT
 
 Podemos pegar a tabela do exemplo acima e inserir um novo valor. 
 
 E podemos aproveitar novamente o CASE expressão para inserir o valor apropriado no Jantar coluna. 
 DECLARE @DogName nvarchar(60), @GoodDog bit;SET @DogName ='Preguiçoso';SET @GoodDog =0;INSERT INTO Dogs ( DogName, GoodDog, Dinner )VALUES ( @DogName, @GoodDog, CASE @GoodDog WHEN 1 THEN 'Sunday Roast' ELSE 'Airline food' END );SELECT * FROM Dogs; 
 
 Resultado:
 +---------+-----------+-----------+------------ --+| DogId | DogName | GoodDog | Jantar ||---------+-----------+-----------+------------- -|| 1 | Buscar | 1 | Assado de Domingo || 2 | Fofo | 0 | Comida de avião || 3 | Wag | 0 | Comida de avião || 1001 | Brian | 1 | Assado de Domingo || 1002 | Rambo | 0 | Comida de avião || 1003 | BamBam | 1 | Assado de Domingo || 1004 | Preguiçoso | 0 | Comida de avião |+---------+-----------+-----------+------------ --+
 
 Desta vez, o CASE expressão estava avaliando o valor de uma variável que acabamos de definir e inserindo o valor apropriado no Dinner coluna. 
 É uma declaração CASE ou uma expressão CASE?
 
 No SQL, muitas coisas são chamadas de “declarações” quando, na verdade, são outra coisa. Isso também parece ser verdade para o T-SQL “CASE demonstração". 
 
 Embora seja frequentemente chamado de CASE declaração, é mais correto chamá-la de CASE expressão . É também assim que a documentação da Microsoft se refere a ele. 
 
 No SQL Server, em vez de ser uma instrução em si, CASE pode ser usado em qualquer instrução ou cláusula que permita uma expressão válida. Uma expressão é uma combinação de símbolos e operadores que são avaliados para obter um único valor de dados. 
 
 No entanto, alguns SGBDs distinguem entre o CASE instrução e o CASE expressão e têm uma sintaxe ligeiramente diferente para cada um. MySQL distingue entre o CASE instrução e o CASE operador, que é essencialmente o mesmo que o CASE expressão.