Sqlserver
 sql >> Base de données >  >> RDS >> Sqlserver

3 façons d'utiliser ALL dans SQL Server

Vous connaissez peut-être le ALL option dans SQL Server. Peut-être l'avez-vous utilisé avec le UNION opérateur pour inclure tous les doublons qui pourraient être renvoyés dans le jeu de résultats.

Mais saviez-vous que ALL peut également être utilisé dans deux autres contextes ?

ALL peut être utilisé dans les trois contextes suivants :

  • Comme argument du SELECT clause.
  • Comme argument de l'UNION clause.
  • Comme opérateur logique lors de la comparaison d'une valeur scalaire avec un ensemble de valeurs à une seule colonne.

Des exemples de chacun de ces contextes suivent.

ALL dans le SELECT Article

Lorsqu'il est utilisé avec le SELECT clause, ALL spécifie que les valeurs en double sont renvoyées dans le jeu de résultats.

Vous l'utilisez probablement déjà implicitement sans même le savoir.

Dans T-SQL, la syntaxe du SELECT la clause se présente comme suit :

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 partie qui va [ ALL | DISTINCT ] signifie que vous avez le choix entre ALL et DISTINCT .

Les crochets signifient que cette partie est facultative.

  • ALL spécifie que les lignes en double peuvent apparaître dans le jeu de résultats.
  • DISTINCT spécifie que seules des lignes uniques peuvent apparaître dans le jeu de résultats.

ALL est la valeur par défaut, donc si vous ne spécifiez pas ALL ou DISTINCT , ALL est utilisé.

Exemple

Ainsi, les deux déclarations suivantes sont équivalentes :

SELECT DogName 
FROM Dogs;

SELECT ALL DogName 
FROM Dogs;

Exemple de résultat :

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

Les deux résultats montrent qu'il y a deux chiens nommés "Fetch".

Si nous échangeons le ALL argument pour DISTINCT , une seule ligne sera renvoyée pour "Fetch". C'est parce que DISTINCT supprime toutes les valeurs en double du jeu de résultats.

SELECT DISTINCT DogName 
FROM Dogs;

Exemple de résultat :

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

ALL dans l'UNION Article

ALL fait la même chose lorsqu'il est utilisé avec le UNION clause. Il spécifie que les valeurs en double sont renvoyées dans le jeu de résultats.

Mais évidemment, UNION est une clause différente de SELECT , le contexte est donc légèrement différent.

L'UNION La clause concatène les résultats de deux requêtes en un seul jeu de résultats. Vous pouvez l'utiliser avec ou sans le ALL argument :

  • UNION ALL – Inclut les doublons.
  • UNION – Exclut les doublons.

Exemple

Voici un exemple d'utilisation de UNION ALL pour combiner deux requêtes.

Ajoutons une table appelée Cats . Nous avons donc deux tables :Dogs et Cats

Dogs 

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

Cats 

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

Maintenant, sélectionnons le nom du chien/chat dans chaque table et utilisons UNION ALL combiner les résultats des deux tableaux. 

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

Résultat :

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

Dans ce cas, sept lignes sont renvoyées. Nous pouvons voir que "Fetch" est retourné deux fois. C'est parce qu'il y a deux chiens nommés Fetch.

Il y a aussi un chat et un chien du même nom :Fluffy. (Nous savons que l'autre est un chat car il n'y avait qu'un seul chien appelé Fluffy dans l'exemple précédent).

Voyons ce qui se passe lorsque je supprime le ALL arguments.

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

Résultat :

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

Cette fois, seules cinq lignes sont renvoyées. Les deux doublons sont supprimés.

Notez que cela est différent de l'application de DISTINCT à chaque SELECT individuel déclaration. Si nous avions fait cela, Fluffy aurait été renvoyé deux fois, car le ALL ne s'appliquerait qu'au SELECT déclaration à laquelle il est appliqué (et non aux résultats concaténés).

Voici un exemple pour illustrer ce que je veux dire.

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

Résultat :

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

Le ALL Opérateur

Le ALL L'opérateur peut être utilisé avec une sous-requête pour comparer une valeur scalaire avec un ensemble de valeurs à une seule colonne renvoyé par la sous-requête.

Exemple

Pour rappel, voici nos deux tableaux :

Dogs 

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

Cats 

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

Exécutons maintenant une sous-requête en utilisant ALL opérateur.

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

Résultat :

(0 rows affected)

Dans ce cas, aucune ligne n'a été renvoyée. C'est parce que ALL nécessite que l'expression scalaire se compare positivement à chaque valeur renvoyée par la sous-requête.

Dans ce cas, la sous-requête était si large que toutes les lignes de Dogs le tableau a été rendu. Cela nécessiterait que chaque chien ait au moins un chat correspondant avec le même nom.

Modifions légèrement la sous-requête.

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

Résultat :

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

Cette fois, j'obtiens un résultat positif, car toutes les lignes renvoyées par la sous-requête avaient une ligne correspondante dans le Cats tableau (dans ce cas, une seule ligne).