3 manieren om ALL in SQL Server te gebruiken

Je bent misschien bekend met de ALL optie in SQL Server. Misschien heb je het samen met de UNION . gebruikt operator om eventuele duplicaten op te nemen die mogelijk worden geretourneerd in de resultatenset.

Maar wist je dat ALL kan ook in twee andere contexten worden gebruikt?

ALL kan in de volgende drie contexten worden gebruikt:

• Als argument voor de SELECT clausule.
• Als argument voor de UNION clausule.
• Als logische operator bij het vergelijken van een scalaire waarde met een reeks waarden met één kolom.

Voorbeelden van elk van deze contexten volgen.

ALL in de SELECT Clausule

Bij gebruik met de SELECT clausule, ALL specificeert dat dubbele waarden worden geretourneerd in de resultatenset.

Je gebruikt dit waarschijnlijk al impliciet zonder het te weten.

In T-SQL is de syntaxis voor de SELECT clausule gaat als volgt:

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 ]

Het deel dat gaat [ ALL | DISTINCT ] betekent dat u de keuze krijgt tussen ALL en DISTINCT .

De vierkante haken geven aan dat dit onderdeel optioneel is.

• ALL specificeert dat dubbele rijen in de resultatenset kunnen verschijnen.
• DISTINCT geeft aan dat alleen unieke rijen in de resultatenset kunnen worden weergegeven.

ALL is de standaardwaarde, dus als u ALL niet opgeeft of DISTINCT , ALL wordt gebruikt.

Voorbeeld

De volgende twee uitspraken zijn dus equivalent:

SELECT DogName 
FROM Dogs;

SELECT ALL DogName 
FROM Dogs;

Voorbeeld resultaat:

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

Beide resultaten laten zien dat er twee honden zijn met de naam "Fetch".

Als we de ALL . verwisselen argument voor DISTINCT , wordt er slechts één rij geretourneerd voor "Fetch". Dit komt omdat DISTINCT verwijdert eventuele dubbele waarden uit de resultatenset.

SELECT DISTINCT DogName 
FROM Dogs;

Voorbeeld resultaat:

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

ALL in de UNION Clausule

ALL doet hetzelfde bij gebruik met de UNION clausule. Het specificeert dat dubbele waarden worden geretourneerd in de resultatenset.

Maar natuurlijk, UNION is een andere clausule dan SELECT , dus de context is iets anders.

De UNION clausule voegt de resultaten van twee query's samen tot één resultaatset. Je kunt het gebruiken met of zonder de ALL argument:

• UNION ALL – Bevat duplicaten.
• UNION – Sluit duplicaten uit.

Voorbeeld

Hier is een voorbeeld van het gebruik van UNION ALL om twee zoekopdrachten te combineren.

Laten we een tabel toevoegen met de naam Cats . We hebben dus twee tabellen:Dogs en Cats

Dogs

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

Cats

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

Laten we nu de naam van de hond/kat uit elke tabel selecteren en UNION ALL . gebruiken om de resultaten van beide tabellen te combineren.

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

Resultaat:

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

In dit geval worden zeven rijen geretourneerd. We kunnen zien dat "Fetch" twee keer wordt geretourneerd. Dit komt omdat er twee honden zijn die Fetch heten.

Er is ook een kat en een hond met dezelfde naam:Fluffy. (We weten dat de andere een kat is omdat er in het vorige voorbeeld maar één hond was die Fluffy heette).

Eens kijken wat er gebeurt als ik de ALL . verwijder argument.

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

Resultaat:

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

Deze keer worden er slechts vijf rijen geretourneerd. Beide duplicaten zijn verwijderd.

Merk op dat dit anders is dan het toepassen van DISTINCT aan elke individuele SELECT uitspraak. Als we dat hadden gedaan, zou Fluffy twee keer zijn geretourneerd, omdat de ALL zou alleen gelden voor de SELECT verklaring dat het wordt toegepast tegen (niet op de aaneengeschakelde resultaten).

Hier is een voorbeeld om te illustreren wat ik bedoel.

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

Resultaat:

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

De ALL Operator

De ALL operator kan worden gebruikt met een subquery om een ​​scalaire waarde te vergelijken met een reeks waarden met één kolom die door de subquery worden geretourneerd.

Voorbeeld

Ter opfrissing zijn hier onze twee tabellen:

Dogs

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

Cats

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

Laten we nu een subquery uitvoeren met de ALL telefoniste.

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

Resultaat:

(0 rows affected)

In dit geval zijn er geen rijen geretourneerd. Dit komt omdat ALL vereist dat de scalaire expressie positief wordt vergeleken met elke waarde die wordt geretourneerd door de subquery.

In dit geval was de subquery zo breed dat alle rijen van de Dogs tafel is geretourneerd. Dit zou vereisen dat elke hond ten minste één corresponderende kat met dezelfde naam had.

Laten we de subquery iets veranderen.

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

Resultaat:

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

Deze keer krijg ik een positief resultaat, omdat alle rijen die door de subquery zijn geretourneerd een overeenkomstige rij hadden in de Cats tabel (in dit geval slechts één rij).