SQL
Filtrer les résultats en utilisant WHERE et HAVING

Syntaxe

• SELECT nom_colonne
  FROM nom_table
  WHERE valeur d'opérateur nom_colonne
• SELECT nom_colonne, agrégat_fonction (nom_colonne)
  FROM nom_table
  GROUP BY nom_colonne
  Valeur d'opérateur agrégat_fonction (nom_colonne)

La clause WHERE ne renvoie que les lignes correspondant à ses critères

Steam a une section de jeux de moins de 10 $ sur sa page de magasin. Quelque part au cœur de leurs systèmes, il y a probablement une requête qui ressemble à:

SELECT * 
FROM Items 
WHERE Price < 10

Utilisez IN pour renvoyer des lignes avec une valeur contenue dans une liste

Cet exemple utilise la table Car de l'exemple de bases de données.

SELECT *
FROM Cars
WHERE TotalCost IN (100, 200, 300)

Cette requête renvoie la voiture n ° 2 qui coûte 200 et la voiture n ° 3 qui coûte 100. Notez que cela équivaut à utiliser plusieurs clauses avec OR , par exemple:

SELECT *
FROM Cars
WHERE TotalCost = 100 OR TotalCost = 200 OR TotalCost = 300

Utilisez LIKE pour trouver des chaînes et des sous-chaînes correspondantes

Voir la documentation complète sur l'opérateur LIKE .

Cet exemple utilise la table Employees de l'exemple de base de données.

SELECT *
FROM Employees
WHERE FName LIKE 'John'

Cette requête ne renverra que l'employé n ° 1 dont le prénom correspond à «John» exactement.

SELECT *
FROM Employees
WHERE FName like 'John%'

Ajouter % vous permet de rechercher une sous-chaîne:

• John% - renverra tout employé dont le nom commence par «John», suivi de toute quantité de caractères
• %John - renverra tout employé dont le nom se termine par «John», par n'importe quel nombre de caractères
• %John% - renverra tout employé dont le nom contient «John» n'importe où dans la valeur

Dans ce cas, la requête renvoie Employee # 2 dont le nom est "John" ainsi que Employee # 4 dont le nom est "Johnathon".

Clause WHERE avec des valeurs NULL / NOT NULL

SELECT *
FROM Employees
WHERE ManagerId IS NULL

Cette instruction renvoie tous les enregistrements d' employé dont la valeur de la colonne ManagerId est NULL .

Le résultat sera:

Id    FName    LName    PhoneNumber    ManagerId    DepartmentId
1     James    Smith    1234567890     NULL         1

SELECT *
FROM Employees
WHERE ManagerId IS NOT NULL

Cette instruction retournera tous les enregistrements d' employé dont la valeur de ManagerId n'est pas NULL .

Le résultat sera:

Id    FName       LName     PhoneNumber    ManagerId    DepartmentId
2     John        Johnson   2468101214     1            1
3     Michael     Williams  1357911131     1            2
4     Johnathon   Smith     1212121212     2            1

Remarque: La même requête ne renverra pas de résultats si vous modifiez la clause WHERE ManagerId = NULL en WHERE ManagerId = NULL ou WHERE ManagerId <> NULL .

Utilisez HAVING avec des fonctions d'agrégat

Contrairement à la clause WHERE , HAVING peut être utilisé avec des fonctions d'agrégat.

Une fonction d'agrégat est une fonction où les valeurs de plusieurs lignes sont regroupées en tant que données d'entrée sur certains critères pour former une valeur unique de signification ou de mesure plus significative ( Wikipedia ).

Les fonctions d'agrégation courantes incluent COUNT() , SUM() , MIN() et MAX() .

Cet exemple utilise la table Car de l'exemple de bases de données.

SELECT CustomerId, COUNT(Id) AS [Number of Cars]
FROM Cars
GROUP BY CustomerId
HAVING COUNT(Id) > 1

Cette requête renvoie le nombre CustomerId et Number of Cars de tout client disposant de plusieurs voitures. Dans ce cas, le seul client qui possède plus d'une voiture est le client n ° 1.

Les résultats ressembleront à:

Utilisez entre pour filtrer les résultats

Les exemples suivants utilisent les exemples de bases de données Ventes d'articles et Clients .

Remarque: l'opérateur BETWEEN est inclus.

Utilisation de l'opérateur BETWEEN avec des nombres:

SELECT * From ItemSales
WHERE Quantity BETWEEN 10 AND 17

Cette requête renvoie tous les enregistrements ItemSales dont la quantité est supérieure ou égale à 10 et inférieure ou égale à 17. Les résultats seront les suivants:

Utilisation de l'opérateur BETWEEN avec les valeurs de date:

SELECT * From ItemSales
WHERE SaleDate BETWEEN '2013-07-11' AND '2013-05-24'

Cette requête renverra tous ItemSales enregistrements avec un SaleDate qui est supérieur ou égal à 11 Juillet 2013 et inférieure ou égale au 24 mai 2013.

Lorsque vous comparez des valeurs de date / heure au lieu de dates, vous devrez peut-être convertir les valeurs de date / heure en valeurs de date ou ajouter ou soustraire 24 heures pour obtenir les résultats corrects.

Utilisation de l'opérateur BETWEEN avec des valeurs de texte:

SELECT Id, FName, LName FROM Customers
WHERE LName BETWEEN 'D' AND 'L';

Exemple en direct: violon SQL

Cette requête renvoie tous les clients dont le nom est alphabétiquement compris entre les lettres "D" et "L". Dans ce cas, les clients n ° 1 et n ° 3 seront renvoyés. Le client n ° 2, dont le nom commence par un «M», ne sera pas inclus.

Égalité

SELECT * FROM Employees 

Cette instruction retournera toutes les lignes de la table Employees .

Id   FName     LName    PhoneNumber   ManagerId   DepartmentId    Salary  Hire_date     CreatedDate   ModifiedDate
1    James     Smith    1234567890    NULL        1               1000    01-01-2002    01-01-2002    01-01-2002
2    John      Johnson  2468101214    1           1               400     23-03-2005    23-03-2005    01-01-2002
3    Michael   Williams 1357911131    1           2               600     12-05-2009    12-05-2009    NULL
4    Johnathon Smith    1212121212    2           1               500     24-07-2016    24-07-2016    01-01-2002

L'utilisation d'un WHERE à la fin de votre SELECT vous permet de limiter les lignes renvoyées à une condition. Dans ce cas, il existe une correspondance exacte avec le signe = :

SELECT * FROM Employees WHERE DepartmentId = 1

Ne renverra que les lignes où DepartmentId est égal à 1 :

Id   FName     LName    PhoneNumber   ManagerId   DepartmentId    Salary  Hire_date     CreatedDate   ModifiedDate
1    James     Smith    1234567890    NULL        1               1000    01-01-2002    01-01-2002    01-01-2002
2    John      Johnson  2468101214    1           1               400     23-03-2005    23-03-2005    01-01-2002
4    Johnathon Smith    1212121212    2           1               500     24-07-2016    24-07-2016    01-01-2002

ET et OU

Vous pouvez également combiner plusieurs opérateurs pour créer des conditions WHERE plus complexes. Les exemples suivants utilisent la table Employees :

Id   FName     LName    PhoneNumber   ManagerId   DepartmentId    Salary  Hire_date     CreatedDate   ModifiedDate
1    James     Smith    1234567890    NULL        1               1000    01-01-2002    01-01-2002    01-01-2002
2    John      Johnson  2468101214    1           1               400     23-03-2005    23-03-2005    01-01-2002
3    Michael   Williams 1357911131    1           2               600     12-05-2009    12-05-2009    NULL
4    Johnathon Smith    1212121212    2           1               500     24-07-2016    24-07-2016    01-01-2002

ET

SELECT * FROM Employees WHERE DepartmentId = 1 AND ManagerId = 1

Reviendra:

Id   FName     LName    PhoneNumber   ManagerId   DepartmentId    Salary  Hire_date     CreatedDate   ModifiedDate
2    John      Johnson  2468101214    1           1               400     23-03-2005    23-03-2005    01-01-2002

OU

SELECT * FROM Employees WHERE DepartmentId = 2 OR ManagerId = 2

Reviendra:

Id   FName     LName    PhoneNumber   ManagerId   DepartmentId    Salary  Hire_date     CreatedDate   ModifiedDate
3    Michael   Williams 1357911131    1           2               600     12-05-2009    12-05-2009    NULL
4    Johnathon Smith    1212121212    2           1               500     24-07-2016    24-07-2016    01-01-2002

Utilisez HAVING pour vérifier plusieurs conditions dans un groupe

Tableau des commandes

Pour vérifier les clients qui ont commandé les deux - ProductID 2 et 3, HAVING peut être utilisé

 select customerId
 from orders
 where productID in (2,3)
 group by customerId
 having count(distinct productID) = 2

Valeur de retour:

La requête sélectionne uniquement les enregistrements avec les ID de produit dans les questions et la clause HAVING recherche les groupes ayant 2 ID de produit et pas un seul.

Une autre possibilité serait

 select customerId
 from orders
 group by customerId
 having sum(case when productID = 2 then 1 else 0 end) > 0
    and sum(case when productID = 3 then 1 else 0 end) > 0

Cette requête sélectionne uniquement les groupes ayant au moins un enregistrement avec productID 2 et au moins un avec productID 3.

Où EXISTE

Sélectionne les enregistrements dans TableName qui ont des enregistrements correspondants dans TableName1 .

SELECT * FROM TableName t WHERE EXISTS (
    SELECT 1 FROM TableName1 t1 where t.Id = t1.Id)