Sqlserver
 sql >> Base de Dados >  >> RDS >> Sqlserver

3 maneiras de usar ALL no SQL Server


Você pode estar familiarizado com o ALL opção no SQL Server. Talvez você o tenha usado junto com o UNION operador para incluir quaisquer duplicatas que possam ser retornadas no conjunto de resultados.

Mas você sabia que ALL também pode ser usado em dois outros contextos?

ALL pode ser usado nos três contextos a seguir:
  • Como argumento para SELECT cláusula.
  • Como argumento para o UNION cláusula.
  • Como um operador lógico ao comparar um valor escalar com um conjunto de valores de coluna única.

Seguem exemplos de cada um desses contextos.

ALL no SELECT Cláusula


Quando usado com o SELECT cláusula, ALL especifica que valores duplicados são retornados no conjunto de resultados.

Você provavelmente já usa isso implicitamente, mesmo sem saber.

No T-SQL, a sintaxe do SELECT cláusula fica assim:
SELECT [ ALL | DISTINCT ]  
[ TOP ( expression ) [ PERCENT ] [ WITH TIES ] ]   
<select_list>   
<select_list> ::=   
    {   
      *   
      | { table_name | view_name | table_alias }.*   
      | {  
          [ { table_name | view_name | table_alias }. ]  
               { column_name | $IDENTITY | $ROWGUID }   
          | udt_column_name [ { . | :: } { { property_name | field_name }   
            | method_name ( argument [ ,...n] ) } ]  
          | expression  
          [ [ AS ] column_alias ]   
         }  
      | column_alias = expression   
    } [ ,...n ]

A parte que vai [ ALL | DISTINCT ] significa que você pode escolher entre ALL e DISTINCT .

Os colchetes significam que esta parte é opcional.
  • ALL especifica que linhas duplicadas podem aparecer no conjunto de resultados.
  • DISTINCT especifica que somente linhas exclusivas podem aparecer no conjunto de resultados.

ALL é o valor padrão, portanto, se você não especificar ALL ou DISTINCT , ALL é usado.

Exemplo


Portanto, as duas afirmações a seguir são equivalentes:
SELECT DogName 
FROM Dogs;

SELECT ALL DogName 
FROM Dogs;

Exemplo de resultado:
+-----------+
| DogName   |
|-----------|
| Fetch     |
| Fluffy    |
| Wag       |
| Fetch     |
+-----------+
(4 rows affected)
+-----------+
| DogName   |
|-----------|
| Fetch     |
| Fluffy    |
| Wag       |
| Fetch     |
+-----------+
(4 rows affected)

Ambos os resultados mostram que existem dois cães chamados “Fetch”.

Se trocarmos o ALL argumento para DISTINCT , apenas uma linha será retornada para “Fetch”. Isso ocorre porque DISTINCT remove quaisquer valores duplicados do conjunto de resultados. 
SELECT DISTINCT DogName 
FROM Dogs;

Exemplo de resultado:
+-----------+
| DogName   |
|-----------|
| Fetch     |
| Fluffy    |
| Wag       |
+-----------+
(3 rows affected)

ALL na UNION Cláusula


ALL faz a mesma coisa quando usado com o UNION cláusula. Ele especifica que valores duplicados são retornados no conjunto de resultados.

Mas obviamente, UNION é uma cláusula diferente de SELECT , então o contexto é um pouco diferente.

A UNION A cláusula concatena os resultados de duas consultas em um único conjunto de resultados. Você pode usá-lo com ou sem o ALL argumento:
  • UNION ALL – Inclui duplicatas.
  • UNION – Exclui duplicatas.

Exemplo


Aqui está um exemplo de uso de UNION ALL para combinar duas consultas.

Vamos adicionar uma tabela chamada Cats . Portanto, temos duas tabelas:Dogs e Cats

Dogs 
+---------+-----------+
| DogId   | DogName   |
|---------+-----------|
| 1       | Fetch     |
| 2       | Fluffy    |
| 3       | Wag       |
| 1002    | Fetch     |
+---------+-----------+

Cats 
+---------+-----------+
| CatId   | CatName   |
|---------+-----------|
| 1       | Meow      |
| 2       | Fluffy    |
| 3       | Scratch   |
+---------+-----------+

Agora vamos selecionar o nome do cachorro/gato de cada tabela e usar UNION ALL para combinar os resultados de ambas as tabelas. 
SELECT DogName AS PetName
FROM Dogs
UNION ALL
SELECT CatName
FROM Cats;

Resultado:
+-----------+
| PetName   |
|-----------|
| Fetch     |
| Fluffy    |
| Wag       |
| Fetch     |
| Meow      |
| Fluffy    |
| Scratch   |
+-----------+
(7 rows affected)

Nesse caso, sete linhas são retornadas. Podemos ver que “Fetch” é retornado duas vezes. Isso ocorre porque existem dois cães chamados Fetch.

Há também um gato e um cachorro com o mesmo nome:Fofo. (Sabemos que o outro é um gato porque havia apenas um cachorro chamado Fluffy no exemplo anterior).

Vamos ver o que acontece quando eu removo o ALL argumento. 
SELECT DogName AS PetName
FROM Dogs
UNION
SELECT CatName
FROM Cats;

Resultado:
+-----------+
| PetName   |
|-----------|
| Fetch     |
| Fluffy    |
| Meow      |
| Scratch   |
| Wag       |
+-----------+
(5 rows affected)

Desta vez, apenas cinco linhas são retornadas. Ambas as duplicatas são removidas.

Observe que isso é diferente de aplicar DISTINCT para cada SELECT individual demonstração. Se tivéssemos feito isso, Fluffy teria sido retornado duas vezes, porque o ALL só se aplicaria ao SELECT declaração que está sendo aplicada (não aos resultados concatenados).

Aqui está um exemplo para ilustrar o que quero dizer. 
SELECT DISTINCT DogName AS PetName
FROM Dogs
UNION ALL
SELECT DISTINCT CatName
FROM Cats;

Resultado:
+-----------+
| PetName   |
|-----------|
| Fetch     |
| Fluffy    |
| Wag       |
| Fluffy    |
| Meow      |
| Scratch   |
+-----------+
(6 rows affected)

Os ALL Operador


O ALL O operador pode ser usado com uma subconsulta para comparar um valor escalar com um conjunto de valores de coluna única retornado pela subconsulta.

Exemplo


Para relembrar, aqui estão nossas duas tabelas:

Dogs 
+---------+-----------+
| DogId   | DogName   |
|---------+-----------|
| 1       | Fetch     |
| 2       | Fluffy    |
| 3       | Wag       |
| 1002    | Fetch     |
+---------+-----------+

Cats 
+---------+-----------+
| CatId   | CatName   |
|---------+-----------|
| 1       | Meow      |
| 2       | Fluffy    |
| 3       | Scratch   |
+---------+-----------+

Agora vamos executar uma subconsulta usando o ALL operador. 
SELECT 
    CatId,
    CatName
FROM Cats c 
WHERE c.CatName = ALL (SELECT DogName FROM Dogs);

Resultado:
(0 rows affected)

Nesse caso, nenhuma linha foi retornada. Isso ocorre porque ALL requer que a expressão escalar seja comparada positivamente com todas valor que é retornado pela subconsulta.

Nesse caso, a subconsulta era tão ampla que todas as linhas do Dogs mesa foi devolvida. Isso exigiria que cada cão tivesse pelo menos um gato correspondente com o mesmo nome.

Vamos alterar um pouco a subconsulta. 
SELECT 
    CatId,
    CatName
FROM Cats c 
WHERE c.CatName = ALL (
    SELECT DogName FROM Dogs 
    WHERE DogId = 2
    );

Resultado:
+---------+-----------+
| CatId   | CatName   |
|---------+-----------|
| 2       | Fluffy    |
+---------+-----------+

Desta vez recebo um resultado positivo, pois todas as linhas retornadas pela subconsulta tinham uma linha correspondente no Cats tabela (neste caso, apenas uma linha).