Cet article contient des exemples de requêtes SQL de base que les débutants peuvent utiliser pour récupérer des données de leurs bases de données.
Basique SELECT Requête
Voici un exemple de la requête probablement la plus couramment utilisée en SQL :
SELECT *
FROM Pets;Résultat :
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Cette requête sélectionne toutes les lignes et toutes les colonnes de Pets table. C'est parce que l'astérisque (* ) le caractère générique sélectionne toutes les colonnes.
Sélectionner les noms de colonne
Pour des raisons de performances, il est généralement préférable d'éviter de sélectionner toutes les colonnes, sauf si vous en avez vraiment besoin. Il est généralement préférable de sélectionner uniquement les colonnes dont vous avez besoin.
Voici un exemple.
SELECT PetId, PetName
FROM Pets;Résultat :
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 3 | Scratch | | 4 | Wag | | 5 | Tweet | | 6 | Fluffy | | 7 | Bark | | 8 | Meow | +---------+-----------+
Filtrer les résultats
Vous pouvez ajouter un WHERE clause pour filtrer les résultats uniquement sur les lignes dont vous avez besoin.
SELECT PetId, PetName
FROM Pets
WHERE PetName = 'Fluffy';Résultat :
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 6 | Fluffy | +---------+-----------+
Voici un autre exemple de filtrage des résultats. Cette fois, nous utilisons l'opérateur supérieur à (> ) pour le filtrer par date.
SELECT PetName, DOB
FROM Pets
WHERE DOB > '2020-01-01';Résultat :
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Vous pouvez remplacer l'opérateur supérieur à par d'autres opérateurs, tels que l'opérateur supérieur ou égal à (>= ), opérateur inférieur à (< ), ou inférieur ou égal à l'opérateur (<= ).
Vous pouvez également utiliser le BETWEEN opérateur pour filtrer les résultats sur une plage spécifique (par exemple, entre deux dates).
SELECT
PetName,
DOB
FROM Pets
WHERE DOB BETWEEN '2018-01-01' AND '2020-01-01';Résultat :
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
Trier les résultats
Vous pouvez ajouter un ORDER BY clause pour trier les lignes renvoyées par la requête.
Ordre croissant
Utilisez le ASC mot-clé pour trier les résultats par ordre croissant. Il s'agit de la valeur par défaut, vous pouvez donc également omettre ce mot-clé si vous voulez que les résultats soient dans l'ordre croissant.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC;Ou :
SELECT PetId, PetName
FROM Pets
ORDER BY PetName;Résultat :
+---------+-----------+ | PetId | PetName | |---------+-----------| | 7 | Bark | | 2 | Fetch | | 1 | Fluffy | | 6 | Fluffy | | 8 | Meow | | 3 | Scratch | | 5 | Tweet | | 4 | Wag | +---------+-----------+
Ordre décroissant
Utilisez le DESC mot-clé pour trier les résultats par ordre décroissant.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName DESC;Résultat :
+---------+-----------+ | PetId | PetName | |---------+-----------| | 4 | Wag | | 5 | Tweet | | 3 | Scratch | | 8 | Meow | | 1 | Fluffy | | 6 | Fluffy | | 2 | Fetch | | 7 | Bark | +---------+-----------+
Trier par plusieurs colonnes
Vous pouvez trier sur plusieurs colonnes en répertoriant chaque colonne, séparée par une virgule.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId ASC;
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId DESC;Résultat :
+---------+-----------+ | PetId | PetName | |---------+-----------| | 7 | Bark | | 2 | Fetch | | 1 | Fluffy | | 6 | Fluffy | | 8 | Meow | | 3 | Scratch | | 5 | Tweet | | 4 | Wag | +---------+-----------+ (8 rows affected) +---------+-----------+ | PetId | PetName | |---------+-----------| | 7 | Bark | | 2 | Fetch | | 6 | Fluffy | | 1 | Fluffy | | 8 | Meow | | 3 | Scratch | | 5 | Tweet | | 4 | Wag | +---------+-----------+ (8 rows affected)
Nous pouvons voir que les deux Fluffys sont dans un ordre différent dans chaque résultat (nous pouvons le dire en regardant leur PetId valeurs). C'est parce que le PetName la colonne a été triée en premier, puis le PetId trié tous les doublons du premier tri.
Trier par colonnes masquées
Vous pouvez trier par colonnes qui ne sont pas incluses dans le SELECT liste.
SELECT PetId, PetName
FROM Pets
ORDER BY DOB DESC;Résultat :
+---------+-----------+ | PetId | PetName | |---------+-----------| | 5 | Tweet | | 1 | Fluffy | | 6 | Fluffy | | 4 | Wag | | 2 | Fetch | | 3 | Scratch | | 7 | Bark | | 8 | Meow | +---------+-----------+
Dans ce cas, nous pouvons déduire de ces résultats que Tweet est le plus jeune animal de compagnie, et Meow c'est le plus vieux. En effet, nous avons trié par date de naissance (DOB ) colonne par ordre décroissant.
Juste pour être sûr, le revoici avec le DOB colonne incluse dans le SELECT liste.
SELECT PetId, PetName, DOB
FROM Pets
ORDER BY DOB DESC;Résultat :
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 5 | Tweet | 2020-11-28 | | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | | 4 | Wag | 2020-03-15 | | 2 | Fetch | 2019-08-16 | | 3 | Scratch | 2018-10-01 | | 7 | Bark | NULL | | 8 | Meow | NULL | +---------+-----------+------------+
En fait, nous pouvons maintenant voir que Meow et Bark ont NULL valeurs dans le DOB colonne. Par conséquent, nous ne savons pas s'ils sont réellement plus âgés ou plus jeunes.
Mais cela démontre que NULL les valeurs sont traitées comme les valeurs les plus basses possibles. Soyez conscient de NULL valeurs lors de l'exécution de requêtes.
Correspondance de modèle
Vous pouvez utiliser le LIKE opérateur pour utiliser la correspondance de modèle.
SELECT PetId, PetName
FROM Pets
WHERE PetName LIKE 'F%';Résultat :
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 6 | Fluffy | +---------+-----------+
Dans cet exemple, nous recherchons tous les animaux dont les noms commencent par la lettre F . Le signe de pourcentage (% ) est un caractère générique qui correspond à n'importe quelle chaîne de zéro caractère ou plus. Il peut être utilisé comme préfixe ou suffixe, et il peut également être utilisé au milieu d'une chaîne.
Voici un autre exemple.
SELECT FirstName, LastName, Email
FROM Owners
WHERE Email LIKE '%@example.%';Résultat :
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
Sélectionner dans une liste
Le IN L'opérateur détermine si une valeur spécifiée correspond à une valeur dans une sous-requête ou une liste.
Voici un exemple.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName IN ('Fluffy', 'Bark', 'Wag');Résultat :
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 4 | Wag | 2020-03-15 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Sous-requêtes
Vous pouvez utiliser le IN opérateur lors de l'exécution d'une sous-requête (une requête imbriquée dans une autre requête).
Voici un exemple.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Résultat :
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
Cela a renvoyé des colonnes d'une table (PetTypes ), mais uniquement lorsqu'il y avait au moins une ligne correspondante dans une autre table (Pets ) qui correspondait au PetTypeId colonne.
Pour le démontrer davantage, le contenu pertinent de ces deux tableaux est présenté ci-dessous.
Les PetTypes tableau :
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | | 4 | Rabbit | +-------------+-----------+
Les Pets tableau :
+-------------+-----------+ | PetTypeId | PetName | |-------------+-----------| | 2 | Fluffy | | 3 | Fetch | | 2 | Scratch | | 3 | Wag | | 1 | Tweet | | 3 | Fluffy | | 3 | Bark | | 2 | Meow | +-------------+-----------+
Nous pouvons voir que les PetTypes table contient un animal de compagnie de type Rabbit , mais aucun des animaux de compagnie dans Pets la table a été affectée à ce type (c'est-à-dire qu'il n'y a pas de valeur de 4 dans le Pets.PetTypeId colonne).
Voir 12 opérateurs SQL couramment utilisés et cette liste d'opérateurs SQL pour plus d'informations sur les opérateurs dans SQL.
Joints
On peut se demander si les jointures SQL sont considérées comme des "requêtes SQL de base", mais j'inclurai quand même une jointure ici.
Alors pour terminer cet article, voici un exemple de jointure interne.
SELECT
p.PetName,
pt.PetType
FROM Pets p
INNER JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;Résultat :
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+
Dans ce cas, nous avons utilisé un INNER JOIN pour renvoyer tous les noms d'animaux avec leurs types d'animaux respectifs. Nous avons utilisé le ON clause pour spécifier le prédicat à évaluer pour chaque paire de lignes jointes. Dans ce cas, le p.PetTypeId colonne est une clé étrangère du pt.PetTypeId colonne, qui est la clé primaire pour les PetTypes tableau.
Dans cet exemple, j'ai également utilisé des alias sur les tables, ce qui a aidé à garder le code agréable et concis.
Voir mon tutoriel sur les jointures SQL pour plus d'exemples de jointures.
