3 modi per utilizzare TUTTO in SQL Server

Potresti avere familiarità con ALL opzione in SQL Server. Forse l'hai usato insieme a UNION per includere eventuali duplicati che potrebbero essere restituiti nel set di risultati.

Ma lo sapevi che ALL può essere utilizzato anche in altri due contesti?

ALL può essere utilizzato nei seguenti tre contesti:

• Come argomento per SELECT clausola.
• Come argomento per UNION clausola.
• Come operatore logico quando si confronta un valore scalare con un insieme di valori a colonna singola.

Seguono esempi di ciascuno di questi contesti.

ALL nel SELECT Clausola

Se utilizzato con SELECT clausola, ALL specifica che i valori duplicati vengono restituiti nel set di risultati.

Probabilmente lo usi già implicitamente senza nemmeno saperlo.

In T-SQL, la sintassi per SELECT la clausola va così:

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 che va [ ALL | DISTINCT ] significa che puoi scegliere tra ALL e DISTINCT .

Le parentesi quadre indicano che questa parte è facoltativa.

• ALL specifica che le righe duplicate possono essere visualizzate nel set di risultati.
• DISTINCT specifica che nel set di risultati possono essere visualizzate solo righe univoche.

ALL è il valore predefinito, quindi se non specifichi ALL o DISTINCT , ALL viene utilizzato.

Esempio

Quindi le seguenti due affermazioni sono equivalenti:

SELECT DogName 
FROM Dogs;

SELECT ALL DogName 
FROM Dogs;

Esempio di risultato:

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

Entrambi i risultati mostrano che ci sono due cani chiamati "Fetch".

Se scambiamo il ALL argomento per DISTINCT , verrà restituita solo una riga per "Fetch". Questo perché DISTINCT rimuove tutti i valori duplicati dal set di risultati.

SELECT DISTINCT DogName 
FROM Dogs;

Esempio di risultato:

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

ALL nel UNION Clausola

ALL fa la stessa cosa se usato con UNION clausola. Specifica che i valori duplicati vengono restituiti nel set di risultati.

Ma ovviamente, UNION è una clausola diversa da SELECT , quindi il contesto è leggermente diverso.

Il UNION La clausola concatena i risultati di due query in un unico set di risultati. Puoi usarlo con o senza ALL argomento:

• UNION ALL – Include duplicati.
• UNION – Esclude i duplicati.

Esempio

Ecco un esempio di utilizzo di UNION ALL per combinare due query.

Aggiungiamo una tabella chiamata Cats . Quindi abbiamo due tabelle:Dogs e Cats

Dogs

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

Cats

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

Ora selezioniamo il nome del cane/gatto da ciascuna tabella e utilizziamo UNION ALL per combinare i risultati di entrambe le tabelle.

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

Risultato:

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

In questo caso vengono restituite sette righe. Possiamo vedere che "Fetch" viene restituito due volte. Questo perché ci sono due cani di nome Fetch.

C'è anche un gatto e un cane con lo stesso nome:Fluffy. (Sappiamo che l'altro è un gatto perché nell'esempio precedente c'era solo un cane chiamato Fluffy).

Vediamo cosa succede quando rimuovo ALL argomento.

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

Risultato:

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

Questa volta vengono restituite solo cinque righe. Entrambi i duplicati vengono rimossi.

Nota che questo è diverso dall'applicazione di DISTINCT a ogni singolo SELECT dichiarazione. Se lo avessimo fatto, Fluffy sarebbe stato restituito due volte, perché ALL si applicherebbe solo per il SELECT dichiarazione contro cui viene applicato (non ai risultati concatenati).

Ecco un esempio per illustrare cosa intendo.

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

Risultato:

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

Il ALL Operatore

Il ALL può essere utilizzato con una sottoquery per confrontare un valore scalare con un insieme di valori a colonna singola restituito dalla sottoquery.

Esempio

Come aggiornamento, ecco i nostri due tavoli:

Dogs

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

Cats

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

Ora eseguiamo una sottoquery usando ALL operatore.

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

Risultato:

(0 rows affected)

In questo caso, non sono state restituite righe. Questo perché ALL richiede che l'espressione scalare venga confrontata positivamente con ogni valore restituito dalla sottoquery.

In questo caso, la sottoquery era così ampia che tutte le righe di Dogs la tabella è stata restituita. Ciò richiederebbe che ogni cane avesse almeno un gatto corrispondente con lo stesso nome.

Modifichiamo leggermente la sottoquery.

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

Risultato:

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

Questa volta ottengo un risultato positivo, perché tutte le righe restituite dalla sottoquery avevano una riga corrispondente in Cats tabella (in questo caso, solo una riga).