3 formas de usar TODO en SQL Server

Es posible que esté familiarizado con ALL opción en SQL Server. Quizás lo hayas usado junto con UNION operador para incluir cualquier duplicado que pueda devolverse en el conjunto de resultados.

Pero, ¿sabías que ALL también se puede utilizar en otros dos contextos?

ALL se puede utilizar en los siguientes tres contextos:

• Como argumento del SELECT cláusula.
• Como argumento de UNION cláusula.
• Como operador lógico al comparar un valor escalar con un conjunto de valores de una sola columna.

A continuación se muestran ejemplos de cada uno de estos contextos.

ALL en el SELECT Cláusula

Cuando se usa con SELECT cláusula, ALL especifica que se devuelven valores duplicados en el conjunto de resultados.

Probablemente ya usas esto implícitamente sin siquiera saberlo.

En T-SQL, la sintaxis para SELECT cláusula dice así:

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 ]

La parte que va [ ALL | DISTINCT ] significa que puedes elegir entre ALL y DISTINCT .

Los corchetes significan que esta parte es opcional.

• ALL especifica que pueden aparecer filas duplicadas en el conjunto de resultados.
• DISTINCT especifica que solo pueden aparecer filas únicas en el conjunto de resultados.

ALL es el valor predeterminado, por lo que si no especifica ALL o DISTINCT , ALL se utiliza.

Ejemplo

Entonces, las siguientes dos declaraciones son equivalentes:

SELECT DogName 
FROM Dogs;

SELECT ALL DogName 
FROM Dogs;

Resultado de ejemplo:

+-----------+
| DogName   |
|-----------|
| Fetch     |
| Fluffy    |
| Wag       |
| Fetch     |
+-----------+
(4 rows affected)
+-----------+
| DogName   |
|-----------|
| Fetch     |
| Fluffy    |
| Wag       |
| Fetch     |
+-----------+
(4 rows affected)

Ambos resultados muestran que hay dos perros llamados "Fetch".

Si intercambiamos el ALL argumento para DISTINCT , solo se devolverá una fila para "Obtener". Esto se debe a que DISTINCT elimina cualquier valor duplicado del conjunto de resultados.

SELECT DISTINCT DogName 
FROM Dogs;

Resultado de ejemplo:

+-----------+
| DogName   |
|-----------|
| Fetch     |
| Fluffy    |
| Wag       |
+-----------+
(3 rows affected)

ALL en la UNION Cláusula

ALL hace lo mismo cuando se usa con UNION cláusula. Especifica que se devuelven valores duplicados en el conjunto de resultados.

Pero obviamente, UNION es una cláusula diferente a SELECT , por lo que el contexto es ligeramente diferente.

La UNION La cláusula concatena los resultados de dos consultas en un único conjunto de resultados. Puede usarlo con o sin ALL argumento:

• UNION ALL – Incluye duplicados.
• UNION – Excluye duplicados.

Ejemplo

Aquí hay un ejemplo del uso de UNION ALL para combinar dos consultas.

Agreguemos una tabla llamada Cats . Entonces tenemos dos tablas:Dogs y Cats

Dogs

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

Cats

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

Ahora seleccionemos el nombre del perro/gato de cada tabla y usemos UNION ALL para combinar los resultados de ambas tablas.

SELECT DogName AS PetName
FROM Dogs
UNION ALL
SELECT CatName
FROM Cats;

Resultado:

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

En este caso, se devuelven siete filas. Podemos ver que "Fetch" se devuelve dos veces. Esto se debe a que hay dos perros llamados Fetch.

También hay un gato y un perro con el mismo nombre:Fluffy. (Sabemos que el otro es un gato porque solo había un perro llamado Fluffy en el ejemplo anterior).

Veamos qué sucede cuando elimino ALL argumento.

SELECT DogName AS PetName
FROM Dogs
UNION
SELECT CatName
FROM Cats;

Resultado:

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

Esta vez solo se devuelven cinco filas. Se eliminan ambos duplicados.

Tenga en cuenta que esto es diferente a aplicar DISTINCT a cada individuo SELECT declaración. Si hubiéramos hecho eso, Fluffy habría sido devuelto dos veces, porque ALL solo aplicaría para el SELECT declaración contra la que se está aplicando (no a los resultados concatenados).

Aquí hay un ejemplo para ilustrar lo que quiero decir.

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)

Los ALL Operador

Los ALL El operador se puede usar con una subconsulta para comparar un valor escalar con un conjunto de valores de una sola columna devuelto por la subconsulta.

Ejemplo

Como repaso, aquí están nuestras dos tablas:

Dogs

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

Cats

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

Ahora ejecutemos una subconsulta usando ALL operador.

SELECT 
    CatId,
    CatName
FROM Cats c 
WHERE c.CatName = ALL (SELECT DogName FROM Dogs);

Resultado:

(0 rows affected)

En este caso, no se devolvieron filas. Esto se debe a que ALL requiere que la expresión escalar se compare positivamente con every valor que devuelve la subconsulta.

En este caso, la subconsulta era tan amplia que todas las filas de Dogs se devolvió la mesa. Esto requeriría que cada perro tuviera al menos un gato correspondiente con el mismo nombre.

Cambiemos ligeramente la subconsulta.

SELECT 
    CatId,
    CatName
FROM Cats c 
WHERE c.CatName = ALL (
    SELECT DogName FROM Dogs 
    WHERE DogId = 2
    );

Resultado:

+---------+-----------+
| CatId   | CatName   |
|---------+-----------|
| 2       | Fluffy    |
+---------+-----------+

Esta vez obtengo un resultado positivo, porque todas las filas devueltas por la subconsulta tenían una fila correspondiente en Cats tabla (en este caso, solo una fila).