Guide de l’opérateur SQL « différent de »

L’opérateur « différent de », écrit <> ou !=, est vrai quand deux valeurs sont différentes. Place-le dans une clause WHERE pour écarter les lignes qui correspondent à une valeur. Les exemples fonctionnent avec PostgreSQL, MySQL, SQLite et SQL Server.

Comment utiliser « différent de »

Place <> ou != entre deux valeurs. Les deux veulent dire exactement la même chose. <> est l’écriture du standard SQL, et != celle de la plupart des langages de programmation.

value1 <> value2
value1 != value2

SELECT 5 <> 3;
-- Output: true

SELECT 'apple' != 'apple';
-- Output: false

SELECT NULL <> 3;
-- Output: NULL

-- MySQL and SQLite show true and false as 1 and 0. SQL Server can't
-- select a comparison like this: use it in a WHERE clause there.

Dans une requête, « différent de » se place dans la clause WHERE et garde toutes les lignes dont la valeur est différente :

-- Input: tickets
-- id | subject               | status
-- ---+-----------------------+--------
-- 1  | Login fails on Safari | open
-- 2  | Typo on pricing page  | closed
-- 3  | Export times out      | pending
-- 4  | Add a dark theme      | NULL

SELECT id, subject, status
FROM tickets
WHERE status <> 'closed';

-- Output:
-- id | subject               | status
-- ---+-----------------------+--------
-- 1  | Login fails on Safari | open
-- 3  | Export times out      | pending

Le ticket 4 n’apparaît pas dans le résultat, alors que son statut n’est pas 'closed'. C’est la première règle ci-dessous.

Les règles à connaître

• « Différent de » ne correspond jamais à NULL. Comparer NULL à quoi que ce soit donne NULL (inconnu) et non vrai, donc la clause WHERE écarte la ligne. Ajoute OR column IS NULL pour garder les lignes sans valeur :

-- Input: the tickets table above

SELECT id, subject, status
FROM tickets
WHERE status <> 'closed' OR status IS NULL;

-- Output:
-- id | subject               | status
-- ---+-----------------------+--------
-- 1  | Login fails on Safari | open
-- 3  | Export times out      | pending
-- 4  | Add a dark theme      | NULL

• Un NULL dans une liste NOT IN supprime toutes les lignes. status NOT IN ('closed', 'pending') est un raccourci pour status <> 'closed' AND status <> 'pending', donc un seul NULL dans la liste rend toute la condition inconnue. Méfie-toi quand la liste vient d’une sous-requête sur une colonne qui accepte les NULL :

-- Input: the tickets table above

SELECT id, status FROM tickets WHERE status NOT IN ('closed', 'pending');

-- Output:
-- id | status
-- ---+-------
-- 1  | open

SELECT id, status FROM tickets WHERE status NOT IN ('closed', NULL);

-- Output:
-- id | status
-- ---+-------
-- (0 rows)

• MySQL et SQL Server ignorent la casse par défaut, donc 'Apple' <> 'apple' y est faux.

• Demande ce que tu veux quand c’est possible. status <> 'closed' correspond aussi à tout statut ajouté plus tard, et comme il correspond souvent à la majeure partie du tableau, la base de données profite rarement d’un index. Si tu veux dire « ouvert ou en attente », status IN ('open', 'pending') le dit clairement.

Syntaxe alternative

NOT (status = 'closed') est une autre façon d’écrire status <> 'closed', et ignore les NULL de la même manière.

Pour comparer sans la surprise des NULL, utilise IS DISTINCT FROM, un « différent de » compatible NULL qui traite NULL comme une valeur à part entière (SQL Server l’a ajouté en 2022, SQLite en 3.39) :

-- Input: the tickets table above

SELECT id, status FROM tickets WHERE status IS DISTINCT FROM 'closed';

-- Output:
-- id | status
-- ---+--------
-- 1  | open
-- 3  | pending
-- 4  | NULL

-- MySQL has no IS DISTINCT FROM. Use its NULL-safe <=> instead:
SELECT id, status FROM tickets WHERE NOT (status <=> 'closed');

Quand utiliser « différent de » ?

Utilise « différent de » quand une requête doit ignorer les lignes qui ont une valeur précise. La plupart des usages entrent dans l’un de ces cinq cas.

Exclure un statut ou une catégorie

Commandes annulées, factures annulées, une catégorie que tu n’as pas en stock : <> écarte les lignes avec cette valeur et garde tout le reste.

Ignorer un enregistrement précis

Compare un id pour écarter une ligne ou un groupe : l’article en cours de lecture quand tu listes les articles liés, l’utilisateur connecté dans une liste d’autres membres, ou un service dans un rapport d’entreprise. Les nombres n’ont pas besoin de guillemets.

Affiner les résultats avec d’autres conditions

Combine <> avec AND et OR pour exclure une valeur tout en filtrant sur d’autres colonnes, par exemple les commandes non annulées au-dessus d’un certain montant. Pour exclure plusieurs valeurs d’une même colonne, utilise NOT IN.

Trouver les lignes où deux colonnes diffèrent

« Différent de » fonctionne aussi entre deux colonnes. Compare une ancienne valeur à une nouvelle, une quantité comptée au chiffre enregistré, ou une adresse de livraison à une adresse de facturation.

Garder les lignes sans valeur

Comme <> ignore les NULL, décide si les lignes sans valeur doivent figurer dans le résultat. Ajoute OR column IS NULL pour les garder, ou utilise la syntaxe compatible NULL ci-dessus.

Exemples concrets de « différent de »

Additionner les factures qui comptent

Les factures annulées ne doivent pas compter dans le chiffre d’affaires :

-- Input: invoices
-- invoice_id | customer   | status | amount
-- -----------+------------+--------+--------
-- 1001       | Acme Corp  | paid   | 1200.00
-- 1002       | Birch & Co | void   | 450.00
-- 1003       | Acme Corp  | open   | 300.00
-- 1004       | Cobalt Ltd | paid   | 875.50

SELECT SUM(amount) AS invoiced
FROM invoices
WHERE status <> 'void';
-- Output: 2375.50

Lister les articles liés, sauf celui en cours de lecture

Un lecteur est sur l’article 2. Affiche les autres articles sur le même sujet :

-- Input: articles
-- id | title                | topic
-- ---+----------------------+-------
-- 1  | Indexing basics      | SQL
-- 2  | Your first JOIN      | SQL
-- 3  | Docker for beginners | DevOps
-- 4  | Window functions     | SQL

SELECT id, title
FROM articles
WHERE topic = 'SQL'
  AND id <> 2;

-- Output:
-- id | title
-- ---+-----------------
-- 1  | Indexing basics
-- 4  | Window functions

Afficher uniquement les produits vendables

Écarte les produits abandonnés, ceux sans prix défini et ceux en rupture de stock :

-- Input: products
-- product_name   | category     | price | stock_quantity
-- ---------------+--------------+-------+---------------
-- Desk Organizer | Office       | 18.50 | 40
-- Fax Machine    | Discontinued | 89.00 | 3
-- Gift Wrap      | Seasonal     | 0.00  | 120
-- Trail Backpack | Outdoors     | 64.00 | 0
-- Water Bottle   | Outdoors     | 12.99 | 75

SELECT product_name, category, price
FROM products
WHERE category <> 'Discontinued'
  AND price > 0
  AND stock_quantity <> 0;

-- Output:
-- product_name   | category | price
-- ---------------+----------+------
-- Desk Organizer | Office   | 18.50
-- Water Bottle   | Outdoors | 12.99

Trouver les champs qui ont vraiment changé

Un journal d’audit enregistre chaque sauvegarde, y compris celles qui n’ont rien modifié. Compare les deux colonnes pour ne garder que les vrais changements :

-- Input: audit_log
-- log_id | field_name | old_value   | new_value
-- -------+------------+-------------+------------
-- 1      | email      | dan@old.com | dan@new.com
-- 2      | city       | Austin      | Austin
-- 3      | plan       | free        | pro

SELECT log_id, field_name, old_value, new_value
FROM audit_log
WHERE old_value <> new_value;

-- Output:
-- log_id | field_name | old_value   | new_value
-- -------+------------+-------------+------------
-- 1      | email      | dan@old.com | dan@new.com
-- 3      | plan       | free        | pro

Si l’une des colonnes peut être NULL, utilise IS DISTINCT FROM (ou NOT (old_value <=> new_value) dans MySQL), sinon une valeur définie pour la première fois ne comptera pas comme un changement.

Relancer tous ceux qui n’ont pas dit oui

Les invités qui n’ont pas répondu ont un rsvp NULL, et ce sont eux qui ont le plus besoin d’une relance :

-- Input: invitations
-- guest       | email            | rsvp
-- ------------+------------------+------
-- Ines Moreau | ines@example.com | yes
-- Raj Patel   | raj@example.com  | no
-- Hana Sato   | hana@example.com | NULL
-- Leo Grant   | leo@example.com  | maybe

SELECT guest, email, rsvp
FROM invitations
WHERE rsvp <> 'yes' OR rsvp IS NULL;

-- Output:
-- guest     | email            | rsvp
-- ----------+------------------+------
-- Raj Patel | raj@example.com  | no
-- Hana Sato | hana@example.com | NULL
-- Leo Grant | leo@example.com  | maybe

Pour aller plus loin sur « différent de »

Sur ce blog :

• Guide SQL COALESCE : remplacer les NULL par une valeur avant de comparer
• Guide SQL LIKE : NOT LIKE pour écarter le texte qui correspond à un motif
• Guide de l’instruction SQL CASE : utiliser des comparaisons pour choisir une valeur
• Having vs Where en SQL : où placer un filtre quand tu regroupes des lignes
• Comparer deux valeurs dans PostgreSQL : les autres opérateurs de comparaison

Documentation officielle :

• PostgreSQL : opérateurs de comparaison
• MySQL : <> et !=
• SQLite : opérateurs
• SQL Server : <>, != et IS DISTINCT FROM