En SQL, un opérateur est un caractère spécial ou un mot-clé spécifiant une action effectuée sur une ou plusieurs expressions.
Les opérateurs SQL font partie intégrante de SQL et nous permettent d'écrire des requêtes qui renvoient des résultats pertinents.
Dans cet article, je présente 12 des opérateurs SQL les plus couramment utilisés lors de l'écriture de requêtes SQL.
Les égaux (= ) Opérateur
L'opérateur égal à (= ) est probablement l'opérateur le plus couramment utilisé en SQL. Il compare l'égalité de deux expressions. Même si vous n'êtes que vaguement familiarisé avec SQL, vous connaissez probablement cet opérateur.
Imaginez que nous ayons une base de données pour un hôtel pour animaux de compagnie et que nous souhaitions obtenir des informations sur tous les animaux nommés Fluffy.
Dans ce cas, nous pourrions faire ceci :
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy';Résultat :
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
Notre requête utilise l'opérateur Equals (= ) pour comparer l'égalité de la valeur du PetName colonne et la chaîne Fluffy .
Dans notre cas, nous pouvons voir que l'hôtel pour animaux de compagnie a actuellement deux animaux appelés Fluffy.
Le supérieur à (> ) Opérateur
L'opérateur Supérieur à (> ) compare deux expressions et renvoie TRUE si l'opérande gauche a une valeur supérieure à l'opérande droit; sinon, le résultat est FALSE .
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 | +-----------+------------+
Dans ce cas, il compare la valeur du DOB colonne et la date 2020-01-01 pour voir si le DOB colonne est plus grande.
Le moins que (< ) Opérateur
L'opérateur Inférieur à (< ) fait le contraire. Il compare deux expressions et renvoie TRUE si l'opérande gauche a une valeur inférieure à l'opérande droit; sinon, le résultat est FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB < '2020-01-01';Résultat :
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
Supérieur ou égal à (>= ) Opérateur
L'opérateur supérieur ou égal à (>= ) compare deux expressions et renvoie TRUE si l'opérande gauche a une valeur supérieure ou égale à l'opérande droit; sinon, il renvoie FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB >= '2020-09-17';Résultat :
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Notez qu'il a renvoyé 2020-09-17 et toutes les dates supérieures à cela. Si nous avions utilisé l'opérateur Supérieur à (> ), seules les deux premières lignes auraient été renvoyées.
Inférieur ou égal à (<= ) Opérateur
L'opérateur Inférieur ou égal à (<= ) compare deux expressions et renvoie TRUE si l'opérande de gauche a une valeur inférieure ou égale à l'opérande de droite; sinon, le résultat est FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB <= '2020-09-17';Résultat :
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | | Wag | 2020-03-15 | | Fluffy | 2020-09-17 | +-----------+------------+
Notez qu'il a renvoyé 2020-09-17 et toutes les dates inférieures à cela. Si nous avions utilisé l'opérateur Inférieur à (< ), seules les trois premières lignes auraient été renvoyées.
Le AND Opérateur
Le AND L'opérateur combine deux expressions booléennes et renvoie TRUE lorsque les deux expressions sont TRUE .
Voici un exemple.
SELECT PetId, DOB
FROM Pets
WHERE PetName = 'Fluffy'
AND DOB > '2020-01-01';Résultat :
+---------+------------+ | PetId | DOB | |---------+------------| | 1 | 2020-11-20 | | 6 | 2020-09-17 | +---------+------------+
Dans ce cas, nous n'obtenons que les détails des animaux dont le nom est Fluffy et leur date de naissance est comprise entre les deux dates.
Le OR Opérateur
Le OR L'opérateur combine deux expressions booléennes et renvoie TRUE lorsque l'une des conditions est TRUE .
Voici un exemple.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy' OR PetName = 'Bark';Résultat :
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
C'est fondamentalement l'opposé du AND opérateur. Si nous avions utilisé AND , aucune ligne n'aurait été renvoyée, car nous ne pouvons pas avoir deux valeurs différentes dans une colonne en même temps.
Le BETWEEN Opérateur
Le BETWEEN L'opérateur nous permet de spécifier une plage à tester. Par exemple, nous pouvons l'utiliser pour renvoyer des animaux nés 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 | +-----------+------------+
Le NOT Opérateur
Le NOT annule une entrée booléenne (il inverse la valeur de toute expression booléenne). Renvoie donc TRUE lorsque l'expression est FALSE .
Voici ce qui se passe lorsque nous ajoutons le NOT opérateur à notre exemple précédent.
SELECT
PetName,
DOB
FROM Pets
WHERE DOB NOT BETWEEN '2018-01-01' AND '2020-01-01';Résultat :
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Cette fois, nous avons tous les autres animaux - les animaux qui n'étaient pas né entre ces dates.
Dans MariaDB, NOT se limite à nier le IN , BETWEEN , et EXISTS clauses. La plupart des autres SGBD autorisent NOT pour nier toute expression.
Le IN Opérateur
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 | +---------+-----------+------------+
Nous pourrions obtenir le même résultat en utilisant deux OR opérateurs :
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy'
OR PetName = 'Bark'
OR PetName = 'Wag';
Cependant, le IN L'opérateur est une manière plus concise de le faire. Le IN L'opérateur est particulièrement utile lorsque vous disposez d'une longue liste de valeurs à comparer.
Le IN l'opérateur s'exécute presque toujours plus rapidement que plusieurs OR opérateurs, en particulier sur les grands ensembles de données.
Un autre avantage du IN opérateur, est qu'il peut contenir un autre SELECT liste. C'est ce qu'on appelle une sous-requête . Une sous-requête est une requête imbriquée dans une autre requête (ou même une autre sous-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 | +-------------+-----------+
Cet exemple nous montre combien de types d'animaux se trouvent dans notre hôtel pour animaux de compagnie.
Nous pourrions utiliser le NOT opérateur pour retourner cela et voir combien de types d'animaux ne sont pas dans notre hôtel pour animaux de compagnie.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId NOT IN ( SELECT PetTypeId FROM Pets );Résultat :
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 4 | Rabbit | +-------------+-----------+
Notre base de données contient donc un animal de compagnie de type Rabbit , mais nous n'avons actuellement aucun lapin comme animal de compagnie.
Le + et || Opérateurs de concaténation de chaînes
Le + et || Les opérateurs de concaténation de chaînes vous permettent de concaténer des chaînes. La concaténation de chaînes est l'opération consistant à joindre des chaînes de caractères de bout en bout.
La raison pour laquelle j'ai répertorié deux opérateurs qui font la même chose est que le + est pris en charge dans SQL Server, et le || L'opérateur est pris en charge dans DB2, Oracle, PostgreSQL, SQLite.
Voici un exemple qui fonctionne dans SQL Server.
SELECT
FirstName,
LastName,
FirstName + LastName
FROM Owners;Résultat :
+-------------+------------+--------------------+ | FirstName | LastName | (No column name) | |-------------+------------+--------------------| | Homer | Connery | HomerConnery | | Bart | Pitt | BartPitt | | Nancy | Simpson | NancySimpson | | Boris | Trump | BorisTrump | +-------------+------------+--------------------+
Dans ce cas, les propriétaires ont leur prénom et leur nom stockés dans des colonnes différentes. Dans notre SELECT list, nous les récupérons d'abord individuellement, mais nous les récupérons également à nouveau, en utilisant un opérateur de concaténation pour les joindre.
Il y a cependant quelques problèmes avec nos résultats.
- Il n'y a pas d'espace entre le prénom et le nom.
- Il n'y a pas de nom de colonne.
Heureusement, cela est facile à résoudre.
Nous pouvons utiliser la même opération de concaténation pour inclure un espace entre le prénom et le nom.
Et nous pouvons utiliser un alias de colonne pour le résultat concaténé afin de fournir un nom de colonne dans le jeu de résultats.
SELECT
FirstName,
LastName,
FirstName + ' ' + LastName AS FullName
FROM Owners;Résultat :
+-------------+------------+---------------+ | FirstName | LastName | FullName | |-------------+------------+---------------| | Homer | Connery | Homer Connery | | Bart | Pitt | Bart Pitt | | Nancy | Simpson | Nancy Simpson | | Boris | Trump | Boris Trump | +-------------+------------+---------------+
Si vous utilisez DB2, Oracle, PostgreSQL, SQLite, échangez le + pour || et ça devrait bien fonctionner.
Si vous utilisez MySQL ou MariaDB, vous devrez utiliser le CONCAT() fonction pour concaténer des chaînes.
Le LIKE Opérateur
Le LIKE L'opérateur vous permet d'effectuer une correspondance de modèle. Il détermine si une chaîne de caractères spécifique correspond à un modèle spécifié. Un modèle peut inclure des caractères normaux et des caractères génériques.
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '%.com';Résultat :
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
Dans cet exemple, j'ai utilisé le LIKE opérateur en conjonction avec le % opérateur générique pour renvoyer les propriétaires dont les adresses e-mail se terminent par .com .
Opérateur bonus ! Le % Opérateur générique
Le % L'opérateur générique 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.
Il a tendance à être plus couramment utilisé comme suffixe et son utilisation est limitée au milieu de modèles, bien qu'il existe des cas d'utilisation valides pour l'utiliser au milieu d'un modèle, comme les suivants :
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '[email protected]%.com';Résultat :
+-------------+------------+------------------+ | FirstName | LastName | Email | |-------------+------------+------------------| | Bart | Pitt | [email protected] | +-------------+------------+------------------+
Dans ce cas, nous ne connaissions pas l'adresse e-mail de Bart, mais nous savions qu'elle commençait par [email protected] et se terminait par .com . Par conséquent, nous avons pu utiliser LIKE en conjonction avec le % opérateur générique pour remplir le reste.
Gardez à l'esprit que cette technique peut renvoyer de nombreuses lignes non pertinentes, en fonction des données et de la manière dont vous construisez votre instruction SQL.
Sachez également que les requêtes contenant le LIKE La clause peut s'exécuter beaucoup plus lentement que d'autres requêtes, et vous devriez probablement éviter d'utiliser le LIKE clause à moins que vous n'en ayez vraiment besoin. Utilisation du % l'opérateur en tant que préfixe peut être particulièrement lent.
Cela ne veut pas dire que vous ne devriez pas l'utiliser du tout. Le LIKE L'opérateur fait partie intégrante de SQL, et vous rencontrerez de nombreux scénarios où ce sera la seule option (ou du moins, la meilleure option).
Plus d'opérateurs SQL
Consultez ma liste complète d'opérateurs SQL pour tout un tas d'autres opérateurs qui ne sont pas inclus ici.
